Have a ton of things going on right now, but none are finished so there’s not much to post.
Mostly I’m working on an entry for the Instructables Arduino Contest, but just now my MakerBot Cupcake showed up on the doorstep. Do I risk missing the deadline for the contest in order to use the Cupcake to make something for my entry? Decisions, decisions.
[tags]arduino, fdm, makerbot[/tags]
The Hall Effect sensor (usually shortened to “Hall sensor”) is an amazingly useful bit of circuitry: a simple, easy-to-use component that responds to a magnetic field by changing the voltage level it emits. What it does is so simple it’s not even obvious why it’s useful until you start seeing where and how hall sensors are used. One of the more useful things you can do with a Hall sensor is to detect motion and to count motions without touching the thing you’re detecting. Imagine you want to detect if a door is open or closed, and you want to count how many times the door is opened or closed. The simplest solution might be to put a physical switch somewhere near a hinge or latch, but this is hard to do without interfering with the door’s regular operation. Instead of modifying the door, you could instead use a Hall sensor with a magnet. The magnet goes on the edge of the door and a Hall sensor goes on the door frame so that it lines up with the magnet when the door is closed.
Because Hall sensors output a voltage, the first solution for hooking it up to an Arduino might be to connect it to an analog pin, repeatedly read the value, and wait for it to change. This is called “busy waiting” or a “polling loop” in CS lingo and it is generally frowned upon for reasons best illustrated by a code example:
// if the door is opened, call a function that turns on alarms. otherwise, turn them off.
loop()
{
int i = analogRead(0);
if (i > 0) {
Serial.println("door is closed");
DisableAlarms(); // a function that turns off all the flashing lights.
}
else {
Serial.println("door is opened");
DoAlarm(); // a function that turns on a bunch of flashing lights
}
}
Looks ok, right? And it mostly is, except for one thing. What happens if the door is quickly opened and closed while the DisableAlarms() function is running? What if you want to do other things in your script, like read a temperature sensor and print out the value? What if you want to keep track of how long the door was open the last time it was opened?
A common solution for this is to use an "interrupt". Interrupts aren’t always obvious at first, but once you understand how they interact with an Arduino script you’ll find all sorts of places to use them. (They’re instrumental to modern computing and the Wikipedia entry is a CS-heavy description as a result.)
An interrupt is exactly what it sounds like — it interrupts your Arduino script when an outside event happens, your script can do some simple task, then the script goes back to what it was doing earlier. The doorbell on your front door is an excellent example of an interrupt. You could go to the door every minute and check to see if someone is there or you can wait for the doorbell to ring. When it rings ("an interrupt occurs"), you temporarily stop whatever you’re doing and check to see who is at the door ("execute the interrupt routine"). When you’re done answering the door ("servicing the interrupt") you go back to whatever it is you were doing earlier.
So let’s say you want to know how long it’s been since the last time a door was opened. You could poll the Hall sensor, but your script has a lot of other things that need to be done, like display values from sensors or take input from other sensors. Instead of polling, let’s use an interrupt:
unsigned long doorNow = 0; unsigned long doorLast = 0; unsigned long doorDiff = 0; int doorCount = 0;
void setup()
{
// We need to tell the Arduino what to do when the interrupt happens and
// the details of our interrupt. We want to use interrupt #0, we want
// to know when it's going from a low value to a high value, and we want
// it to run the SetDoor() function. See the arduino.cc reference for
// the various options and pins available on your particular Arduino.
attachInterrupt(0, SetDoor, RISING);
Serial.begin(9600);
}
void loop ()
{
Serial.println(doorCount);
Serial.println(doorDiff);
}
// this is the function that is called to service the interrupt
// It checks the time, then computes the difference between now
// and the last time the interrupt was serviced.
void SetDoor()
{
doorCount++;
doorLast = doorNow;
doorNow = millis();
doorDiff = doorNow - doorLast;
}
Note that the only thing that happens in loop() is printing the value of "doorDiff" and “doorCount”. We never actually go read the sensor to see if the door is opened or closed, we let the interrupt handler update the values of doorLast, doorNow, and doorDiff on every occurance of the interrupt.
Another common application of this is to compute the speed of a rotating object. Instead of putting the magnet on the edge of the door, put the magnet on the edge of a disc, say a gear or pully. Every time the magnet goes by we know the disc has made a revolution. We can use the time between revolutions to compute the current speed of the disc and we also know how many times the disc has revolved.
Interrupts are useful in other places and don’t always require Hall sensors. How many scripts have you seen (or written :-) that use digitalRead() to determine if a button has been pushed? You could easily use an interrupt to simulate an on/off switch using a simple pushbutton switch and an interrupt handler that did something like:
void ButtonPress()
{
if (buttonState == 1) {
buttonState = 0;
}
else {
buttonState = 1;
}
Then in your code, instead of doing a digitalRead() and hoping it’s while the button is pressed, you could just test the value of buttonState:
if (buttonState == 1) { // someone pushed the button!
DoButtonStuff();
}
What are the downsides of interrupts on the Arduino? The biggest problem is that most Arduino only have two interrupt pins available. Another problem is that it’s risky to do anything complex in your interrupt handler and it’s a bad idea to call other functions from within your handler. When an interrupt handler is called, the Arduino temporarily stops doing everything else, so it’s best to stick with simple math and setting/testing global variables in your interrupt handler as in the above examples. If you do something involving input/output in your interrupt handler — say call Serial.println() — you might run into problems that are very difficult to debug.
Now, go make something and tell people what you did and how it works.
[tags]arduino, hall sensor, interrupt[/tags]
[thx to Tom Igoe for making me write all this down]
Question: Can we teach people how to debug? We often talk about “the art of debugging”, but is it really an art? Is it a science? A mixture of both?
I’ve never given thought to explicitly teaching a unit on debugging, it’s always something that gets covered along the way while teaching coding and physical computing. Which isn’t surprising, I don’t remember anyone teaching any sort of debugging in any of my CS classes or ever thinking of it as an academic subject. It was mostly treated as a practical thing that we’d pick up after we got work. You get your first few coding jobs, you have bugs to fix, and someone senior (usually) comes by and teaches you what they know about finding bugs in software.
However, I think that where I really learned how to debug wasn’t while writing software, it was while working on cars and motorcycles. When you’re faced with a motor that won’t start or a strange noise or an intermittent failure in some part of the electrics, you have a problem space much bigger than you can see all at once. You have to break the problem down, rule out areas that can’t obviously be at fault, and try and focus on the areas where the problem might lie. There’s an iterative process of selecting smaller and smaller domains until you get to the point you can start asking questions that are simple enough to be easily answered. “Why won’t the car start?” can’t be answered until you’ve answered all the little questions, like “is the battery fully charged?” or “is the fuel pump sending fuel to the carbs?” or “are the spark plugs firing?”. More often than not, answering those questions simply leads to even more big questions that have to be broken down again, “ok, why isn’t power getting from the battery to the spark plugs?”
Another issue is that in the physical world, you don’t have x-ray vision (debuggers) or the ability to replicate the problem over and over without causing physical damage (“let’s add some printf’s and run it again”). You have to learn to break the problem down into tests that won’t damage the engine or make the problem worse. You also can’t magically make most of the car go away with #ifdef’s in order to isolate the problem, you have to physically connect and disconnect various things both for safety reasons and so that you can perform proper tests. (Always remove the ground strap from the negative pole of the battery. No, really. Trust me on this.)
When unit testing started gaining in popularity in the software dev world it made perfect sense to me. This is the way I fix a vehicle — break the problem down into increasingly smaller chunks, isolating unrelated systems from one another, to the point that I can “Has the flayrod gone askew on treadle, yes or no?” instead of being stuck at “there’s a problem at the mill”. Granted, we use these tests to prevent bugs in code under development, but adding them to an existing code base often reveals all sorts of, “oh, so that’s why it makes that odd noise on Tuesdays after lunch” bugs that were never worth tracking down. The problem with unit testing, however, is that you’re usually adding it from the bottom up while you’re actively focused on the task of software development. You’re almost ruling out the need for debugging later by doing extensive testing now, or you’re adding it to an existing code base to “increase stability,” as they say. (In other words, there are all sorts of mildly annoying bugs we can’t find easily, so let’s just add unit tests and hope that fixes things.)
My gut feeling is that there’s a pattern involved in debugging both hardware and software problems, and that the pattern is similar to other patterns we use in hacking and design. I believe “my car won’t start” and “my LED won’t light” can be solved using similar methodologies to generate domain-specific questions. Each domain requires its own set of knowledge and specialized tools, but I think the process for fixing each problem is similar.
So how do we teach debugging? I think we start by teaching the good ol’ scientific method, translated to computational space:
Ok, granted, that seems pretty obvious, but it took us humans a really long time to sort that out and write it down. I suspect most of us couldn’t recite the scientific method off the top of our heads, especially if we didn’t study science in high school or college.
Using these steps also requires a certain amount of domain specific knowledge and ability to choose and use the appropriate tools. If I don’t know ground from positive and that current can only flow through an LED one way, I’m not going to get very far figuring out why my LED won’t turn on because I’ll never be able to ask the correct questions.
In theory, what we’re teaching when we teach computing is the necessary domain specific knowledge and tools, so the student should be able to debug simple problems in their own work. What I’m suggesting is that we also hammer on the above methodology any time a student shows up saying, “my LED won’t turn on”. Make the student break the problem down, generate the questions, then show the student how to answer those questions if they’re unable to do so on their own. If the student can’t ask the right questions, then there’s a bigger problem: the student doesn’t have the domain specific knowledge to turn the LED on in the first place. If the student can ask, “is there power to the LED” then you can show them how to use a multimeter to answer that question. But if they’re still unclear on polarity, then they’ve got a bigger problem.
I think we can teach debugging, even though we weren’t taught debugging when we were learning. Not only can we, I think we do students a disservice if we don’t teach debugging as a core competency.
Footnotes: “Kit-building isn’t learning” and “It’s not my fault that Windows sucks”.
There are at least two exceptions to the above.
1) Building a kit isn’t the same as studying and learning a subject. Knowing only how to solder and read English, one can put together kits ranging from a simple Adafruit Arduino kit to a complex synthesizer from PAiA. But unless the builder does research into why the kit is put together the way it is, they haven’t learned much, if anything, about what they’ve built. As a result if there is a problem, whether it is in the instructions, the components, or their assembly, they’re going to find it very difficult to ask the right questions that will let them debug the problem. (I’ve assembled kits from both outfits and they both provide excellent kit-building instructions.)
2) Windows sucks. Ok, all computers suck, but Microsoft has spent decades innovating new and wonderful ways for Windows to suck, so I’m picking on them. There comes a point in debugging a hardware or software problem where the problem is out of operational scope. Maybe “my LED won’t turn on” because there’s a subtle bug in the USB driver between the IDE and the breadboard. The student will probably never have the domain specific knowledge needed to start asking questions about the USB driver, and odds are the instructor won’t either. Sadly, even the person who developed the driver or tool or OS can’t formulate the right questions either, this is why the final step in many troubleshooting guides is, “reinstall the drivers and then the operating system”.
[tags]debugging, pedagogy[/tags]
I’ve been happy using the ecamm iMage with my Macs for Processing, so I decided to go ahead and use it for ARToolkit as well.
Before I ran the two-stage calibration, it barely worked. I did the two-stage using only cardboard boxes and rulers to prop things up and keep things square, and the resulting calibration file is very usable.
I’m posting rev 1 of my calibration file, let me know how it works for you.
[tags]artoolkit, ecamm, image[/tags]
and it’s rather large.
Something that has continually bugged me about the various flavors of Arduino is the number of pins that there are not 8 of. As in, 5 analog pins or 6 PWM pins or whatever. I end up adding multiplexors so I can drive 8 PWM outputs or read 8 sensors or what-have-you.
Arduino MEGA fixes all my problems, at the cost of size and a few extra $$$:
PWM: 14 pins, I’ll try not to complain about it not being 16
Analog Input: 16 pins
Thanks to all the extra I/O, I was able to ditch a specialized, $25 PWM controller and some support hardware and move my entire project from a pc board to an Arduino MEGA shield.
[tags]arduino mega[/tags]
The reprap people have a new arduino-like out, the Sanguino. It uses the Atmel atmega644p, so it has 4x the memory, 14 more i/o pins, and JTAG support.
I ordered a couple of kits and soldered them up. Instructions are easy to follow, both for soldering up the board and for modifying Arduino to support the new chip. However, I ran into two problems right off the start, one of which would have probably stymied someone without any arduino/microcontroller experience.
1) No bootloader was installed on the Atmel. This is not the end of the world if you have a bootloader lying around. We had one in studio, but I can’t find it and everyone else is out of country/town. I took this as a sign that I should have my own, so I ordered a couple of USBtinyISP‘s from Limor (always buy two of anything you rely upon), soldered them up, and bootloaded the Sanguino. I wrote a simple sketch that blinks the debug LED, pushed it to the Sanguino and yea, everything works now!
Now, to try replacing the Arduino nano or mini on one of my project boards.
2) Oh. How cute. It won’t work on a breadboard. The spacing on the Sanguino pins is so wide that when it’s plugged into the center of ye olde standard breadboard, you can’t access one side of the Sanguino’s pins. That is, if you put one side of the Sanguino in column b so that you can use column a, the other side is in column j, not in column i. Looking at the board layout, I think this could have been completely avoided by moving the pins in a “row” on each side, and putting the labels for the pins inbetween the pins ala the Nano.
Yuck. I guess I’ll have to get clever if I want to use this with my existing projects.
[tags]arduino, sanguino[/tags]
… because I’m currently doing a lot of hacking to try and finish up my first-semester project in the mTID program at CMU. I have a backlog of half-finished posts that will get finished after the semester is over.
[tags]design,mtid,school[/tags]
I wish this were in The Onion and not the Pittsburgh Post-Gazette:
A national children’s advocacy group is pushing to get Pittsburgh removed from the Street View of Google’s map search until the technology is refined so pedophiles can’t use it to pinpoint children’s homes, schools and playgrounds.
Street View, an addition to Google Maps that uses vehicle cameras to take 360-degree, street-level views of neighborhoods, allows users to virtually cruise down a street and across a city. In the process, the tool shows pictures of children, toys and family cars that could tip a would-be predator to an area where children could be found and potentially victimized, according to the group, Stop Internet Predators.
[…]
OMFG! I bet you could use Street View to find cars to steal! Or burglars could find houses with plate glass front windows surrounded by bushes that are easy to break into! Rapists could find bushes to hide in!
I mean, it’s not like people can drive around neighborhoods and find those things in real time, is it?
Sadly, this ignorance about crime is nothing new.
Quintilian, INSTITUTIO ORATORIA, II, xvi (first century AD):
“Doctors have been caught using poisons, and those who falsely assume the
name of philosopher have occasionally been detected in the gravest crimes.
Let us give up eating, it often makes us ill; let us never go inside
houses, for sometimes they collapse on their occupants; let never a sword
be forged for a soldier, since it might be used by a robber.”
[tags]google, idiocy, privacy[/tags]
After ~5 minutes looking on the interwebs, I gave up and just made my own EAGLE library file for the Arduino Nano. I haven’t used it to make a board yet, so I’m going to call this the “alpha” version until I do. Use as you like, just don’t blame me if it’s broken.
[tags]Arduino,EAGLE,pcb[/tags]
Powered by WordPress