What was the hardest to program this year in Java?

[cybiko123]

Was anyone else having a problem getting the debugger to work?

[LukeS]

The hardest part of programming is always convincing everyone that it's not a code problem! Fine, it was twice, when someone accidentally would comment out `break;' on one-line cases in switches.

Things we did abstract farther:
Our side kicker was incredibly complex. So, I created a the `hardware.SideKicker' class that made it work work like ``sideKicker.set(SideKicker.Mode.kLoad);''. It had 4 states: kick, load, close, and wait (which are normally run in that order). Beside that, I further broke the kicker down into the `hardware.sideKicker.Loader' and `hardware.sideKicker.Latch', both of which `hardware.SideKicker' used. Even after that, all the timing logic and such is still fairly complex, but I did manage to make it pretty zen.

Same thing with the front kicker, although it is a lot more straight forward (kick and load), no timer issues other than the 2 second rules of the competition.

We also further abstracted the driverstation ``LCD''.

• LCD.lines[0-5] is an array storing the desired text.
• LCD.update() updates the hardware based on the array, adding spaces if necessary (having parts of long numbers left over can be very confusing when debugging a problem).
• LCD.println(str) adds a line, scrolling the other lines (this changes the array, and runs LCD.update()

[Robototes2412]

to be honest, i stole my team's driverstationlcd class from the Comet's code

[Lord_Jeremy]

Hah, I think the most complex thing in my code was the kicker stepping system, though the order processing system wasn't all that simple either. Of course the autonomous handler and the stepping manipulator building-blocks system were way more complicated but those were disabled in the competition version of the code. This was simply because I had to finish them after shipping and the mentors didn't want untested code in competition. In regard to WPI crap, I ended up doing a bunch of extensions just so I would have my own inheritance tree to play with, and I had to fix some bugs along the way.

Oh and speaking of shifting the blame away from programming, I had some serious issues with that. For two days at our regional the robot didn't move on the field. It worked just fine in the pit, tethered and it worked fine at school on wireless. Eventually I solved the problem by reimaging the cRIO, but that was after the mentors had ordered me to remove the Java code I wrote and replace it with the default LabView code. (There was a lot of fighting about this. Apparently someone from another team that used Java but switched to LabView came over and said that the Java code was the problem.) Unfortunately, this whole mess has now prevented us from going to Atlanta, although we've already paid the fee...

[Egg 3141592654]

Originally Posted by Lord_Jeremy

For two days at our regional the robot didn't move on the field. It worked just fine in the pit, tethered and it worked fine at school on wireless. Eventually I solved the problem by reimaging the cRIO, but that was after the mentors had ordered me to remove the Java code I wrote and replace it with the default LabView code. (There was a lot of fighting about this. Apparently someone from another team that used Java but switched to LabView came over and said that the Java code was the problem.)

Interesting, because something similar happened, except by willingness of I. I have the robot coded in not just java, but in Labview as backup (boredom produces somewhat valuable things sometimes). Since I never had time to test either code before the robot was shipped, I scrapped the java code and perfected the Labview code. It was sad to see 4 days of hard work go to waste and STILL nothing worked (NOTE: it was not a code error that killed our robot, someone just wired all pwms backwards).

As for the actual question, hands down our parallel kicker. It wasn't the code itself, but the implementation and lag prevention that was very difficult.

[Robototes2412]

i solved a similar lag problem with a kicker thread

[FRC4ME]

Originally Posted by Lord_Jeremy

In regard to WPI crap, I ended up doing a bunch of extensions just so I would have my own inheritance tree to play with, and I had to fix some bugs along the way.

I wouldn't go so far as to call it "crap." Were you around in the days of IFI? The default code didn't really have bugs in it - I'll give you that - but its organization didn't make much sense. Lines like "extern volatile near unsigned long short VAR" were not uncommon, and many teams ended up using Kevin Watson's unofficial default code instead.

When I was on a high school, I wrapped all of WPI's classes as well. In fact, I'm beginning to wonder if that's what they want you to do. Let WPI handle the low-level hardware drivers and interactions with the FPGA, but write the high-level inheritance tree yourself.

[Robototes2412]

Mecanum drive was also up there

[michael714]

One thing that frustrated us was the 21 character limit for the User Message box in the Dashboard DriverStationLCD. I know that it's a holdover from the old system, but it would have been nice to be able to change that limit for the new driver station LCD. After reading the posts here, it sounds like it might have been possible to write a new class to override the limit, but as relatively beginner Java programmers, it was not entirely obvious.

Another bummer was the DefaultCode template. The Timer.delay() routine was not as useful as we thought it would be. We needed delays because of how our pneumatic kicker was designed, but we wanted the teleop periodic to keep looping as well. Timer.delay() did not allow that to happen. Eventually, we learned that we should have put our pneumatic code into a thread that is separate from our joystick read and motor control. But working with threads will be something new for our team. It would be nice to have a sample routine with some task in its own thread.

It wasn't very friendly that the DefaultCode template tells you that you should not use it. We understood not to use it as-is, but the comment at the beginning of the template was a bit offputting. A bit more commenting throughout would also be helpful- I'm going to send my suggestions to the folks at WPI. One specific point was the disable mode. Didn't understand when and how it could be used until shortly before the competition. Finally discovered that it allowed us to use the driver station to set our autonomous mode and that was very helpful.

Not directly related to Java, the Driver Station update process was frustrating. The deal about having to install, then uninstall, then reinstall was frustrating. And somehow we downloaded what we thought was the latest update, but when we got to the competition, we were told that it was not the latest update. They point to a date on the dashboard, but this indication was not described in any readme or release notes for the driver station update.

We did most of our debugging via System.out.println statements, but it seemed like occasionally those statements directly interfered with other code- no specific example at this time. Just curious if anyone else noticed that.

The WPIlib user guide for Java was not complete and so there were some things we wanted to know but were not described in the document.

When we tried to receive data from the NXT Magnetic Compass, we received an error message along the lines of "Invalid Manufacturer." Not sure if that was a Java problem or something else.

Had some problems getting digital inputs to show up on the dashboard using the Dashboard example code. The analog inputs showed up fine, but not the digital inputs.

Not sure why writing data to the DriverStationLCD was so time consuming, but we experienced that and noticed that others have made posts about it as well.

Things that we loved:

- The gyro class worked quite smoothly
- Being able to set autonomous mode via disabled mode was cool
- The Java was much easier to work with than Labview for those of us who have written code using text for years
- It was quite easy to implement holonomic drive code and it was beautiful to see the result
- Although I have my complaints about the DefaultCode template, in the end, we did write code that worked and we did implement our first successful autonomous code in 4 years (scored a goal in autonomous from the middle zone!)

[synth3tk]

Originally Posted by michael714

Not sure why writing data to the DriverStationLCD was so time consuming, but we experienced that and noticed that others have made posts about it as well.

I waited for CD on that one. I remember figuring out how to set an autonomous mode during disable (which is a really cool trick [though I never got autonomous working]) right before researching the DriverStationLCD deal.

Other than that, 964's code was relatively simple, so we didn't go through the hassle of writing our own classes or anything exciting.