Slashdot Mirror
What Micro-Controller Would You Use to Teach With?
Rukie asks: "I'm looking into starting some sort of robotics class for my high school, which severely lacks any sort of technological classes. I am now wondering what micro-controllers are best for an educational environment. I definitely want something more advanced than the Legos, but something that won't fly over people's heads. Are there cheap, scaleable micro-controllers for learning in a classroom or at home? I'm curious how my fellow readers have hacked up toys to make their own robotics at minimal cost."
I like this one.
https://www.eff.org/https-everywhere
Check out http://www.parallax.com/ and their Basic Stamp series. They have a wide range or processors and great educational programs based on them. The also have robots and robotics based programs based upon the Basic Stamp.
Basic Stamp
AVR.
Good luck with that.
If you dont use something simple like Legos and their language, it'll go over all their heads. Most of these kids you'll teach probably wont have a mastery of algebra, let alone have the mental concept of complex systems like robotics. There's always a few that do, but they'd benefit from an extracurricular group after school.
You'd be best teaching how a computer works (from ground up), how circuits work, basic circuit theory, and basic radio theory.
Building computers from junk parts, and installing Linux would teach them a lot.
Understanding how to use a 555 timer with other basic inputs would teach them how to control input to output, along with basic principles of common "parts".
Radio theory could teach that all signals are EM, and given proper parts, we can listen and create them. Show how to build a crystal am radio and then turn it into a transmitter. Apply to current theory.
Parallax sells these simple microcontroller devel systems with mini breadboards and a circuit project book. I've seen one for $60 or $80 at Radio Shack. I'm way beyond that though, so I have not really tried them. The big downside is it's probably programmed in BASIC.
I like the Brainstem from Acroname. I haven't done any big projects with one, but I've played with a couple and they definitely hit the spot in terms of easeability, powerfulity and economicalness. I've used the SV203 from Pontech in the past and it's a solid & simple board. Great if you're keeping the board tethered to a computer and not doing any actual processing on board. Brainstem gives you a little/lot more high level power.
I would go for PIC: they are cheap, programmers are available everywere, free assembler/IDE and net is full of information. Yes they are stupid small ram devices, but also very easy to use.
The Make magazine featured the leafproject recently which uses a custom board [2] for their "open source robot using artificial intelligence and vision"
I'm currently taking a Microprocessors class at Ferris State University. We're using the Motorola 68HC11. It's a CISC processor with simple nmenonics. We both have quite a few physical boards, but we also use a Windows-based emulator called Wookie with MiniIDE as the IDE/assembler.
I'm enjoying the class so far.
Bugs are just features that have been fixed.
Great features top of its head to tip of its toes.
The 6808 micro-controller (long version of the name is M9S08GB60) would be excellent for teaching a class on robotics. As its been around since the dawn of time, there's a lot of support readily available for it. Complete, detailed reference manuals are freely available, Freescale will even ship printed copies to you for free. Compilers are available that allow you to program in your choice of assembly, C, or C+. The "M68DEMO908GB60" demo board is available from many online retailers for around $50 which makes it easier to use the microcontroller for prototyping as well as experimentation and class labs.
f
What lends the 6808 microcontroller is its Pulse-Width-Modulation components (it has 2 modules, one with 5 channels and the other with 3 channels and all channels can be set up for either incoming our outgoing). In addition to all that it runs up to 40MHz without cooling and includes 4K of RAM and 60K of ROM all on-die, so no extra chips for those. It has more power than you could ever hope to use in a class-room.
A good example project is available here: http://home.comcast.net/~starwreck/FinalReport.pd
... and in the DRM, bind them.
The Microchip PICmicro is a very good choice. Try the PIC16F84 - the chip is cheap, programmers that connect to a PC parallel port are simple to build, a chip can be electronically erased and reprogrammed hundreds of times.
The assembly language is also very simple. There are only thirty-five instructions and two addressing modes. It's also very easy to calculate instruction timing (for delay loops, etc.). I learned to program those things when I was at high school.
Things like the BASIC stamp are less than helpful. You aren't close enough to the metal. If you don't like the PICmicro, an AVR chip would be my second choice.
As much as I love the open source Arduino board for my own personal use, and even though the basic STAMP is raher expensive (even with the education discount), Parallax has an extremely thourough set of documentation that is perfect for an educational environment. They have a fee book available for download called "What is a Microcontroller" that should fit all your needs. It contains a series of predesigned lessons that assume no technical experience for your students. All your lesson plans are done for you.
I would recommend either an 8051-based microcontroller or an AVR. Atmel makes both. They're easy to design hardware around, often include on-chip flash ROM, are very well documented, and simple to program. You can also get kits and evaluation boards if you don't feel like building your own hardware.
The University of Minnesota just moved to the PIC because of its ease of programming as compared to the Motorola 6800 series microcontrollers that were in use before. The PIC comes in 8 and 16-bit varieties and has a range of available memory sizes. I'm not sure about pricing, but they are somewhat of a standard "learning" microcontroller, so your students will have a leg-up when they get to college.
We all know what to do, but we don't know how to get re-elected once we have done it
PIC is a braindead horror show architecture from the 70s, and Microchip's microcontrollers are the hardware equivalent of spaghetti code, built with kludge upon kludge.
Go with a simple yet elegant architecture, as it will teach good design practice. With PICs these kids will spend a lot of their time writing tricks to compensate for the hardware's flaws, and may get the impression that programming amounts to writing "clever", unmaintainable code.
Avoid the frustration and go with the AVR lineup. If you want to showcase a traditional design, introduce them to the 8051 (but don't necessarily have them in the lab). If you need more features, use the Freescale HCS12 with the GCC toolchain (coding in assembly for the HCS12 isn't practical, since it essentially implements the old fashioned, register starved 68HC11 instruction set). And if you want performance for higher level applications (which may not be the case), go with an ARM part.
I like the ATMEL line. They are straight forward and highly functional.
Politics is the art of looking for trouble, finding it everywhere, diagnosing it incorrectly and applying the wrong fix.
Take a look at Wiring. This is a microcontroller development system for artists. There's a board with an Atmel microcontroller and I/O interfaces. There's an integrated development environment with a simplified programming language. All open source. IDE runs on Linux, MacOS, or Windows.
The neat thing about this system is that it uses a modern microcontroller, the Atmel ATMega128, with 128K of memory and a 16MHz clock. This is a substantially more powerful machine than the PIC or the Basic STAMP. The development environment is really GCC, generating machine code; it's not an interpreter. So you can actually do non-trivial work on the thing.
All this is packaged up with an IDE and a set of documentation designed to be used standalone; all you need is their big download to install the IDE, and their web site to tell you how to use the board. You don't have to dump a set of Atmel manuals and a GCC manual on the user.
I've never used it for robotics (used Stamps and 68hc11s before, though), ARM is a pretty sweet architecture. They're low cost, low power, and have really nice assembly code.
Whoops, I meant 1K files... it can store 11 1K programs, not 1M. Sorry about that.
An FPGA would be a great way to get people started with embedded systems. Something like the Spartan 3 starter board would be a good sub-$100 system to start with. Rather than have to piece together a working circuit, have them program one in one of the Hardware Description Languages. I'll be the first to admit that it is not easy, but it is a great way to learn about how various components can come together to make a useful device. and with the Spartan 3 board, you get a svga controller, a few buttons and switches, and a ps2 port for mouse or keyboard. Xilinx has a free software system you can download to develop HDL systems and apply the systems to the FPGA. The future of computer science and EE, in my opinion, will put more and more emphasis on FPGA's as a very high speed platform for development of hardware embedded systems.
There are some robotics groups out there already. FIRST http://usfirst.org/ Robotics has been around for years. However, the cost is a bit steep, so a sponsor is needed. The team I work with was able to get a sponsor after one year of searching. The robots are pretty simple, you are handed a kit for electronics, and a base chassis, from there, you can add on accelleromters, gyroscopes, cameras, and other sensors to make things more complicated. Everything is custom made, so it is a great way to learn how to engineer things.
For basic programming, you can use the MSP430F1121. They are very simple to use, as well as being the best low power processor out there. The prices for it aren't too bad either. There is a whole range of MSP430's, and depends what level you want to teach at. MSP4301232 is the same as 1121 except it has an ADC, so you can perhaps get students to do a simple temperature sensor.
Either way, there are many around. Atmel micros aren't too bad, I am not a big fan of Motorola's.. In the end, I work on MSP430s all day long, designing hardware and writing C.. so I'd go for them. As a matter of fact, I learned about micros on a 1121.
I'd go with Atmel AVRs.
They are widely used, well documented and well supported.
There are a large range of chips with a consistent instruction set, so they can learn on a simple eight pin 1-Kbyte chip and then apply that knowledge the next day on a large 32-pin 16-Kbyte device.
They are extensively used in industry so students can feel like they are learning something practical.
1) They have heaps of I/O options
2) They have USB
3) They are seriously capable chips (no real need to screw around with assembler)
4) They are cheap
5) The scale.
Once you are comfortable with the 'low end' (>50MHz) part, you can scale up to better chips that do htings like run PDA's. The architecture stays the same, just lots of new I/O options and better performance and memory and...
It's not so much a chip, as a family. They are simply brilliant.
Forget Stamps, PIC's, AVR's. They are just old technology.
Texas Instruments has $20 USB-based development boards for the MSP430 series microcontrollers. The MSP430 is a nice, clean C-friendly 16-bit architecture. It's practically luxurious, by microcontroller standards.
Although perhaps, as others have said, microcontrollers are a bit too hardcore for students. A better idea might be to use full-fledged PCs running DOS (FreeDOS if there are licensing issues), either by scavenging old laptops or by running a cable to the robot from a desktop PC. DOS is nice and simple, well-documented and well-supported with development tools.
(Disclaimer: I am employed in the creation of MSP430 development tools.)
I'm personally using this : http://www.robominds.com/ There are good available libs for robotics purpose : http://www.motorobots.org/ I also saw others recommending the parallax which might fit better in your budget
This is basically what the Picaxe microcontroller series was made for. Their website is at http://www.picaxe.co.uk/ and a reseller for them in the united states is located at www.phanderson.com. It is basically a PIC microcontroller (they use various models, from 8-pins to 40, so the scalability factor is there), with a custom ROM flashed onto them that has a BASIC interpreter. Think of a Parallax BASIC-STAMP, only all in one chip, and the chips range from $3-10 for most of them, so its almost as cheap as you can get it. Additionally, the BASIC software development environment is free to download, has no limitations, and is geared towards an academic setting (it even includes the ability to draw out simple logic circuits and have it convert them to basic code). Also, THEY DO NOT REQUIRE A SEPARATE PROGRAMMER. To program a PIC normally, you would need a ~$50-100 programmer for each student, but these hook directly up to the serial port (a cable is just 3 wires coming out of a DB9 connector), so each student can easily reprogram their own, or even do it from home. They're incredibly versatile (check out the forum at their main site), and perfectly suited to academic use, for both younger and older students
I'm perfect in every way, except for my humility.
This is a common topic on comp.robotics.misc... search the archives -- its come up at least once in the past couple of months. Instead of using embedded processors, why not use the PC with an I/O board?
? products_id=8207
http://www.phidgets.com/
http://wiring.org.co/
And single-board computers are getting affordable...
http://www.sparkfun.com/commerce/product_info.php
How about the iRobot Create platform? You can get ten of them for $1k, it's got the controller as well as the mechanics in a robust package.
To put a witty saying into 120 characters, jst rmv ll th vwls.
Some micros are easier for one and harder for the other. If you're doing more software, are you going to be using a compiler, or will you be teaching them assembly? How critical is timing? If you're doing more hardware, you might think of what kind of microcontroller peripherals (i.e timers, UARTs, PWMs) will be useful to you.
I prefer 16-bit micros because they're easier to program on, and thus easier to teach to beginners. If you go 8-bit, you will be dealing with pointers in weird ways which will distract from the real task.
I like the MSP430 a whole lot, but it doesn't have 5V tolerant I/O so it will be a pain for novices to hook it up to interesting things.
If I had a time machine, I'd choose a 68000 variant. It has a nice architecture that is easy to program.
Avoid anything from Microchip. Their architecture is hideously evil and will cause your students to give up technology and go to law school.
The Renesas M16C line is very pleasant to program and simple to interface. It's easily available, but not as popular as others. Unfortunately, there's no GCC port.
ARMs are nice in a lot of ways. They're fast, cheap and and have lots of tools available, but they require quite a bit of setup and are not simple to program for. If you're going to program in C and you're willing to hand your students a starter environment, an ARM could work quite well.
I definitely agree with the AVR. It has lots of nice Linux tools, and has models with just about everything on board, including FPGA.
sub f{($f)=@_;print"$f(q{$f});";}f(q{sub f{($f)=@_;print"$f(q{$f});";}f});
check out the cerebellum from Carnegie Mellon. personally, though, i think lego mindstorms toolkits can take a high school student very far. in high school a friend of mine used one and did some pretty cool stuff with it in C. we learned a lot about stacks (we overflowed that a couple times...recursion can be a bad idea ;) and we even learned about multi threading (yes, it can do it!) but if you're looking for something more advanced, i definitely recommend the cerebellum. its what a lot of first year CMU kids start using for their robotics projects.
http://www.cs.cmu.edu/~myrover/cerebellum/
disclaimer: i'm a CMU student.
If you want to start off with C, I recommend the AVR Butterfly.
You can get an AVR Butterfly http://www.atmel.com/products/AVR/butterfly/ for $20 at digikey... it comes with an LCD screen, a five way joystick-like button, a speaker, some sensors, RS232 level converters, and an ATMega processor. To program it, you just wire up an RS232 plug to the board and download the C/Assembly compiler from their web site. GNU tools for this are also available. No specialized programmer required.
The advantage of a board like this is it's quick. You don't need to wire up a micro with an oscillator and some output devices. You don't need a special programmer. You don't need to buy a C compiler. It's all there, and $20 is fairly cheap. If the kids like 'em, they can buy their own for home.
If you want to start off with something easier, like BASIC, the BASIC stamp seems like the way to go.
Good luck!
I think you're students will become extremelly enthusiastic towards robotics if they get involved in a program like FIRST robotics. Check out regional event this year and talk to some of the students, a huge majority of them will tell you that because of FIRST they intend to persue a carrer in engineering.
Check what people are working on at chiefdelphi, the environment there is very much like what the students are like at their schools. They ask questions, chat with each other, have fun, and mentors offer guidance for some of the tougher problems.
I'd recommend Atmel AVRs without a moment's hesitation.
The PIC and 8051 grew from architectures that were considered spartan and stripped to the bone a generation ago, and got a foothold only because (compared the "real" CPUs) they were somewhat affordable. They've matured, of course... but people who start on PICs almost inevitably get saddled with all the legacy baggage. In contrast, people whose first exposure is to Atmel or Motorola take one look at the PIC's legacy stuff, say "eeeewwww!", skip the first 20 chapters of the book, and go right to the good (modern) stuff.
The Motorola/Freescale MCUs are powerful, but they're NOT for newbies.
The nice thing about AVRs is that they're fairly robust and hard to permanently kill. I've abused AVRs pretty badly, and I've NEVER had one permanently die on me. There were a few I'd thought were dead, but ultimately they were all resurrected via high-voltage programming or by supplying an external clock signal to them. I've grossly exceeded the i/o pins' current-draw capabilities, connected power backwards, created pin-to-pin shorts, and still lived to tell about it. From what I've read, other platforms aren't quite as forgiving and wantonly abusable as AVRs. I know people who've driven 5v-relays straight from AVR i/o pins.
AVRs also have a great resource -- avrfreaks.net
AVR development tools are fairly cheap. An ISP-only programmer costs around $30-35. The Dragon costs $50, but adds support for high-voltage programming (handy for fixing messed up fusebits and reviving chips that otherwise appear to be dead) and Debugwire (think of it as single-wire JTAG for debugging). Unless you actually care about compatibility with Atmel's old chips, I'd recommend a Dragon over the STK500, if only for the Dragon's Debugwire capabilities.
AVR Studio is a free IDE (Windows only, though... but I think there's a Linux alternative) that natively supports assembly, but also integrates seamlessly with WinAVR for C/C99/C++ (of the 3, C99 is the one I find the most useful... it basically gives you the linguistic niceties of C++, like parametric polymorphism, without the huge libraries and resource requirements normally required for full-blown C++).
One major tip: if you want to use C (or eventually C99 or C++), buy John Pardue's book ("C Programming for Microcontrollers) and a Butterfly. He sells it directly from his website (smileymicros.com) for less than it costs from Amazon, and you can pick up the relevant hardware from him for less than you'd spend buying it all from Digikey. No, it's not the greatest book on C programming ever written... but it's the single best book you can get for learning C as it applies to AVR microcontrollers. Remember, 99% of C is learning how to use its libraries. Let's just say that time spent learning to use stdio in a generic C programming book isn't going to do much for your AVR programming skills...
Architecturally, AVRs are fairly well-behaved. The biggest problem I've had is the fact that they're SO well-behaved, it's easy to get a false sense of security and overlook details that are different between them. Unfortunately, Atmel's datasheets seem to have the same general editorial philosophy as the first O'Reilly books (say it once, never repeat anything, and bury important details in the middle of otherwise nondescript paragraphs on page 183, without so much as a gray box or sidebar to call attention to it). However, everyone at avrfreaks.net is painfully aware of those documentation shortcomings, and when somebody gets snared by one of them, someone else usually notices within 5 minutes, sighs, yawns, and politely points them in the right direction. It's exceptionally rare for anyone to get flamed.
As far as robots go, AVRs definitely seem to be just about everyone's favorite 8-bit processor. 6809s are popular with some more advanced users (though many of them freely admit that they aren't quite sure why they used a 6809 instead of an AVR), and the 68332 is a longtime favorite at the high en
That's no lightweight system, and it comes with a serious set of development tools who's big brother version is used in the real world.
p p/14149.html
Looks like they offer an educational version too:
http://www.arm.com/markets/embedded_solutions/arm
Bavarian Purity Law of Rice Krispie Squares: Rice Krispies, Marshmallows, Butter, Vanilla.
That's about the worst advice one can give IMO. Most of these MCUs programmed with basic are much more expensive than the other MCUs. And the memory fills all too quickly (as if it's not bad enough using C). And they're usually pretty slow. In think those 3 points kinda defeats the whole point of using MCUs in the first place. And if they're ever going to use 'em for anything (beyond this basic class), it's NOT going to be using basic anyways (makes me shudder just as much as the thought of teaching VB to people wanting to learn programming).
What to use? There's lots of good stuff out there, but my favorite: Atmel AVR MCUs. Used with AVR Studio, WinAVR and a port of GCC/LibC - good dev environment for 0$ (there are free linux tools too). Works great. Simple to use. Inexpensive. Wide range of devices. You can use any other text editor you so please. There's tons of other compilers for it (like IAR). Mature tools. Lots of great docs on atmel's site. Very good communities like avrfreaks. Programmed using one of the 2 languages everybody else uses (C, or the specific MCU's assembly) Making programmers for the chips is trivial and inexpensive. There's tons of good and inexpensive development boards out there (atmels' and 3rd party). The only thing I can think of that makes me still consider the others is the new ICE MkII that's required if you want to use debugwire on some of the new tiny MCUs (expensive).
In second choice, I'd pick Microchip PICs, but there are lots of other alternatives like the 8051 and 68HC11 based ones. I'd pick Basic Stamp stuff dead last.
Amazing. He asks for a high-school level system and most of you guys are reccomending systems that require makefiles, compilers, linking, programmers, $50 Stamp chips and a truckload of groundwork before you even get to flash a LED.
The guy who reccomended PicAxes is right on the money. I know they arent that well known in America yet, but even experienced Micro Gurus would do well to check them out. $5 chips that a 12yo can program in basic with flowcharts with 3 wires connected to a serial port.
Inbuilt routines for Infrared, Radio Control Servo inputs and outputs, hardware PWM's, A/D converters, Motor Control, you name they've got it.
I can program Pics, AVR's, and nearly every 8 bit micro starting from 6502, 6809 and z80 days onwards, and I still reach for a PicAxe when I want to get something happening quickly and easily. I know about the mother duck principle, but believe me Microcode Gurus, have a look at these things. They have been called the "555 timer of the new millenium" and its very true.
To flash an LED -
DO
TOGGLE 1
PAUSE 100
LOOP
thats it !
no header files, no definitions, no compiling, linking, hex files. type that in, plug it in, push program, and you are away
Check them out, they rock.
http://en.wikipedia.org/wiki/Picaxe
Good info on the AVR series. I have had similar positive experiences with the AVR microcontrollers and community.
Georgia institute of Technology is playing around with some robotics (made by Microsoft :( ) for their introduction to Computer Science class. These robots will probably be simple enough for your class, but more advanced than legos. while I hate (really hate) to be an add for Microsoft, here are the links to the info
http://www.microsoft.com/presspass/press/2006/jul0 6/07-12PersonalRobotsEducationPR.mspx
http://www.roboteducation.org/
this program is just starting up, but you should keep an eye on it. If microsoft doesn't screw this up, then this will probibly be helpful to you.
as far as cheep goes, i can't tell you how good this will be. (crazy thought) you might be able to contact m$ and they may be interested in starting something like this in the high schools. so they might have money set aside just for that. you might get lucky. I doubt it, but you might. there is no harm in trying.
good luck, i hope this helps.
Since if you want to do everything from the ground up (understanding of servos, of the electronics involved to run said servos, actually building the electronics, etc), I think that a Z80 would be a rather good choice.
;) I never bothered putting in safeties, if I blew a Z80 I'd just plug in a new one.
They're very cheap, very useful little toys, and no need for complex electronics either, generally no need for buffer structures, has its own ram refresh, you can just plug in an eprom pretty much without a problem, build the whole thing on standard experimental PCB, and has a very simple straightforward assembly language with direct IN/OUT which can drive a lot of commonly available ICs for servo control, light control, sensor control, etc.
The cheap factor is kinda handy
Coz eternity my friend, is a long *ing time.
I'll plug the guys I know: http://digilentinc.com/
I've worked with a handful of their boards and they are pretty nice. These guys exist to serve the academic market and even take a hit on some of the boards they sell at academic pricing. If you work with them, tell them the WSU LUG sent you.
IMHO, although I am not that much fond of their architecture, PICs are as scalable as you can get, from tiny little 5-pin SOT mites to serious high pin count have-it-alls.
Just make sure you jump them on time when scale (functional, software complexity) grows too big, as they don't agree quite well with mainstream computer science paradigms, by which I mean: "no hardware supported general purpose stack in RAM".
However, that probably will never be a problem for high school simple robotics projects.
Zilog has a nice range of chips with a very good amount of peripherals built in. Their development environment is very nice for stepping through and debugging code. Pity it is only for windows, and their really could be more sample code out there.
And they run plenty of competitions with circuit cellar, so you can often get free devel kits.
You are absolutely right about the advantages of having pre-made educational resources. The situation is quite different depending on whether all the students are doing an activity or if just one or two of them are doing it as an activity. A single student or small group can be very motivated and can cope with almost anything. If you've got a whole class, you need something pretty bullet-proof.
Having said the above, I have a student using an Arduino. He has already used other standalone chips but finds the Arduino much easier to deal with. It uses an AVR Atmel chip which seems to be the favorite among the other posters. It is cheap, is already connected to your computer and doesn't need an extra chip burner. It is designed as a multi-media interface and they've worked out connections to a wide variety of multi-media and web enabled programs. It really is excellent as a controller for robotics projects.
Go with Parallax. You arent looking to turn them into industry geniuses in your class, so get them excited about it by using a parallax basic stamp. There are tons of code examples on thier site as well.
Maybe introduce them to others at the end of the class year, like the AVR/PIC/Renesas micros.
100% agree. Microchip's products are really great as they do a range of devices from cheap and simple devices up to quite complex ones. They are fun to use and quick to learn - sure, in the real world, high level languages like Java are desired by employers, but these are so abstract that you don't get a feel for the actual workings of the computer. Its vital that people understand how the actual machine works, and there's nothing like a bit of assembler and some flashing LEDs and push buttons to do this.
The Vex robotics kit (from IFI, the folks behind First Robotics) is geared towards what you're talking about.
It can even be programmed visually, in "Easy-C". This lets people drag and drop into a visual editor, essentially making a flow chart. It displays the generated C code.
When you tire of that, you can program it in C using the MPLAB compiler (and possibly others).
I, too, would recommend First Robotics (www.usfirst.org) as well as the Best robotics competition, which has a lower cost of entry, but no programming to my knowledge. http://www.bestinc.org/
ttyl,
--buddy
I teach my 11 year old daughter with an Oopic controller. It's simple, programmable in BASIC, Java, or C++. It's simple and fairly easy for her to understand. It's also affordable!
Here's the website: http://oopic.com/
Keith
Support bacteria. They're the only culture some people have.
When I went to high school, we played with a Lego 'Dacta' system. It seems more than sufficient - I have fond memories of a 'gun' we made that would only shoot blue pieces, and only a distance of about a foot. ;) I can't see why a Mindstorms kit isn't good enough for education.
But anyway, if you're doing microcontroller level education... Parallax BASIC STAMP.
They're ridiculously expensive for their capabilities, they have nowhere near as much I/O as your standard AVR or PIC chip... but they're probably the best thing on earth for educational use because they're ridiculously easy to work with and program. You can easily explain BASIC to kids on a chalkboard. "int main(void)", not so much. Assembly code? completely forget it.
http://www.ti.com/corp/docs/landing/ez430tool/inde x.htm?DCMP=430Day&HQS=Other+OT+ez430
No first hand experience.
We use the Handyboard http://handyboard.com/ which is kinda old-tech with a Motorola 68HC11, but is very beginner friendly. There is a free C compiler available http://www.botball.org/educational-resources/ic.ph p that is also very easy to use. With the expansion board there are many interfaces: analog inputs, digital in/out, sonar, motor drivers, servos, LCD screen.
Man, thank you very much, following your links I found out that I have a PICAXE distributor here in my country, actually an online electronics store I didn't know about.
Great. Now are there any kits for learning ladder logic on a budget?
I've used both. The comments about the Microchip PIC (on which the Stamp is based) are correct - but it is a super simple place to start. Your students will be writing BASIC programs in no time and starting to learn the beginning ins and outs of microcontrollers. There are also a lot of robot kits available from Parallax and others.
But, for more capability and for your more advanced students, definitely go AVR. The Butterfly demo board allows a lot of extra capability with the LCD display already built in.
Might also look at Nuts & Volts magazine. Lots of ideas, resources, etc.
For high school kids?
I think something like a Basic Stamp would be a better fit. You're not gonna have time to teach these kids Assembly Language or C programming AND still have time left over so that they can do something useful with it. I think you'd want to them over the hurdle of learning to program as quickly as possible so that they can move onto the fun stuff: making robots that can move, make decisions, sense their environment, etc.
I think learning BASIC would be much easier. It's what we learned in 7th & 8th grade.
We had 68HC11 Heathkit trainers in an advanced digital electronics class taught at the High School level. It took us a long time to learn to do even trivial things in assembly on those things, and we met for 10 hours per week. (Two 5 hour days).
Opinions expressed are my own and not necessarily those of my employer.
What are you trying to teach the students? If you get a bare microcontroller like a PIC then you quickly have to spend a lot of time teaching electronics so that the students know how to properly connect hardware to collect sensor data and drive motors. You end up explaining different communications protocols (what is this RS232-TTL chip for, what is SPI and I2C, etc.) which may or may not be the purpose of the class. If the purpose is to "build a robot that does task x" then you're better off getting a kit of some sort that has some built-in interfaces for sensor inputs and motor outputs. I've had many years of experience with the Handyboard and must suggest it has a good choice, though $200-250 may be a bit pricey to get started. Oregon State and Atmel have teamed up to produce a system for their EE curriculum that looks promising, though you would have to get in contact with them to see how you might be able to purchase their boards in bulk (they have a website you can order some parts from, base kit is $105). If you want to teach "this is how you program a robot" then you can pick up any programmable robotics set and get going quickly. For younger students that haven't programmed before something more graphical may be better for them (Mindstorms for example, though you don't seem to want this sort of thing). Any way you go you'll probably end up teaching teamwork skills (and you should probably throw in some documentation skills also). There is a freshman program developed around the Handyboard that teaches such skills at Ohio State (dislaimer: I was a TA for this program) which has quite a few materials you may find useful. In summary, make sure you decide on your curriculm, then pick a controller that best fits into both that and your budget.
I would advise that YOU get a design to that level before you present it to the students. The interested students can always "work backwards" if they are interested in that stuff, or build onto the framework to do actual robotics. (An interesting excercise might be to change the DAC chip to another manufacturer, and have them work out the code changes needed to make it work.)
Some advice on a reference framework - put in a timing loop (so they can count seconds), put in some diagnostic LEDs (one just on the power bus, some to blink to make sure the software loop is still running, maybe two or three more for general debugging). The idea is to provide useful tools. Stay away from interrupts in the code at all costs (it just adds complication, and you almost certainly don't need the response time).
As for which particular chip to use, you want something with free software tools, reasonable chip cost, and low hardware costs. The AVR is good on this front (programmer is $70, software tools are free). A nice bootloader is available at http://reza.net/avr/, although you can always use the programmer. You are stuck with C, which I like, but I don't have enough experience with high school kids (it's been a long time for me) to know if that's the best choice.
It's not wasting time, I'm educating myself.
I own an arduino http://www.arduino.cc/ it is a development board based on the AVR. The AVR has a boot loader and interact with the computer over USB. The IDE is a c++-like language, but it hides all the obscure stuff, you define the pins, and use them. Very easy and simple to use.
On the roboteducation.org website they also offer a way to set up a robot using Myro (My Robotics) [http://www.roboteducation.org/guides.html] which is coded in Python, and runs on linux. I have used it with a Scribbler robot (scribblerrobot.com) and linux and it works well. Of course it does not really teach how to program a microcontroller as much as how to program a robot.
Accentuate the positive, don't waste your mod points on the negative.
If you really wanna dive into AVR programming, you could also check out the Arduino.
It uses an AVR for the controller and doesn't require a PIC programmer, connects over USB to the computer, has support for Windows, Linux and OSX, and comes ready for working when you get it. The only part that is kinda limiting to people unfamiliar with programming is that it uses C++ as the language, but has a very simple instruction set, so the learning curve may be slightly steep for beginner programmers.
...spike
Ewwwwww, coconut...
If you're interested in a whole curriculum out of the box, then CMU's Robotics Academy might be something worth checking out.
The lesson plans involve either the LEGO NXT robotics kits, or the VEX robotics kits, and have been under development and used by school for several years now.
I like the little 8051 chips from Silicon Labs http://www.silabs.com./ A good variety of diffrent 8051 chips with various perpherials. Dev kits for only $100 comes with an eval Keil C compiler but you can download SDCC http://sdcc.sourceforge.net/ that will integrate with the IDE.
Mindstorms is just as flexible and scalable as any micro controller, and you don't have to worry your students with learning low level C/C++. Even if you do find libraries for the controller you use, you still have no choice but to use C. At least with Mindstorms, your students can use a drag and drop GUI, or if they so choose, any number of high level languages, including C, C++, Java, and if they're really daring, assembly. Hardware debugging is much less painful (actually, almost eliminated), and the experience may be seen as more enjoyable by the students. The only time I would go with something other than Mindstorms is if you find a fully developed board with quick and easy peripheral connectors. Getting your students to wire up everything to a breadboard probably isn't all that desirable. In most cases, you'll probably still have to develop the libraries for any peripherals that you'll use. Unless your students are much more capable than what I give them credit for, stick them with something that they can actually master in 5 months.
http://sparkfun.com/ is the USA distributor. I also highly recommend this platform... it's awesome.
I make these: http://beatseqr.com
Maybe you should look into getting the TAB "Build your own robot" or "Build your own sumobot" kits.
The bots are BASIC Stamp based, come with software for programming them, and the only thing needed to program one is a serial cable. They are expandable, fairly durable, easy to put together, cheaper than many of the other options I have seen on here, and the programs can be tried out immediately.
There is no "-1 offended" or "-1 you don't agree with me" mod options for a reason.
I used the Parallax basic stamp to teach several robotics classes for high-school students about 9 to 6 years ago and was disappointed in it's very limited basic.
As I remember, Parallax basic only allowed for "if then goto ", and not "if then else ". Further, you could only travel about 4 gosubs deep in the stack. I don't know if this has changed.
Then I found the BasicX 24 pin stamp, which is pin for pin compatible to the parallax basic stamp.
The cost for one was about the same as the Parallax, but BasicX offered better volume discounts.
The BasicX programming language was modelled after Visual basic, meaning you could have functions, arrays, and even interrupts.
My first post-"hello world" program was to use interrupts to blink two lights on the chip. One interval was 3.14159 seconds, the other was 2.71828 seconds. I remember the code being fairly easy to write. Unfortunately, I never taught the high school class again to see how the students latched on. Instead I moved onto finishing my graduate degree, but this chip still sticks in my head.
I strongly recommend looking at www.basicx.com before designing a curriculum.
You immediately rule out Legos, and that may not be appropriate.
I would agree that depending on the class level, the RCS programming may be overly simplistic. But by no means is RCS the only way to program the Lego Mindstorms. A quick peek at Google and you'll see things like NQC, a Lego Mindstorm with Linux Mini-HowTo, and a whole wealth of free stuff that keeps the Mindstorm relevant to a more experienced class level.
The other nice thing about Mindstorms is that you can do things physical, not just things that you can see (LEDs, meters) or hear, and it's well integrated so you're fighting the task at hand, and not fighting making an ad-hoc collection of parts work together. (Though there is definitely value in the latter, it just depends on where you want to put the emphasis.)
Heck, you can even find hits searching on "mindstorm" and "gentoo". Emerge THAT!
The living have better things to do than to continue hating the dead.
--dave (With apologiis to Donald Knuth) c-b
davecb@spamcop.net
The BEST simple cpu was used at OSU's EE dept: the Moto 6809!
It is clean "orthogonal", exhibits modern addressing modes, has 2 tandem 8-b accumulators for 16-b ops. Software: Microware's OS9, Flex, out there. AND the BEST TEXT ever is Programming the 6809, Sybex Zaks.
FPGAs can make a 6809 uController. See OpenCores.org.
Or just buy an Atmel Butterfly, a $20 demo w an ATmega169, RAM, I/O. LCD, etc.
But PICs are not RISC but LISC (Lobotomized Instr.Set).
The BEST simple cpu was used at OSU's EE dept: the Moto 6809!
It is clean "orthogonal", exhibits modern addressing modes, has 2 tandem 8-b accumulators for 16-b ops.
REsources. Software: Microware's OS9, Flex, out there. AND the BEST TEXT ever is Programming the 6809, Sybex Zaks.
FPGAs can make a 6809 uController. See OpenCores.
Or just buy an Atmel Butterfly, a $20 demo w an ATmega169, RAM, I/O. LCD, etc.
But PICs are not RISC but LISC (Lobotomized Instr.Set).
There are a few handy chips off the top of my head:
The various PIC chips may be worthwhile, but probably not what you really want. A classic example is the Zilog Z80 (http://www.zilog.com/products/businessline.asp?bl =273) which offers some development boards, but is probably a bit expensive for this budget. The Motorola HC11, however, is probably perfect. There are dozens of vendors who offer various educational and prototyping boards. There is also vast amounts of information about such things and ample source samples and course materials involving it(for example http://www.coe.montana.edu/ee/cady/ee361/hc11lnks. htm).
Several people have mentioned the Atmel AVR's, and I can't fault them. But don't overlook the 8051 derivatives. Atmel makes a nice line, as does Silabs, NXP and Dallas. One in particular is worth mention. The Atmel AT89C51ED2. It has 64k of flash, 2k EEPROM, and 1.7k of internal XRAM, and a bunch of useful extensions like SPI etc...
The real trick is, it has a bootloader ROM. You hold reset high, and pulse PSEN (from memory, check the Datasheet), and it starts a bootloader. You can do this with a couple push buttons. You then program it via the UART. That chip, a MAX232 and a xtal is all you need. Intel's MCS-51 BASIC is available from numerous sites, and will run entirely internal on the chip. When you outgrow that, you have 64k of flash, and enough XRAM to code in C (go find SDCC on sourceforge).
The AVR is nice, but single source, and for some reason, they don't make a version with a factory bootloader. The single source doesn't sound like a problem... until you go look at Silabs, Dallas, and NXP's offerings!
The old dog has learned some new tricks.
First off, I'd dump any mention of 68hc08, 68hc11, 8051, z80, etc. There are more of those doing more than you would ever believe out there in the world, but it's like suggesting that someone learn GUI programming by giving them an 8086 with dual floppy drives and 256K of memory, and a copy of Windows 1.0. Time has passed them by; learning the quirks and tricks necessary to get them running happily is more an exercise in dedication in the modern world than any way to learn modern processing./ edu_base.php LPC2148 Education board on my desk at the moment. It's a bit pricey at 99 EU, but without all the motors, LCD and LED displays you can get the basic board http://www.embeddedartists.com/products/boards/lpc 2148.php a bit cheaper.
/frank
As a professional embedded programmer, I'm quite surprised by the number of recommendations for the AVR in this thread. I've never used it, but I may have to look into it. Quite a rabid following there.
I would recommend getting into ARM. In the professional world, they have pretty much taken over the middle ground of 30-200 MHz 32-bit processors, especially in the custom-chip arena.
With the NXP (nee Philips) LPC versions, you can have a 256KB FLASH/32KB RAM device with a USB port and a million on-board peripherals for the cost of a $10 chip (Digi-key quantity 1), a PCB, and a crystal. Pre-built development boards are a dime a dozen; I'm partial to the http://www.embeddedartists.com/ boards, and happen to have their http://www.embeddedartists.com/products/education
ARMS are extremely well supported by the excellent GNUARM toolset (http://www.gnuarm.com/), giving you a completely free C/C++/Assembly toolset, and there are a huge number of sample programs available from Embedded Artists, Keil, Olimex, etc., for doing almost anything you might want.
Why teach them about code pages, completely screwey function call mechanics, 256 byte jumps, limited capability C libraries, etc., when they could be learning about putting their name on the display, spinning a motor, playing a tune, and shipping data up to a PC over USB?
And the worms ate into his brain.
I just taught a C programming class using the ADuC microcontroller from Analog Devices. ARM based device with ADCs, DACs, and a bunch of digital IO, plus the software, and you can get it all for about 20 bucks.
"Jesus Christ, when is "wants" ever apostrophized (apostropheed?)?)"
:-0
/spiel
Only on slasdot are dumb typos apostle-ized.
You isensitive clod, no wonder you chose AC. I am the victim of a short lived "teaching revolution" in late 60's - early 70's, spelling and punctuation were ignored in favour of "raw expressiveness", I think it had something to do with the technology buzz over the space race. Anyhow, I realise it's a dumb typo but unfortunately my brain is now hard-wired in a way that does not see many of it's own typo's. People ten years younger often suffer from poor multiplication skills (the teaching theory was "multiplication is simply route memory for fast addition, therfore it's not maths"). I think that had something to do with the subsequent space race apathy. The best way to educate your kids, is to educate yourself.
Thankfull the email system at work has a spiel chucker on it.
And did you exchange a walk on part in the war for a lead role in a cage? - Pink Floyd.