SnapperGPS
How can I transfer snapshot data using I2C instead of going through WebUSB? #35
-
|
Thank you for your time and patience. Recently, I’ve been exploring how to transfer snapshot data using the public GPIO I2C interface, such as sending data directly to an ESP32 or other modules via I2C. While reading your paper titled "Probabilistic Snapshot GNSS for Low-Cost Wildlife Tracking," I noticed that snapshot data was transferred to a cellular module through I2C. I was wondering if you could kindly share the relevant code? It would be incredibly helpful for my learning process. |
Beta Was this translation helpful? Give feedback.
Replies: 0 comments 10 replies
-
|
The code is pretty specific to the used cellular module (a Blues Notecard), which uses JSON via I2C for communication. This is probably quite different from what you would want to do when talking to your ESP32, but below is a little library for reference. (The acelerometer-snappergps firmware is another example that includes I2C communication.) /****************************************************************************
* i2c.c
* SnapperGPS
* Jonas Beuchert
* 2022
* Functions to communicate with Notecard via I2C
*****************************************************************************/
#include "em_cmu.h"
#include "em_emu.h"
#include "em_i2c.h"
#include "em_gpio.h"
#include "pinouts.h" // For debugging only
#include "timer.h" // For debugging only
#include "notecard_i2c.h"
// I2C variables
static volatile I2C_TransferReturn_TypeDef I2C_Status;
// Interrupt handler
void I2C0_IRQHandler(void) {
I2C_Status = I2C_Transfer(I2C0);
}
// Public functions
void I2C_enableInterface() {
CMU_ClockEnable(cmuClock_I2C0, true);
GPIO_PinModeSet(I2C_SDA_PORT, I2C_SDA_PIN, gpioModeWiredAnd, 1);
GPIO_PinModeSet(I2C_SCL_PORT, I2C_SCL_PIN, gpioModeWiredAnd, 1);
for (int i = 0; i < 9; i++) {
GPIO_PinModeSet(I2C_SCL_PORT, I2C_SCL_PIN, gpioModeWiredAnd, 0);
GPIO_PinModeSet(I2C_SCL_PORT, I2C_SCL_PIN, gpioModeWiredAnd, 1);
}
I2C0->ROUTE = I2C_ROUTE_SDAPEN | I2C_ROUTE_SCLPEN | I2C_LOC;
I2C_Init_TypeDef i2cInit = I2C_INIT_DEFAULT;
I2C_Init(I2C0, &i2cInit);
NVIC_ClearPendingIRQ(I2C0_IRQn);
NVIC_EnableIRQ(I2C0_IRQn);
}
void I2C_disableInterface() {
GPIO_PinModeSet(I2C_SDA_PORT, I2C_SDA_PIN, gpioModeDisabled, 0);
GPIO_PinModeSet(I2C_SCL_PORT, I2C_SCL_PIN, gpioModeDisabled, 0);
I2C_Reset(I2C0);
CMU_ClockEnable(cmuClock_I2C0, false);
NVIC_DisableIRQ(I2C0_IRQn);
}
/**************************************************************************/
/*!
@brief Transmits an amount of data from the host in blocking mode.
@param[in] device_address
The I2C address.
@param[in] buffer
The data to transmit over I2C. The caller should have shifted
it right so that the low bit is NOT the read/write bit.
@param[in] size
The number of bytes to transmit.
@returns A string with an error, or `nullptr` if the transmission was
successful.
*/
/**************************************************************************/
const char *noteI2cTransmit(uint16_t device_address_, uint8_t *buffer_, uint16_t size_) {
// Adapted from AN0011
I2C_TransferSeq_TypeDef seq;
seq.addr = device_address_;
seq.flags = I2C_FLAG_WRITE;
seq.buf[0].data = buffer_;
seq.buf[0].len = size_;
// Do a polled transfer
I2C_Status = I2C_TransferInit(I2C0, &seq);
while (I2C_Status == i2cTransferInProgress)
{
// Enter EM1 while waiting for I2C interrupt
EMU_EnterEM1();
// Could do a timeout function here
}
const char * result = NULL;
return result;
}
/**************************************************************************/
/*!
@brief Receives an amount of data from the Notecard in blocking mode.
@param[in] device_address
The I2C address.
@param[out] buffer
A buffer to hold the data read from the I2C controller.
@param[in] requested_byte_count
The number of bytes requested.
@param[out] available
The number of bytes available for subsequent calls to receive().
@returns A string with an error, or `nullptr` if the receive was
successful.
*/
/**************************************************************************/
const char *noteI2cReceive(uint16_t device_address_, uint8_t *buffer_, uint16_t size_, uint32_t *available_) {
// Adapted from AN0011
I2C_TransferSeq_TypeDef seq;
seq.addr = device_address_;
seq.flags = I2C_FLAG_READ;
seq.buf[0].data = buffer_;
seq.buf[0].len = size_; // Might need to add REQUEST_HEADER_SIZE = 2
// Do a polled transfer
I2C_Status = I2C_TransferInit(I2C0, &seq);
while (I2C_Status == i2cTransferInProgress)
{
// Enter EM1 while waiting for I2C interrupt
EMU_EnterEM1();
// Could do a timeout function here
}
const char * result = NULL;
return result;
// TODO: set available
}
static const char basis_64[] =
"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
int JB64EncodeLen(int len)
{
return ((len + 2) / 3 * 4) + 1;
}
int JB64Encode(char *encoded, const char *string, int len)
{
int i;
char *p;
p = encoded;
for (i = 0; i < len - 2; i += 3) {
*p++ = basis_64[(string[i] >> 2) & 0x3F];
*p++ = basis_64[((string[i] & 0x3) << 4) | ((int) (string[i + 1] & 0xF0) >> 4)];
*p++ = basis_64[((string[i + 1] & 0xF) << 2) | ((int) (string[i + 2] & 0xC0) >> 6)];
*p++ = basis_64[string[i + 2] & 0x3F];
}
if (i < len) {
*p++ = basis_64[(string[i] >> 2) & 0x3F];
if (i == (len - 1)) {
*p++ = basis_64[((string[i] & 0x3) << 4)];
*p++ = '=';
} else {
*p++ = basis_64[((string[i] & 0x3) << 4) | ((int) (string[i + 1] & 0xF0) >> 4)];
*p++ = basis_64[((string[i + 1] & 0xF) << 2)];
}
*p++ = '=';
}
*p++ = '\0';
return p - encoded;
}This allows me to send JSON data to the cellular module using their specific JSON commands. For binary data, like the raw snapshots, I use base64 encoding (example below), something you probably would not want to do when writing your own comms protocol. char* snapshotAddress = (char*)SNAPSHOT_BUFFER_LOCATION;
int binaryDataLen = 48;
memset(message, 0, 255);
for (size_t toTransmitLen = SNAPSHOT_BUFFER_SIZE; toTransmitLen > 0; toTransmitLen -= (size_t) binaryDataLen) {
JB64Encode(&message[1], snapshotAddress, binaryDataLen);
msgLen = strlen(&message[1]);
((uint8_t *) message)[0] = (uint8_t) msgLen;
noteI2cTransmit(i2caddress, (uint8_t *) message, msgLen + 1);
Timer_delayMilliseconds(1);
snapshotAddress += binaryDataLen * sizeof(uint8_t);
}P.S: If you end up building something cool, I am of course happy to see it :) But no pressure. |
Beta Was this translation helpful? Give feedback.
-
|
I noticed the accelerometer-snappergps firmware. However, I’m a bit confused about how to invoke the relevant cellular module functions to carry out I2C protocol transmission after obtaining good snapshot data in main.c. Could you please provide an example of the complete code? I’m relatively new to embedded hardware development and more familiar with Python as my primary programming language. While I’m still learning C language , I’d really appreciate it if you could help me better understand the entire transmission process through a clear and detailed explanation. |
Beta Was this translation helpful? Give feedback.
-
|
Oh, OK, let me give a few more details. // Power off the radio
Radio_disableHFXOInput();
Radio_powerOff();After these lines, you insert the new code. I2C_enableInterface();Just as an example, sending some text via I2C works like this: char message[255];
sprintf(&message[1], "This is random text and these are two random values: %lu, %lu", value1, value2);
size_t msgLen = strlen(&message[1]);
((uint8_t *) message)[0] = (uint8_t) msgLen;
noteI2cTransmit(i2caddress, (uint8_t *) message, msgLen + 1);
Timer_delayMilliseconds(1);
memset(message, 0, 255);Here, I provide the message length as first value of the sent array to let the receiving MCU know how much data to expect, but this is not mandatory. The delay of 1 millisecond also depends on your setup as does the maximum message length (256 here). To send a snapshot instead of text, just do this: char message[255];
char* snapshotAddress = (char*)SNAPSHOT_BUFFER_LOCATION;
int binaryDataLen = 48;
memset(message, 0, 255);
for (size_t toTransmitLen = SNAPSHOT_BUFFER_SIZE; toTransmitLen > 0; toTransmitLen -= (size_t) binaryDataLen) {
JB64Encode(&message[1], snapshotAddress, binaryDataLen);
msgLen = strlen(&message[1]);
((uint8_t *) message)[0] = (uint8_t) msgLen;
noteI2cTransmit(i2caddress, (uint8_t *) message, msgLen + 1);
Timer_delayMilliseconds(1);
snapshotAddress += binaryDataLen * sizeof(uint8_t);
}
memset(message, 0, 255);This base64 encodes the binary data and then sends it as a string. However, this is not the most efficient way (uses more bytes). You can just replace the Depending on how often you would like to wake up your host MCU (ESP32?), you may not want to call this every time after you shut your radio off, but instead first save lots of snapshot data to memory (as usual) and then read it back at a later point in time. To get an idea of how this could work, look at how data is read back before USB transfer by inspecting the code after Eitehr way, the last step is: I2C_disableInterface(); |
Beta Was this translation helpful? Give feedback.
-
|
Thanks again for your previous reply. By the way, I have currently tested transmitting raw data via LEUART. The main code is as follows: ... other codes
// Transmit to cellular module via LEUART
void send_cellular_serial(uint8_t *dest, uint32_t length){
uint8_t *addr = dest;
while (addr < dest + length) {
LEUART_Tx(LEUART0, *addr++);
}
}
... other codes
// Power off the radio
Radio_disableHFXOInput();
Radio_powerOff();
if (frequencyGood) {
// TODO: remove (Flash green LED once)
enableGreenLED(true);
Timer_delayMilliseconds(10);
enableGreenLED(false);
} else {
// TODO: remove (Flash red LED once)
enableRedLED(true);
Timer_delayMilliseconds(10);
enableRedLED(false);
}
// Create struct that holds meta data and overwrite the first few bytes of the snapshot
snapshotMetaData_t *metaData = (snapshotMetaData_t*)SNAPSHOT_BUFFER_LOCATION;
metaData->time = time;
metaData->ticks = ticks;
metaData->pages = PAGES_PER_SNAPSHOT;
metaData->temperature = temperature;
metaData->batteryVoltage = batteryVoltage;
// Address of source array
uint8_t* address = (uint8_t*)SNAPSHOT_BUFFER_LOCATION;
// Transmit to cellular module via LEUART
if (frequencyGood){
init_cellular_serial();
send_cellular_serial(address, SNAPSHOT_BUFFER_SIZE);
}
... other codesThrough the above code I can receive the following data:
Through the snapshot data above, I can currently parse the first 4 bytes of data to correctly parse the time. What I am currently confused about is that the byte length of the received snapshot data is only 4096, which is inconsistent with the #define SNAPSHOT_BUFFER_SIZE 0x1800 in the main.c code. print(len(bytes.fromhex(raw_data))) # --> 4096
raw_bytes = bytes.fromhex('0c0e f667')
timestamp = int.from_bytes(raw_bytes, byteorder='little')
print(timestamp) # --> 1744178700
dt = datetime.utcfromtimestamp(timestamp)
print(dt) # --> 2025-04-09 06:05:00Is there a problem with the send_cellular_serial function I wrote earlier? Also, if I want to parse the raw data myself, what code should I refer to? |
Beta Was this translation helpful? Give feedback.
-
|
Maybe the serial comms library that you are using to receive data (pyserial?) on your operating system (Windows?) has an input buffer/queue limit of 4096? |
Beta Was this translation helpful? Give feedback.
-
Yes, earlier today it was confirmed that the serial port buffer size of the 4G module used was limited to 4096 bytes, and now it can receive 6144 bytes of data normally. |
Beta Was this translation helpful? Give feedback.
-
I have obtained 6144 bytes of raw snapshot data. How should I parse this 6144 bytes of snapshot data correctly? Or is there any parsing rule? For example, the first 4 bytes are the time, etc. Is there any reference code? |
Beta Was this translation helpful? Give feedback.
Oh, OK, let me give a few more details.
You want to look in the firmware and find the lines where you turn the radio off after acquiring a snapshot, these lines:
After these lines, you insert the new code.
First, enable I2C:
I2C_enableInterface();Just as an example, sending some text via I2C works like this:
H…