views:

1446

answers:

13

I've experience in doing desktop and web programming for a few years. I would like to move onto doing some embed system programming. After asking the initial question, I wonder which hardware / software IDE should I start on...

Or... doesn't matter?

Which development platform is the easiest to learn and program in (take in consideration of IDE usability)?

Which one is the easiest to debug if something goes wrong?

My goal is to learn about "how IO ports work, memory limitations/requirements incl. possibly paging, interrupt service routines." Is it better to learn one that I'll use later on, or the high level concept should carry over to most micro-controllers?

Thanks!

update: how is this dev kit for a start? Comment? suggestion?

+5  A: 

Given that you already have programming experience, you might want to consider getting an Arduino and wiping out the firmware to do your own stuff with AVR Studio + WinAVR. The Arduino gives you a good starting point in understanding the electronics side of it. Taking out the Arduino bootloader would give you better access to the Atmel's innards.

To get at the goals you're setting out, I would also recommend exploring desktop computers more deeply through x86 programming. You might build an x86 operating system kernel, for instance.

Brian
wiping out firmware = de-Arduino? cool, never thought of that.Your advice of learning those concepts in x86 first is because.. the development cycle is much shorter and easier to debug? Please give me some more details on how to learn C kernel programming and how I can apply that knowledge to microcontroller programming later on. I thought they're complete different subjects..Thanks.
Henry
Mostly because the x86 is extremely well documented. It's also easier to see what you're doing. Plus you already have one. Much of the conceptual stuff related to microcontrollers also applies to low-level stuff on a desktop computer. You can read some details here: http://www.osdever.net/bkerndev/index.php?the_id=90 and there's a cookbook-style tutorial here: http://www.jamesmolloy.co.uk/tutorial_html/index.html.
Brian
Thx for the advice, but I think I shall go straight to programming the mcu in C. Which AVR dev kit would u recommend? Would like to try AVR Studio / WinAVR controlling some LED / control, speaker, mortor, or whatever interesting. Thanks.
Henry
If you know some basic electronics you don't even need a dev kit for AVR, it is very easy to set up on a breadboard. It then suffices to get a programmer.
starblue
+10  A: 

Personally, I'd recommend an ARM Cortex-M3 based microcontroller. The higher-power ARM cores are extremely popular, and these low-power versions could very well take off in a space that is still littered with proprietary 8/16-bit cores. Here is a recent article on the subject: The ARM Cortex-M3 and the convergence of the MCU market.

The Arduino is very popular for hobbyist. Atmel's peripheral library is fairly common across processor types. So, it would smooth a later transition from an AVR to an ARM.

I don't mean to claim that an ARM is better than an AVR or any other core. Choosing an MCU for a commercial product usually comes down to peripherals and price, followed by existing code base and development tools. Besides, microcontrollers are general much much simpler than a desktop PC. So, it's really not that hard to move form one to another after you get the hang of it.

Also, look into FreeRTOS if you are interested in real-time operating system (RTOS) development. It's open source and contains a nice walk through of what an RTOS is and how they have implemented one. In fact, their walk-through example even targets an AVR.


Development tools for embedded systems can be very expensive. However, there are often open source alternatives for the more open cores like ARM and AVR. For example, see the WinARM and WinAVR projects.

Those tool-chains are based on GCC and are thus also available (and easier to use IMHO) on non-Windows platforms. If you are familiar with using GCC, then you know that there are an abundance of "IDE's" to suit your taste from EMACS and vi (my favorite) to Eclipse.

The commercial offerings can save you a lot of headaches getting setup. However, the choice of one will very much depend on your target hardware and budget. Also, Some hardware support direct USB debugging while others may require a pricey JTAG adapter.


Other Links:


Low-Cost Cortex-M3 Boards:

Judge Maygarden
Thank you for the link, that's indeed interesting, but I'm concern about the cost of the ARM based microcontroller. http://beagleboard.org/ seems like a good idea, but are all ARM based microcontroller/processor compatible with the same code ARM code? thx.
Henry
The beagle board uses an ARM Cortex-A8, which is *entirely* different than an ARM Cortex-M3. An A8 is 500+ MHz, has an MMU, FPU, and the beagle board has a couple hundred meg of RAM and an SD card slot for GBs of flash, and is designed to run an OS like linux. An M3 only goes to 72MHz, has tens of kB of RAM and 100s of kB of flash, and is a 'real' embedded system, with performance constraints that you need to learn about.
KeyserSoze
@Henry If you stick to portable C code and don't count vendor specific peripherals, then ARM based code is compatible. However, there are 3 variants of ARM assembly language. There is the original 32-bit version and the often optional 16-bit "Thumb" variant. The Cortex-M0/3 only have the new Thumb2 which is supposed to meet in the middle as far as execution speed versus code size.
Judge Maygarden
Is there a dev kit for ARM Cortex-M3? how much is ARM Cortex-M3 compare to a similar performance Atmel chip? thx.
Henry
@Henry Why don't you specify your desired budget and features (USB, LCD display, NAND flash, etc.) and then people can make detailed suggestions? I have Atmel and ST Cortex-M3 development boards that were in the $200-$300 range if I recall correctly. There are a lot of other providers as well (e.g. NXP, Toshiba, TI, etc.).
Judge Maygarden
@Henry I want to reiterated that I've heard nothing but good things about AVR microcontrollers as in the Arduino. It's just that I haven't personally used them. So, I can't expound on them as fully.
Judge Maygarden
I'm not sure about what feature I need yet, budget =< $200 is fine. I just want to get my feet wet on doing some embed programming in C/C++, and work with sensors, motor, and LCD display. Thanks!
Henry
Have you heard of Cortex Microcontroller Software Interface Standard http://www.onarm.com/ ? What is it and what does it bring to the table? Does it mean if my C code is using CMSIS, then it should work across all ARM based microcontroller? cool... abstraction is good..
Henry
Yes, I've worked with CMSIS recently with STM32 and SAM3U variants. It unifies the startup code and access to the built-in/core features of the Cortex-M3 like the lower-power modes and interrupt controller. All the other peripherals (SPI, ADC, UART, etc.) will still be vendor specific.
Judge Maygarden
with budget ~ $200, which dev kit should I get? Thx.
Henry
and.. under what situation do I need to use a RTOS? Thx.
Henry
@Henry An RTOS makes it much easier to respond to multiple, prioritized, asynchronous events. Even if that is the case, you have to weigh the extra memory and processing cost before deciding to use an RTOS over rolling your own scheduling solution.
Judge Maygarden
Re: Budget - Developer boards are expensive, since they sell in low qualities (one per developer). The chips themselves are surprisingly cheap if you buy them by the thousands.
doppelfish
Re: RTOS - Choose a board that runs linux. Use an RTOS only if you *must* meet realtime requirements. RTOSs tend to be somewhat bland and beasty, and it's hard to get them to run at all and to program against them without the support of the manufacturer can be time consuming.
doppelfish
@dopplefish I've had an excellent experience using FreeRTOS on both STM32 and SAM3U targets, but I'm used to running without an OS. Suggesting Linux for an AVR or an Cortex-M3 is not very practical.
Judge Maygarden
A: 

You might consider a RoBoard. Now, this board may not be what you are looking for in terms of a microcontroller, but it does have the advantage of being able to run Windows or DOS and thus you could use the Microsoft .NET or even C/C++ development tools to fiddle around with things like servos or sensors or even, what the heck, build a robot! It's actually kinda fun.

There's also the Axon II, which has the ATmega640 processor.

Either way, both boards should help you achieve your goal.

Sorry for the robotics focus, just something I'm interested in and thought it may help you too.

The RoBoard is just a small single-board computer. It won't him explore embedded system development per se.
Trent
@Trent - That's why I said it may not be what he's looking for, however, like I said he would still be able to control servos, sensors etc... Plus he could run Windows XP embedded...
+1  A: 

Whatever you do, make sure you get a good development environment. I am not a fan of Microchip's development tools even though I like their microcontrollers (I have been burned too many times by MPLAB + ICD, too much hassle and dysfunction). TI's 2800 series DSPs are pretty good and have an Eclipse-based C++ development environment which you can get into for < US$100 (get one of the "controlCARD"-based experimenter's kits like the one for the 28335) -- the debugger communications link is really solid; the IDE is good although I do occasionally crash it.

Somewhere out there are ICs and boards that are better; I'm not that familiar with the embedded microcontroller landscape, but I don't have much patience for poor IDEs with yet another software tool chain that I have to figure out how to get around all the bugs.

Jason S
I'll second that. Good development tools make a world of difference and are arguably more important than the microcontroller selection.
semaj
Yes, that's why I ask this question with IDE next to the ICs... :)
Henry
A side note to the PIC ICD situation, if you plan to muck around with the circuit at all or even leave the electronics exposed, pick up a spare PIC programmer, i've burnt a bunch of em, they have very poor protection against high voltage/shorts.
Mark
+4  A: 

I will second the ARM Cortex-M3 or even ARM7 based. Since you mentioned I/O, I suggest trying different vendors. Some vendors make you do read-modify-writes to registers to change output values, others make it simpler without the read-modify-write but that method has its cons as well. go to sparkfun.com and look through the development boards. Olimex (sold through sparkfun and others) have a wide variety of low cost eval boards, perfect for what you are doing.

I prefer the instruction set of the msp430 for learning assembler (some assembly is required if you really want to go embedded). Arm is a close second IMO. You can pick up an ez430 from ti for like 20 bucks or so, then for $10 more you can pick up three more msp430 boards. Unfortunately the AVR which is probably the most popular architecture for hobbyists (pic used to be) is a really ugly instruction set, you kinda have to use C to avoid it. Might as well go with something clean that is clean both in its instruction set which makes the compilers job a lot easier making the C result in cleaner code as well. both the msp430 and the arm family have gcc solutions as well as it is easy to use build and use llvm with its clang (llvm has a 64 bit problem with its gcc front end).

My bottom line is if you want to really learn about embedded and I/O and interrupts related to I/O. go to sparkfun grab a couple of $30 arm7s from lpc and st, and the stm32, go get something from stellaris, the 1968 or the 811 perhaps. An ez430 from ti (the stellaris family is now part of ti). Oh and back to sparkfun and grab an arduino mini, or lily pad one of the sub $20 but make sure to get the usb to serial thing that both powers it and gives you serial/debug access to to it. I was really really disappointed with the stm32 demo units from st or it was actually an rtos vendor. I am still very close to never buying from st again as a result.

EDIT

Wow I struck some nerves with my first answer. Probably strike some more with the edit.

There are a couple of ways to do it. One is the single register type thing. the read-modify-write solution. If you want to change one I/O output you need to read the register change the one bit that corresponds to the I/O pin (so that you dont change the other I/O pins) and write it back. This consumes instructions, which is bad for embedded, bulky and slow esp if you do it in a high level language. Another solution is tailored to bit banging. There is a register for setting I/O pins when you write to it you put a 1 in the location for the I/O pin or pins you want to set then you write, the bits you write zero will remain unchanged. And another register that when you write a 1 it clears the corresponding I/O pin. These are great for bit-banging. But bad if you dont know what the data value is. If you are taking some data from an input and just passing it on to the I/O pin then you have to do an if it is a one then write here else write there. Back to the bulky and slow. The point of my answer was that both of these solutions exist, some chips give you both, others have only one of the two solutions. It is a trade-off, and something worth experiencing, the vendors are different enough in this respect and others. Another example of differences among vendors and chips is some provide wire-or outputs and pull ups or no pull ups on the inputs which can make a difference if you have to start adding discrete parts for every I/O pin when you could have just chosen another vendor and saved everyone time and money. That kind of thing will make you unemployed quickly.

Cortex-M3, the choices I know of are the STM32 from ST which I would (did) buy from sparkfun. And the stellaris family formerly Luminary Micro, now owned by TI. I would avoid the 811 eval board, the clock was some number that was harder to find divisors for than the others. Also I bricked my first one within a few hours and had to order and wait for another. The others are less easy to brick. If you are careful with your IO enables and directions, and are just wanting to learn/play the 811 is fine. Hmm, did I just see that LPC has a cortex m3 now? If not they will, everyone in the arm business and some that are not will likely pick up the cortex-m3 for the embedded market. When you look at all the factors from tools, available programmers, cost per unit, cost for development, performance, power, etc, these things are hard to beat.

The cons to using the cortex-m3 vs arm7 based first is that with the arm7 you can learn the arm instruction set first then switch to the thumb subset. With the cortex-m3 all you have is thumb and thumb2. Also the interrupt vector table is goofy compared to normal arms. Not goofy as in bad or stupid but goofy as in different. Many would consider the ARM way as goofy, yes, understood and agree. the cortex-m3 is more of an exception to the arm family than the rule, so I would suggest learning it as your second or Nth ARM not your first. Here again, all good stuff worth learning of you want to know about this market and environment. The str711 board from olimex which you can get at sparkfun is a good one to start with. I think it was the sam7-64 that I spent more time on though. The LPCs are quite popular. sparkfun has a couple with the 9 pin serial port on boards so you dont have to add one.

Other than a few lines to boot the thing which many other people have already written, yes it is possible without using or learning ASM. I will touch more nerves with these statements but embedded means resource and performance limited so many traditional programming rules go out the door like not using globals for example. High level languages like C can become quite painful esp for bad instruction sets like the PIC. Because you are so close to the metal a noticeable amount of your code is not portable from one chip family to another or even within the same chip family some times. So using C for portability is not a valid argument. Most compilers are garbage, gcc for example is marginal (one size fits all fits no one by definition) at best. It depends on how much you want to control and how much you want to be a slave to others. By being interested in embedded systems to me means you want to be in control, that means understanding the vector table, knowing when and where and why your compiler is throwing away 50% or more of your performance, you could have made that remote control last longer with one battery instead of requiring three to just squeak by just by not knowing the tools and what they are doing. The vast majority of programmers in the world run their programs at half speed or less and double the size. Bulky and slow, just think of the electricity and storage savings. You normally dont see this on a desktop, but you will when you go embedded. Now saying that almost all of my code is in C, I normally only have a few lines of assembler to set the stack and boot and a few line functions here and there where the compiler will never compete or to cover problems that compilers tend to have.

I wanted an stm32, being at the time the only other cortex-m3. Wanted something to compare with the stellaris family. When they arrived I found that you had to live in their sandbox. I have zero use for the rtos, I want it removed and want to use my own bootloader and code. At least at the time that was an extra-cost item for something I had already paid twice as much as I normally would for competing products. So they are in their box, never to be reopened or used. Eventually to be tossed. Yes, half the problem was I didnt do enough research, I had assumed the boards were like other normal eval boards, this was a first time burn for me. Burn me once shame on you burn me twice shame on me. And it was the rtos vendor not ST that was the real culprit. So once the olimex stm32 board was available from sparkfun I bought one.

The arduino has this sandbox problem as well. So most of the searches you do looking for info will be within that sandbox. The difference is everything is open to view, the info is there if you want to do your own thing and have control of the board. The arduino is not as easy as the AVR butterfly for those that remember that platform.

The AVR butterfly and now the arduino is amazing in the sense of the followers it has drawn. Perhaps Atmel is just more user friendly as a company to overcome the instruction set and tools. They dont limit themselves to the AVR BTW they also have an ARM line and probably more stuff, I have not looked in a while. You definitely wont need stackoverflow for help if you go with an arduino. And you wont need any assembler if you dont want. And with sparkfun's arduino mini or lillypad the cost to play is next to nothing.

I think they could do soo much more with the msp430. Sure they have this uber low power market they want to hit. But the instruction set had this feeling of the pdp-11 when I first saw it. Very clean, I recommend the msp430 first for those wanting to learn assembly, then switch to ARM, by then you will see that all assembly languages are just syntax as far as learning. Performance and pain and other things are another story of course. I think they could easily expand the speed of the msp430 and allow for more use of the address space. I have spent some time recently fiddling with an opencore msp430 which you could put in an fpga and get more memory and speed and features if you like, could even add usb if you wanted. Not in a super low power package of course. I also dabbled in writing my own msp430 clone just to learn a little hdl, didnt finish it but had some fun.

dwelch
@dwelch Out of curiosity, what problems did you have with the STM32?
Judge Maygarden
I love the low-power modes of the MSP430. It can wake up from any interrupt, which makes them a breeze to use as compared to many of the Cortex-M3's. Unfortunately, they still haven't integrated USB as far as I know. We have to use an external UART-to-USB bridge on our MSP430-based devices.
Judge Maygarden
Thanks, but is it possible to learn without ASM? I don't want to go that low-level, since I'm used to doing high level programming/scripting.
Henry
possible to learn without ASM: absolutely! you can do almost anything in C/C++. You do have to learn how to specify interrupts, and how to access the device's peripheral registers.
Jason S
How to pick a vendor? Interested in ARM Cortex-M3.
Henry
Regarding read-modify-write, Cortex M3's bit-banding feature, makes that unnecessary for single bit writes.
Clifford
What's wrong with read-modify-writes? What's the other way? How is it better than read-modify-writes?
Henry
Note: the feb 2010 issue of circuit cellar has an article on the cortex-m3. Says there are 6 vendors. Also note NXP is the company that makes the LPC parts.
dwelch
wow dwelch, thanks for such a LOOONG response! much appreciated. I was on AVRFreak board and there are many who suggest against using Cortex M3 as my first mcu. I think I will look into either AVR or moto/freescale MC12. Then go into ARM. If ARM vendors tend to sandbox themselves from others, and C code will usually not be portable, then what are the Pros of ARM?
Henry
The pros are that every few minutes, certainly once an hour you touch something powered by an arm. They are taking on intel's markets and are going to make some headway. Not arm, everyone sandboxes, I am one of the rare types that wants to see the guts, would rather see the guts of the thing than the pretty cover. The ones that bug me are the inexpensive and popular platforms that take extra effort to hide the guts. Just received an lpcxpresso today, more secrets, more disappointment.
dwelch
I have created a stackexchange proposal for the eZ430-Chronos Kit: http://area51.stackexchange.com/proposals/13122/ti-ez430-chronos-development-tool?referrer=YppEIivQP8lCxT7Iq4t4JA2
lImbus
+1  A: 

ARM is the most widely used embedded architecture and covers an enormous range of devices from multiple vendors and a wide range of costs. That said there are significant differences between ARM7, 9, 11, and Cortex devices - especially Cortex. However if getting into embedded systems professionally is your aim, ARM experience will serve you well.

8 bit architectures are generally easier to use, but often very limited in both memory capacity and core speeds. Also because they are simple to use, 8-bit skills are relatively easy to acquire, so it is a less attractive skill for a potential employer because it is easy to fulfil internally or with less experienced (and therefore less expensive) staff.

However if this is a hobby rather than a career, the low cost of parts, boards, and tools, and ease of use may make 8 bit attractive. I would suggest AVR simply because it is supported by the free avr-gcc toolchain. Some 8 bit targets are supported by SDCC, another open source C compiler. I believe Zilog make their Z8 compiler available for free, but you may need to pay for the debug hardware (although this is relatively inexpensive). Many commercial tool vendors provide code-size-limited versions of their tools for evaluation and non-commercial use, but beware most debuggers require specialist hardware which may be expensive, although in some cases you can build it yourself if you only need basic functionality and low speeds.

Whatever you do do take a look at www.embedded.com. If you choose ARM, I have used WinARM successfully on commercial projects, although it is not built-for-comfort! A good list of ARM resources is available here. For AVR definitely check out www.avrfreaks.net

I would only recommend Microchip PIC parts (at least the low-end ones) for highly cost sensitive projects where the peripheral mix is a good fit to the application; not for learning embedded systems. PIC is more of a branding than an architecture, the various ranges PIC12, 16, 18, 24, and PIC32 are very different from each other, so learning on one does not necessarily stand you in good stead for using another - often you even need to purchase new tools! That said, the dsPIC which is based on the PIC24 architecture may be a good choice if you wanted to get some simple DSP experience at the same time.

In all cases check out compiler availability (especially if C++ support is a requirement) and cost, and debugger hardware requirements, since often these will be the most expensive parts of your dev-kit, the boards and parts are often the least expensive part.

Clifford
Is AVR used in commercial products at all? Or is it mostly used by the hobbyist?
Henry
What's a good ide/toolchain for ARM Cortex-M3? Do I need a hardware debugger to start? What do they do? Thank you.
Henry
No chip vendor would survive only serving the hobbyist market. AVR are used extensively in commercial products.
Clifford
AVR and PIC are generally fighting over top dog in market share of the 8bit uC market, so both are widely used commercially. Microchip did offer to buy Atmel back in 2008 although atmel said "no way man".
Mark
8 bit devices of all flavours including AVR are widely used in commercial products, but these tend to be simple, low-end, or deeply embedded devices, such as toys, heating controllers, domestic appliances etc. So you may not be aware of them, but they constitute probably the vast majority of applications. Atmel claim they have 30% of the "8-bit Flash Microcontroller" market. At various times Microchip and Atmel have claimed to be number one. But either way AVR is the better technical design compared to low-end PICs, and its instruction set is better suited to C code generation.
Clifford
+1  A: 

Some recommend the ARM. I'd recommend it, not as a first platform to learn, but as a second platform. ARM is a bit complex as a platform to learn the low-level details of embedded, because its start-up code and initialisation requirements are more complicated than many other micros. But ARM is a big player in the embedded market, so well worth learning. So I'd recommend it as a second platform to learn.

The Atmel AVR would be good for learning many embedded essentials, for 3 main reasons:

  1. Architecture is reasonably straight-forward
  2. Good development kits available, with tutorials
  3. Fan forum with many resources

Other micros with development kits could also be good—such as MSP430—although they may not have such a fan forum. Using a development kit is a good way to go, since they are geared towards quickly getting up-and-running with the micro, and foster effective learning. They are likely to have tutorials oriented towards quickly getting started.

Well, I suppose the development kits and their tutorials are likely to gloss over such things as bootloaders and start-up code, in favour of getting your code to blink the LED as soon as possible. But that could be a good way to get started, and you can explore the chain of events from "power-on" to "code running" at your pace.

I'm no fan of the PICs, at least the PIC16s, due to their architecture. It's not very C-friendly. And memory banks are painful.

Craig McQueen
I don't want to use Arduino programming language though. Is it easy to use Arduino Mega with AVR Studio? Also, how can I learn how to control an electric motor, or use a DAC with Arduino Mega? Would a more feature-rich dev kit be more beneficial? thx
Henry
Sure, no need to use the Arduino software. Write your code using AVR studio, and upload to the board using programming software directly. As for motors or DACs, I'm sure there would be development boards that would suit. A Google search should find something.
Craig McQueen
+1  A: 

This is kind of a hard question to answer as your ideal answer very much depends on what it is your interested in learning.

If your goal is just to dive a little deeper into the inner workings of computing systems i would almost recommend you forgo the embedded route and pick up a book on writing a linux kernel module. Write something simple that reads a temperature sensor off the SMbus or something like that.

If your looking at getting into high level (phones, etc) embedded application development, download the Android SDK, you can code in java under eclipse and even has a nice emulator.

If your looking at getting into the "real" microcontroller space and really taking a look at low level system programming, i would recommend you start on a very simple architecture such as an AVR or PIC, something without an MMU.

Diving into the middle ground, for example an ARM with MMU and some sort of OS be it linux or otherwise is going to be a bit of a shock as without a background is both system programming and hardware interfacing i think the transition will be very rough if you plan to do much other than write very simple apps, counting button presses or similar.

Mark
side question, is complexity level of AVR similar to Freescale HC08/HC12? Thanks.
Henry
An AVR such as the ATmega328 (Arduino) is an 8bit MCU and would be similar to the HC08 in design/capabilities, both similar to low end PIC18 or PIC16 parts. The HC12 is a 16bit MCU, and would be most similar to a PIC24,dsPIC, or AVR XMEGA. I believe all these MCU's are RISC designs and use harvard architectures. For what its worth my first introduction to MCU programming was learning assembly on a 68HC11 core, which is the predecessor to the HC12. From there i moved on to PIC's and later to more complex cores.
Mark
+1  A: 

It does matter, you need to gradually acquire experience starting with simpler systems. Note that by simpler I dont mean less powerful, I mean ease of use, ease of setup etc. In that vein I would recommend the following (I have no vested interest in a any of the products, I just found them the best):

I've started using one of these (MBED developer board). The big selling points for me were that I could code in C or C++, straightforward connection vis USB and a slick on-line development environment (no local tool installation required at all!).

http://mbed.org/

Five minutes afer opening box I had a sample blinky program (the 'hello world' of the emedded world) running the following:

#include "mbed.h"

DigitalOut myled(LED1);

int main()
{
    while(1)
    {
        myled = 1;
        wait(0.2);
        myled = 0;
        wait(0.2);
    }
}

That's it! Above is the complete program!

It's based on ARM Cortex M3, fast and plenty of memory for embedded projects (100mhz, 256k flash & 32k ram). The online dev tools have a very good library and plenty of examples and theres a very active forum. Plenty of help on connecting devices to MBED etc

Even though I have plenty of experience with embedded systems (ARM 7/9, Renases M8/16/32, Coldfire, Zilog, PIC etc) I still found this a refreshingly easy system to get to grips with while having serious capability.

After initially playing with it on a basic breadboard I bought a base board from these guys: http://www.embeddedartists.com/products/lpcxpresso/xpr_base.php?PHPSESSID=lj20urpsh9isa0c8ddcfmmn207. This has a pile of I/O devices (including a miniture OLED and a 3axis accelerometer). From the same site I also bought one of the LCPExpresso processor boards which is cheap, less power/memory than the MBED but perfect for smaller jobs (still hammers the crap out of PIC/Atmega processors). The base board supports both the LCPExpresso and the MBED. Purchasing the LCPExpress processor board also got me me an attached JTAG debugger and an offline dev envoronment (Code Red's GCC/Eclipse based dev kit). This is much more complex than the online MBED dev environment but is a logical progression after you've gained expeience with the MBED.

With reference to my original point noite that the MBED controller is much more capable than the the LPCExpresso controller BUT is much simpler to use and learn with.

Tim Ring
Das blinkin lampen.
kenny
A: 

I use PICs, but would consider Arduino if I chose today. But from your goals:

  • how IO ports work
  • memory limitations/requirements
  • interrupt service routines

I wonder if you best bet is just to hack in the Linux kernel?

kenny
A: 

I use microchips PIC's, its what I started on, I mainly got going on it due to the 123 microcontroller projects for the evil genius book. I took a Microprocessors class at school for my degree and learned a bit about interrupts and timing and things, this helped a ton with my microcontrollers. I suppose some of the other programmers etc may be better/easier, but for $36 for the PicKit1, I'm too cheap to go buy another one...and frankly without using them I don't know if they are easier/better, I like mine and recommend it every chance I get, and it took me forever to really actually look at it, but I was able to program another chip off board with ICSP finally. I don't know what other programmers do it, but for me that's the nicest thing 5 wire interface and you're programmed. Can't beat that with a stick...

onaclov2000
A: 

I've only used one of those.

The Freescale is a fine chip. I've used HC-something chips for years for little projects. The only caveat is that I wouldn't touch CodeWarrier embedded with a 10 foot pole. You can find little free C compilers and assemblers (I don't remember the name of the last one I used) that do the job just fine. Codewarrior was big and confusing and regardless of how much I knew about the chip architecture and C programming always seemed to only make things harder. If you've used Codewarrior on the Mac back in the old days and think CW is pretty neat, well, it's not at all like that. CW embedded looks vaguely similar, but it works very differently, and not very well.

A command-line compiler is generally fine. Professionals who can shell out the big bucks get expensive development environments, and I'm sure they make things better, but without that it's still far better than writing assembly code for a desktop PC in 1990, and somehow we managed to do that just fine. :-)

Ken
+1  A: 

Texas Instruments has released a very interesting development kit at a very low price: The eZ430-Chronos Development Tool contains an MSP430 with display and various sensors in a sports watch, including a usb debug programmer and a usb radio access point for 50$

There is also a wiki containing lots and lots of information.

I have already created a stackexchange proposal for the eZ430-Chronos Kit.

lImbus