Running Lights - Embedded "Hello World" I'm getting my feet wet in embedded development, and like all those before me, my first task was to make an LED blink. I went a bit further than that and made a "runner" that lights up each led from 0 to 7 in sequence. The sequence begins as soon as the board is powered on. You can see it in action here.

I'm using an ATxMegaA1 chip with the avr-gcc compiler and tool chain. The document I consulted most was the Using IO pins and external interrupts doc. 

I decided that creating an "Led" concept was a nice abstraction to wrap around the port they're attached to on the board. I also introduced a macro to change the delay when I'm debugging, because the simulator is orders of magnitudes slower than the real chip.

It's my first ever c, so please be brutal.

led.h

#include &lt;avr/io.h&gt;

#define LEDPORT PORTE_OUT
#define LEDPORT_DIR PORTE_DIR

void init(void);
void toggleLights(int ledPosition);


led.c

#include "led.h"

void init(void)
{
    LEDPORT_DIR = 0b11111111; //Configure LED port for output
    LEDPORT = 0b11111111; //LEDs are active low, this makes sure they're off on start up
}

//Turns light at provided port pin on and all others off.
void toggleLights(int ledPosition)
{
    LEDPORT = ~(1 &lt;&lt; ledPosition);
}


Blink.c

#include &lt;stdint.h&gt;
#include "led.h"

#ifdef DEBUG
    #define DELAYITERATIONS 0
#else
    #define DELAYITERATIONS 10000
#endif 

void delay(volatile uint32_t d)
{
    while (d-- != 0)     // loops while non-0 and decrements
    ;
}

int main(void)
{
    init();

    while(1)
    {
        for (int i = 0; i &lt; 8; i++)
        {
            toggleLights(i);
            delay(DELAYITERATIONS);
        }
    }
}
Toggling?  Or setting?
Our toggleLights function is oddly named and doesn't do what I'd expect.  (Specifically, a toggle turns off things on and on things off.)
In C, and especially in embedded C, we shouldn't be afraid to use unsigned integers as bit arrays.
So, perhaps we want a setLights function that looks something like this:
void setLights(uint8_t lights) {
    LEDPORT = lights;
}

And to turn each of the eight lights on, one at a time, we can bitshift over them in our for loop:
for (uint8_t lights = 1; lights != 0; lights &lt;&lt;= 1) {
    setLights(lights);
    // delay
}

So now we're effectively doing what your code attempts to do, but the setLights function is even more flexible.  It just sets the lights to exactly whatever we tell it to set them to (arguably, the function may not need to exist at all... but it does restrict our input to a correct type and give us some sense of safety).

Using typedef
Firstly, we should be using a uint8_t here rather than an int because we're never going to use any values that we can't represent with 8 bits and that'll save us 24 bits.
But how about we use our own name for the type?
typedef uint8_t light_positions;

So now,our setLights function becomes:
void setLights(light_positions lights);

And our for loop becomes:
for (light_positions lights = 1; lights != 0; lights &lt;&lt;= 1) { // ...

This type helps add to the clarity of what this variable is supposed to represent and be used for.  This can be especially useful in embedded C where you might be prone to having lots of variables of the uint8_t type (or other sizes of unsigned integers).

lights &lt;&lt;= 1
&lt;&lt;= is a compound assignment operator.  Everyone knows and is familiar with +=, correct?  It's the most common of the ten compound assignment operators.
Meanwhile, &lt;&lt; is a bitwise left shift operator (you used it in your toggleLights function).
So here's what's happening in our for loop.
We initialize lights to 0x00000001.  Run the loop body.  Update statement shifts lights to the left by 1 (lights &lt;&lt;= 1), and we end up with: 0x00000010.
We repeat this several times until we get to 0x10000000, and the next update statement shifts all of the bits out.  We end up with 0x00000000 (just 0) and the for loop exits, because lights != 0 returns false now.

About preprocessor macros...
Preprocessor macros are sometimes necessary, but generally, lead to code that is harder to debug.
Rather than your version of the macro, I think the code is more clear if we just inline it in the loop:
toggleLights(lights);
#ifdef DEBUG
    delay(1000);
#endif

Of course, if we're using the DELAYITERATIONS in multiple spots, then your version is fine--we don't want to be writing extra code necessarily.  But if we're only using it in one spot, write it more like this.

Use bools...
There are a number of ways to use true/false in C (which helps make your code more human readable).  Pick one and use it.

Hexadecimal vs Binary
Using hexadecimal notation is arguably more readable than counting the number of 1s in binary notation.  I think I'd prefer seeing 0xFF rather than 0b1111111.
Did you even notice there are only seven ones there?