How to access GPIO pins on Atmega with memory mapping?

Question

I'm programming the Atmega328P in embedded C. I'm going to use 16 pins for turning on LEDs, and I have to use PORTB, PORTD and PORTC for this. I would like to just iterate a pointer so I can turn them on/off instead having to deal with what port each pin relates to. So an example would be how I need three if statements to iterate through the 16 pins like shown below:

// Enable outputs
DDRB = 0b00111111; // 6 outputs
DDRC = 0b00110000; // 2 outputs
DDRD = 0xFF;       // 8 outputs

// LED pins
uint8_t ledpin[] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15};
uint8_t idx = 0;

// Set LEDs
if (idx < 8)
    for(int i = 0; i < 8; i++)
        PORTD |= (1 << ledpin[i]);

if( idx > 8 && idx < 14)
    for(int i = 8; i < 14 ; i++)
        PORTB |= (1 << ledpin[i]);

if (idx >= 14)
    for(int i = 14; i < 16; i++)
        PORTC |= (1 << ledpin[i]);

I would rather use a memory map where I could just say "pin0 address + offset" like this:

// Base address of ports
uint8_t base 0x00
uint8_t offset = 0x04;

// LED pins
uint8_t ledpin[] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15};

// Set LEDs
for(int i = 0; i < 16; i++){
    (base + offset) |= (1 << ledpin[i]); // Pseudo code
     offset += 0x04;
}

The code above is obviously not optimized, nor totally functioning code but I think it gets my point accross as to what I want to achieve. Ultimately I will use this in a code to control a LED cube which will work quite differently, but it's essential that I don't need to decode what port each pin belong to all the time. Is there a good way to solve this with virtually no overhead?

EDIT

After investigating and trying out a lot of stuff with good help from the answers I have found that it's not possible to address individual bits in the AVR ports. Each PORTB/C/D have their own address, but it's not possible to manipulate the bits with memory mapping, like incrementing a pointer address. Atmega328P datasheet page 280 shows the memory map of the IO ports (image below).

Answer 1

Is there a good way to solve this with virtually no overhead?

There is no practical way to get 'virtually no overhead' in C on AVR. Code that looks like it should have low overhead often doesn't, and you have to look at the disassembly to see the real code.

AVR has a RISC architecture that needs many instructions to do 'simple' operations. IN, OUT, and SBI/CBI (bit set/clear) instructions take literal arguments only, which must be 'hard-coded' at compile time. But there is no barrel shifter, so bit masks computed at run time can take many instructions to produce. Pointers are made from 8 bit registers that are loaded one byte at a time, so pointer operations may use more cycles than port I/O with conditional code.

Here's the best I have managed to produce so far (It's basically the same as your code except the pin masks are precomputed, and it's wrapped in a function instead of inlined)...

// LED pin masks
#define LP0  1<<0
#define LP1  1<<1
#define LP2  1<<2
#define LP3  1<<3
#define LP4  1<<4
#define LP5  1<<5
#define LP6  1<<6
#define LP7  1<<7
#define LP8  1<<0
#define LP9  1<<1
#define LP10 1<<2
#define LP11 1<<3
#define LP12 1<<4
#define LP13 1<<5
#define LP14 1<<0
#define LP15 1<<1

// pin mask array
uint8_t ledpin_mask[] = {LP0,LP1,LP2,LP3,LP4,LP5,LP6,LP7,LP8,LP9,LP10,LP11,LP12,LP13,LP14,LP15};

// turn on LED
void setled(uint8_t pin)
{
  if (pin < 8)
  {
       PORTD |= (ledpin_mask[pin]);
  }
  else if ( pin < 14)
  {
       PORTB |= (ledpin_mask[pin]);
  }
  else
  {
       PORTC |= (ledpin_mask[pin]);
  }
}

...which generates the following machine code:-

void setled(uint8_t pin)
{
  96:   28 2f           mov r18, r24
  98:   30 e0           ldi r19, 0x00   ; 0
if (pin < 8)
  9a:   88 30           cpi r24, 0x08   ; 8
  9c:   40 f4           brcc    .+16        ; 0xae <setled+0x18>
{
     PORTD |= (ledpin[pin]);
  9e:   9b b1           in  r25, 0x0b   ; 11
  a0:   f9 01           movw    r30, r18
  a2:   e0 50           subi    r30, 0x00   ; 0
  a4:   ff 4f           sbci    r31, 0xFF   ; 255
  a6:   80 81           ld  r24, Z
  a8:   89 2b           or  r24, r25
  aa:   8b b9           out 0x0b, r24   ; 11
  ac:   08 95           ret
}
else if ( pin < 14)
  ae:   8e 30           cpi r24, 0x0E   ; 14
  b0:   40 f4           brcc    .+16        ; 0xc2 <setled+0x2c>
{
     PORTB |= (ledpin[pin]);
  b2:   95 b1           in  r25, 0x05   ; 5
  b4:   f9 01           movw    r30, r18
  b6:   e0 50           subi    r30, 0x00   ; 0
  b8:   ff 4f           sbci    r31, 0xFF   ; 255
  ba:   80 81           ld  r24, Z
  bc:   89 2b           or  r24, r25
  be:   85 b9           out 0x05, r24   ; 5
  c0:   08 95           ret
}
else
{
     PORTC |= (ledpin[pin]);
  c2:   98 b1           in  r25, 0x08   ; 8
  c4:   f9 01           movw    r30, r18
  c6:   e0 50           subi    r30, 0x00   ; 0
  c8:   ff 4f           sbci    r31, 0xFF   ; 255
  ca:   80 81           ld  r24, Z
  cc:   89 2b           or  r24, r25
  ce:   88 b9           out 0x08, r24   ; 8
  d0:   08 95           ret

That's 12 or 14 machine code instructions executed depending on the port, which is probably about as close as you can get to 'virtually no overhead' without coding in optimized assembler.

Answer 2

How about a structure of the addresses?

//PORTD = 0x10000
struct {
 void * 0x10000;
 void * 0x10001;
 void * 0x10002;
 ...
 // PORTB = 0x20000
 void * 0x20000;
 void * 0x20001;
etc.
}

Then you can iterate over the structure.

Answer 3

Unfortunately you can't have a pointer to certain bit of port directly.

If a struct that for each led contains both the port address and bit index is too wasteful, use one more level of indirection. I introduce a concept of LED Handle which is simply a byte to conveniently point indirectly to an IO port and bit in it.

First, generate a table that contains the addresses of used IO ports, for example:

volatile uint8_t *portlist[3]={&PORTB, &PORTC, &PORTD};

Now you can just fetch the address to a port via table indexes (0-2).

Next, generate the list of LEDs, by generating an array of "LED Handles", where the "LED Handle" is just a byte where for example high nybble is index to the port table, and low nybble is the bit in the port.

uint8_t ledlist1[] = {0x07, 0x14, 0x26};

In this case, first entry, 0x07, uses port index 0, which is PORTB, and led bit 7.

0x14 would be port index 1 (PORTC) and led bit 4. 0x26 would be port index 2 (PORTD) and bit 6.

Example function to set a bit to one via this led handle:

void led_on(uint8_t ledhandle)
{
    volatile uint8_t *ledport = portlist[ledhandle>>4];
    *ledport |= (1 << (ledhandle&0x07));
}

So, it uses the high 4 bits of the parameter as index to port table, from where it fetches the address of the port to ledport pointer. Then, it uses the low 3 bits of the parameter to calculate a bit mask for the bit to turn on, and accesses the port address pointed by ledport to set it on.

Then you can just do a for loop that for each entry in LED table calls the led_on like this:

for (i=0; i<3; i++)
    led_on(ledlist1[i]);

If this sounds awkward, you can change the led_on to take directly the LED table index, so you don't have to work with "LED Handles" that are contained in the LED table.

You can have further macros to make it more abstract, for example:

#define PB 0
#define PC 1
#define PD 2
#define LED(portindex,portbit) ((portindex<<4)|(portbit))

uint8_t ledlist2[]={
    LED(PB,7),
    LED(PC,4),
    LED(PD,6)
};