MusaMahmood/Multimodal-CV-FW-USB-ADS1298R
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Change read size to 64, add throughput testing.

Browse Source
This commit is contained in:
Musa Mahmood 2025-04-09 09:14:24 -04:00
parent 9f5d281a62
commit d2ffd09079
3 changed files with 36 additions and 198 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

31
base/types.h
View File

@ -1,31 +0,0 @@
#include <stdint.h>
#include <stdbool.h>
#include <stddef.h>
#include <stdio.h>
#include <string.h>
typedef uint8_t u8;
typedef uint16_t u16;
typedef uint32_t u32;
typedef uint64_t u64;
typedef int8_t s8;
typedef int16_t s16;
typedef int32_t s32;
typedef int64_t s64;
typedef s8 b8;
typedef s16 b16;
typedef s32 b32;
typedef float f32;
#define Create_String(s) ((String){.count=(sizeof(s)-1), .data=(s)})
typedef struct {
s32 count;
u8* data;
} String;
String create_string(char* data) {
s32 count = strlen(data);
String s = {count, data};
return s;
}

70
base/usb_logging.h
View File

@ -1,70 +0,0 @@
// Helper code for saving data to USB
// Global log buffer and usage:
static u8 log_buffer[4096];
static s32 m_log_usage = 0;
// Sending logs
static bool m_send_logs = 0;
static s32 m_log_buffer_send_index = 0;
static volatile bool tx_complete = true;
static bool full_tx_complete = false;
// Functions for adding to and resetting buffer:
#define LOG_MODE 0
// Mode 0: do not wrap around, do not append to buffer
// Mode 1: wrap around to beginning.
static void reset_log_buffer(void) {
// If debug, then memset buffer
memset(log_buffer, 0, sizeof(log_buffer));
m_log_usage = 0;
m_log_buffer_send_index = 0;
tx_complete = true;
full_tx_complete = false;
}
static void add_to_log_buffer(String str) {
// Bounds check the buffer:
if (m_log_usage + str.count >= sizeof(log_buffer)) {
// Failure!.. How to handle? Turn on LEDs?
return; // Do not add to buffer
}
memcpy(&log_buffer[m_log_usage], str.data, str.count);
m_log_usage += str.count;
}
// FOR STRING LITERALS ONLY
// #define JIIM_LOG_USB(strlit) add_to_log_buffer(Create_String(strlit))
// Dynamic strings
static u8 sprint_buffer[128];
static s32 sprint_length;
// #TODO: Inline
void add_format_string_to_log_buffer(void) {
// Replace null terminator with \n where required.
sprint_buffer[sprint_length] = '\n';
String s = {sprint_length+1, sprint_buffer};
add_to_log_buffer(s);
}
// #TODO: I need to append a \n here
#define JIIM_LOG(fmt, ...) \
sprint_length = sprintf(sprint_buffer, fmt, ##__VA_ARGS__); \
add_format_string_to_log_buffer()
/*
void send_usb_log(String str) {
// Zero buffer:
//memset(str.data, 0, NRF_DRV_USBD_EPSIZE);
// Copy string:
//memcpy(m_tx_buffer, str.data, str.count);
app_usbd_cdc_acm_write(&m_app_cdc_acm, str.data, str.count);
}
void log_usb(char* data) {
send_usb_log(create_string(data));
}
*/

133
main.c
View File

@ -1,9 +1,8 @@
// What I want is to be able to send logs ONLY in log mode, so I need to keep a buffer of strings #include <stdint.h>
// String logs[64], pointing to different strings. #include <stdbool.h>
// I just fucking hate strlen for this kind of thing #include <stddef.h>
// If only there's a way to precompute string lengths. #include <stdio.h>
// Nordic drivers and application code:
#include "nrf.h" #include "nrf.h"
#include "nrf_drv_usbd.h" #include "nrf_drv_usbd.h"
#include "nrf_drv_clock.h" #include "nrf_drv_clock.h"
@ -25,13 +24,6 @@
#include "nrf_log_ctrl.h" #include "nrf_log_ctrl.h"
#include "nrf_log_default_backends.h" #include "nrf_log_default_backends.h"
// **** jiim base code ****
#include "base/types.h"
#include "base/usb_logging.h"
// **** Sensor driver APIs ****
#include "ads1298.h"
/** /**
* @brief Enable power USB detection * @brief Enable power USB detection
* *
@ -63,23 +55,29 @@ APP_USBD_CDC_ACM_GLOBAL_DEF(m_app_cdc_acm,
CDC_ACM_COMM_EPIN, CDC_ACM_COMM_EPIN,
CDC_ACM_DATA_EPIN, CDC_ACM_DATA_EPIN,
CDC_ACM_DATA_EPOUT, CDC_ACM_DATA_EPOUT,
APP_USBD_CDC_COMM_PROTOCOL_AT_V250); APP_USBD_CDC_COMM_PROTOCOL_AT_V250
);
#define READ_SIZE 1 #define READ_SIZE 64
static char m_rx_buffer[READ_SIZE]; static char m_rx_buffer[READ_SIZE];
static char m_tx_buffer[NRF_DRV_USBD_EPSIZE]; static char m_tx_buffer[NRF_DRV_USBD_EPSIZE];
static bool m_send_flag = 0; static bool m_run_throughput_test = false;
static bool m_send_flag = false;
/** /**
* @brief User event handler @ref app_usbd_cdc_acm_user_ev_handler_t (headphones) * @brief User event handler @ref app_usbd_cdc_acm_user_ev_handler_t (headphones)
* */ * */
static void cdc_acm_user_ev_handler(app_usbd_class_inst_t const * p_inst, static void cdc_acm_user_ev_handler(app_usbd_class_inst_t const * p_inst,
app_usbd_cdc_acm_user_event_t event) { app_usbd_cdc_acm_user_event_t event)
{
app_usbd_cdc_acm_t const * p_cdc_acm = app_usbd_cdc_acm_class_get(p_inst); app_usbd_cdc_acm_t const * p_cdc_acm = app_usbd_cdc_acm_class_get(p_inst);
switch (event) { switch (event)
case APP_USBD_CDC_ACM_USER_EVT_PORT_OPEN: { {
case APP_USBD_CDC_ACM_USER_EVT_PORT_OPEN:
{
/*Setup first transfer*/ /*Setup first transfer*/
ret_code_t ret = app_usbd_cdc_acm_read(&m_app_cdc_acm, ret_code_t ret = app_usbd_cdc_acm_read(&m_app_cdc_acm,
m_rx_buffer, m_rx_buffer,
@ -90,26 +88,24 @@ static void cdc_acm_user_ev_handler(app_usbd_class_inst_t const * p_inst,
case APP_USBD_CDC_ACM_USER_EVT_PORT_CLOSE: case APP_USBD_CDC_ACM_USER_EVT_PORT_CLOSE:
break; break;
case APP_USBD_CDC_ACM_USER_EVT_TX_DONE: case APP_USBD_CDC_ACM_USER_EVT_TX_DONE:
tx_complete = true;
if (m_send_logs && full_tx_complete) { reset_log_buffer(); }
break; break;
case APP_USBD_CDC_ACM_USER_EVT_RX_DONE: { case APP_USBD_CDC_ACM_USER_EVT_RX_DONE:
{
ret_code_t ret; ret_code_t ret;
NRF_LOG_INFO("Bytes waiting: %d", app_usbd_cdc_acm_bytes_stored(p_cdc_acm)); NRF_LOG_INFO("Bytes waiting: %d", app_usbd_cdc_acm_bytes_stored(p_cdc_acm));
do { do
{
/*Get amount of data transfered*/ /*Get amount of data transfered*/
size_t size = app_usbd_cdc_acm_rx_size(p_cdc_acm); size_t size = app_usbd_cdc_acm_rx_size(p_cdc_acm);
NRF_LOG_INFO("RX: size: %lu char: %c", size, m_rx_buffer[0]); NRF_LOG_INFO("RX: size: %lu char: %c", size, m_rx_buffer[0]);
if (m_rx_buffer[0] == 0xFF) {
if (m_rx_buffer[0] == 0) { m_run_throughput_test = true;
m_send_flag = false;
m_send_logs = false;
} }
if (m_rx_buffer[0] == 1) { if (m_rx_buffer[0] == 1) {
m_send_flag = true; m_send_flag = false;
} }
if (m_rx_buffer[0] == 2) { if (m_rx_buffer[0] == 2) {
m_send_logs = true; m_send_flag = true;
} }
/* Fetch data until internal buffer is empty */ /* Fetch data until internal buffer is empty */
@ -125,8 +121,10 @@ static void cdc_acm_user_ev_handler(app_usbd_class_inst_t const * p_inst,
} }
} }
static void usbd_user_ev_handler(app_usbd_event_type_t event) { static void usbd_user_ev_handler(app_usbd_event_type_t event)
switch (event) { {
switch (event)
{
case APP_USBD_EVT_DRV_SUSPEND: case APP_USBD_EVT_DRV_SUSPEND:
break; break;
case APP_USBD_EVT_DRV_RESUME: case APP_USBD_EVT_DRV_RESUME:
@ -139,7 +137,8 @@ static void usbd_user_ev_handler(app_usbd_event_type_t event) {
case APP_USBD_EVT_POWER_DETECTED: case APP_USBD_EVT_POWER_DETECTED:
NRF_LOG_INFO("USB power detected"); NRF_LOG_INFO("USB power detected");
if (!nrf_drv_usbd_is_enabled()) { if (!nrf_drv_usbd_is_enabled())
{
app_usbd_enable(); app_usbd_enable();
} }
break; break;
@ -156,37 +155,17 @@ static void usbd_user_ev_handler(app_usbd_event_type_t event) {
} }
} }
ads1298_info_t m_info;
static ble_exg_t m_exg;
// Global Data:
// Unfortunately I need to precompute these strlens manually :skull-emoji:
// String hello_string = {21, "Hello, I am a string\n"};
void Send_USB_Logs(void) {
if (!tx_complete) return;
// We should check that the USB data is
s32 bytes_remaining = m_log_usage - m_log_buffer_send_index;
if (bytes_remaining <= 0) {
full_tx_complete = true;
return;
}
app_usbd_cdc_acm_write(&m_app_cdc_acm, &log_buffer[m_log_buffer_send_index], 64);
m_log_buffer_send_index += 64;
tx_complete = false;
}
int main(void) { int main(void) {
ret_code_t ret; ret_code_t ret;
static const app_usbd_config_t usbd_config = { static const app_usbd_config_t usbd_config = {
.ev_state_proc = usbd_user_ev_handler .ev_state_proc = usbd_user_ev_handler
}; };
// #TODO: remove logging maybe?
ret = NRF_LOG_INIT(NULL); ret = NRF_LOG_INIT(NULL);
APP_ERROR_CHECK(ret); APP_ERROR_CHECK(ret);
NRF_LOG_DEFAULT_BACKENDS_INIT(); // Init RTT Backend
ret = nrf_drv_clock_init(); ret = nrf_drv_clock_init();
APP_ERROR_CHECK(ret); APP_ERROR_CHECK(ret);
@ -202,7 +181,7 @@ int main(void) {
ret = app_usbd_init(&usbd_config); ret = app_usbd_init(&usbd_config);
APP_ERROR_CHECK(ret); APP_ERROR_CHECK(ret);
// NRF_LOG_INFO("USBD CDC ACM example started."); NRF_LOG_INFO("USBD CDC ACM example started.");
app_usbd_class_inst_t const * class_cdc_acm = app_usbd_cdc_acm_class_inst_get(&m_app_cdc_acm); app_usbd_class_inst_t const * class_cdc_acm = app_usbd_cdc_acm_class_inst_get(&m_app_cdc_acm);
ret = app_usbd_class_append(class_cdc_acm); ret = app_usbd_class_append(class_cdc_acm);
@ -212,52 +191,16 @@ int main(void) {
ret = app_usbd_power_events_enable(); ret = app_usbd_power_events_enable();
APP_ERROR_CHECK(ret); APP_ERROR_CHECK(ret);
} else { } else {
JIIM_LOG("No USB power detection enabled\r\nStarting USB now"); NRF_LOG_INFO("No USB power detection enabled\r\nStarting USB now");
app_usbd_enable(); app_usbd_enable();
app_usbd_start(); app_usbd_start();
} }
// Throughput testing:
reset_log_buffer(); // initialize log buffer with `A`
JIIM_LOG("Hello world!");
JIIM_LOG("HELLO WORLD %d FORMATTED", 2);
JIIM_LOG("sizeof(log_buffer): %d", sizeof(log_buffer));
// TODO#: ads1298_init_gpio().
// TODO#: Push logs over USB.
JIIM_LOG("Hello, I am a string2");
JIIM_LOG("Hello, I am a string2");
JIIM_LOG("Hello, I am a string2");
JIIM_LOG("Hello, I am a string2");
JIIM_LOG("Hello, I am a string2");
JIIM_LOG("Hello, I am a string2");
// String hello_string = Create_String("Hello, I am a string2\n");
// add_to_log_buffer(hello_string);
// add_to_log_buffer(hello_string);
// add_to_log_buffer(hello_string);
ads1298_initialize(&m_exg, &m_info);
if (m_info.nChs > 0) {
// #TODO: replace with sprintf()...
JIIM_LOG("Number of channels available: %d", m_info.nChs);
} else {
JIIM_LOG("ERROR: ADS129x NOT DETECTED!");
}
//memset(m_tx_buffer, 0x41/*"A"*/, NRF_DRV_USBD_EPSIZE);
//size_t size = NRF_DRV_USBD_EPSIZE;
//s32 count = 0;
while (true) { while (true) {
while (app_usbd_event_queue_process()) {/* Nothing to do */} while (app_usbd_event_queue_process()) {/* Nothing to do */}
if (m_send_flag) { if(m_run_throughput_test) {
}
if (m_send_logs) {
// static int frame_counter; // static int frame_counter;
// size_t size = sprintf(m_tx_buffer, "Hello USB CDC FA demo: %u\r\n", frame_counter); // size_t size = sprintf(m_tx_buffer, "Hello USB CDC FA demo: %u\r\n", frame_counter);
@ -265,11 +208,7 @@ int main(void) {
// ret = app_usbd_cdc_acm_write(&m_app_cdc_acm, m_tx_buffer, size); // ret = app_usbd_cdc_acm_write(&m_app_cdc_acm, m_tx_buffer, size);
// if (ret == NRF_SUCCESS) { ++frame_counter; } // if (ret == NRF_SUCCESS) { ++frame_counter; }
// app_usbd_cdc_acm_write(&m_app_cdc_acm, m_tx_buffer, size); app_usbd_cdc_acm_write(&m_app_cdc_acm, m_tx_buffer, NRF_DRV_USBD_EPSIZE);
// send_usb_log(hello_string);
//log_usb("TestTestTest");
// count += 1;
Send_USB_Logs();
} }
UNUSED_RETURN_VALUE(NRF_LOG_PROCESS()); UNUSED_RETURN_VALUE(NRF_LOG_PROCESS());