I have an array uint8_t data[256]. But each element is single byte.
My data bus is 32 bit long. So, If I want to access 32 bits, I do:
DATA = data[i] + (data[i + 1] << 8) + (data[i + 2] << 16) + (data[i + 3] << 24);
But this translates into 4 separate read requests in the memory of one byte each.
How can I access all the 4 bytes in the form of single transaction?
If you know the endian-ness of your data (or if you don't care), and your data is aligned (or have a byte-addressing process and you don't care about efficiency) you can cast data to a uint32_t * and access it in 4-byte chucks, like so:
DATA = ((uint32_t *)data)[i/4];
This of course assumes i is a multiple of 4.
Just cast data to uint32_t.
uint8_t data[256] = {1,2,3,4,5,6,7,8} ;
int main(int argc, char **argv)
{
int index = 1 ;
uint32_t d = *(uint32_t *)(data + index) ;
printf ("%08x\n", d) ;
}
Output on a little endian architecture will be
05040302
Output on a big endian architecture will be
02030405
However depending on the achitecture of the processor your progam is running on, you might run into memory alignment problems (performance hit if you address an unaligned memory, or even a crash if your processor doesn't support unaligned memory addressing).
uint32_t d = *(uint32_t *)(data + index) ; with index = 1 is an unaligned access, with potential undefined behavior.Maybe you should store data as an array of 32-bit:
uint32_t data[64];
DATA = data[i];
DATA = data[i+1];
...
int data[256]; but here in your comment you seem to be saying uint8_t data[256]; — these are very different! It makes a wreck out of your question, in fact.As @dwayne-towell mentioned - you need to care of endianness of you data. In one transaction it might be realized like an example below:
#include <stdio.h>
#include <stdint.h>
int
main()
{
uint8_t data[256];
uint32_t i, *p;
// Add some 32bit numbers
p = (uint32_t *)data;
for (i = 0; i < sizeof(data)/sizeof(uint32_t); ++i) {
*(p++) = i;
}
// Print some 32bit numbers
p = (uint32_t *)data;
for (i = 0; i < sizeof(data)/sizeof(uint32_t); ++i) {
printf("value=%u\n", *(p++));
}
return (0);
}
datais of typeint [256], not only one byte is read for each summand.int data[256];be composed of single-bytes. The 'bytes' would have to be at least 16 bits each (CHAR_BIT == 16). There is some confusion in the assumptions you're making, I think. If, as one of your comments suggests, you meanuint8_t data[256];, then one question is 'are you going to index at values ofithat are not multiples of 4'? and another question is 'what happens if you try to access an 'improperly aligned' memory address as a 4-byte unit?' You need to know the answers to both before risking short-cuts.