|
Intro to Physical Computing Syllabus code, circuits, & construction
|
Microcontrollers |
|||
| A microcontroller is a small, inexpensive computer, usually used for sensing input from the real world and controlling devices based on that input. Most electronic devices you use today have a microcontroller in them of some form or another. Microcontrollers are easy to use with simple sensors and output devices, and they can communicate with desktop computers fairly simply as well. When you're building some form of customized sensor or output device, using a microcontroller is an excellent way to separate the customized part of your project from the part that's best done on a desktop computer. They're also very useful for when you're designing a simple interactive device that doesn't need the full power of a desktop computer, but does need to be smaller or cheaper. | See also Dan O'Sullivan's notes on microcontrollers. My notes draw heavily from Dan's. |
|||
| There are several different levels of microcontrollers and microcontroller systems. Some are very small, chip-size devices, to which you have to connect your own electronics. Others are larger, composed of several components and ports for input output, ready to plug right into other devices.
Higher level microcontrollers will have a simple hardware interface to other devices (usually a plug or a couple of wires), and a simpler programming language, if at all. They will also usually be the most expensive of microcontrollers, because someone else has done the work for you. Lower level microcontrollers will require more work, both in terms of hardware connections (you will have to build your own circuits to interface them to other devices), and in terms of programming (you will need to use a lower level programming language like C or assembler). However, lower level processors are generally cheapest and most flexible in terms of what you can make them do. |
||||
| Some typical examples of microcontrollers at various levels:
High Level: Teleo What is it: a series of interface modules that allow the user to connect sensors, motors, lights, MIDI devices, and more with little or no electronics work. Programming language: Max/MSP. The modules themselves are pre-programmed, and speak a proprietary RS-485 serial protocol. They can be addressed via a series of objects for Cycling74's Max/MSP programming language. There is also a C++ software development kit for those who want to write their own PC programs to address the modules, but the modules themselves are not reprogrammable. Hardware interface: RS-485 serial protocol Cost: $199.00 for starter kit without Max/MSP. Additional modules are approx. $95.00. The Teleo starter set, pictured at right. Each module is approximately 3.0 inches by 3.5 inches in size. Middle Level: NetMedia's BX-24 Microcontroller module What is it: electronic module with microcontroller, power supply, serial interface, memory, input/output interface pins Programming Language: BX BASIC, very close to Visual Basic. Hardware Interface: simple digital and analog circuits interface to I/O pins. Cost: $50.00 Mid-level microcontrollers are usually programmed by connecting a serial cable from a PC on which the code is written to the microcontroller itself. Beyond that, no additional hardware is needed.
A variety of mid-level modules and low-level microcontrollers. Middle Level: Wiring and Arduino What is it: electronic module with microcontroller, power supply, USB-to-serial interface, input/output interface pins Programming Language: Wiring, a simpler variation on C that's very similar to Processing. Hardware Interface: simple digital and analog circuits interface to I/O pins. Cost: Wiring: $80.00. Arduino: $30.00. Both can be obtained from Sparkfun in the US. Like other mid-level microcontrollers, Wiring and Arduino connect directly to the programming computer. Unlike the others, though, they have a built-in USB-to-serial interface, so they connect right to your USB port. Beyond that, no additional hardware is needed. Both the software and hardware for Wiring and Arduno are open-source, with plans available online. So if you like working at a low level, you can use these as a bridge to get there. They're both based on the Atmel family of microcontrollers. Like any other computer, a microcontroller has to have input ports to detect action by a user, and output ports through which it expresses the results of its programs. The pins sticking out of the microcontrollers are the inputs and outputs. Other devices, like light, heat, or motion sensors, motors, lights, our sound devices, are attached to these pins to allow the microcontroller to be sensitive to the world and to express itself. Low Level: Microchip's PICMicro microcontroller What is it: Microcontroller chip Programming Language: Assembler, C, BASIC Hardware Interface: requires programmer to make power and timing circuitry in order to operate; thereafter, I/O circuits are similar to BX-24 and other middle and low-level circuits. Cost: $1.00 - $15.00 depending on model used. Lower level microcontrollers lack some of the basic circuitry of the mid-level modules. Notice, for example, that the PICs above is missing the clock crystal that the BX-24 above has (the long tube at the bottom of the BX-24). Likewise, some of the other chips, such as the voltage regulator, external EEPROM memory, and serial port buffer, are also missing. These must be added by the user if they're needed. Lower level microcontrollers typically require an external hardware programmer in order to be programmed. Typically, the programmer is attached to the PC via a serial, parallel, or USB cable, and the microcontroller is placed in the programmer to re-program it. Some programmers have cables to allow them to connect to the circuit in which the microcontroller is embedded in order to reprogram it. This is called in-circuit programming. |
||||
| Things to consider when picking a microcontroller:
Costs
Time
Expandability/Compatibility
Physical and Electrical Characteristics
|
||||
| The Economics of Microcontroller Development
One of the first questions that people usually ask when they learn that low-level and mid-level controllers can do many of the same things is, why the difference in cost? Why does a BX-24 or a Basic Stamp cost $50 and up, while a PIC or an SX micro costs less than $10? Furthermore, why are mid-level controllers' development software free, while the software for low-level controllers is not? The answer, as you might expect, lies in the aims of the people selling them. Companies that make mid-level microcontroller modules (NetMedia for the BX-24, Parallax for the Basic Stamp, Basic Micro for the Basic Atomm) are in the hardware business. They make their money by selling you modules. They typically serve a fairly low-volume customer who buys sometimes one, sometimes a dozen, but seldom more than a hundred modules at a time. In order to keep that customer coming back, they also develop proprietary development environments, so that you can't reprogram their modules with the other guy's software. However, so you won't get upset about that, they give it away for free. It's their belief that the unique combination of microcontroller, supporting circuitry, and development environment that they offer makes for the best way to use microcontrollers, and it's worth a premium price. For beginners, they're often right. Companies that make low-level controllers, on the other hand (Microchip, Atmel, Ubicom), are used to selling in very high volumes. They sell controllers to major manufacturers who put them in things like cars, toys, light switches, microwave ovens, and more. Their customers need to shave off every spare expense in order to make a profit on the end product. These customers willing to train engineers in low-level coding, to develop their own software tools, and so forth, in order to get a high-volume, low-cost chip. In fact, the low-level processors are the hearts of the mid-level processors. Check out the big chip on a Basic Stamp 2; it's a PIC. Low-level manufacturers don't spend a lot of time making development environments, so they can specialize on making a wide variety of good chips. They're used to dealing in such large volumes, in fact, that a few chips more or less is no big deal. Most of them even offer a limited number of free samples on their websites, for prospective customers. So what if you're a beginner or small guy who wants to use low-level chips? You probably don't have the time or expertise to develop your own compiler for it, and you'd rather not have to use the assembly language of the controller, if you can avoid it. This is where third-party software developers come in. Companies like CCS, Microengineering Labs, Crownhilll, Hi-Tech, and others make and sell custom higher-level development environments for low-level controllers. They're in the software business. Because the profit margin on low-level controllers is already so low, they choose not to develop extra hardware to sell you premium hardware, but instead, they make really good software tools so that it's easy for you to program the low-level controllers. Many of them also make custom hardware programmers, that make it easier on the hardware end too. So where does this leave you, the hobbyist or beginner with microcontrollers? What should you choose? Using mid-level microcontrollers will cost you relatively little up front, in terms of peripherals. The software's free, and a serial cable is about $5.00. The various components you'll need to make a typical project will run you $50 - $75, maybe. The microcontroller will run you another $50. If you know your way around a circuit, and you're reasonably sure you won't destroy your microcontroller, this isn't a bad way to go. You can always keep the project intact and re-use the microcontroller for other projects. You'll save yourself time not having to learn how a hardware programmer works, or which compiler to choose, or how to configure it. For the beginner seeking immediate gratification, mid-level is the way to go. The only downside is that if you want to build many more projects, you've got that $50 cost on top of any other project costs each time. And if you damage the microcontroller, there's another $50. And another and another, until you learn to be careful with your circuits. Using low-level controllers, on the other hand, is more of a hassle up front. You've got to choose a development environment and pay for it, choose a hardware programmer and pay for it, and learn to set all the stuff up. For a decent compiler and a decent but cheap programmer, you'll probably shell out about $300.00. You'll spend a lot of time early on cursing and wishing you'd bought a Basic Stamp 2, or a BX-24. The advantage comes a bit later on, once everything's set up and you begin making projects. First, if you fry the chip, you're only out a few dollars to replace it. It gets better the longer you continue making microcontroller projects. You don't have to spend more money on the development environment, and the chips are cheap. If you can work a bit for gratification, and you're in for the long haul, it's a good way to go. Open-source mid-level tools like Wiring and Arduino are really promising because they combine the best of both worlds. They let you learn at a mid or high level, then when you know what you're doing, you can take the low-level guts of the device (an Atmel controller, in the case of these two tools) and gain the cost benefits of working low level. There are more hybrid open-source projects like this coming online all the time. A number of them were presented at the Sketching in Hardware workshop in 2006, and resource links were gathered online at that link, if you'd like to learn more. |
||||
