jacob.eva/librnode
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Move to platform neutral serial interface & rename sleep function

Browse Source
This commit is contained in:
Jacob Eva 2025-08-05 18:08:09 +01:00
parent 99786ea246
commit 95147000c0
9 changed files with 199 additions and 92 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

138
src/librnode.c
View File

@ -25,7 +25,7 @@ int rnode_handle_resp(struct RNode* rn, bool* in_frame, uint8_t* cmd, uint8_t* c
uint8_t sbyte;
uint8_t resp_buf[RESP_BUF_SIZE] = {0};
len = read_port(rn->fd, resp_buf, RESP_BUF_SIZE);
len = read_port(&rn->handle, resp_buf, RESP_BUF_SIZE);
if (len > 0) {
log_trace("Read %d bytes", len);
@ -261,9 +261,9 @@ int rnode_detect(struct RNode* rn) {
uint16_t frame_len = 0;
memcpy(tx_buf, (uint8_t[16]){FEND, CMD_DETECT, DETECT_REQ, FEND, FEND, CMD_FW_VERSION, 0x00, FEND, FEND, CMD_PLATFORM, 0x00, FEND, FEND, CMD_MCU, 0x00, FEND}, 16*sizeof(uint8_t));
err_code = write_port(rn->fd, tx_buf, 16);
err_code = write_port(&rn->handle, tx_buf, 16);
if (!err_code) {
sleep_ms(100);
sleep_mils(100);
err_code = rnode_handle_resp(rn, &in_frame, &cmd, cmd_buf, &cmd_buf_l, &frame_len);
return (err_code == -1) ? -1 : rn->connected;
} else {
@ -283,9 +283,9 @@ int rnode_detect(struct RNode* rn) {
int rnode_init(struct RNode* rn, char* port, uint32_t baud, bool detect, bool force_detect) {
rn->port = port;
rn->baud = baud;
rn->fd = open_port(rn->port, baud);
open_port(&rn->handle, rn->port, baud);
if (rn->fd > 0) {
if (&rn->handle > 0) {
if (detect) {
if (rnode_detect(rn)) {
log_info("RNode detected successfully on port %s", port);
@ -315,7 +315,7 @@ int rnode_init(struct RNode* rn, char* port, uint32_t baud, bool detect, bool fo
int rnode_reset(struct RNode* rn) {
uint8_t tx_buf[4];
memcpy(tx_buf, (uint8_t[4]){FEND, CMD_RESET, CMD_RESET_BYTE, FEND}, 4*sizeof(uint8_t));
return write_port(rn->fd, tx_buf, 4);
return write_port(&rn->handle, tx_buf, 4);
}
/* Sets an RNode's platform attribute manually
@ -347,7 +347,7 @@ int rnode_set_bt(struct RNode* rn, uint8_t val) {
}
uint8_t tx_buf[4];
memcpy(tx_buf, (uint8_t[4]){FEND, CMD_BT_CTRL, val, FEND}, 4*sizeof(uint8_t));
err_code = write_port(rn->fd, tx_buf, 4);
err_code = write_port(&rn->handle, tx_buf, 4);
return err_code;
}
@ -379,7 +379,7 @@ int rnode_get_bt_pin(struct RNode* rn, uint32_t timeout) {
while (current <= start + timeout) {
if (err_code >= 0) {
sleep_ms(50);
sleep_mils(50);
err_code = rnode_handle_resp(rn, &in_frame, &cmd, cmd_buf, &cmd_buf_l, &frame_len);
time(&ltime); current = ltime;
if (rn->bt_pairing_pin != 0) {
@ -406,7 +406,7 @@ int rnode_set_disp_int(struct RNode* rn, uint8_t disp_int) {
int err_code = 0;
uint8_t tx_buf[4];
memcpy(tx_buf, (uint8_t[4]){FEND, CMD_DISP_INT, disp_int, FEND}, 4*sizeof(uint8_t));
err_code = write_port(rn->fd, tx_buf, 4);
err_code = write_port(&rn->handle, tx_buf, 4);
return err_code;
}
@ -421,7 +421,7 @@ int rnode_set_disp_timeout(struct RNode* rn, uint8_t timeout) {
int err_code = 0;
uint8_t tx_buf[4];
memcpy(tx_buf, (uint8_t[4]){FEND, CMD_DISP_INT, timeout, FEND}, 4*sizeof(uint8_t));
err_code = write_port(rn->fd, tx_buf, 4);
err_code = write_port(&rn->handle, tx_buf, 4);
return err_code;
}
@ -436,7 +436,7 @@ int rnode_set_disp_addr(struct RNode* rn, uint8_t addr) {
int err_code = 0;
uint8_t tx_buf[4];
memcpy(tx_buf, (uint8_t[4]){FEND, CMD_DISP_ADDR, addr, FEND}, 4*sizeof(uint8_t));
err_code = write_port(rn->fd, tx_buf, 4);
err_code = write_port(&rn->handle, tx_buf, 4);
return err_code;
}
@ -454,7 +454,7 @@ int rnode_set_disp_rot(struct RNode* rn, uint8_t rot) {
uint8_t tx_buf[4];
memcpy(tx_buf, (uint8_t[4]){FEND, CMD_DISP_ROT, rot, FEND}, 4*sizeof(uint8_t));
err_code = write_port(rn->fd, tx_buf, 4);
err_code = write_port(&rn->handle, tx_buf, 4);
return err_code;
}
@ -469,7 +469,7 @@ int rnode_start_disp_recon(struct RNode* rn) {
int err_code = 0;
uint8_t tx_buf[4];
memcpy(tx_buf, (uint8_t[4]){FEND, CMD_DISP_RCND, 1, FEND}, 4*sizeof(uint8_t));
err_code = write_port(rn->fd, tx_buf, 4);
err_code = write_port(&rn->handle, tx_buf, 4);
return err_code;
}
@ -484,7 +484,7 @@ int rnode_set_np_int(struct RNode* rn, uint8_t np_int) {
int err_code;
uint8_t tx_buf[4];
memcpy(tx_buf, (uint8_t[4]){FEND, CMD_NP_INT, np_int, FEND}, 4*sizeof(uint8_t));
err_code = write_port(rn->fd, tx_buf, 4);
err_code = write_port(&rn->handle, tx_buf, 4);
return err_code;
}
@ -505,10 +505,10 @@ int rnode_get_interfaces(struct RNode* rn) {
uint16_t frame_len = 0;
memcpy(tx_buf, (uint8_t[4]){FEND, CMD_INTERFACES, 0x00, FEND}, 4*sizeof(uint8_t));
err_code = write_port(rn->fd, tx_buf, 4);
err_code = write_port(&rn->handle, tx_buf, 4);
if (!err_code) {
sleep_ms(100);
sleep_mils(100);
err_code = rnode_handle_resp(rn, &in_frame, &cmd, cmd_buf, &cmd_buf_l, &frame_len);
}
@ -536,7 +536,7 @@ int rnode_select_interface(struct RNode* rn, uint8_t interface) {
if (rn->interfaces[interface] != 0) {
memcpy(tx_buf, (uint8_t[4]){FEND, CMD_SEL_INT, interface, FEND}, 4*sizeof(uint8_t));
err_code = write_port(rn->fd, tx_buf, 4);
err_code = write_port(&rn->handle, tx_buf, 4);
} else {
return err_code;
}
@ -574,10 +574,10 @@ int rnode_set_freq(struct RNode* rn, uint32_t freq) {
memcpy(tx_buf + 2, escaped_freq, escaped_freq_size*sizeof(uint8_t));
tx_buf[2 + escaped_freq_size] = FEND;
err_code = write_port(rn->fd, tx_buf, 2 + escaped_freq_size + 1);
err_code = write_port(&rn->handle, tx_buf, 2 + escaped_freq_size + 1);
if (!err_code) {
sleep_ms(100);
sleep_mils(100);
err_code = rnode_handle_resp(rn, &in_frame, &cmd, cmd_buf, &cmd_buf_l, &frame_len);
if (!err_code) {
return rn->freq;
@ -606,10 +606,10 @@ int rnode_get_freq(struct RNode* rn) {
memcpy(tx_buf, (uint8_t[7]){FEND, CMD_FREQUENCY, 0, 0, 0, 0, FEND}, 7*sizeof(uint8_t));
err_code = write_port(rn->fd, tx_buf, 7);
err_code = write_port(&rn->handle, tx_buf, 7);
if (!err_code) {
sleep_ms(100);
sleep_mils(100);
err_code = rnode_handle_resp(rn, &in_frame, &cmd, cmd_buf, &cmd_buf_l, &frame_len);
if (!err_code) {
return rn->freq;
@ -646,10 +646,10 @@ int rnode_set_bw(struct RNode* rn, uint32_t bw) {
memcpy(tx_buf + 2, escaped_bw, escaped_bw_size*sizeof(uint8_t));
tx_buf[2 + escaped_bw_size] = FEND;
err_code = write_port(rn->fd, tx_buf, 2 + escaped_bw_size + 1);
err_code = write_port(&rn->handle, tx_buf, 2 + escaped_bw_size + 1);
if (!err_code) {
sleep_ms(100);
sleep_mils(100);
err_code = rnode_handle_resp(rn, &in_frame, &cmd, cmd_buf, &cmd_buf_l, &frame_len);
if (!err_code) {
return rn->bw;
@ -678,10 +678,10 @@ int rnode_get_bw(struct RNode* rn) {
memcpy(tx_buf, (uint8_t[7]){FEND, CMD_BANDWIDTH, 0, 0, 0, 0, FEND}, 7*sizeof(uint8_t));
err_code = write_port(rn->fd, tx_buf, 7);
err_code = write_port(&rn->handle, tx_buf, 7);
if (!err_code) {
sleep_ms(100);
sleep_mils(100);
err_code = rnode_handle_resp(rn, &in_frame, &cmd, cmd_buf, &cmd_buf_l, &frame_len);
if (!err_code) {
return rn->bw;
@ -710,10 +710,10 @@ int rnode_set_txp(struct RNode* rn, uint8_t txp) {
memcpy(tx_buf, (uint8_t[4]){FEND, CMD_TXPOWER, txp, FEND}, 4*sizeof(uint8_t));
err_code = write_port(rn->fd, tx_buf, 4);
err_code = write_port(&rn->handle, tx_buf, 4);
if (!err_code) {
sleep_ms(100);
sleep_mils(100);
err_code = rnode_handle_resp(rn, &in_frame, &cmd, cmd_buf, &cmd_buf_l, &frame_len);
if (err_code > 0) {
return txp == rn->txp ? 0 : -1;
@ -742,10 +742,10 @@ int rnode_get_txp(struct RNode* rn) {
memcpy(tx_buf, (uint8_t[4]){FEND, CMD_TXPOWER, 0xFF, FEND}, 4*sizeof(uint8_t));
err_code = write_port(rn->fd, tx_buf, 4);
err_code = write_port(&rn->handle, tx_buf, 4);
if (!err_code) {
sleep_ms(100);
sleep_mils(100);
err_code = rnode_handle_resp(rn, &in_frame, &cmd, cmd_buf, &cmd_buf_l, &frame_len);
if (!err_code) {
return rn->txp;
@ -774,10 +774,10 @@ int rnode_set_sf(struct RNode* rn, uint8_t sf) {
memcpy(tx_buf, (uint8_t[4]){FEND, CMD_SF, sf, FEND}, 4*sizeof(uint8_t));
err_code = write_port(rn->fd, tx_buf, 4);
err_code = write_port(&rn->handle, tx_buf, 4);
if (!err_code) {
sleep_ms(100);
sleep_mils(100);
err_code = rnode_handle_resp(rn, &in_frame, &cmd, cmd_buf, &cmd_buf_l, &frame_len);
if (err_code > 0) {
return sf == rn->sf ? 0 : -1;
@ -807,10 +807,10 @@ int rnode_get_sf(struct RNode* rn) {
memcpy(tx_buf, (uint8_t[4]){FEND, CMD_SF, 0xFF, FEND}, 4*sizeof(uint8_t));
err_code = write_port(rn->fd, tx_buf, 4);
err_code = write_port(&rn->handle, tx_buf, 4);
if (!err_code) {
sleep_ms(100);
sleep_mils(100);
err_code = rnode_handle_resp(rn, &in_frame, &cmd, cmd_buf, &cmd_buf_l, &frame_len);
if (!err_code) {
return rn->sf;
@ -839,10 +839,10 @@ int rnode_set_cr(struct RNode* rn, uint8_t cr) {
memcpy(tx_buf, (uint8_t[4]){FEND, CMD_CR, cr, FEND}, 4*sizeof(uint8_t));
err_code = write_port(rn->fd, tx_buf, 4);
err_code = write_port(&rn->handle, tx_buf, 4);
if (!err_code) {
sleep_ms(100);
sleep_mils(100);
err_code = rnode_handle_resp(rn, &in_frame, &cmd, cmd_buf, &cmd_buf_l, &frame_len);
if (err_code > 0) {
return cr == rn->cr ? 0 : -1;
@ -872,10 +872,10 @@ int rnode_get_cr(struct RNode* rn) {
memcpy(tx_buf, (uint8_t[4]){FEND, CMD_CR, 0xFF, FEND}, 4*sizeof(uint8_t));
err_code = write_port(rn->fd, tx_buf, 4);
err_code = write_port(&rn->handle, tx_buf, 4);
if (!err_code) {
sleep_ms(100);
sleep_mils(100);
err_code = rnode_handle_resp(rn, &in_frame, &cmd, cmd_buf, &cmd_buf_l, &frame_len);
if (err_code > 0) {
return rn->cr;
@ -907,10 +907,10 @@ float rnode_set_st_alock(struct RNode* rn, float at_l) {
memcpy(tx_buf + 2, (uint8_t[2]){(at >> 8 & 0xFF), (at & 0xFF)}, 1*sizeof(uint8_t));
tx_buf[2 + 1] = FEND;
err_code = write_port(rn->fd, tx_buf, 2 + 1 + 1);
err_code = write_port(&rn->handle, tx_buf, 2 + 1 + 1);
if (!err_code) {
sleep_ms(100);
sleep_mils(100);
err_code = rnode_handle_resp(rn, &in_frame, &cmd, cmd_buf, &cmd_buf_l, &frame_len);
if (err_code > 0) {
return at_l == rn->st_alock ? 0 : -1;
@ -942,10 +942,10 @@ float rnode_set_lt_alock(struct RNode* rn, float at_l) {
memcpy(tx_buf + 2, (uint8_t[2]){(at >> 8 & 0xFF), (at & 0xFF)}, 1*sizeof(uint8_t));
tx_buf[2 + 1] = FEND;
err_code = write_port(rn->fd, tx_buf, 2 + 1 + 1);
err_code = write_port(&rn->handle, tx_buf, 2 + 1 + 1);
if (!err_code) {
sleep_ms(100);
sleep_mils(100);
err_code = rnode_handle_resp(rn, &in_frame, &cmd, cmd_buf, &cmd_buf_l, &frame_len);
if (err_code > 0) {
return at_l == rn->lt_alock ? 0 : -1;
@ -974,10 +974,10 @@ int rnode_set_interface_state(struct RNode* rn, bool state) {
memcpy(tx_buf, (uint8_t[4]){FEND, CMD_RADIO_STATE, state, FEND}, 4*sizeof(uint8_t));
err_code = write_port(rn->fd, tx_buf, 4);
err_code = write_port(&rn->handle, tx_buf, 4);
if (!err_code) {
sleep_ms(100);
sleep_mils(100);
err_code = rnode_handle_resp(rn, &in_frame, &cmd, cmd_buf, &cmd_buf_l, &frame_len);
if (err_code > 0) {
return state == rn->int_state[rn->sel_int] ? 0 : -1;
@ -1010,7 +1010,7 @@ int rnode_get_interface_state(struct RNode* rn) {
int rnode_set_normal_mode(struct RNode* rn) {
uint8_t tx_buf[4];
memcpy(tx_buf, (uint8_t[4]){FEND, CMD_CONF_DELETE, 0x00, FEND}, 4*sizeof(uint8_t));
return write_port(rn->fd, tx_buf, 4);
return write_port(&rn->handle, tx_buf, 4);
}
/* Enable the serial TNC mode of operation on an RNode
@ -1023,7 +1023,7 @@ int rnode_set_tnc_mode(struct RNode* rn) {
int err_code = 0;
uint8_t tx_buf[4];
memcpy(tx_buf, (uint8_t[4]){FEND, CMD_CONF_SAVE, 0x00, FEND}, 4*sizeof(uint8_t));
err_code = write_port(rn->fd, tx_buf, 4);
err_code = write_port(&rn->handle, tx_buf, 4);
return err_code;
}
@ -1033,7 +1033,7 @@ int rnode_set_int_avoid(struct RNode* rn, bool avoid) {
int err_code = 0;
uint8_t tx_buf[4];
memcpy(tx_buf, (uint8_t[4]){FEND, CMD_DIS_IA, !avoid, FEND}, 4*sizeof(uint8_t));
err_code = write_port(rn->fd, tx_buf, 4);
err_code = write_port(&rn->handle, tx_buf, 4);
return err_code;
}
@ -1064,7 +1064,7 @@ int rnode_set_fw_hash(struct RNode* rn, uint8_t* hash) {
encode_slip(escaped_hash, &escaped_hash_size, hash, FW_HASH_SIZE, false);
memcpy(tx_buf + 2, escaped_hash, escaped_hash_size*sizeof(uint8_t));
tx_buf[2 + escaped_hash_size] = FEND;
return write_port(rn->fd, tx_buf, 2 + escaped_hash_size + 1);
return write_port(&rn->handle, tx_buf, 2 + escaped_hash_size + 1);
}
/* Write to an arbitrary address in an RNode's EEPROM
@ -1091,10 +1091,10 @@ int rnode_write_eeprom(struct RNode* rn, uint8_t address, uint8_t value) {
tx_buf[2 + escaped_data_size] = FEND;
err_code = write_port(rn->fd, tx_buf, 2 + escaped_data_size + 1);
err_code = write_port(&rn->handle, tx_buf, 2 + escaped_data_size + 1);
if (!err_code) {
sleep_ms(6);
sleep_mils(6);
}
return err_code;
}
@ -1359,10 +1359,10 @@ int rnode_dump_eeprom(struct RNode* rn) {
uint16_t frame_len = 0;
memcpy(tx_buf, (uint8_t[4]){FEND, CMD_ROM_READ, 0x00, FEND}, 4*sizeof(uint8_t));
err_code = write_port(rn->fd, tx_buf, 4);
err_code = write_port(&rn->handle, tx_buf, 4);
if (!err_code) {
sleep_ms(100);
sleep_mils(100);
err_code = rnode_handle_resp(rn, &in_frame, &cmd, cmd_buf, &cmd_buf_l, &frame_len);
}
@ -1471,28 +1471,28 @@ int rnode_wipe_eeprom(struct RNode* rn) {
log_trace("RNode firmware version too low!");
return -2;
} else {
err_code = write_port(rn->fd, tx_buf, 4);
err_code = write_port(&rn->handle, tx_buf, 4);
}
if (err_code) {
return err_code;
}
err_code = close_port(rn->fd);
err_code = close_port(&rn->handle);
if (!err_code) {
sleep_ms(13000);
sleep_mils(13000);
if (rn->platform == PLATFORM_NRF52) {
// Due to the current janky emulated EEPROM implementation for the
// RAK4631, extra time must be given to allow for writing.
sleep_ms(10000);
sleep_mils(10000);
}
} else {
return err_code;
}
rn->fd = open_port(rn->port, rn->baud);
open_port(&rn->handle, rn->port, rn->baud);
return (err_code == 0) ? 0 : -1;
}
@ -1516,12 +1516,12 @@ int rnode_flash(struct RNode* rn, char* zip_path, bool update, uint8_t* serial,
// show update logo on RNode display
uint8_t tx_buf[4];
memcpy(tx_buf, (uint8_t[4]){FEND, CMD_FW_UPD, 0x01, FEND}, 4*sizeof(uint8_t));
err_code = write_port(rn->fd, tx_buf, 4);
err_code = write_port(&rn->handle, tx_buf, 4);
}
// Close port to prepare for flashing
if (!err_code) {
err_code = close_port(rn->fd);
err_code = close_port(&rn->handle);
}
if (!err_code) {
@ -1697,11 +1697,11 @@ int rnode_flash(struct RNode* rn, char* zip_path, bool update, uint8_t* serial,
}
// Wait for reset and boot. This value may have to be adjusted in the
// future if firmware becomes more complex.
sleep_ms(15000);
sleep_mils(15000);
rn->fd = open_port(rn->port, rn->baud);
open_port(&rn->handle, rn->port, rn->baud);
if (rn->fd > 0) {
if (&rn->handle > 0) {
if (!update) {
uint8_t checksum[CHECKSUM_SIZE];
void* signature;
@ -1752,7 +1752,7 @@ int rnode_flash(struct RNode* rn, char* zip_path, bool update, uint8_t* serial,
}
if (!err_code) {
sleep_ms(750);
sleep_mils(750);
err_code = rnode_set_fw_hash(rn, hash);
} else {
return err_code;
@ -1761,18 +1761,18 @@ int rnode_flash(struct RNode* rn, char* zip_path, bool update, uint8_t* serial,
if (!err_code) {
log_info("Waiting 10 seconds for RNode to come online...");
sleep_ms(10000);
sleep_mils(10000);
if (rn->platform == PLATFORM_NRF52) {
err_code = close_port(rn->fd);
err_code = close_port(&rn->handle);
// Due to the current janky emulated EEPROM implementation for the
// RAK4631, extra time must be given to allow for writing.
log_info("Waiting an extra 15 seconds for RNode to come online...");
sleep_ms(15000);
sleep_mils(15000);
} else if (rn->platform == PLATFORM_ESP32) {
rnode_reset(rn);
err_code = close_port(rn->fd);
err_code = close_port(&rn->handle);
log_info("Waiting for ESP32 reset...");
sleep_ms(7000);
sleep_mils(7000);
}
err_code = rnode_init(rn, rn->port, rn->baud, true, true);
} else {
@ -1789,9 +1789,9 @@ int rnode_flash(struct RNode* rn, char* zip_path, bool update, uint8_t* serial,
int rnode_disconnect(struct RNode* rn) {
uint8_t tx_buf[4];
memcpy(tx_buf, (uint8_t[4]){FEND, CMD_LEAVE, 0xFF, FEND}, 4*sizeof(uint8_t));
return write_port(rn->fd, tx_buf, 4);
return write_port(&rn->handle, tx_buf, 4);
}
int rnode_cleanup(struct RNode* rn) {
close_port(rn->fd);
close_port(&rn->handle);
}

2
src/librnode.h
View File

@ -68,7 +68,7 @@
struct RNode {
char* port;
int fd;
struct serial handle;
uint32_t baud;
uint8_t platform;

6
src/libs/flashers/nrf/dfu_serial.c
View File

@ -180,7 +180,7 @@ static void dfu_serial_u32_to_bytes(uint32_t val, uint8_t* array, uint16_t offse
// Waits the time necessary for the MCU to erase its flash before we begin sending the new image
int dfu_serial_wait_for_erase(uint32_t total_img_size) {
return sleep_ms(MAX(0.5, (total_img_size / FLASH_PAGE_SIZE) * FLASH_PAGE_ERASE_TIME));
return sleep_mils(MAX(0.5, (total_img_size / FLASH_PAGE_SIZE) * FLASH_PAGE_ERASE_TIME));
}
int dfu_serial_send_start_dfu(uart_drv_t *p_uart, uint8_t mode, uint32_t softdevice_size, uint32_t bootloader_size, uint32_t application_size) {
@ -330,7 +330,7 @@ int dfu_serial_send_firmware(uart_drv_t *p_uart, struct RNode* rn, const uint8_t
// nrf52 is erasing and writing to flash
if (i % 8 == 0) {
err_code = sleep_ms(FLASH_PAGE_WRITE_TIME);
err_code = sleep_mils(FLASH_PAGE_WRITE_TIME);
if (err_code) {
log_error("Timing failed during flash, please try flashing again!");
break;
@ -339,7 +339,7 @@ int dfu_serial_send_firmware(uart_drv_t *p_uart, struct RNode* rn, const uint8_t
}
if (!err_code) {
err_code = sleep_ms(FLASH_PAGE_WRITE_TIME);
err_code = sleep_mils(FLASH_PAGE_WRITE_TIME);
if (err_code) {
log_error("Timing failed during flash, please try flashing again!");

4
src/libs/flashers/nrf/uart_linux.c
View File

@ -135,12 +135,12 @@ int uart_drv_open(uart_drv_t *p_uart, bool touch)
// Opening and closing serial port once is necessary to enter DFU mode
if (touch) {
sleep_ms(SERIAL_WAIT_TIME);
sleep_mils(SERIAL_WAIT_TIME);
close(fd);
// Wait, then open it again
sleep_ms(TOUCH_RESET_WAIT_TIME);
sleep_mils(TOUCH_RESET_WAIT_TIME);
fd = open(tty_path, O_RDWR | O_NOCTTY);

25
src/libs/serial.h
View File

@ -11,16 +11,33 @@
* with this program. If not, see <https://www.gnu.org/licenses/>.
*/
#ifndef SERIAL_H
#include <stdint.h>
#define SERIAL_H
int open_port(char* path, uint32_t baud);
#ifdef linux
struct serial {
int fd;
};
#endif
int write_port(int fd, uint8_t* data, uint16_t data_len);
#ifdef _WIN32
#include <windows.h>
int read_port(int fd, uint8_t* rx_data, uint16_t size);
struct serial {
HANDLE fd;
};
#endif
int close_port(int fd);
int open_port(struct serial* handle, char* path, uint32_t baud);
int write_port(struct serial* handle, uint8_t* data, uint16_t data_len);
int read_port(struct serial* handle, uint8_t* rx_data, uint16_t size);
int close_port(struct serial* handle);
#endif

29
src/libs/serial_linux.c
View File

@ -11,13 +11,15 @@
* with this program. If not, see <https://www.gnu.org/licenses/>.
*/
#include "serial.h"
#include <unistd.h>
#include <fcntl.h>
#include <termios.h>
#include <stdint.h>
#include "logging/log.h"
int open_port(char* path, uint32_t baud) {
int open_port(struct serial* handle, char* path, uint32_t baud) {
struct termios options;
speed_t baud_s;
@ -31,9 +33,9 @@ int open_port(char* path, uint32_t baud) {
break;
}
int fd = open(path, O_RDWR | O_NOCTTY);
handle->fd = open(path, O_RDWR | O_NOCTTY);
tcgetattr(fd, &options);
tcgetattr(handle->fd, &options);
cfsetispeed(&options, baud_s);
cfsetospeed(&options, baud_s);
@ -57,17 +59,17 @@ int open_port(char* path, uint32_t baud) {
options.c_cc[VMIN] = 0;
options.c_cc[VTIME] = 5; // 0.5 seconds
if (tcsetattr(fd, TCSANOW, &options))
if (tcsetattr(handle->fd, TCSANOW, &options))
{
log_error("Cannot set RNode port options!");
return -1;
} else {
return fd;
return 0;
}
}
int write_port(int fd, uint8_t* data, uint16_t data_len) {
int write_port(struct serial* handle, uint8_t* data, uint16_t data_len) {
unsigned char data_str[1024] = "";
for (int i = 0; i < data_len; i++) {
sprintf(data_str+(i*3), "%02x ", data[i]);
@ -75,7 +77,7 @@ int write_port(int fd, uint8_t* data, uint16_t data_len) {
log_trace("Writing [%s] to RNode serial port.", data_str);
if (write(fd, data, data_len) != data_len) {
if (write(handle->fd, data, data_len) != data_len) {
log_error("Could not write all data to the RNode port! Is the RNode still connected?");
return -1;
} else {
@ -83,14 +85,19 @@ int write_port(int fd, uint8_t* data, uint16_t data_len) {
}
}
int read_port(int fd, uint8_t* rx_data, uint16_t size) {
int ret = read(fd, rx_data, size);
int read_port(struct serial* handle, uint8_t* rx_data, uint16_t size) {
int ret = read(handle->fd, rx_data, size);
if (ret == -1) {
log_error("Could not read from RNode port! Is the RNode still connected?");
}
return ret;
}
int close_port(int fd) {
return close(fd);
int close_port(struct serial* handle) {
if (!close(handle->fd)) {
log_error("Error closing RNode port! Is the RNode still connected?");
return -1;
} else {
return 0;
}
}

83
src/libs/serial_win32.c
View File

@ -10,3 +10,86 @@
* You should have received a copy of the GNU General Public License along
* with this program. If not, see <https://www.gnu.org/licenses/>.
*/
#include "serial.h"
int open_port(struct serial* handle, char* path, uint32_t baud) {
DCB dcbSerialParams = {0};
COMMTIMEOUTS timeouts = {0};
uint32_t baud_s;
// Currently RNodes only support a baud rate of 115200, add more support as needed in future.
switch (baud) {
case 115200:
baud_s = CBR_115200;
break;
default:
baud_s = CBR_115200;
break;
}
handle.fd = CreateFile(
path, GENERIC_READ|GENERIC_WRITE, 0, NULL,
OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL );
if (handle.fd == INVALID_HANDLE_VALUE) {
log_error("Cannot open RNode port!");
return -1;
}
dcbSerialParams.DCBLength = sizeof(dcbSerialParams);
dcbSerialParams.BaudRate = baud_s;
if (GetCommState(handle.fd, &dcbSerialParams) == 0) {
CloseHandle(handle.fd);
log_error("Cannot set RNode port options!");
return -1;
}
timeouts.ReadIntervalTimeout = 50;
timeouts.ReadTotalTimeoutConstant = 50;
timeouts.ReadTotalTimeoutMultiplier = 10;
timeouts.WriteTotalTimeoutConstant = 50;
timeouts.WriteTotalTimeoutMultiplier = 10;
if (SetCommTimeouts(handle.fd, &timeouts) == 0) {
CloseHandle(handle.fd);
log_error("Cannot set RNode port timeouts!");
return -1;
}
}
int write_port(struct serial* handle, uint8_t* data, uint16_t data_len) {
unsigned char data_str[1024] = "";
for (int i = 0; i < data_len; i++) {
sprintf(data_str+(i*3), "%02x ", data[i]);
}
log_trace("Writing [%s] to RNode serial port.", data_str);
if (!WriteFile(handle.fd, data_len, NULL, NULL)) {
log_error("Could not write all data to the RNode port! Is the RNode still connected?");
CloseHandle(handle.fd);
return -1;
}
return 0;
}
int read_port(struct serial* handle, uint8_t* rx_data, uint16_t size) {
int ret;
if (!ReadFile(handle.fd, rx_data, size, &ret, NULL)) {
log_error("Could not read from RNode port! Is the RNode still connected?");
return -1;
}
return ret;
}
int close_port(struct serial* handle) {
if (CloseHandle(handle.fd) == 0) {
log_error("Error closing RNode port! Is the RNode still connected?");
return -1;
}
return 0;
}

2
src/libs/util.c
View File

@ -13,7 +13,7 @@
#include "util.h"
int sleep_ms(int ms)
int sleep_mils(int ms)
{
#ifdef WIN32
Sleep(ms);

2
src/libs/util.h
View File

@ -17,6 +17,6 @@
#include <unistd.h>
#include <time.h>
int sleep_ms(int ms);
int sleep_mils(int ms);
#endif