In the last competition we had a number of IR and other optical sensors on our robot. Due to the halogen lights however, we kept getting a true when it shouldn’t have detected anything. Are there any sensors that you guys use that aren’t affected by them or how do you get around that.
We usually use shading cones or recess the receiving sensor deeper into an enclosing project box to limit the amount of ambient light striking it.
I do not have any ideas on how to shield against light, except to create an enclosure around the sensor. However, you could use some different technology, like hall-effect or mechanical::safety::
People here will be better able to help you if you describe what you are trying to do with the sensors.
we got around it by designing our robot so it doesn’t need any sensors other than the compressor pressure switch. It’s amazing what you can do with mechanical design, to eliminate the need for software
Closed-loop programming is good enough for most cases. However, when you are building a robot that will be in a different scenario at most times, you cannot rely on closed-loop. Open-loop seems like it would be slower, but it would be trustworthy. Would you rather shoot 100 frisbees into the goal at a 60% accuracy, or would you shoot 60 frisbees and make all 60 into the goal? The latter would be more impressive because that is a 100% accuracy compared to a 60% accuracy of the first one. Also, these numbers above are sarcastic. It would be more of a 7-9 or 8-9 ratio of made goals.
I don’t see how open loop would be slower. It actually should be much faster than closed loop. In response to the OP we used banner sensors that could be tuned based on light.
We had a similar problem in 2012 with sharp IR sensors from Pololu electronics.
http://www.pololu.com/catalog/product/1134
They are inexpensive and worked very well at first to control the indexing of the balls in our pick up. Between the 1st and 2nd competition we change the robot covering for a couple of reasons. That’s when we started getting false positives. At that point for many reasons we could not go back to a robot covering that shielded the sensors. The human operator ended up being the controller. A tough lesson. So in the future we would use them again but design shielding in to the robot.
Can you explain why you say this? It’s pretty much the opposite of my experience.
The robot will not be in the same place very often. It needs to adapt by itself to it’s surroundings. Also, yes, open-loop can be faster, or it can be slower depending on how you tackle it. In the case that I was thinking about, it would take time to read sensors and joysticks, process that information and then move the robot. That would basically have very little impact, unless you are doing complex processing (like vision). So, you are right. The impact of speed would be very little.
I still don’t understand your previous post. You seem to be saying that closed-loop control is not capable of dealing with dynamic situations, and that open-loop programming is necessary in such cases. Again, that is completely opposite to my experience. Please tell us what you mean by open-loop and closed-loop in this context.
I’m confused. A few weeks ago, you said:
You seem to be contradicting yourself.
Microcontrollers can respond to input much faster than a human could. The lag in reading input is barely noticed compared to the time taken off repetitive tasks. For example closed loop code on a shooter could reduce down time between shots and increase reliability. This makes the action of shooting much faster.
Also, open loop relies on human feedback or constants. Humans make mistakes and constants aren’t as accurate as battery voltage decreases. Closed loop properly programmed will always be better than open loop code.
To address the open/closed loop control issue-
The confusion probably comes from the fact that the poster isn’t too familiar with implementations of closed loop control in FRC. It’s really hard to make blanket statements about one method being faster than another, or one being more reliable than another unless you have spend a significant amount of time working with both.
I do agree that a well-written closed loop control (PID, bang-bang, take-back-half…) is much superior to an open loop version, but in some cases, a team with little programming resources may not need to have PID control on their arm, but instead have two end of travel limits.
My recommendation to the poster is to spend time in the offseason experimenting with different control methods before commenting on their effectiveness.
As for the optical sensors, our team uses the banner IR sensors. We’ve used them on our drive wheels, our shooter wheels, and to detect the bump in 2012. We’ve found that with high speed control, we’d sometimes see that the speed reported would get cut in half when we went to competition, due to false positives. We fixed this by making sure that when we did high speed sensing, the black and white parts of the shaft that the sensor looked at were equal lengths. This makes it harder for the sensor to skip over one of them and report the incorrect speed. We also turned down the sensitivity as far as it would go without loosing the signal.
PID is quite required, to my opinion. Last year (2013), our robot did well, but the shooter wasn’t consistent because we didn’t have a way to measure the shooter speed. We would just place the shooters at 100% power and shoot from the same place. Programming a consistent robot closed loop can be hard because you need to calculate the motor speed using the hundreds of variables, mostly:
-battery voltage
-motor life
-controller life
-load on motors
-bearing stress
-multitudes of other variables
Yes, you could use vision so that the robot can determine whether the disk went into the goal. However, that would be hard because there is a small slot of time where the disk would show the greatest proof of position and landing. Encoders can be a life-changer when you want to want to have a very accurate robot while remaining simple.
Not only is PID not required, you do not need hundreds of variables. A bang-bang shooter algorithm is incredibly easy to program(it’s an if statement, if your programmers can program the robot to shoot they can program bang bang). Furthermore it only needs an encoder/ir sensor(we used banner sensors) to feed it RPM. As long as you know the speed of the wheel you don’t need to account for any other variables.
For position PID is great. Though we haven’t used it before, I have heard that limiting the controller to PD or just P is still a pretty darn effective motion controller.
To sum up, sensors don’t have to be complicated. Even with complex code(like vision code) teams like 341 have made it much simpler and easier for the rest of us.
The above makes no sense. I think perhaps you are misunderstanding what “closed loop” means.
Perhaps I should take a stab at explaining exactly what it means as we’re referring to it…
…And reducing the variables (very few of the ones mentioned actually apply in closed-loop control).
Actually, I’ll start out with: The only variables listed that would have ANY effect at ALL on, say, a shooter, would be the battery voltage (which really only affects open-loop controls–unless it’s totally dead) and the load on the motors (they do have to take a bit of load when the disc goes through–but that’s why you have closed-loop control). All of the others have no effect on the control system, or should have been dealt with in the design of the robot (like bearing stress–just get a bearing rated for the load, don’t worry about the bearing stress).
Closed-loop control goes something like this: The cRIO sends a command to the speed controller to have the motor go speed X. The controller boosts the motor to speed X (as the controller sees it) by boosting power. A sensor on the shooter wheel indicates speed and sends a signal to the cRIO indicating the actual speed. The cRIO then compares the actual speed to the set speed and then tells the controller to increase power, decrease power, or keep the same power.
cRIO->Controller->Motor->Sensor->cRIO->Controller…
The program could look something like:
speed = 100
if (sensor < 95)
//speed increase
else if (sensor > 105)
//speed decrease
An open-loop control, by contrast, goes:
cRIO->Controller->Motor
and looks like:
speed = 100
in code.
I don’t remember how many goals we made…but we did get high seed and won the Arizona regional 
This thread is starting to smell of a simplicity VS. complexity argument.