int serialization functions

5 files changed, 69 insertions, 51 deletions

diff --git a/fw/main.c b/fw/main.c
index 2452d78..b7b1efd 100644
--- a/fw/main.c
+++ b/fw/main.c
@@ -202,23 +202,15 @@ handleTblCtrlFrame(const CanFrame *frame) {
 			.eid = TAB_CTRL_CAN_ID | ((tab << 5u) & 0xE0) | (row & 0x1F)};
 		response.rtr = false;
 		response.dlc = 6u;
-		response.data[0u] = (key >> 24u) & 0xFF;
-		response.data[1u] = (key >> 16u) & 0xFF;
-		response.data[2u] = (key >> 8u) & 0xFF;
-		response.data[3u] = (key >> 0u) & 0xFF;
-		response.data[4u] = (val >> 8u) & 0xFF;
-		response.data[5u] = (val >> 0u) & 0xFF;
+		serU32Be(response.data, key);
+		serU16Be(response.data+4u, val);
 		return canTx(&response);
 	} else { // DATA
 		if (frame->dlc != 6u) {
 			return ERR;
 		}
-		key = ((U32)frame->data[0u] << 24u)
-			| ((U32)frame->data[1u] << 16u)
-			| ((U32)frame->data[2u] << 8u)
-			| ((U32)frame->data[3u] << 0u);
-		val = ((U16)frame->data[4u] << 8u)
-			| ((U16)frame->data[5u] << 0u);
+		key = deserU32Be(frame->data);
+		val = deserU16Be(frame->data+4u);
 		return tabWrite(&tbls[tab], row, key, val);
 	}
 }
@@ -245,15 +237,11 @@ respondSigCtrl(Signal sig) {
 
 	// SigId
 	if (sigFmt->id.isExt) { // extended
-		response.data[0u] = 0x80 | ((sigFmt->id.eid >> 24u) & 0x1F); // EXIDE=1
-		response.data[1u] = (sigFmt->id.eid >> 16u) & 0xFF;
-		response.data[2u] = (sigFmt->id.eid >> 8u) & 0xFF;
-		response.data[3u] = (sigFmt->id.eid >> 0u) & 0xFF;
+		serU32Be(response.data, sigFmt->id.eid & 0x1FFFFFFF);
+		response.data[0u] |= 0x80; // EXIDE=1
+
 	} else { // standard
-		response.data[0u] = 0u; // EXIDE=0
-		response.data[1u] = 0u;
-		response.data[2u] = (sigFmt->id.sid >> 8u) & 0x07;
-		response.data[3u] = (sigFmt->id.sid >> 0u) & 0xFF;
+		serU32Be(response.data, sigFmt->id.sid & 0x7FF);
 	}
 
 	// Encoding
@@ -288,15 +276,11 @@ setSigFmt(const CanFrame *frame) {
 	if (frame->data[0u] & 0x80) { // EXIDE
 		// Extended
 		sigFmt.id.isExt = true;
-		sigFmt.id.eid = (((U32)frame->data[0u] & 0x1F) << 24u)
-			| ((U32)frame->data[1u] << 16u)
-			| ((U32)frame->data[2u] << 8u)
-			| ((U32)frame->data[3u] << 0u);
+		sigFmt.id.eid = deserU32Be(frame->data) & 0x1FFFFFFF;
 	} else {
 		// Standard
 		sigFmt.id.isExt = false;
-		sigFmt.id.sid = (((U16)frame->data[2u] & 0x07) << 8u)
-			| ((U16)frame->data[3u] << 0u);
+		sigFmt.id.sid = deserU16Be(frame->data+2u) & 0x7FF;
 	}
 
 	// Unpack Encoding
diff --git a/fw/serial.c b/fw/serial.c
index d0fc762..fd60bcd 100644
--- a/fw/serial.c
+++ b/fw/serial.c
@@ -8,22 +8,44 @@
 
 #include "serial.h"
 
+void
+serU16Be(U8 buf[2u], U16 n) {
+	buf[0u] = (n >> 8u) & 0xFF;
+	buf[1u] = (n >> 0u) & 0xFF;
+}
+
+U16
+deserU16Be(const U8 buf[2u]) {
+	return ((U16)buf[0u] << 8u)
+		| ((U16)buf[1u] << 0u);
+}
+
+void
+serU32Be(U8 buf[4u], U32 n) {
+	buf[0u] = (n >> 24u) & 0xFF;
+	buf[1u] = (n >> 16u) & 0xFF;
+	buf[2u] = (n >> 8u) & 0xFF;
+	buf[3u] = (n >> 0u) & 0xFF;
+}
+
+U32
+deserU32Be(const U8 buf[4u]) {
+	return ((U32)buf[0u] << 24u)
+		| ((U32)buf[1u] << 16u)
+		| ((U32)buf[2u] << 8u)
+		| ((U32)buf[3u] << 0u);
+}
+
 Status
 serWriteCanId(U16 addr, const CanId *id) {
 	U8 buf[4u];
 
 	// Copy ID to buffer
 	if (id->isExt) { // extended
-		buf[0u] = (id->eid>>0u) & 0xFF;
-		buf[1u] = (id->eid>>8u) & 0xFF;
-		buf[2u] = (id->eid>>16u) & 0xFF;
-		buf[3u] = (id->eid>>24u) & 0x1F;
+		serU32Be(buf, id->eid & 0x1FFFFFFF);
 		buf[3u] |= 0x80; // set EID flag in bit 31
 	} else { // standard
-		buf[0u] = (id->sid>>0u) & 0xFF;
-		buf[1u] = (id->sid>>8u) & 0x07;
-		buf[2u] = 0u;
-		buf[3u] = 0u; // clear EID flag in bit 31
+		serU32Be(buf, id->sid & 0x7FF);
 	}
 
 	return eepromWrite(addr, buf, sizeof(buf));
@@ -43,14 +65,10 @@ serReadCanId(U16 addr, CanId *id) {
 	// Unpack
 	if (buf[3u] & 0x80) { // bit 31 is standard/extended flag
 		id->isExt = true; // extended
-		id->eid = ((U32)buf[0u] << 0u)
-			| ((U32)buf[1u] << 8u)
-			| ((U32)buf[2u] << 16u)
-			| (((U32)buf[3u] & 0x1F) << 24u);
+		id->eid = deserU32Be(buf) & 0x1FFFFFFF;
 	} else {
 		id->isExt = false; // standard
-		id->sid = ((U16)buf[0u] << 0u)
-			| (((U16)buf[1u] & 0x07) << 8u);
+		id->sid = deserU32Be(buf) & 0x7FF;
 	}
 
 	return OK;
diff --git a/fw/serial.h b/fw/serial.h
index b071038..093b40c 100644
--- a/fw/serial.h
+++ b/fw/serial.h
@@ -20,19 +20,31 @@ enum {
 	SER_SIGFMT_SIZE = 8,
 };
 
+// Serialize a U16 into a big-endian array of bytes.
+void serU16Be(U8 buf[2u], U16 n);
+
+// Deserialize a big-endian array of bytes into a U16.
+U16 deserU16Be(const U8 buf[2u]);
+
+// Serialize a U32 into a big-endian array of bytes.
+void serU32Be(U8 buf[4u], U32 n);
+
+// Deserialize a big-endian array of bytes into a U32.
+U32 deserU32Be(const U8 buf[4u]);
+
 // Write a CAN ID to the EEPROM.
-// CAN IDs are stored in the lower 11 or 29 bits of a little-endian U32.
+// CAN IDs are stored in the lower 11 or 29 bits of a big-endian U32.
 // Bit 31 indicates standard/extended: 0=>std, 1=>ext.
 Status serWriteCanId(EepromAddr addr, const CanId *id);
 
 // Read a CAN ID from the EEPROM.
-// CAN IDs are stored in the lower 11 or 29 bits of a little-endian U32.
+// CAN IDs are stored in the lower 11 or 29 bits of a big-endian U32.
 // Bit 31 indicates standard/extended: 0=>std, 1=>ext.
 Status serReadCanId(EepromAddr addr, CanId *id);
 
 // Write a SigFmt to the EEPROM.
 // SigFmts use 8 bytes of space.
-// The ID is stored little-endian in the first 4 bytes: 0--3.
+// The ID is stored in the first 4 bytes: 0--3.
 // Start and Size occupy bytes 4 and 5.
 // The Byte-order and Signedness flags are bits 7 and 6 of byte 6, respectively.
 // Byte order: [6][7] = {0=>LE, 1=>BE}.
diff --git a/fw/table.c b/fw/table.c
index 47a3ab9..c78d5e8 100644
--- a/fw/table.c
+++ b/fw/table.c
@@ -4,19 +4,23 @@
 #include "types.h"
 #include "can.h"
 #include "eeprom.h"
+#include "signal.h"
+#include "serial.h"
 
 #include "table.h"
 
 Status
 tabWrite(const Table *tab, U8 k, U32 key, U16 val) {
+	U16 addr;
+	U8 row[sizeof(key) + sizeof(val)];
+
 	if (k >= TAB_ROWS) {
 		return FAIL;
 	}
 
-	U16 addr = tab->offset + k*TAB_ROW_SIZE;
-	U8 row[sizeof(key) + sizeof(val)] = {
-		(key>>0u)&0xFF, (key>>8u)&0xFF, (key>>16u)&0xFF, (key>>24u)&0xFF, // LE
-		(val>>0u)&0xFF, (val>>8u)&0xFF}; // LE
+	addr = tab->offset + k*TAB_ROW_SIZE;
+	serU32Be(row, key);
+	serU16Be(row+sizeof(key), val);
 	return eepromWrite(addr, row, sizeof(row));
 }
 
@@ -32,8 +36,8 @@ tabRead(const Table *tab, U8 k, U32 *key, U16 *val) {
 
 	addr = tab->offset + k*TAB_ROW_SIZE;
 	status = eepromRead(addr, row, sizeof(row));
-	*key = ((U32)row[0u]<<0u) | ((U32)row[1u]<<8u) | ((U32)row[2u]<<16u) | ((U32)row[3u]<<24u); // LE
-	*val = ((U16)row[4u]<<0u) | ((U16)row[5u]<<8u); // LE
+	*key = deserU32Be(row);
+	*val = deserU16Be(row+sizeof(U32));
 	return status;
 }
 
diff --git a/fw/table.h b/fw/table.h
index da9baa0..c1cc03d 100644
--- a/fw/table.h
+++ b/fw/table.h
@@ -9,9 +9,9 @@
  *
  * Values are unsigned 16-bit integers.
  *
- * Numbers are stored little-endian.
+ * Numbers are stored big-endian.
  *
- * See also: doc/datafmt.pdf
+ * See also: `doc/datafmt.pdf'
  *
  * Device: PIC16F1459
  * Compiler: XC8 v3.00