32 bit number handling with ATTiny and Atmel Studio

Question

I am wondering how the ATTiny, specifically the ATTiny24 stores 32 bit unsigned ints in memory. I'm trying to take a 32 bit value and write it to a 32 bit location in the EEPROM. I have attempted to use a simple mask, but every time I try, I get the lower two bytes (lsb) correctly and the upper two bytes are all zeros. For example, when I try to write: 0x12345678 the output is: 0x00005678. Is there a setting in Atmel Studio I need to set, or do I need to use another method other than masking.

Ultimately I want to be able to read a 32 bit counter value and write it to a specific location in the EEPROM. I am working on modifying an existing circuit and thus do not have the luxury to debug with a serial output.

Code Snippets:

In main:

unsigned long test_val = 305419896;  //0x12345678
EEprom_Long_Write(0x25,test_val);

Functions:

EEprom_Long_Write:

void EEprom_Long_Write(unsigned char eeadr, unsigned long EE_Data)
{
    unsigned char temp=0;
    unsigned char count= eeadr + 3;
    unsigned long mask=0;
    unsigned char position=24;  
    while (eeadr <= count)
    {
        mask = ((1<<8)-1) << position;
        temp = (EE_Data & mask) >> position;
        EEPROM_write(eeadr, temp);
        position = position-8;
        eeadr++;
    }
}

EEPROM_write:

void EEPROM_write(unsigned char ucAddress, unsigned char ucData)
{   
    while(EECR & (1<<EEPE));        //Wait for completion of previous write
    EECR =(0<<EEPM1) | (0>>EEPM0);  // Set Programming mode
    EEARL = ucAddress;              // Setup address and data registers
    EEDR = ucData;                  // Load Data Register
    EECR |= (1<<EEMPE);             // Write logical one to EEMPE
    EECR |= (1<<EEPE);              // Start eeprom write be setting EEPE

}

Use `stdint.h` types, not the built-in names to have types with defined width. — too honest for this site, Jul 14 '15 at 14:12

too honest for this site · Accepted Answer · 2015-07-14T14:37:41.347

2

You fell into the pit of integer promotion and coercion. ((1<<8)-1) is processed as int, not long (better: uint32_t). On AVR, int has the minimum size allowed by the standard: 16 bits.

As is is anyway too complicated, you can use the following:

uint8_t shift = 32U;   // enough is enough
do {
    shift -= 8U;
    EEPROM_write(eeadr++, (uint8_t)(EE_Data >> shift));
} while ( shift ) ;

This safes you one additional shift and the explicit masking and some registers.

Note my use of stdint.h types (you have to include the header, of course). You should correct all declarations accordingly. The cast to uint8_t implies masking.

edited Jul 14 '15 at 14:37

answered Jul 14 '15 at 14:24

too honest for this site

12,050
4
30
52

Thanks for that! Would I also need to change my function definition to `void EEprom_Long_Write(unsigned char eeadr, uint32_t EE_Data)` ? – soupaloop Jul 14 '15 at 14:34
@soupaloop: You should always use the proper types. If `eeadr` is guaranteed to be less than 256, use `uint8_t`, else `uint16_t`, etc. Read about `stdint.h` (Wikipedia, or the linked standard). Hmm, I will edit my answer, `shift` should be `uint8_t` on AVR actually (sorry, I'm more used to ARM now, where 32 bits are standard). And: **please** read the linked text! This is **vital**. – too honest for this site Jul 14 '15 at 14:37
@soupaloop: If my answer solved your problem, you should consider accepting it. – too honest for this site Jul 15 '15 at 10:35

score 1 · Answer 2 · answered Jul 14 '15 at 14:28

1

Change this:

mask = ((1<<8)-1) << position;
temp = (EE_Data & mask) >> position;

to this:

temp = (EE_Data >> position) & 0xFF;

answered Jul 14 '15 at 14:28

dlask

8,776
1
26
30

32 bit number handling with ATTiny and Atmel Studio

2 Answers2