Arrays / ring buffers: how to put bytes in but read longs out?

Projects Programming
1

It's just the syntax I'm stuck on - pointers and *s and so on.

I'm streaming data from a Mac to an Arduino byte by byte, but the data represents int32_t values. I can control the byte order myself to make things as simple as possible, and I can handle chopping a signed int32_t into 8-bit chunks correctly on the Mac. What's the fastest way to read them out, though (ie for an Arduino, not needing to be portable, not needing to reconstruct them into another variable)?

So, I have a buffer:

unsigned char buffer[BUFFER_SIZE];

and two pointers:

unsigned char headPtr;
int32_t       tailPtr;

but I can't do this:

headPtr = buffer;
tailPtr = buffer;       // no can do, dude, long * =/= char *

How do I tell the compiler I know what I'm doing without having to resort to reconstructing the int32_t with shifts and ORs?

2

How do I tell the compiler I know what I'm doing without having to resort to reconstructing the int32_t with shifts and ORs?

You can't, you read out the bytes and put them back together.

Mark

3

Yes you can, use an array of int32_t, cast it to (uint8_t*) for the buffer inserts.

long buffer [N] ;
char * bufptr = (char*)buffer ;

Or similar...

4

Ahh, super, thanks.

Made the mistake of asking on a C++ forum and couldn't persuade anyone why it might be a desirable approach when time is tight and your processor's got lots to do in a short time and a small space... and most importantly, doesn't need to be portable to other architectures. Points taken, though, I'm trying to keep things much more clean and safe at the Mac end of things...

5

You could also use a union with MartT's approach. Suppose you know that there will be 8 longs coming in, which would be 32 bytes in the stream. Then, something like the following might work:

#define MAXBYTES   32

union {
   long input[MAXBYTES / sizeof(long)];
   char buffer[MAXBYTES];
} myUnion;

Then read the incoming data into myUnion.buffer[] as a byte stream and pull it out from myUnion.input[] as an array of longs.

6

Something like this? Take advantage of the fact that it's always ok to compare any pointer to a void*

byte buf[64]; // buffer size *must* be a multiple of sizeof(long)

const void *ENDOFBUF = buf + sizeof(buf);

byte *in = buf;
long *out = (long *) buf;

void pushByte(byte b) {
  *in++ = b;
  if(in >= ENDOFBUF) in = buf;
}

long popLong() {
  long l = *out++;
  if(out >= ENDOFBUF) out = (long *) buf;
  return l;
}


void setup(){}
void loop(){}
7

A time-honored approach is to define a macro GETLONG(byteptr) that fetches and reassembles the bytes in the correct byte order (beware "endianness"!)
On an AVR, you can probably do something like #define GETLONG(p) (*((long *)byteptr), but in other cases it would be more complicated (if you have to fix endianness, or allow for unaligned memory accesses on a system that doesn't allow that.) By using the macro (or a function), you allow the complicated cases to be implemented without destroying the readability of the code.

8

Thanks all, very helpful.

I've gone for econjack's union suggestion for this project - no need to worry about pointers, I can just use standard array notation. Gonna have to come back and re-read everything once I'm a bit more * happy

:slight_smile: