AVR Freaks

Now I've always wondered why we don't define our bits this way:

https://www.avrfreaks.net/index.p...

Nothing stops you defining bit masks rather than bit numbers if you prefer. In fact if you are willing to live without io.h (or whatever it's called in your compiler) you can redefine the entire set of SFRs and bit names if you like except that it would hugely confuse anyone else trying to use the code if they assumed registers/bits defined the "normal" way. One possibility is to use a case change to avoid name pollution such as:

Another alternative is:

Note that the XMEGA and UC3 device headers *do* contain bit masks as well as (in some cases) bit positions. They also contain group masks, so code for them usually looks quite clean.

- Dean :twisted:

My code below would be the best fit answer for the question and preferred for people who's already familiar with assembly bitwise codes.

#include <avr/io.h>

#define sbi(x,y) ((x) |= _BV(y))
#define cbi(x,y) ((x) &=~_BV(y))
#define tbi(x,y) ((x) ^= _BV(y))
#define gbi(x,y) ((x) & (1<< (y)))
#define vbi(x,y) (((x)>>(y))&1)

#define __DDR(pad) DDR ## pad
#define _DDR(pad) __DDR(pad)
#define DDR(name) _DDR(PAD_##name)

#define __PORT(pad) PORT ## pad
#define _PORT(pad) __PORT(pad)
#define PORT(name) _PORT(PAD_##name)

#define __PIN(pad) PIN ## pad
#define _PIN(pad) __PIN(pad)
#define PIN(name) _PIN(PAD_##name)

#define PAD(pad, name) _##pad(PAD_##name)

#define sbi_pad(pad, name) sbi(pad(name), PIN_##name)
#define cbi_pad(pad, name) cbi(pad(name), PIN_##name)
#define tbi_pad(pad, name) tbi(pad(name), PIN_##name)
#define gbi_pad(pad, name) gbi(pad(name), PIN_##name)
#define vbi_pad(pad, name) vbi(pad(name), PIN_##name)

Which will allow you to use it like these.

// good old bitwise actions
unsigned char flag = 0;
#define FLAG_HI 0
sbi(flag, FLAG_HI); //set flag
cbi(flag, FLAG_HI); //clear flag
tbi(flag, FLAG_HI); //toggle
gbi(flag, FLAG_HI); //get flag. Can be used on if clause like  if(gbi(flag, FLAG_HI)) {...}
vbi(flag, FLAG_HI); //makes it exactly 1 or 0. Useful on complex bit concatenation

// Suppose a red LED is connected on PD2
#define PAD_LED_R D
#define PIN_LED_R 2

sbi_pad(DDR, LED_R); // setup to output pin
...
sbi_pad(PORT, LED_R); // light on
// Also, below are the same as this
sbi(PORT(LED_R), PIN(LED_R));
sbi(PAD(PORT, LED_R), PIN(LED_R));

// When you need full pad access. Suppose there are 8 leds connected on PB0~PB7.
#define PAD_LEDS B
DDR(LED) = 0xFF; // setup to output pin
...
PORT(LED) = 0b11100100; // trivial multiple light on and off
#define PIN_LED_G 1
PORT(LED) = _BV(PIN(LED_R)) | _BV(PIN(LED_G)); // using _BV() from avr/io.h.
PORT(LED) = _BV(PIN_LED_R) | _BV(PIN_LED_G); // the same. choose on your favor

//which means you can also bitwisely access with variable index
char i;
for(i=3;i<=6;i++)
    sbi(PORT(LED), i); // turn on LED index 3 to 6

How about the below implementation for IO port operations? Any performance issues? I used this for Atmega328P, but not sure of any side effects or bad programming practices!

enum
{
	CL_INPUT=0,
	CL_OUTPUT=1,
};

#define AVR_DIR_OUT 1
#define AVR_DIR_IN 0
#define IOPORTD 3
#define IOPORTB 1
#define IOPORTC 2

#define IOBitSet(ioport, bit) (ioport==IOPORTD)?(PORTD|=1<<bit):(ioport==IOPORTB)?(PORTB|=1<<bit):(ioport==IOPORTC)?(PORTC|=1<<bit):0
#define IOBitClear(ioport, bit) (ioport==IOPORTD)?(PORTD&=~(1<<bit)):(ioport==IOPORTB)?(PORTB&=~(1<<bit)):(ioport==IOPORTC)?(PORTC&=~(1<<bit)):0
#define IOBitDirOut(ioport, bit) (ioport==IOPORTD)?(DDRD|=1<<bit):(ioport==IOPORTB)?(DDRB|=1<<bit):(ioport==IOPORTC)?(DDRC|=1<<bit):0
#define IOBitDirIn(ioport, bit) (ioport==IOPORTD)?(DDRD&=~(1<<bit)):(ioport==IOPORTB)?(DDRB&=~(1<<bit)):(ioport==IOPORTC)?(DDRC&=~(1<<bit)):0
#define IOBitInvert(ioport, bit) (ioport==IOPORTD)?(PORTD^=1<<bit):(ioport==IOPORTB)?(PORTB^=1<<bit):(ioport==IOPORTC)?(PORTC^=1<<bit):0


// IS_BIT_SET returns non zero or zero value. So while using ensure you check if zero or non zero.
// Do not use for comparing with a value based on bit position.
#define IS_BIT_SET(ioport, bit) (ioport==IOPORTD)?(PIND&(1<<bit)):(ioport==IOPORTB)?(PINB&(1<<bit)):(ioport==IOPORTC)?(PINC&(1<<bit)):0


// Operation on Entire Ports
#define IOPortSet(ioport, value) (ioport==IOPORTD)?(PORTD|=(value)):(ioport==IOPORTB)?(PORTB|=(value)):(ioport==IOPORTC)?(PORTC|=(value)):0
#define IOPortClear(ioport, value) (ioport==IOPORTD)?(PORTD&=~(value)):(ioport==IOPORTB)?(PORTB&=~(value)):(ioport==IOPORTC)?(PORTC&=~(value)):0
#define IOPortDirOut(ioport, value) (ioport==IOPORTD)?(DDRD|=(value)):(ioport==IOPORTB)?(DDRB|=(value)):(ioport==IOPORTC)?(DDRC|=(value)):0
#define IOPortDirIn(ioport, value) (ioport==IOPORTD)?(DDRD&=~(value)):(ioport==IOPORTB)?(DDRB&=~(value)):(ioport==IOPORTC)?(DDRC&=~(value)):0
#define IOPortInvert(ioport, value) (ioport==IOPORTD)?(PORTD^=(value)):(ioport==IOPORTB)?(PORTB^=(value)):(ioport==IOPORTC)?(PORTC^=(value)):0
#define IOPortRead(ioport) (ioport==IOPORTD)?(PIND):(ioport==IOPORTB)?(PINB):(ioport==IOPORTC)?(PINC):0

// Only sample implementation. Mapping needs to be changed according to the hardware.

enum IODevices
{
	LED1=0,
	LED2,
	BUZZER,
	HCSR_04_TRIGGER1,
	HCSR_04_ECHO1,
        HCSR_04_TRIGGER2,
	HCSR_04_ECHO2,
	RELAY1,
	RELAY2,
};


struct IOStructure
{
	uint8_t port:2;
	uint8_t bitNum:3;
	uint8_t IOType:1;
};


// Update this structure when new devices have to be added.
// enum IODevices must also be updated// before updating this. Both must match in the order of assignment

struct IOStructure IODeviceList[] =
{
	{IOPORTD,PD3,CL_OUTPUT},               // LED1
	{IOPORTB,PB0,CL_OUTPUT},               // LED2
	{IOPORTB,PB1,CL_OUTPUT},			   // Pin for Buzzer
	{IOPORTD,PD3,CL_OUTPUT},               // Trigger1
	{IOPORTB,PB3,CL_INPUT},                // Echo1
        {IOPORTB,PB5,CL_OUTPUT},               // Trigger2
	{IOPORTB,PB4,CL_INPUT},                 // Echo2
	{IOPORTC,PC2,CL_OUTPUT},			   // Pin for Relay1
	{IOPORTC,PC3,CL_OUTPUT},			   // Pin for Relay2

	};


/*
// initializeAllIODevices function can be used if needed. But occupies little more memory.
// Since it is called only once, it is not required to go for this function. Instead all IOs
// can be initialized individually.
*/
void initializeAllIODevices (void)
{
	uint8_t count;
	for(count=0;count<(sizeof(IODeviceList)/sizeof(IODeviceList[0]));count++)
	{
		if(IODeviceList[count].IOType==CL_OUTPUT)
		{
			IOBitDirOut((IODeviceList[count].port),IODeviceList[count].bitNum);
		}
	}
}


void setIODeviceDir(enum IODevices device, uint8_t direction)
{
    if(direction==AVR_DIR_OUT)
    {
        IOBitDirOut(IODeviceList[device].port,IODeviceList[device].bitNum);
    }
    else
    {
        IOBitDirIn(IODeviceList[device].port,IODeviceList[device].bitNum);
    }

}

 // Function used to turn the IO pin connected to the device High/Low.
 // User need to take care of active high or active low configurations.
 // This function will just turn the port pin high
 void setIODeviceState (enum IODevices device, uint8_t state)
 {
	 if(state==HIGH)
     {
         IOBitSet(IODeviceList[device].port,IODeviceList[device].bitNum);
     }
     else
    {
        IOBitClear(IODeviceList[device].port,IODeviceList[device].bitNum);
    }
};


void toggleIODevice (enum IODevices device)
{
    IOBitInvert(IODeviceList[device].port,IODeviceList[device].bitNum);
};


   // Function used to check is the IO device connected to particular pin is High or low
   // This function will just check if the port pin High or not
   // In case the port pin is high, function will return non zero value
   // In case the IO pin is low, function will return false.
   // Please note that function will not return 1 in case bit is set.

 uint8_t isIODeviceHigh(enum IODevices device)
 {
	 return(IS_BIT_SET(IODeviceList[device].port,IODeviceList[device].bitNum));
};


/* pulseIODevice function is used to pulse the particular device for certain number
of times at a specific rate.
period is the total width of the pulse in milli seconds.
onTime: Ontime must be less than the rate
*/
void pulseIODevice(enum IODevices deviceNum, uint8_t numTimes, uint16_t period, uint16_t onTime)
{
	int loop;
	
	for(loop=0;loop<numTimes;loop++)
	{
		IOBitSet(IODeviceList[deviceNum].port,IODeviceList[deviceNum].bitNum);
				CL_delay_mS(onTime);
		IOBitClear(IODeviceList[deviceNum].port,IODeviceList[deviceNum].bitNum);
		CL_delay_mS(period-onTime);
	}

};

Yes, there is a significant performance issue after I tested. Wrote two routines. In first case, I see the pulse@2.667MHz and in second case the pulsing is @190.5KHz with 16MHz clock.

 //Case1: (Pl Comment when testing case 2)
    /*
    IOBitDirOut(IOPORTB,0);
    while(1)
    {
        IOBitSet(IOPORTB,0);
        IOBitClear(IOPORTB,0);
    }*/
    //Case2 (Pl Comment when testing case 1)
    setIODeviceDir(LED2,AVR_DIR_OUT);
    while(1)
    {
        setIODeviceState(LED2,HIGH);
        setIODeviceState(LED2,LOW);
    }

Another question I have is if I do not call any of the functions related to case2, compiler should optimize the code right? But I get approx 900 bytes of code when C files containing functions related to case2 are added to the project (but the functions are not called) against 140 bytes when C files related to case 2 above are removed from the project. I have optimization -Os selected. Any other settings? I am using the GNU compiler provided by Atmel.

When comparing performance of something like these i/o macro's its probably more informative to look at the list file.

Some time ago I had a breef peek into the "arduino" stuff and I bumped into some text somewhere about the terribly slow "digital_write()" stuff.

So then he took those functions and rewrote them as macro's. The author claimed his macro's were optimized by the compiler into single sbi() cbi() instructions.

(Euhhmmm.. The "normal" arduino digital functions check if a pin is used as pwm and turn of pwm if written to as a bit. I don't like arduino very much).

Well, lot's of people are complaining:

https://duckduckgo.com/html?q=ar...

This post drops "Paul Stoffregen" 's name. (& posts) He's a smart guy.

http://forum.arduino.cc/index.ph...

If you are talking about C++ then "static const" is preferable as it is type checked.

Still not entirely following how this equates to Arduino though? In Arduino I can "pinMode(13, OUTPUT); digitalWrite(13, HIGH)". I have no idea what "13" is. It could be PORTB bit 5 or it could be PORTD bit 2 or something completely different. I just know that will take the 13th pin on the header "high".

The way the Arduino code achieves this (even with different pin mapping on different Arduino layouts) is using look up tables that map "13" to a PORT, a DDR and a bit number. It's true this makes it hugely inefficient as there are multiple instances of indirection but it achieves the goal of mapping which makes things simple for the user.

How do your pinMode() and digitalWrite() achieve this mapping then?

If they need to know it is PORTB.5 then why don't they simply use:

DDRB |= (1 << 5);
PORTB |= (1 << 5);

or if they have an aversion to typing "1 <<" then:

DDRB |= _BV(5);
PORTB |= _BV(5);

Eclipse is a half way house between Code::Blocks (which is very simple) and AS7 (which is unnecessarily bloated). It should certainly let you control things like -std=

Just installed Eclipse Neon CDT and then added the AVR plugin from the "Marketplace" and when I create an AVR project I find I have this control:

In fact it picked -std=gnu99 as the default (which is nice!).

My only argument with this is that it doesn't seem to offer c89/gnu89 - but I guess no one wants those in this day and age?

I just posted that into Eclipse and used the line:

pinMode(LED1, OUTPUT);

Eclipse will show you the full expansion or it will allow you to step through the expansion 1 step at a time. Not that it matters (because it happens at compile time) but there are THIRTY-SEVEN steps in the expansion of that macro! The ultimate expansion is:

((1==1)?(((uint8_t)19/8)==2)?((*(volatile uint8_t *)((0x11) + 0x20))|=1<<(19-((19/8)*8))):(((uint8_t)19/8)==0)?((*(volatile uint8_t *)((0x17) + 0x20))|=1<<(19-((19/8)*8))):(((uint8_t)19/8)==1)?((*(volatile uint8_t *)((0x14) + 0x20))|=1<<(19-((19/8)*8))):0:(((uint8_t)19/8)==2)?((*(volatile uint8_t *)((0x11) + 0x20))&=~(1<<(19-(19/8)*8))):(((uint8_t)19/8)==0)?((*(volatile uint8_t *)((0x17) + 0x20))&=~(1<<(19-(19/8)*8))):(((uint8_t)19/8)==1)?((*(volatile uint8_t *)((0x14) + 0x20))&=~(1<<(19-(19/8)*8))):0)

Gulp! Quite clever the compiler boils all of that down into:

	pinMode(LED1, OUTPUT);
  6c:	8b 9a       	sbi	0x11, 3	; 17

If you want to post any test code I'll happily run it through Codevision to test for compatibility.

And Codevision's result using v3.23a...

174 words/348 bytes including interrupt vectors, delay_ms() and crt0.

List file...