// // Written by vad7, 10.01.2023. vad7@yahoo.com // #include "nrf24batch.h" #include #include #include #include #include #include #include #include #include #define TAG "nrf24batch" #define VERSION "1.9" #define SCAN_APP_PATH_FOLDER STORAGE_APP_DATA_PATH_PREFIX #define LOG_FILEEXT ".txt" #define NRF_READ_TIMEOUT 300UL // ms #define WORK_PERIOD 2 // ms, Timer period #define MAX_CHANNEL 125 #define FONT_5x7_SCREEN_WIDTH 25 #define NRF_EN_DYN_ACK 0 // does not work on some nrf24l01+ chips, (0/1) const char SettingsFld_Info[] = "Info:"; const char SettingsFld_Ch[] = "Ch:"; const char SettingsFld_Rate[] = "Rate:"; const char SettingsFld_DPL[] = "DPL:"; const char SettingsFld_CRC[] = "CRC:"; const char SettingsFld_RETR[] = "RETR:"; const char SettingsFld_Address[] = "Address:"; const char SettingsFld_Resend[] = "Resend:"; const char SettingsFld_Delay[] = "Delay_ms:"; const char SettingsFld_WriteStart[] = "Write start:"; const char SettingsFld_Payload[] = "Payload struct:"; const char SettingsFld_ReadDefault[] = "R default:"; const char SettingsFld_WriteDefault[] = "W default:"; const char SettingsFld_Read[] = "R:"; // Read cmd const char SettingsFld_Write[] = "W:"; // Write cmd const char SettingsFld_Set[] = "S:"; // Set cmd (like Write but without "Write start" packet) const char SettingsFld_ReadBatch[] = "RBatch:"; const char SettingsFld_WriteBatch[] = "WBatch:"; const char SettingsFld_SetBatch[] = "SBatch:"; const char SettingsFld_Listen[] = "Listen:"; const char SettingsFld_ReadCmdRepeatPeriod[] = "ReadCmd repeat:"; const char AskQuestion_Save[] = "SAVE BATCH?"; #define Settings_i 'i' #define Settings_n 'n' #define VAR_EMPTY ((int32_t)0x80000000) nRF24Batch* APP; uint8_t what_doing = 0; // 0 - setup, 1 - cmd list, 2 - read/write/listen cmd enum { rwt_set_batch = 0, // fast send packet without question rwt_read_batch, // Send read cmd and wait for answer in batch rwt_read_cmd, // Send read cmd and wait for answer rwt_write_batch, // Send write cmd (with Write start pkt if available) with a question before it rwt_listen, // Listen mode (wait incoming pkts) rwt_max }; uint8_t rw_type = rwt_read_batch; // What to do: rwt_* enum { sst_none = 0, sst_sending, sst_receiving, sst_ok, sst_error, sst_timeout }; uint8_t send_status = sst_none; // sst_* bool cmd_array = false; uint8_t cmd_array_idx; uint8_t cmd_array_cnt = 0; bool cmd_array_hex; uint8_t save_settings = 0; uint16_t view_cmd[rwt_max - 1] = {0}; // SetBatch, ReadBatch, Read, WriteBatch uint8_t view_x = 0; char screen_buf[64]; char Info[35] = ""; char file_name[FONT_5x7_SCREEN_WIDTH]; char ERR_STR[FONT_5x7_SCREEN_WIDTH]; uint8_t ERR = 0; uint8_t NRF_rate; // 0 - 250Kbps, 1 - 1Mbps, 2 - 2Mbps uint8_t NRF_channel; // 0..125 uint8_t NRF_DPL; // 1 - Dynamic Payload Length uint8_t NRF_CRC; // 1 - No, 1 - CRC 1byte, 2 - CRC 2byte uint8_t NRF_RETR = ((0b0011 << 4) | 0b1111); // Automatic Retransmission, ARD, ARC uint8_t NRF_Payload; // Payload len in bytes, 0..32 bool NRF_ERROR = 0; uint8_t NRF_INITED = 0; // 0 - not, 1 - rw, rwt_listen - listen bool NRF_BOARD_POWER_5V = false; uint8_t NRF_last_packet_send_st = 0; uint8_t NRF_resend = 1; // number of transaction attempts int8_t NRF_repeat = 0; // count number of repeated requests (until < NRF_resend) uint32_t NRF_time; uint16_t ReadCmdRepeatPeriod = 10; // s bool ReadRepeat = false; uint32_t delay_between_pkt = 10; // ms uint8_t addr[5]; // nRF24 address, MSB first uint8_t addr_len = 0; // 2..5 uint8_t payload[32]; uint8_t payload_receive[32]; uint8_t payload_struct[32]; // sizeof(1..4) in bytes of each field, example: 2,1,1 uint8_t payload_fields = 0; uint8_t payload_size = 0; // bytes uint16_t view_Batch = 0; // view pos in Batch or inside WriteBatch (Log[view_Batch]) uint16_t view_WriteBatch = 0; // view pos of WriteBatch list uint8_t setup_cursor = 0; // cursor position on Setup scr uint8_t Edit = 0; char* Edit_pos; char* Edit_start; bool Edit_hex; // 0 - decimal, 1 - hex bool Edited = false; // list of cmds edited Stream* file_stream = NULL; FuriString* ReadDefault = NULL; FuriString* WriteDefault = NULL; FuriString* WriteStart = NULL; FuriString* Constants = NULL; // text of STR=x uint8_t listen_addr[5]; uint8_t listen_addr_len = 0; char* ListenFields = NULL; // ptr to string: field1,field2,... max 5 field now bool ListenNew; FuriHalRtcDateTime ListenLastTime = {0}; uint32_t ListenPrev = 0; uint32_t ListenLast = 0; FuriString** Read_cmd = NULL; // Names of read cmd uint16_t Read_cmd_Total = 0; FuriString** Log = NULL; // Strings: var=n uint16_t Log_Total = 0; FuriString** ReadBatch_cmd = NULL; // Names of read batch cmd uint16_t ReadBatch_cmd_Total = 0; char* ReadBatch_cmd_curr = NULL; // =0xFFFFFFFF - finish FuriString** WriteBatch_cmd = NULL; // Names of write batch cmd uint16_t WriteBatch_cmd_Total = 0; uint16_t WriteBatch_cmd_curr = 0; // == _Total - finish FuriString** SetBatch_cmd = NULL; // Names of set batch cmd uint16_t SetBatch_cmd_Total = 0; uint16_t SetBatch_cmd_curr = 0; // == _Total - finish #define POWER_READ_PERIOD 501 // ms uint16_t pwr_read_timer = 0; int Current = 0; int CurrentStart = 0; enum { ask_write_batch = 1, ask_save_batch, ask_skip_cmd, ask_return, ask_exit }; uint8_t ask_question = 0; // 1 - Ask now - ask_* uint8_t ask_question_answer = 0; // 0 - no, 1 - yes static bool ask_fill_screen_buf(void) { if(ask_question == ask_write_batch) strcpy(screen_buf, "RUN WRITE BATCH?"); else if(ask_question == ask_save_batch) strcpy(screen_buf, "SAVE AS WRITE BATCH?"); else if(ask_question == ask_skip_cmd) strcpy(screen_buf, "SKIP CMD?"); else if(ask_question == ask_return) strcpy(screen_buf, "RETURN?"); else if(ask_question == ask_exit) strcpy(screen_buf, "EXIT?"); else return false; strcat(screen_buf, ask_question_answer ? " YES" : " NO"); return true; } //#define MIN(a, b) ((a= '0' && c <= '9') return true; if(hex) { c &= ~0x20; if(c >= 'A' && c <= 'F') return true; } else if(c == '-') return true; return false; } // Return num bytes in array static uint8_t ConvertHexToArray(char* hex, uint8_t* array, uint8_t maxlen) { uint8_t len = 0; while(maxlen) { uint8_t ch = *hex++; if(ch < ' ') break; if(ch < '0') continue; *array++ = (GetHexVal(ch) << 4) + GetHexVal(*hex++); len++; maxlen--; } return len; } int32_t str_to_int(char* p) { if(*(p + 1) == 'x') { // hex return strtol(p + 2, NULL, 16); } else return strtol(p, NULL, 10); } void str_rtrim(char* p) { char* delim_col = strchr(p, '\r'); if(delim_col) *delim_col = '\0'; else { delim_col = strchr(p, '\n'); if(delim_col) *delim_col = '\0'; } } static void add_to_str_hex_bytes(char* out, uint8_t* arr, int bytes) { if(bytes <= 0) return; out += strlen(out); do { snprintf(out, 3, "%02X", *arr++); out += 2; } while(--bytes); } // skip leading zeros static void add_to_str_hex_variable(char* out, uint8_t* arr, int size) { if(size <= 0) return; out += strlen(out); arr += size - 1; while(*arr == 0 && size > 1) { arr--; size--; } do { snprintf(out, 3, "%02X", *arr--); out += 2; } while(--size); } void Edit_insert_digit(char new) { if(*Edit_pos == '-') return; if(what_doing <= 1) { if(strlen(Edit_start) < (what_doing == 0 && setup_cursor == 2 ? 3 : 5 * 2)) { memmove(Edit_pos + 1, Edit_pos, strlen(Edit_pos) + 1); *Edit_pos = new; } } else { FuriString* fs = Log[view_Batch]; FuriString* ns = furi_string_alloc(); if(ns) { uint16_t len = Edit_pos - (char*)furi_string_get_cstr(fs); furi_string_set_n(ns, fs, 0, len); furi_string_cat_printf(ns, "%c", new); furi_string_cat_str(ns, Edit_pos); Log[view_Batch] = ns; Edit_pos = (char*)furi_string_get_cstr(ns); Edit_start = Edit_pos + (Edit_start - (char*)furi_string_get_cstr(fs)); Edit_pos += len; furi_string_free(fs); } } } int32_t get_payload_receive_field(uint8_t* var, uint8_t size) { if(size <= 1) return *var; else if(size == 2) return *(int16_t*)var; else if(size == 3) return (*(uint32_t*)var) & 0xFFFFFF; else return *(int32_t*)var; } void free_Log() { if(Log_Total) { for(uint16_t i = 0; i < Log_Total; i++) if(Log[i]) furi_string_free(Log[i]); Log_Total = 0; } if(Log) { free(Log); Log = NULL; } } void free_store(void) { if(Constants) { furi_string_free(Constants); Constants = NULL; } if(ReadDefault) { furi_string_free(ReadDefault); ReadDefault = NULL; } if(WriteDefault) { furi_string_free(WriteDefault); WriteDefault = NULL; } if(WriteStart) { furi_string_free(WriteStart); WriteDefault = NULL; } if(ListenFields) { free(ListenFields); ListenFields = NULL; } if(Read_cmd_Total) { for(uint16_t i = 0; i < Read_cmd_Total; i++) furi_string_free(Read_cmd[i]); Read_cmd_Total = 0; } if(Read_cmd) { free(Read_cmd); Read_cmd = NULL; } if(ReadBatch_cmd_Total) { for(uint16_t i = 0; i < ReadBatch_cmd_Total; i++) furi_string_free(ReadBatch_cmd[i]); ReadBatch_cmd_Total = 0; } if(ReadBatch_cmd) { free(ReadBatch_cmd); ReadBatch_cmd = NULL; } if(WriteBatch_cmd_Total) { for(uint16_t i = 0; i < WriteBatch_cmd_Total; i++) furi_string_free(WriteBatch_cmd[i]); WriteBatch_cmd_Total = 0; } if(WriteBatch_cmd) { free(WriteBatch_cmd); WriteBatch_cmd = NULL; } if(SetBatch_cmd_Total) { for(uint16_t i = 0; i < SetBatch_cmd_Total; i++) furi_string_free(SetBatch_cmd[i]); SetBatch_cmd_Total = 0; } if(SetBatch_cmd) { free(SetBatch_cmd); SetBatch_cmd = NULL; } free_Log(); } void update_power(void) { Current = furi_hal_power_get_battery_current(FuriHalPowerICFuelGauge) * 1000; } void check_en_power_5V(void) { if(!furi_hal_power_is_otg_enabled() && !furi_hal_power_is_charging()) { FURI_LOG_D("PWR", "NO 5V, TURN ON"); notification_message(APP->notification, &sequence_blink_yellow_100); furi_delay_ms(10); update_power(); CurrentStart = Current; furi_hal_power_enable_otg(); NRF_BOARD_POWER_5V = true; furi_delay_ms(100); NRF_INITED = 0; } } static bool select_settings_file() { DialogsApp* dialogs = furi_record_open("dialogs"); bool result = false; FuriString* path; path = furi_string_alloc(); furi_string_set(path, SCAN_APP_PATH_FOLDER); DialogsFileBrowserOptions browser_options; dialog_file_browser_set_basic_options(&browser_options, ".txt", NULL); browser_options.hide_ext = false; bool ret = dialog_file_browser_show(dialogs, path, path, &browser_options); furi_record_close("dialogs"); if(ret) { if(!file_stream_open( file_stream, furi_string_get_cstr(path), FSAM_READ_WRITE, FSOM_OPEN_EXISTING)) { FURI_LOG_D(TAG, "Cannot open file \"%s\"", furi_string_get_cstr(path)); file_stream_close(file_stream); } else { FURI_LOG_D(TAG, "Open file \"%s\"", furi_string_get_cstr(path)); strncpy( file_name, furi_string_get_cstr(path) + sizeof(SCAN_APP_PATH_FOLDER), sizeof(file_name)); result = true; } } furi_string_free(path); return result; } static void prepare_nrf24(void) { check_en_power_5V(); if(!NRF_INITED || rw_type == rwt_listen || NRF_INITED == rwt_listen) { FURI_LOG_D("NRF", "Prepare"); uint8_t adrlen, *adr; if(rw_type == rwt_listen) { adrlen = listen_addr_len; adr = listen_addr; NRF_INITED = rwt_listen; } else { adrlen = addr_len; adr = addr; NRF_INITED = 1; } furi_hal_gpio_write(nrf24_CE_PIN, false); nrf24_set_mac(REG_RX_ADDR_P0, adr, adrlen); uint8_t tmp[5] = {0}; nrf24_read_reg(nrf24_HANDLE, REG_RX_ADDR_P0, tmp, adrlen); for(uint8_t i = 0; i < adrlen / 2; i++) { uint8_t tb = tmp[i]; tmp[i] = tmp[adrlen - i - 1]; tmp[adrlen - i - 1] = tb; } NRF_ERROR = memcmp(adr, tmp, adrlen) != 0; if(NRF_ERROR) { NRF_INITED = 0; return; } // EN_DYN_ACK(0x01) option for W_TX_PAYLOAD_NOACK cmd broke AA on some fake nRF24l01+, i.e. set it to 0 nrf24_write_reg( nrf24_HANDLE, REG_FEATURE, NRF_EN_DYN_ACK + (NRF_DPL ? 4 : 0)); // Dynamic Payload, Payload with ACK, W_TX_PAYLOAD_NOACK command nrf24_write_reg(nrf24_HANDLE, REG_RF_CH, NRF_channel); nrf24_write_reg( nrf24_HANDLE, REG_RF_SETUP, (NRF_rate == 0 ? 0b00100000 : NRF_rate == 1 ? 0 : 0b00001000) | 0b111); // +TX high power nrf24_write_reg( nrf24_HANDLE, REG_CONFIG, 0x70 | ((NRF_CRC == 1 ? 0b1000 : NRF_CRC == 2 ? 0b1100 : 0))); // Mask all interrupts nrf24_write_reg( nrf24_HANDLE, REG_SETUP_RETR, NRF_RETR); // Automatic Retransmission, ARD<<4 + ARC nrf24_write_reg(nrf24_HANDLE, REG_EN_AA, 0x01); // Auto acknowledgement nrf24_write_reg(nrf24_HANDLE, REG_DYNPD, NRF_DPL ? 0x3F : 0); // Enable dynamic payload reg nrf24_write_reg(nrf24_HANDLE, RX_PW_P0, payload_size); nrf24_set_maclen(nrf24_HANDLE, adrlen); nrf24_set_mac(REG_TX_ADDR, adr, adrlen); nrf24_write_reg(nrf24_HANDLE, REG_EN_RXADDR, 1); //nrf24_set_idle(nrf24_HANDLE); } nrf24_flush_tx(nrf24_HANDLE); nrf24_flush_rx(nrf24_HANDLE); nrf24_write_reg(nrf24_HANDLE, REG_STATUS, MAX_RT | RX_DR | TX_DS); } // true - ok uint8_t nrf24_send_packet() { if(furi_log_get_level() == FuriLogLevelDebug) { char buf[65]; buf[0] = 0; add_to_str_hex_bytes(buf, payload, payload_size); FURI_LOG_D(TAG, "SEND: %s", buf); } //nrf24_flush_tx(nrf24_HANDLE); //nrf24_write_reg(nrf24_HANDLE, REG_STATUS, RX_DR | TX_DS | MAX_RT); NRF_last_packet_send_st = nrf24_txpacket(nrf24_HANDLE, payload, payload_size, true); // ACK if(NRF_last_packet_send_st) { if((rw_type == rwt_read_cmd || rw_type == rwt_read_batch) && send_status == sst_sending) { // Read nrf24_set_rx_mode(nrf24_HANDLE); send_status = sst_receiving; // receiving } } else notification_message(APP->notification, &sequence_blink_red_100); NRF_time = furi_get_tick(); FURI_LOG_D( TAG, "Send packet: %d%s", NRF_last_packet_send_st, send_status == sst_receiving ? ", Receiving" : ""); return NRF_last_packet_send_st; } uint8_t nrf24_resend_read_packet() { if(Log_Total && !cmd_array) { FuriString* str = Log[Log_Total - 1]; char* p = strstr(furi_string_get_cstr(str), ": "); if(p) { if(strncmp(p + 2, "0x", 2) == 0) p += 2; furi_string_left(str, p - furi_string_get_cstr(str) + 2); } } return nrf24_send_packet(); } // true - new packet bool nrf24_read_newpacket() { bool found = false; uint8_t packetsize; uint8_t st = nrf24_rxpacket(nrf24_HANDLE, payload_receive, &packetsize, NRF_DPL ? 0 : payload_size); if(st & RX_DR) { NRF_time = furi_get_tick(); if(furi_log_get_level() == FuriLogLevelDebug) { char buf[65]; buf[0] = 0; add_to_str_hex_bytes(buf, payload_receive, packetsize); FURI_LOG_D(TAG, "READ(%X): %s", st, buf); } if(Log_Total) { FuriString* str = Log[Log_Total - 1]; uint8_t size = 1; char* p = strchr((char*)furi_string_get_cstr(str), '*'); if(p) { p++; if(*p == '=') size = 0; // string else { size = *p - '0'; if(size > 4) size = 0; } } int32_t var = get_payload_receive_field(payload_receive, size); //FURI_LOG_D(TAG, "VAR(%d): %ld", size, var); if(size == 0) furi_string_cat_printf(str, "%c", (char)var); else { char hex[9]; hex[0] = '\0'; add_to_str_hex_variable(hex, (uint8_t*)&var, size); if((cmd_array && cmd_array_hex) || furi_string_end_with_str(str, "0x")) furi_string_cat_str(str, hex); else { if(var >= 0 && var <= 9) furi_string_cat_printf(str, "%ld", var); else furi_string_cat_printf(str, "%ld (%s)", var, hex); } } if(cmd_array) { if(--cmd_array_cnt) { furi_string_cat_str(str, ","); if(cmd_array_hex) furi_string_cat_str(str, "0x"); payload[cmd_array_idx] += size; // next array element NRF_repeat = -1; send_status = sst_sending; // Will be send after delay_between_pkt } else send_status = sst_ok; } else { if(size == 0) { // string, until '\0' if(var == 0) send_status = sst_ok; } else send_status = sst_ok; } } //notification_message(APP->notification, &sequence_blink_white_100); found = true; } else if(st & 0x80) { // NRF24 hardware error NRF_ERROR = 1; NRF_INITED = 0; } return found; } // Search in constatnt pull (Const1=n; Const2=n;...) // VAR_EMPTY - not found int32_t subs_constant(char* p, uint8_t len) { char* c = (char*)furi_string_get_cstr(Constants); while((c = strchr(c, *p))) { if(strncmp(c, p, len) != 0) { c++; continue; } if(c == (char*)furi_string_get_cstr(Constants) || *(c - 1) == ';' || *(c - 1) <= ' ') { c += len; if(*c == '=') { c++; return str_to_int(c); } } else c += len; } return VAR_EMPTY; } // fill payload with default = p // if var_n = VAR_EMPTY - skip filling var_* bool fill_payload(char* p, uint8_t* idx_i, int32_t var_n) { if(idx_i) *idx_i = 255; uint8_t fld = 0; // field # uint8_t idx = 0; // byte index do { int32_t b = 0; char* end = strchr(p, ','); if(*p >= '0' && *p <= '9') { // Number found b = str_to_int(p); } else if(*p == 'i' && *(p + 1) == ':') { // 'i:' array index b = str_to_int(p + 2); if(idx_i) *idx_i = idx; } else if(*p == 'n' && *(p + 1) < '0') { // var_n if(var_n != VAR_EMPTY) b = var_n; } else if(*p >= 'A') { // constant found uint8_t len; if(end) len = end - p; else { len = strlen(p); if(*(p + len - 1) == '#') len--; } b = subs_constant(p, len); if(b == VAR_EMPTY) { ERR = 1; memset(ERR_STR, 0, sizeof(ERR_STR)); strcpy(ERR_STR, "No "); strncpy(ERR_STR + strlen(ERR_STR), p, sizeof(ERR_STR) - 4); FURI_LOG_D(TAG, "Constant not found: %s", p); return false; } } else if(end == p) { idx += payload_struct[fld]; } else if(*p == '#') { // value in Hexadecimal, end string break; } else { ERR = 2; strcpy(ERR_STR, "char: "); uint8_t l = strlen(ERR_STR); ERR_STR[l] = *p; ERR_STR[l + 1] = '\0'; FURI_LOG_D(TAG, "Wrong format char(%c)", *p); return false; } if(end != p) { payload[idx++] = b; if(payload_struct[fld] > 1) payload[idx++] = b >> 8; if(payload_struct[fld] > 2) payload[idx++] = b >> 16; if(payload_struct[fld] > 3) payload[idx++] = b >> 24; } if(++fld == payload_fields || idx >= sizeof(payload) || end == NULL) break; p = end + 1; } while(1); return true; } // Cmd: "name=payload" bool Run_Read_cmd(FuriString* cmd) { char* p = (char*)furi_string_get_cstr(cmd); p = strchr(p, '='); if(p == NULL) return false; if(Log == NULL) Log = malloc(sizeof(Log)); else Log = realloc(Log, sizeof(Log) * (Log_Total + 1)); if(Log == NULL) { ERR = 3; strcpy(ERR_STR, "Memory low"); FURI_LOG_D(TAG, ERR_STR); return false; } FuriString* fs = furi_string_alloc(); furi_string_set_strn( fs, (char*)furi_string_get_cstr(cmd), p - (char*)furi_string_get_cstr(cmd)); furi_string_cat_str(fs, ": "); bool hexval; if((hexval = *(p + strlen(p) - 1) == '#')) furi_string_cat_str(fs, "0x"); // value in Hex format Log[Log_Total++] = fs; p++; memset(payload, 0, sizeof(payload)); if(ReadDefault && !fill_payload((char*)furi_string_get_cstr(ReadDefault), NULL, VAR_EMPTY)) return false; if(!fill_payload(p, &cmd_array_idx, VAR_EMPTY)) return false; memset(payload_receive, 0, sizeof(payload_receive)); cmd_array = false; if(*(p - 2) == ']' && cmd_array_idx != 255) { // array p = strchr(furi_string_get_cstr(cmd), '['); if(p) { cmd_array_cnt = str_to_int(p + 1); if(cmd_array_cnt > 1) { cmd_array_hex = hexval; cmd_array = true; // array } } } prepare_nrf24(); if(NRF_ERROR) return false; what_doing = 2; NRF_repeat = 0; send_status = sst_sending; // Read - sending nrf24_send_packet(); return true; } // run commands one by one, true - command running bool Run_ReadBatch_cmd(FuriString* cmd) { char* p; if(cmd) { p = strchr((char*)furi_string_get_cstr(cmd), ':'); if(p == NULL) { ERR = 5; strcpy(ERR_STR, "WRONG FORMAT"); return false; } p += 2; ReadBatch_cmd_curr = NULL; free_Log(); } else { if(ReadBatch_cmd_curr) p = ReadBatch_cmd_curr; else return false; } char* end = strchr(p, ';'); uint8_t len; if(end) len = end - p; else { str_rtrim(p); len = strlen(p); } for(uint16_t i = 0; i < Read_cmd_Total; i++) { FuriString* fs = Read_cmd[i]; if(strncmp((char*)furi_string_get_cstr(fs), p, len) == 0) { char c = *((char*)furi_string_get_cstr(fs) + len); if(c != '=' && c != '*' && c != '[') continue; if(end) ReadBatch_cmd_curr = end + 1; else ReadBatch_cmd_curr = (char*)0xFFFFFFFF; if(!Run_Read_cmd(fs)) break; return true; } } if(NRF_ERROR) return false; if(ERR == 0) { ERR = 4; strcpy(ERR_STR, "NOT FOUND"); FuriString* fs = furi_string_alloc(); furi_string_set_strn(fs, p, len); Log[Log_Total++] = fs; FURI_LOG_D(TAG, "CMD %s: %s", ERR_STR, p); } view_Batch = Log_Total ? Log_Total - 1 : 0; return false; } void Prepare_Write_cmd(FuriString* cmd) { free_Log(); if(cmd == NULL) return; char *end, *p = strchr((char*)furi_string_get_cstr(cmd), ':'); if(p == NULL) { ERR = 8; strcpy(ERR_STR, "Wrong batch"); FURI_LOG_D(TAG, ERR_STR); return; } p += 2; Log = malloc(sizeof(Log)); do { end = strchr(p, ';'); uint8_t len; if(end) { len = end - p; end++; } else { str_rtrim(p); len = strlen(p); } FuriString* fs = furi_string_alloc(); if(Log_Total) Log = realloc(Log, sizeof(Log) * (Log_Total + 1)); if(Log == NULL) { ERR = 3; strcpy(ERR_STR, "Memory low"); FURI_LOG_D(TAG, ERR_STR); return; } furi_string_set_strn(fs, p, len); Log[Log_Total++] = fs; } while((p = end)); } // Write / Set batch bool Run_WriteBatch_cmd() { if(Log_Total == 0) return false; uint16_t cmd_curr = rw_type == rwt_write_batch ? WriteBatch_cmd_curr : SetBatch_cmd_curr; if(cmd_curr == 0) { // first prepare_nrf24(); if(NRF_ERROR) return false; if(rw_type == rwt_write_batch && WriteStart) { if(!fill_payload((char*)furi_string_get_cstr(WriteStart), NULL, VAR_EMPTY)) return false; send_status = sst_sending; if(!nrf24_send_packet()) return false; } } char* p = (char*)furi_string_get_cstr(Log[cmd_curr]); uint16_t len = furi_string_size(Log[cmd_curr]); char* arr = NULL; cmd_array = false; int32_t new = 0; for(uint16_t i = 0; i < len; i++) { if(p[i] == '=') { len = i; char* p2 = p + i + 1; if(*p2 == '{') { arr = ++p2; // array cmd_array = true; } new = str_to_int(p2); break; } } FURI_LOG_D( TAG, "%cBatch: =%d, (%d)%s", rw_type == rwt_write_batch ? 'W' : 'S', (int)new, len, p); char *w, *delim_col, i, size; FuriString* str = furi_string_alloc(); stream_rewind(file_stream); while(stream_read_line(file_stream, str)) { w = (char*)furi_string_get_cstr(str); if(strncmp(w, SettingsFld_Write, sizeof(SettingsFld_Write) - 1) == 0) w += sizeof(SettingsFld_Write); else if(strncmp(w, SettingsFld_Set, sizeof(SettingsFld_Set) - 1) == 0) w += sizeof(SettingsFld_Set); else continue; delim_col = strchr(w, '='); if(delim_col == NULL) continue; size = 1; if(*(delim_col - 2) == '*') { if(len != delim_col - w - 2) continue; size = *(delim_col - 1) - '0'; new = new&(size == 1 ? 0xFF : size == 2 ? 0xFFFF : size == 3 ? 0xFFFFFF : 0xFFFFFFFF); } else if(len != delim_col - w) continue; if(strncmp(p, w, len) != 0) continue; delim_col++; str_rtrim(delim_col); cmd_array_cnt = 255; do { memset(payload, 0, sizeof(payload)); if(WriteDefault && !fill_payload((char*)furi_string_get_cstr(WriteDefault), NULL, new)) { view_Batch = cmd_curr; return false; } if(!fill_payload(delim_col, &cmd_array_idx, VAR_EMPTY)) { view_Batch = cmd_curr; return false; } if(cmd_array && cmd_array_idx != 255) { if(cmd_array_cnt != 255) payload[cmd_array_idx] = cmd_array_cnt; } else cmd_array = false; send_status = sst_sending; NRF_repeat = 0; i = 0; do { if(nrf24_send_packet()) break; furi_delay_ms(delay_between_pkt); } while(i++ < NRF_resend); if(i < NRF_resend || i == 0) { // ok if(cmd_array) { // array for(; arr != NULL;) { if(*arr == ',') break; if(*arr == '}' || *arr < ' ') arr = NULL; else arr++; } if(arr == NULL) { send_status = sst_ok; break; } arr++; new = str_to_int(arr); cmd_array_cnt = payload[cmd_array_idx] + size; //furi_delay_ms(delay_between_pkt); // do it fast continue; // send next array element } else send_status = sst_ok; } break; } while(1); if(send_status != sst_ok) { send_status = sst_error; view_Batch = cmd_curr; return false; } return true; } ERR = 7; strcpy(ERR_STR, "NOT FOUND!"); send_status = sst_error; view_Batch = cmd_curr; return false; } // Return 0 - success, otherwise an error static uint8_t load_settings_file() { uint8_t err = 0; FURI_LOG_D(TAG, "Loading settings file"); FuriString* str = furi_string_alloc(); free_store(); Info[0] = '\0'; NRF_INITED = false; while(stream_read_line(file_stream, str)) { char* p = (char*)furi_string_get_cstr(str); if(*p <= '!' || *p == ';') continue; //char* delim_eq = strchr(p, '='); char* delim_col = strchr(p, ':'); if(delim_col == NULL) { // Constant found - no ':' if(Constants == NULL) { Constants = furi_string_alloc_set(str); } else furi_string_cat(Constants, str); } else { str_rtrim(p); if(strncmp(p, SettingsFld_Rate, sizeof(SettingsFld_Rate) - 1) == 0) { NRF_rate = str_to_int(p + sizeof(SettingsFld_Rate)); } else if(strncmp(p, SettingsFld_Info, sizeof(SettingsFld_Info) - 1) == 0) { strncpy(Info, p + sizeof(SettingsFld_Info), sizeof(Info) - 1); } else if(strncmp(p, SettingsFld_Ch, sizeof(SettingsFld_Ch) - 1) == 0) { NRF_channel = str_to_int(p + sizeof(SettingsFld_Ch)); } else if(strncmp(p, SettingsFld_Address, sizeof(SettingsFld_Address) - 1) == 0) { p += sizeof(SettingsFld_Address); addr_len = ConvertHexToArray(p, addr, 5); } else if(strncmp(p, SettingsFld_CRC, sizeof(SettingsFld_CRC) - 1) == 0) { NRF_CRC = str_to_int(p + sizeof(SettingsFld_CRC)); } else if(strncmp(p, SettingsFld_DPL, sizeof(SettingsFld_DPL) - 1) == 0) { NRF_DPL = str_to_int(p + sizeof(SettingsFld_DPL)); } else if(strncmp(p, SettingsFld_RETR, sizeof(SettingsFld_RETR) - 1) == 0) { NRF_RETR = str_to_int(p + sizeof(SettingsFld_RETR)); } else if(strncmp(p, SettingsFld_Resend, sizeof(SettingsFld_Resend) - 1) == 0) { NRF_resend = str_to_int(p + sizeof(SettingsFld_Resend)); } else if(strncmp(p, SettingsFld_Delay, sizeof(SettingsFld_Delay) - 1) == 0) { delay_between_pkt = str_to_int(p + sizeof(SettingsFld_Delay)); } else if( strncmp( p, SettingsFld_ReadCmdRepeatPeriod, sizeof(SettingsFld_ReadCmdRepeatPeriod) - 1) == 0) { ReadCmdRepeatPeriod = str_to_int(p + sizeof(SettingsFld_ReadCmdRepeatPeriod)); } else if(strncmp(p, SettingsFld_Payload, sizeof(SettingsFld_Payload) - 1) == 0) { p += sizeof(SettingsFld_Payload); payload_fields = 0; payload_size = 0; do { uint8_t b = str_to_int(p); if(b < 1 || b > 4) { FURI_LOG_D(TAG, "Wrong payload format (%d)", b); err = 3; break; } payload_struct[payload_fields++] = b; payload_size += b; if(payload_fields == sizeof(payload_struct) - 1) break; if((p = strchr(p, ',')) == NULL) break; p++; } while(1); FURI_LOG_D( TAG, "Payload fields %d: %d,%d,%d", payload_fields, payload_struct[0], payload_struct[1], payload_struct[2]); } else if(strncmp(p, SettingsFld_ReadDefault, sizeof(SettingsFld_ReadDefault) - 1) == 0) { ReadDefault = furi_string_alloc_set_str(p + sizeof(SettingsFld_ReadDefault)); } else if(strncmp(p, SettingsFld_WriteStart, sizeof(SettingsFld_WriteStart) - 1) == 0) { WriteStart = furi_string_alloc_set_str(p + sizeof(SettingsFld_WriteStart)); } else if(strncmp(p, SettingsFld_WriteDefault, sizeof(SettingsFld_WriteDefault) - 1) == 0) { WriteDefault = furi_string_alloc_set_str(p + sizeof(SettingsFld_WriteDefault)); } else if(strncmp(p, SettingsFld_Read, sizeof(SettingsFld_Read) - 1) == 0) { p += sizeof(SettingsFld_Read); if(Read_cmd == NULL) Read_cmd = malloc(sizeof(Read_cmd)); else { Read_cmd = realloc(Read_cmd, sizeof(Read_cmd) * (Read_cmd_Total + 1)); } if(Read_cmd == NULL) { FURI_LOG_D(TAG, "Memory low, err 4"); err = 4; break; } Read_cmd[Read_cmd_Total++] = furi_string_alloc_set_str(p); } else if(strncmp(p, SettingsFld_ReadBatch, sizeof(SettingsFld_ReadBatch) - 1) == 0) { p += sizeof(SettingsFld_ReadBatch); if(ReadBatch_cmd == NULL) ReadBatch_cmd = malloc(sizeof(ReadBatch_cmd)); else { ReadBatch_cmd = realloc(ReadBatch_cmd, sizeof(ReadBatch_cmd) * (ReadBatch_cmd_Total + 1)); } if(ReadBatch_cmd == NULL) { FURI_LOG_D(TAG, "Memory low, err 5"); err = 5; break; } ReadBatch_cmd[ReadBatch_cmd_Total++] = furi_string_alloc_set_str(p); } else if(strncmp(p, SettingsFld_WriteBatch, sizeof(SettingsFld_WriteBatch) - 1) == 0) { p += sizeof(SettingsFld_WriteBatch); if(WriteBatch_cmd == NULL) WriteBatch_cmd = malloc(sizeof(WriteBatch_cmd)); else { WriteBatch_cmd = realloc( WriteBatch_cmd, sizeof(WriteBatch_cmd) * (WriteBatch_cmd_Total + 1)); } if(WriteBatch_cmd == NULL) { FURI_LOG_D(TAG, "Memory low, err 6"); err = 6; break; } WriteBatch_cmd[WriteBatch_cmd_Total++] = furi_string_alloc_set_str(p); } else if(strncmp(p, SettingsFld_SetBatch, sizeof(SettingsFld_SetBatch) - 1) == 0) { p += sizeof(SettingsFld_SetBatch); if(SetBatch_cmd == NULL) SetBatch_cmd = malloc(sizeof(SetBatch_cmd)); else { SetBatch_cmd = realloc(SetBatch_cmd, sizeof(SetBatch_cmd) * (SetBatch_cmd_Total + 1)); } if(SetBatch_cmd == NULL) { FURI_LOG_D(TAG, "Memory low, err 7"); err = 7; break; } SetBatch_cmd[SetBatch_cmd_Total++] = furi_string_alloc_set_str(p); } else if(strncmp(p, SettingsFld_Listen, sizeof(SettingsFld_Listen) - 1) == 0) { p += sizeof(SettingsFld_Listen); char* p2 = strchr(p, '='); if(p2) { listen_addr_len = ConvertHexToArray(p, listen_addr, (p2 - p) / 2); p2++; uint8_t len = strlen(p2); ListenFields = malloc(len + 1); if(ListenFields) memcpy(ListenFields, p2, len); } } } } furi_string_free(str); return err; } static void save_batch(void) { FURI_LOG_D(TAG, "Save Batch"); char *p, *p2; stream_seek(file_stream, 0, StreamOffsetFromEnd); FuriHalRtcDateTime dt; furi_hal_rtc_get_datetime(&dt); stream_write_format(file_stream, "\n%s ", SettingsFld_WriteBatch); p = (char*)furi_string_get_cstr(ReadBatch_cmd[view_cmd[rwt_read_batch]]); p2 = strchr(p, ':'); if(p2 == NULL) p2 = p + strlen(p); stream_write(file_stream, (uint8_t*)p, p2 - p); stream_write_format( file_stream, " %02d.%02d.%02d %02d.%02d: ", dt.day, dt.month, dt.year % 100, dt.hour, dt.minute); for(uint16_t i = 0; i < Log_Total; i++) { p = (char*)furi_string_get_cstr(Log[i]); p2 = strchr(p, ':'); if(p2 && *(p2 - 1) != '*') { // skip string if(*(p2 - 1) == ']') { // array char* p3 = strchr(p, '['); if(p3) { stream_write(file_stream, (uint8_t*)p, p3 - p - (*(p3 - 2) == '*' ? 2 : 0)); stream_write_cstring(file_stream, "={"); p = (p2 += 2); do { while(is_digit(p2, true) || *p2 == 'x') p2++; stream_write(file_stream, (uint8_t*)p, p2 - p); char c = *p2; if(c == '\0') break; if(c != ',') { p2 = strchr(p2, ','); if(p2 == NULL) break; } stream_write_char(file_stream, ','); p = ++p2; } while(1); stream_write_char(file_stream, '}'); } } else { stream_write(file_stream, (uint8_t*)p, p2 - p - (*(p2 - 2) == '*' ? 2 : 0)); stream_write_char(file_stream, '='); p2 += 2; p = strchr(p2, ' '); if(p == NULL) p = p2 + strlen(p2); stream_write(file_stream, (uint8_t*)p2, p - p2); } if(i < Log_Total - 1) stream_write_char(file_stream, ';'); } } } static void input_callback(InputEvent* input_event, FuriMessageQueue* event_queue) { furi_assert(event_queue); PluginEvent event = {.type = EventTypeKey, .input = *input_event}; furi_message_queue_put(event_queue, &event, FuriWaitForever); } void display_remove_asterisk(char* fsp, uint8_t vx) { char* p2 = strchr(fsp, '*'); if(p2) { // remove '*' or '*n' int pos = p2 - fsp; if((pos -= vx) < 0) pos = 0; char c = *(p2 + 1); if(*(screen_buf + pos)) memmove( screen_buf + pos, screen_buf + pos + (c == ':' || c == '=' ? 1 : 2), FONT_5x7_SCREEN_WIDTH + 1 + 2 - pos); } } void render_display_list( Canvas* const canvas, FuriString*** fsa, char delim, uint16_t view_pos, uint16_t max_i) { uint16_t page = view_pos & ~7; char *p, *end; uint16_t y, len; for(uint8_t i = 0; i < 8 && page + i < max_i; i++) { y = 14 + i * 7; p = (char*)furi_string_get_cstr((*fsa)[page + i]); end = strchr(p, delim); if(end) { len = MIN(end - p, view_x); len = MIN(end - p - len, FONT_5x7_SCREEN_WIDTH); strncpy(screen_buf, p + view_x, len); screen_buf[len] = '\0'; display_remove_asterisk(p, MIN(end - p, view_x)); canvas_draw_str(canvas, 5, y, screen_buf); } if((view_pos & 7) == i) { canvas_draw_str(canvas, 0, y, ">"); canvas_draw_str(canvas, -1, y, ">"); } } } void display_edit_ttf_font(Canvas* const canvas, uint8_t start_x, uint8_t start_y) { screen_buf[0] = *Edit_pos; screen_buf[1] = '\0'; int n = canvas_string_width(canvas, screen_buf); int len = Edit_pos - Edit_start; memcpy(screen_buf, Edit_start, len); screen_buf[len] = '\0'; int x = start_x + canvas_string_width(canvas, screen_buf); int len2 = strlen(Edit_pos); memcpy(screen_buf + len, Edit_pos, len2); screen_buf[len + len2] = '\0'; canvas_draw_str(canvas, start_x, start_y, screen_buf); start_y += 1; canvas_draw_line( canvas, x + (len ? 1 : 0), start_y, x + n + (*Edit_pos == '1' && len ? 1 : 0), start_y); } void display_add_status(void) { if(NRF_ERROR) strcat(screen_buf, "nRF24 ERROR!"); else if(ERR) snprintf(screen_buf, sizeof(screen_buf), "ERROR %s", ERR_STR); else if(send_status == sst_error) strcat(screen_buf, "NO ACK!"); else if(send_status == sst_timeout) strcat(screen_buf, "TIMEOUT!"); else if(send_status == sst_none) ; else if(send_status == sst_sending) strcat(screen_buf, "sending"); else if(send_status == sst_receiving) strcat(screen_buf, "receiving"); else if( send_status == sst_ok && (rw_type == rwt_read_cmd || (rw_type == rwt_read_batch && (uint32_t)ReadBatch_cmd_curr == 0xFFFFFFFF) || (rw_type == rwt_set_batch && SetBatch_cmd_curr == Log_Total) || (rw_type == rwt_write_batch && WriteBatch_cmd_curr == Log_Total))) strcat(screen_buf, "OK"); else strcat(screen_buf, "working"); } static void render_callback(Canvas* const canvas, void* ctx) { if(ctx == NULL) return; const PluginState* plugin_state = ctx; if(furi_mutex_acquire(plugin_state->mutex, 5) != FuriStatusOk) return; //canvas_draw_frame(canvas, 0, 0, 128, 64); // border around the edge of the screen if(what_doing == 0) { canvas_set_font(canvas, FontSecondary); // 8x10 font, 6 lines snprintf(screen_buf, sizeof(screen_buf), "%s: %s", addr_len ? "File" : "Open", file_name); canvas_draw_str(canvas, 8, 10, screen_buf); if(addr_len) { if(Edit) { if(setup_cursor == 1) display_edit_ttf_font(canvas, 45, 20); else if(setup_cursor == 2) display_edit_ttf_font(canvas, 55, 30); } if(!Edit || setup_cursor != 1) { screen_buf[0] = '\0'; add_to_str_hex_bytes(screen_buf, addr, addr_len); canvas_draw_str(canvas, 45, 20, screen_buf); } if(!Edit || setup_cursor != 2) { snprintf(screen_buf, sizeof(screen_buf), "%d", NRF_channel); canvas_draw_str(canvas, 55, 30, screen_buf); } canvas_draw_str(canvas, 8, 20, "Address:"); snprintf(screen_buf, sizeof(screen_buf), "Rate: %d, Ch:", NRF_rate); canvas_draw_str(canvas, 8, 30, screen_buf); snprintf( screen_buf, sizeof(screen_buf), "RB: %d, R: %d, WB: %d", ReadBatch_cmd_Total, Read_cmd_Total, WriteBatch_cmd_Total); canvas_draw_str(canvas, 8, 40, screen_buf); canvas_draw_str(canvas, 0, 64, Info); canvas_draw_str(canvas, 0, 10 + setup_cursor * 10, ">"); } else { snprintf(screen_buf, sizeof(screen_buf), "Ver. %s, vad7", VERSION); canvas_draw_str(canvas, 10, 60, screen_buf); canvas_draw_str(canvas, 0, 10, ">"); } } else if(what_doing == 1) { if(rw_type == rwt_listen) { canvas_set_font(canvas, FontSecondary); // 8x10 font, 6 lines canvas_draw_str(canvas, 0, 10, "Listen mode"); canvas_draw_str(canvas, 0, 25, "Address:"); if(Edit) display_edit_ttf_font(canvas, 40, 25); else if(listen_addr_len) { screen_buf[0] = '\0'; add_to_str_hex_bytes(screen_buf, listen_addr, listen_addr_len); canvas_draw_str(canvas, 40, 25, screen_buf); } snprintf( screen_buf, sizeof(screen_buf), "I: %d +(%d) mA", Current - CurrentStart, CurrentStart); canvas_draw_str(canvas, 0, 60, screen_buf); } else { canvas_set_font(canvas, FontBatteryPercent); // 5x7 font, 9 lines, 25 cols if(rw_type == rwt_read_batch) { canvas_draw_str(canvas, 0, 7, "Read Batch:"); render_display_list( canvas, &ReadBatch_cmd, ':', view_cmd[rw_type], ReadBatch_cmd_Total); } else if(rw_type == rwt_read_cmd) { canvas_draw_str(canvas, 0, 7, "Read Command:"); render_display_list(canvas, &Read_cmd, '=', view_cmd[rw_type], Read_cmd_Total); } else if(rw_type == rwt_write_batch) { if(!ask_fill_screen_buf()) strcpy(screen_buf, "Write Batch:"); canvas_draw_str(canvas, 0, 7, screen_buf); render_display_list( canvas, &WriteBatch_cmd, ':', view_cmd[rw_type], WriteBatch_cmd_Total); } else if(rw_type == rwt_set_batch) { strcpy(screen_buf, "Set: "); display_add_status(); canvas_draw_str(canvas, 0, 7, screen_buf); render_display_list( canvas, &SetBatch_cmd, ':', view_cmd[rw_type], SetBatch_cmd_Total); } } } else { // what_doing == 2 if(rw_type == rwt_listen) { canvas_set_font(canvas, FontSecondary); // 8x10 font, 6 lines strcpy(screen_buf, "Listen: "); if(NRF_ERROR) strcat(screen_buf, "nRF24 ERROR!"); else if(ListenNew) { snprintf( screen_buf + strlen(screen_buf), 16, "%02d:%02d:%02d", ListenLastTime.hour, ListenLastTime.minute, ListenLastTime.second); if(ListenPrev) snprintf( screen_buf + strlen(screen_buf), 16, " (%lu)", ListenLast - ListenPrev); } else strcat(screen_buf, "receiving"); snprintf(screen_buf + strlen(screen_buf), 16, " %dmA", Current - CurrentStart); canvas_draw_str(canvas, 0, 10, screen_buf); if(ListenFields) { char *p2, *p = ListenFields; uint8_t hex, len, *pld = payload_receive; for(uint8_t i = 0; i < 5 && *p; i++) { hex = false; p2 = strchr(p, ','); if(p2 == NULL) p2 = p + strlen(p); if(*(p2 - 1) == '#') hex = true; memcpy(screen_buf, p, len = p2 - p); strcpy(screen_buf + len, ": "); if(ListenNew) { len = payload_struct[i]; int32_t n = get_payload_receive_field(pld, len); if(hex) { strcat(screen_buf, "0x"); add_to_str_hex_variable(screen_buf, pld, len); } else { snprintf(screen_buf + strlen(screen_buf), 20, "%ld", n); if(n > 9) { strcat(screen_buf, " ("); add_to_str_hex_variable(screen_buf, pld, len); strcat(screen_buf, ")"); } } pld += len; } canvas_draw_str(canvas, 0, 20 + i * 10, screen_buf); if(*p2 == '\0') break; p = p2 + 1; } } } else if(rw_type == rwt_read_cmd) { // Read command canvas_set_font(canvas, FontSecondary); // 8x10 font, 6 lines if(!ask_fill_screen_buf()) { strcpy(screen_buf, "Read "); strcat(screen_buf, ReadRepeat ? "rep: " : "cmd: "); } display_add_status(); canvas_draw_str(canvas, 0, 10, screen_buf); if(Log_Total) { char* p = (char*)furi_string_get_cstr(Log[Log_Total - 1]); uint8_t vx = MIN(view_x, strlen(p)); strncpy(screen_buf, p + vx, 30); display_remove_asterisk(p, vx); canvas_draw_str(canvas, 0, 15 + 10, screen_buf); } } else if(rw_type == rwt_set_batch) { canvas_set_font(canvas, FontBatteryPercent); // 5x7 font, 9 lines, 25 cols strcpy(screen_buf, "Set: "); display_add_status(); canvas_draw_str(canvas, 0, 7, screen_buf); render_display_list(canvas, &SetBatch_cmd, ':', view_cmd[rw_type], SetBatch_cmd_Total); } else { // rwt_read_batch, rwt_write_batch canvas_set_font(canvas, FontBatteryPercent); // 5x7 font, 9 lines, 25 cols if(!ask_fill_screen_buf()) { strcpy(screen_buf, rw_type == rwt_read_batch ? "Read Batch: " : "Write: "); if(rw_type == rwt_read_batch || send_status != sst_none) { display_add_status(); } else if(rw_type == rwt_write_batch) { char* p = (char*)furi_string_get_cstr(WriteBatch_cmd[view_cmd[rwt_write_batch]]); char* end = strchr(p, ':'); if(end) { uint8_t len = end - p; uint8_t lenb = strlen(screen_buf); end = screen_buf + lenb; lenb = FONT_5x7_SCREEN_WIDTH - lenb; if(len > lenb) { if(view_x < len) { strncpy(end, p + view_x, len = MIN(lenb, len - view_x)); end[len] = '\0'; } } else { strncpy(end, p, len); end[len] = '\0'; } } } } canvas_draw_str(canvas, 0, 7, screen_buf); if(Log_Total) { char* p; uint16_t y, page = view_Batch & ~7; uint8_t vx; for(uint8_t i = 0; i < 8 && page + i < Log_Total; i++) { p = (char*)furi_string_get_cstr(Log[page + i]); y = 14 + i * 7; vx = MIN(view_x, strlen(p)); if((view_Batch & 7) == i) { canvas_draw_str(canvas, 0, y, ">"); canvas_draw_str(canvas, -1, y, ">"); if(Edit) { int n = Edit_pos - p - vx - (FONT_5x7_SCREEN_WIDTH - 4); if(n > 0) vx += n; // fix out of screen int x = 6 + (Edit_pos - p - vx) * 5; canvas_draw_line(canvas, x - 1, y, x - 1, y - 1); canvas_draw_line(canvas, x - 1, y, n = x + 1 * 5, y); canvas_draw_line(canvas, n, y, n, y - 1); } } strncpy(screen_buf, p + vx, FONT_5x7_SCREEN_WIDTH + 2); screen_buf[FONT_5x7_SCREEN_WIDTH + 2] = '\0'; display_remove_asterisk(p, vx); canvas_draw_str(canvas, 6, y, screen_buf); } } } } furi_mutex_release(plugin_state->mutex); } void work_timer_callback(void* ctx) { if(ctx == NULL) return; if(rw_type == rwt_listen && (pwr_read_timer += WORK_PERIOD) >= POWER_READ_PERIOD) { pwr_read_timer = 0; update_power(); } if(what_doing == 2) { const PluginState* plugin_state = ctx; if(furi_mutex_acquire(plugin_state->mutex, 0) != FuriStatusOk) return; if(rw_type == rwt_write_batch || rw_type == rwt_set_batch) { uint16_t* cmd_curr = rw_type == rwt_set_batch ? &SetBatch_cmd_curr : &WriteBatch_cmd_curr; if(ERR == 0 && furi_get_tick() - NRF_time >= delay_between_pkt) { if(send_status == sst_ok) { if(ERR == 0 && *cmd_curr < Log_Total) { if(++(*cmd_curr) < Log_Total) Run_WriteBatch_cmd(); else { // finished ok if(rw_type == rwt_set_batch) what_doing = 1; Edited = false; } } } else if(send_status == sst_sending) { if(NRF_repeat++ < NRF_resend) nrf24_send_packet(); else { view_Batch = *cmd_curr; send_status = sst_error; // error NO_ACK } } } if((ERR || send_status == sst_error) && rw_type == rwt_set_batch) { what_doing = 1; } // ReadBatch or ReadCmd } else if(send_status == sst_sending) { // sending if(furi_get_tick() - NRF_time > delay_between_pkt) { if(NRF_repeat++ < NRF_resend) { nrf24_resend_read_packet(); } else send_status = sst_error; // error NO_ACK } } else if(send_status == sst_receiving) { // receiving for(uint8_t i = 0; i < 3; i++) { if(nrf24_read_newpacket()) { if(rw_type == rwt_listen) { ListenPrev = ListenLast; furi_hal_rtc_get_datetime(&ListenLastTime); ListenLast = furi_hal_rtc_datetime_to_timestamp(&ListenLastTime); ListenNew = true; } else if(send_status != sst_receiving) break; } else { if(rw_type != rwt_listen && furi_get_tick() - NRF_time > NRF_READ_TIMEOUT) { if(NRF_repeat++ < NRF_resend) { send_status = sst_sending; nrf24_resend_read_packet(); } else { FURI_LOG_D(TAG, "TIMEOUT: %lu", furi_get_tick() - NRF_time); send_status = sst_timeout; } } break; } } } else if(send_status == sst_ok) { if(rw_type == rwt_read_batch) { if((uint32_t)ReadBatch_cmd_curr != 0xFFFFFFFF && ERR == 0 && furi_get_tick() - NRF_time >= delay_between_pkt) { Run_ReadBatch_cmd(NULL); } } } furi_mutex_release(plugin_state->mutex); } } void next_rw_type(int8_t add) { do { rw_type += add; if(rw_type >= rwt_max) { if(add > 0) rw_type = 0; else rw_type = rwt_max - 1; } if(rw_type == rwt_set_batch && SetBatch_cmd_Total) break; if(rw_type == rwt_read_batch && ReadBatch_cmd_Total) break; if(rw_type == rwt_read_cmd && Read_cmd_Total) break; if(rw_type == rwt_write_batch && WriteBatch_cmd_Total) break; } while(rw_type != rwt_listen); send_status = sst_none; } void next_view_cmd(int8_t add) { if(rw_type == rwt_listen) return; uint16_t max = (rw_type == rwt_read_batch ? ReadBatch_cmd_Total : rw_type == rwt_read_cmd ? Read_cmd_Total : rw_type == rwt_set_batch ? SetBatch_cmd_Total : WriteBatch_cmd_Total); if((view_cmd[rw_type] += add) >= max) view_cmd[rw_type] = add > 0 ? 0 : max - 1; } int32_t nrf24batch_app(void* p) { UNUSED(p); APP = malloc(sizeof(nRF24Batch)); FuriMessageQueue* event_queue = furi_message_queue_alloc(8, sizeof(PluginEvent)); APP->plugin_state = malloc(sizeof(PluginState)); APP->plugin_state->mutex = furi_mutex_alloc(FuriMutexTypeNormal); if(!APP->plugin_state->mutex) { furi_message_queue_free(event_queue); FURI_LOG_E(TAG, "cannot create mutex"); free(APP->plugin_state); return 255; } // Set system callbacks ViewPort* view_port = view_port_alloc(); view_port_draw_callback_set(view_port, render_callback, APP->plugin_state); view_port_input_callback_set(view_port, input_callback, event_queue); // Open GUI and register view_port APP->gui = furi_record_open(RECORD_GUI); gui_add_view_port(APP->gui, view_port, GuiLayerFullscreen); APP->notification = furi_record_open(RECORD_NOTIFICATION); APP->storage = furi_record_open(RECORD_STORAGE); storage_common_migrate(APP->storage, EXT_PATH("nrf24batch"), SCAN_APP_PATH_FOLDER); storage_common_mkdir(APP->storage, SCAN_APP_PATH_FOLDER); file_stream = file_stream_alloc(APP->storage); FuriTimer* work_timer = furi_timer_alloc(work_timer_callback, FuriTimerTypePeriodic, APP->plugin_state); furi_timer_start(work_timer, WORK_PERIOD); nrf24_init(); check_en_power_5V(); PluginEvent event; for(bool processing = true; processing;) { FuriStatus event_status = furi_message_queue_get(event_queue, &event, 100); furi_mutex_acquire(APP->plugin_state->mutex, FuriWaitForever); // static FuriLogLevel FuriLogLevel = FuriLogLevelDefault; // if(furi_log_get_level() != FuriLogLevel) { // FuriLogLevel = furi_log_get_level(); // if(FuriLogLevel == FuriLogLevelDebug) // furi_hal_uart_set_br(FuriHalUartIdUSART1, 1843200); // } if(what_doing == 2 && rw_type == rwt_read_cmd && ReadRepeat && furi_get_tick() - NRF_time > (uint32_t)(ReadCmdRepeatPeriod * 1000)) { ERR = 0; free_Log(); Run_Read_cmd(Read_cmd[view_cmd[rwt_read_cmd]]); notification_message(APP->notification, &sequence_blink_blue_100); } if(event_status == FuriStatusOk) { // press events if(event.type == EventTypeKey) { switch(event.input.key) { case InputKeyUp: if(event.input.type == InputTypeShort || event.input.type == InputTypeRepeat) { if(!ask_question) { if(Edit) { char c = *Edit_pos; if(Edit_hex) { if(c == '9') *Edit_pos = 'A'; else if(c < 'F' || c < '9') *Edit_pos = c + 1; } else { if(c == '-') *Edit_pos = '0'; else if(c < '9') *Edit_pos = c + 1; else { c = *(Edit_pos - 1); if(Edit_pos > Edit_start && c < '9' && c >= '0') { *Edit_pos = '0'; (*(Edit_pos - 1)) = c + 1; } } } } else if(what_doing == 0) { if(addr_len) { if(setup_cursor > 0) setup_cursor--; else setup_cursor = 2; } } else if(what_doing == 1) next_view_cmd(-1); else if(what_doing == 2) if(view_Batch) view_Batch--; } } break; case InputKeyDown: if(event.input.type == InputTypeShort || event.input.type == InputTypeRepeat) { if(!ask_question) { if(Edit) { if(*Edit_pos != '-') { if(Edit_hex && *Edit_pos == 'A') (*Edit_pos) = '9'; else if(*Edit_pos > '0') (*Edit_pos)--; else if(!Edit_hex) { if(Edit_pos > Edit_start) { if(*(Edit_pos - 1) > '0' && *(Edit_pos - 1) <= '9') { *Edit_pos = '9'; (*(Edit_pos - 1))--; } } else Edit_insert_digit('-'); // negative } } } else if(what_doing == 0) { if(addr_len) { if(setup_cursor < 2) setup_cursor++; else setup_cursor = 0; } } else if(what_doing == 1) next_view_cmd(+1); else if(what_doing == 2) if(view_Batch < Log_Total - 1) view_Batch++; } } break; case InputKeyLeft: if(event.input.type == InputTypeShort || event.input.type == InputTypeRepeat) { if(ask_question) { if(event.input.type == InputTypeShort) ask_question_answer ^= 1; } else if(Edit) { if(Edit_pos > Edit_start) { if(is_digit(Edit_pos - 1, Edit_hex)) Edit_pos--; else if(*(Edit_pos - 1) == 'x' && *(Edit_pos - 3) == ',') Edit_pos -= 4; else if(*(Edit_pos - 1) == ',') Edit_pos -= 2; } } else if(what_doing == 0) { if(addr_len) { rw_type = rwt_listen; what_doing = 1; } } else if(what_doing == 1) { if(event.input.type == InputTypeShort) next_rw_type(-1); else if(view_x) view_x--; } else if(what_doing == 2) if(view_x) view_x--; } else if(event.input.type == InputTypeLong) { if(!ask_question && view_x == 0 && what_doing == 2 && (rw_type == rwt_write_batch || rw_type == rwt_read_batch) && Log_Total && Log[view_Batch] != NULL) { ask_question = ask_skip_cmd; ask_question_answer = 1; } } break; case InputKeyRight: if(event.input.type == InputTypeShort || event.input.type == InputTypeRepeat) { if(ask_question) { ask_question_answer ^= 1; } else if(Edit) { if(is_digit(Edit_pos + 1, Edit_hex)) Edit_pos++; else if(*(Edit_pos + 1) == ',') { Edit_pos += 2; if(*(Edit_pos + 1) == 'x') Edit_pos += 2; } } else if(what_doing == 0) { if(addr_len) { rw_type = rwt_set_batch; what_doing = 1; } } else if(what_doing == 1) { if(event.input.type == InputTypeShort) next_rw_type(+1); else view_x++; } else if(what_doing == 2) view_x++; } break; case InputKeyOk: if(event.input.type == InputTypeShort) { if(ask_question) { if(ask_question_answer) { if(ask_question == ask_save_batch) { save_batch(); } else if(ask_question == ask_write_batch) { if(WriteBatch_cmd_Total) { if(what_doing == 1) { Prepare_Write_cmd( WriteBatch_cmd[view_cmd[rwt_write_batch]]); send_status = sst_none; Edited = false; view_x = 0; view_Batch = 0; } if(Log_Total) { ERR = 0; WriteBatch_cmd_curr = 0; Run_WriteBatch_cmd(); what_doing = 2; } } } else if(ask_question == ask_skip_cmd) { if(rw_type == rwt_write_batch || rw_type == rwt_read_batch) { furi_string_free(Log[view_Batch]); if(view_Batch < Log_Total - 1) memmove( &Log[view_Batch], &Log[view_Batch + 1], sizeof(Log) * (Log_Total - view_Batch - 1)); else view_Batch--; Log_Total--; } } else if(ask_question == ask_exit) { processing = false; } else if(ask_question == ask_return) { if(what_doing == 2) { ERR = 0; send_status = sst_none; Edited = false; what_doing--; } } } ask_question = 0; } else if(Edit) { // insert digit Edit_insert_digit('0'); } else if(what_doing == 0) { if(setup_cursor == 0) { // open file file_stream_close(file_stream); if(select_settings_file()) { uint8_t err = load_settings_file(); if(err) snprintf( file_name, sizeof(file_name), "LOAD ERROR #%d", err); } } else if(setup_cursor == 1) { // change address char* ebuf = (char*)payload; ebuf[0] = '\0'; add_to_str_hex_bytes(ebuf, addr, addr_len); Edit_hex = true; Edit_pos = ebuf + strlen(ebuf) - 1; Edit_start = ebuf; Edit = 1; NRF_INITED = 0; } else if(setup_cursor == 2) { // change channel char* ebuf = (char*)payload; snprintf(ebuf, sizeof(payload), "%d", NRF_channel); Edit_hex = false; Edit_pos = ebuf + strlen(ebuf) - 1; Edit_start = ebuf; Edit = 1; NRF_INITED = 0; } } else if(what_doing == 1) { if(rw_type == rwt_set_batch) { if(SetBatch_cmd_Total) { ERR = 0; send_status = sst_none; Prepare_Write_cmd(SetBatch_cmd[view_cmd[rwt_set_batch]]); if(!ERR) { SetBatch_cmd_curr = 0; Run_WriteBatch_cmd(); what_doing = 2; } Edited = false; } } else if(rw_type == rwt_read_batch) { if(ReadBatch_cmd_Total) { ERR = 0; Run_ReadBatch_cmd(ReadBatch_cmd[view_cmd[rwt_read_batch]]); view_x = 0; view_Batch = 0; what_doing = 2; } } else if(rw_type == rwt_read_cmd) { if(Read_cmd_Total) { ERR = 0; free_Log(); Run_Read_cmd(Read_cmd[view_cmd[rwt_read_cmd]]); view_x = 0; what_doing = 2; } } else if(rw_type == rwt_write_batch) { if(WriteBatch_cmd_Total) { ERR = 0; Prepare_Write_cmd(WriteBatch_cmd[view_cmd[rwt_write_batch]]); send_status = sst_none; Edited = false; view_x = 0; view_Batch = 0; what_doing = 2; } } else if(rw_type == rwt_listen) { if(listen_addr_len) { free_Log(); prepare_nrf24(); if(!NRF_ERROR) { nrf24_set_rx_mode(nrf24_HANDLE); ListenNew = false; send_status = sst_receiving; // receiving } what_doing = 2; } } } else if(what_doing == 2) { if(rw_type == rwt_read_cmd) { ERR = 0; free_Log(); Run_Read_cmd(Read_cmd[view_cmd[rwt_read_cmd]]); } else if(Log_Total) { if(rw_type == rwt_read_batch) { ask_question = ask_save_batch; ask_question_answer = 0; } else if(rw_type == rwt_write_batch) { ask_question = ask_write_batch; ask_question_answer = 0; } } } } else if(event.input.type == InputTypeLong) { if(Edit) { // delete if(what_doing <= 1) { if(strlen(Edit_start) > 1) { memmove(Edit_pos, Edit_pos + 1, strlen(Edit_pos)); if(*Edit_pos == '\0') Edit_pos--; } } else { FuriString* fs = Log[view_Batch]; if(is_digit(Edit_pos + 1, Edit_hex) || (Edit_pos > Edit_start && is_digit(Edit_pos - 1, Edit_hex))) { memmove(Edit_pos, Edit_pos + 1, strlen(Edit_pos)); if(*Edit_pos == '\0') Edit_pos--; furi_string_left(fs, furi_string_size(fs) - 1); } } } else if(what_doing == 1) { if(rw_type == rwt_listen) { if(listen_addr_len) { char* ebuf = (char*)payload; ebuf[0] = '\0'; add_to_str_hex_bytes(ebuf, listen_addr, listen_addr_len); Edit_hex = true; Edit_pos = ebuf + strlen(ebuf) - 1; Edit_start = ebuf; Edit = 1; NRF_INITED = 0; } } else if(rw_type == rwt_read_batch) { if(ReadBatch_cmd_Total) { ERR = 0; Run_ReadBatch_cmd(ReadBatch_cmd[view_cmd[rwt_read_batch]]); view_x = 0; view_Batch = 0; what_doing = 2; } } else if(rw_type == rwt_write_batch) { ask_question = ask_write_batch; ask_question_answer = 0; } } else if(what_doing == 2) { if(rw_type == rwt_read_cmd) { ReadRepeat = !ReadRepeat; } else if(Log_Total) { if(rw_type == rwt_write_batch) { if(!Edit) { Edit = 0; Edit_hex = 0; char* s = (char*)furi_string_get_cstr(Log[view_Batch]); char* p = strchr(s, '='); if(p) { p++; if(*p == '{') p++; // array if(*(p + 1) == 'x') { p += 2; Edit_hex = 1; // hex } if(is_digit(p, Edit_hex)) { Edit_start = p; while(is_digit(p, Edit_hex)) p++; Edit_pos = p - 1; Edited = true; Edit = 1; } } } } else if(rw_type == rwt_read_batch) { ask_question = ask_save_batch; ask_question_answer = 0; } } } } break; case InputKeyBack: if(event.input.type == InputTypeLong) { if(what_doing == 2 && Edited) { if(!ask_question) ask_question_answer = 1; ask_question = ask_exit; } else processing = false; } else if(event.input.type == InputTypeShort) { if(ask_question) ask_question = 0; else if(Edit) { if(what_doing == 0) { if(setup_cursor == 1) { addr_len = ConvertHexToArray((char*)payload, addr, 5); } else if(setup_cursor == 2) { NRF_channel = str_to_int((char*)payload); if(NRF_channel > MAX_CHANNEL) NRF_channel = MAX_CHANNEL; } } else if(what_doing == 1 && rw_type == rwt_listen) { listen_addr_len = ConvertHexToArray((char*)payload, listen_addr, 5); } Edit = 0; } else { if(what_doing == 2 && Edited) { ask_question = ask_return; ask_question_answer = 1; } else if(what_doing != 0) { if(what_doing) what_doing--; if(what_doing == 0) rw_type = rwt_read_batch; if(what_doing <= 1) view_x = 0; ERR = 0; send_status = sst_none; } } } break; default: break; } } } view_port_update(view_port); furi_mutex_release(APP->plugin_state->mutex); } nrf24_set_idle(nrf24_HANDLE); nrf24_deinit(); if(NRF_BOARD_POWER_5V) furi_hal_power_disable_otg(); view_port_enabled_set(view_port, false); gui_remove_view_port(APP->gui, view_port); furi_record_close(RECORD_GUI); furi_record_close(RECORD_NOTIFICATION); furi_record_close(RECORD_STORAGE); if(file_stream) { file_stream_close(file_stream); stream_free(file_stream); } view_port_free(view_port); furi_message_queue_free(event_queue); free_store(); furi_timer_stop(work_timer); furi_timer_free(work_timer); furi_mutex_free(APP->plugin_state->mutex); free(APP->plugin_state); free(APP); return 0; }