From 010c92fc176b7d3ea94c31437ef3fbdafcb3acfe Mon Sep 17 00:00:00 2001 From: Siwat Sirichai Date: Sun, 3 Dec 2023 15:23:00 +0700 Subject: [PATCH] rename all mention of EEPROM to FRAM --- src/espmega_iot_core.cpp | 246 +++++++++++++++++++-------------------- src/espmega_iot_core.hpp | 20 ++-- 2 files changed, 133 insertions(+), 133 deletions(-) diff --git a/src/espmega_iot_core.cpp b/src/espmega_iot_core.cpp index 36aca44..ddfcaf2 100644 --- a/src/espmega_iot_core.cpp +++ b/src/espmega_iot_core.cpp @@ -59,9 +59,9 @@ unsigned long virtual_interupt_timer[VINT_COUNT]; #define PWM_COUNT 16 const uint8_t pwm_pins[PWM_COUNT] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15}; bool pwm_states[PWM_COUNT]; -uint8_t pwm_states_eeprom[PWM_COUNT]; +uint8_t pwm_states_fram[PWM_COUNT]; uint16_t pwm_values[PWM_COUNT]; -uint8_t pwm_values_eeprom[PWM_COUNT * 2]; +uint8_t pwm_values_fram[PWM_COUNT * 2]; // output = m*input+c const float pwm_linear_scaling_m[PWM_COUNT] = {1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1}; const float pwm_linear_scaling_c[PWM_COUNT] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; @@ -118,28 +118,28 @@ char DAC_STATE_TOPIC[75]; char DAC_VALUE_TOPIC[75]; #endif -// EEPROM ADDRESS -#define EEPROM_ADDRESS_AC_MODE 0 // 01bytes -#define EEPROM_ADDRESS_AC_TEMPERATURE 1 // 01bytes -#define EEPROM_ADDRESS_AC_FAN_SPEED 2 // 01bytes -#define EEPROM_ADDRESS_PWM_STATE 3 // 16bytes, thru 18 -#define EEPROM_ADDRESS_PWM_VALUE 19 // 32bytes, thru 50 -#define EEPROM_ADDRESS_HOSTNAME 65 // 15bytes, thru 79 -#define EEPROM_ADDRESS_TOPIC 80 // 20bytes, thru 99 -#define EEPROM_ADDRESS_IP 100 // 04bytes, thru 103 -#define EEPROM_ADDRESS_SUBNET 104 // 04bytes, thru 107 -#define EEPROM_ADDRESS_GATEWAY 108 // 04bytes, thru 111 -#define EEPROM_ADDRESS_DNS 112 // 04bytes, thru 115 -#define EEPROM_ADDRESS_MQTT_SERVER 116 // 04bytes, thru 119 -#define EEPROM_ADDRESS_MQTT_PORT 120 // 02bytes, thru 121 -#define EEPROM_ADDRESS_MQTT_USERNAME 122 // 32bytes, thru 153 -#define EEPROM_ADDRESS_MQTT_PASSWORD 154 // 32bytes, thru 185 -#define EEPROM_ADDRESS_MQTT_USEAUTH 186 // 1bytes -#define EEPROM_ADDRESS_ADC_REPORT_STATE 187 // 8bytes, thru 194 -#define EEPROM_ADDRESS_DAC_STATE 195 // 4bytes, thru 198 -#define EEPROM_ADDRESS_DAC_VALUE 199 // 8bytes, thru 206 -#define EEPROM_ADDRESS_WEBUI_USERNAME 207 // 32bytes, thru 238 -#define EEPROM_ADDRESS_WEBUI_PASSWORD 239 // 32bytes, thru 270 +// FRAM ADDRESS +#define FRAM_ADDRESS_AC_MODE 0 // 01bytes +#define FRAM_ADDRESS_AC_TEMPERATURE 1 // 01bytes +#define FRAM_ADDRESS_AC_FAN_SPEED 2 // 01bytes +#define FRAM_ADDRESS_PWM_STATE 3 // 16bytes, thru 18 +#define FRAM_ADDRESS_PWM_VALUE 19 // 32bytes, thru 50 +#define FRAM_ADDRESS_HOSTNAME 65 // 15bytes, thru 79 +#define FRAM_ADDRESS_TOPIC 80 // 20bytes, thru 99 +#define FRAM_ADDRESS_IP 100 // 04bytes, thru 103 +#define FRAM_ADDRESS_SUBNET 104 // 04bytes, thru 107 +#define FRAM_ADDRESS_GATEWAY 108 // 04bytes, thru 111 +#define FRAM_ADDRESS_DNS 112 // 04bytes, thru 115 +#define FRAM_ADDRESS_MQTT_SERVER 116 // 04bytes, thru 119 +#define FRAM_ADDRESS_MQTT_PORT 120 // 02bytes, thru 121 +#define FRAM_ADDRESS_MQTT_USERNAME 122 // 32bytes, thru 153 +#define FRAM_ADDRESS_MQTT_PASSWORD 154 // 32bytes, thru 185 +#define FRAM_ADDRESS_MQTT_USEAUTH 186 // 1bytes +#define FRAM_ADDRESS_ADC_REPORT_STATE 187 // 8bytes, thru 194 +#define FRAM_ADDRESS_DAC_STATE 195 // 4bytes, thru 198 +#define FRAM_ADDRESS_DAC_VALUE 199 // 8bytes, thru 206 +#define FRAM_ADDRESS_WEBUI_USERNAME 207 // 32bytes, thru 238 +#define FRAM_ADDRESS_WEBUI_PASSWORD 239 // 32bytes, thru 270 char PWM_STATE_TOPIC[75]; char PWM_VALUE_TOPIC[75]; @@ -154,10 +154,10 @@ DHTNEW env_sensor(DHT22_PIN); Thread mqtt_reconnector = Thread(); Thread environment_reporter = Thread(); -Thread eeprom_pwm_updater = Thread(); +Thread fram_pwm_updater = Thread(); Thread user_timer_tick = Thread(); Thread analog_handler = Thread(); -StaticThreadController<5> thread_controller(&mqtt_reconnector, &environment_reporter, &eeprom_pwm_updater, &user_timer_tick, &analog_handler); +StaticThreadController<5> thread_controller(&mqtt_reconnector, &environment_reporter, &fram_pwm_updater, &user_timer_tick, &analog_handler); #ifdef ENABLE_INTERNAL_LCD Thread top_bar_updater = Thread(); @@ -186,7 +186,7 @@ void setup() #ifdef VIRTUAL_INTERRUPT_PRELOAD virtual_interrupt_preload(); #endif - eeprom_retrieve_init(); + fram_retrieve_init(); user_pre_init(); #ifdef ENABLE_INTERNAL_LCD lcd_send_stop_bit(); @@ -244,52 +244,52 @@ void loop() } /** - * @brief Retrieves data from EEPROM and initializes various variables and topics. + * @brief Retrieves data from FRAM and initializes various variables and topics. * */ -void eeprom_retrieve_init() +void fram_retrieve_init() { #ifdef ENABLE_WEBUI - ESPMega_FRAM.read(EEPROM_ADDRESS_WEBUI_USERNAME, (uint8_t *)WEBUI_USERNAME, 32); - ESPMega_FRAM.read(EEPROM_ADDRESS_WEBUI_PASSWORD, (uint8_t *)WEBUI_PASSWORD, 32); + ESPMega_FRAM.read(FRAM_ADDRESS_WEBUI_USERNAME, (uint8_t *)WEBUI_USERNAME, 32); + ESPMega_FRAM.read(FRAM_ADDRESS_WEBUI_PASSWORD, (uint8_t *)WEBUI_PASSWORD, 32); if(strlen(WEBUI_USERNAME)==0) { strcpy(WEBUI_USERNAME,"admin"); - ESPMega_FRAM.write(EEPROM_ADDRESS_WEBUI_USERNAME, (uint8_t *)WEBUI_USERNAME, 32); + ESPMega_FRAM.write(FRAM_ADDRESS_WEBUI_USERNAME, (uint8_t *)WEBUI_USERNAME, 32); } if(strlen(WEBUI_PASSWORD)==0) { strcpy(WEBUI_PASSWORD,"admin"); - ESPMega_FRAM.write(EEPROM_ADDRESS_WEBUI_PASSWORD, (uint8_t *)WEBUI_PASSWORD, 32); + ESPMega_FRAM.write(FRAM_ADDRESS_WEBUI_PASSWORD, (uint8_t *)WEBUI_PASSWORD, 32); } #endif -// EEPROM Data Retrival +// FRAM Data Retrival #ifdef ENABLE_CLIMATE_MODULE - ac_mode = ESPMega_FRAM.read8(EEPROM_ADDRESS_AC_MODE); - ac_temperature = ESPMega_FRAM.read8(EEPROM_ADDRESS_AC_TEMPERATURE); - ac_fan_speed = ESPMega_FRAM.read8(EEPROM_ADDRESS_AC_FAN_SPEED); + ac_mode = ESPMega_FRAM.read8(FRAM_ADDRESS_AC_MODE); + ac_temperature = ESPMega_FRAM.read8(FRAM_ADDRESS_AC_TEMPERATURE); + ac_fan_speed = ESPMega_FRAM.read8(FRAM_ADDRESS_AC_FAN_SPEED); #endif -// EEPROM Data Retrival Validation +// FRAM Data Retrival Validation #ifdef ENABLE_CLIMATE_MODULE if (ac_mode > 2) { ac_mode = 0; - ESPMega_FRAM.write8(EEPROM_ADDRESS_AC_MODE, ac_mode); + ESPMega_FRAM.write8(FRAM_ADDRESS_AC_MODE, ac_mode); } if (ac_temperature > AC_MAX_TEMPERATURE || ac_temperature < AC_MIN_TEMPERATURE) { ac_temperature = AC_MAX_TEMPERATURE; - ESPMega_FRAM.write8(EEPROM_ADDRESS_AC_TEMPERATURE, ac_temperature); + ESPMega_FRAM.write8(FRAM_ADDRESS_AC_TEMPERATURE, ac_temperature); } if (ac_fan_speed > 3) { ac_fan_speed = 0; - ESPMega_FRAM.write8(EEPROM_ADDRESS_AC_TEMPERATURE, ac_fan_speed); + ESPMega_FRAM.write8(FRAM_ADDRESS_AC_TEMPERATURE, ac_fan_speed); } ac_set_state(ac_mode, ac_temperature, ac_fan_speed); #endif - ESPMega_FRAM.read(EEPROM_ADDRESS_PWM_STATE, pwm_states_eeprom, 16); - memcpy(pwm_states, pwm_states_eeprom, 16); - ESPMega_FRAM.read(EEPROM_ADDRESS_PWM_VALUE, pwm_values_eeprom, 32); - memcpy(pwm_values, pwm_values_eeprom, 32); + ESPMega_FRAM.read(FRAM_ADDRESS_PWM_STATE, pwm_states_fram, 16); + memcpy(pwm_states, pwm_states_fram, 16); + ESPMega_FRAM.read(FRAM_ADDRESS_PWM_VALUE, pwm_values_fram, 32); + memcpy(pwm_values, pwm_values_fram, 32); for (int i = 0; i < 15; i++) { if (pwm_states[i] <= 1) @@ -301,18 +301,18 @@ void eeprom_retrieve_init() else pwm_set_value(i, 0); } - IP = eeprom_ip_retrieve(EEPROM_ADDRESS_IP); - SUBNET = eeprom_ip_retrieve(EEPROM_ADDRESS_SUBNET); - GATEWAY = eeprom_ip_retrieve(EEPROM_ADDRESS_GATEWAY); - DNS = eeprom_ip_retrieve(EEPROM_ADDRESS_DNS); - MQTT_SERVER = eeprom_ip_retrieve(EEPROM_ADDRESS_MQTT_SERVER); - eeprom_hostname_retrieve(); - eeprom_mqtt_port_retrieve(); - eeprom_mqtt_useauth_retrieve(); - eeprom_mqtt_username_retrieve(); - eeprom_mqtt_password_retrieve(); + IP = fram_ip_retrieve(FRAM_ADDRESS_IP); + SUBNET = fram_ip_retrieve(FRAM_ADDRESS_SUBNET); + GATEWAY = fram_ip_retrieve(FRAM_ADDRESS_GATEWAY); + DNS = fram_ip_retrieve(FRAM_ADDRESS_DNS); + MQTT_SERVER = fram_ip_retrieve(FRAM_ADDRESS_MQTT_SERVER); + fram_hostname_retrieve(); + fram_mqtt_port_retrieve(); + fram_mqtt_useauth_retrieve(); + fram_mqtt_username_retrieve(); + fram_mqtt_password_retrieve(); mqtt.setServer(MQTT_SERVER, MQTT_PORT); - eeprom_basetopic_retrieve(); + fram_basetopic_retrieve(); base_topic_length = strlen(MQTT_BASE_TOPIC) + 1; memcpy(STATE_REQUEST_TOPIC, MQTT_BASE_TOPIC, 20); strcat(STATE_REQUEST_TOPIC, "/requeststate"); @@ -361,9 +361,9 @@ void eeprom_retrieve_init() strcat(DAC_STATE_TOPIC, "/dac/00/state"); memcpy(DAC_VALUE_TOPIC, MQTT_BASE_TOPIC, 20); strcat(DAC_VALUE_TOPIC, "/dac/00/value"); - ESPMega_FRAM.read(EEPROM_ADDRESS_ADC_REPORT_STATE, (uint8_t *)adc_report_enable, 8); - ESPMega_FRAM.read(EEPROM_ADDRESS_DAC_STATE, (uint8_t *)dac_states, 4); - ESPMega_FRAM.read(EEPROM_ADDRESS_DAC_VALUE, (uint8_t *)dac_values, 8); + ESPMega_FRAM.read(FRAM_ADDRESS_ADC_REPORT_STATE, (uint8_t *)adc_report_enable, 8); + ESPMega_FRAM.read(FRAM_ADDRESS_DAC_STATE, (uint8_t *)dac_states, 4); + ESPMega_FRAM.read(FRAM_ADDRESS_DAC_VALUE, (uint8_t *)dac_values, 8); for (int i = 0; i < DAC_COUNT; i++) { dac_set_state(i, dac_states[i]); @@ -463,9 +463,9 @@ void ota_begin() if(!value.compareTo("yes")) use_auth = true; } else if(!arg.compareTo("webui_username")) { - ESPMega_FRAM.write(EEPROM_ADDRESS_WEBUI_USERNAME, (uint8_t *)value.c_str(), value.length()+1); + ESPMega_FRAM.write(FRAM_ADDRESS_WEBUI_USERNAME, (uint8_t *)value.c_str(), value.length()+1); } else if(!arg.compareTo("webui_password")) { - ESPMega_FRAM.write(EEPROM_ADDRESS_WEBUI_PASSWORD, (uint8_t *)value.c_str(), value.length()+1); + ESPMega_FRAM.write(FRAM_ADDRESS_WEBUI_PASSWORD, (uint8_t *)value.c_str(), value.length()+1); } } set_mqtt_useauth(use_auth); @@ -748,7 +748,7 @@ void mqtt_callback(char *topic, byte *payload, unsigned int length) } /** - * @brief Initializes the threads for various tasks such as MQTT connection, environment reporting, EEPROM PWM update, and user timer tick. + * @brief Initializes the threads for various tasks such as MQTT connection, environment reporting, FRAM PWM update, and user timer tick. * */ void thread_initialization() @@ -761,8 +761,8 @@ void thread_initialization() environment_reporter.onRun(publish_env_state); environment_reporter.setInterval(5000); #endif - eeprom_pwm_updater.onRun(eeprom_pwm_update); - eeprom_pwm_updater.setInterval(1000); + fram_pwm_updater.onRun(fram_pwm_update); + fram_pwm_updater.setInterval(1000); user_timer_tick.onRun(timer_tick_callback); user_timer_tick.setInterval(15000); #ifdef ENABLE_ANALOG_MODULE @@ -1559,34 +1559,34 @@ void trigger15() #endif // End Internal LCD Code Block /** - * @brief Updates the PWM states and values in EEPROM if they have changed. + * @brief Updates the PWM states and values in FRAM if they have changed. * - * If the current PWM states or values are different from the ones stored in EEPROM, - * this function updates the EEPROM with the current values. + * If the current PWM states or values are different from the ones stored in FRAM, + * this function updates the FRAM with the current values. */ -void eeprom_pwm_update() +void fram_pwm_update() { - if (memcmp(pwm_states, pwm_states_eeprom, 16)) + if (memcmp(pwm_states, pwm_states_fram, 16)) { - memcpy(pwm_states_eeprom, pwm_states, 16); - ESPMega_FRAM.write(3, pwm_states_eeprom, 16); + memcpy(pwm_states_fram, pwm_states, 16); + ESPMega_FRAM.write(3, pwm_states_fram, 16); } - if (memcmp(pwm_values, pwm_values_eeprom, 32)) + if (memcmp(pwm_values, pwm_values_fram, 32)) { - memcpy(pwm_values_eeprom, pwm_values, 32); - ESPMega_FRAM.write(19, pwm_values_eeprom, 32); + memcpy(pwm_values_fram, pwm_values, 32); + ESPMega_FRAM.write(19, pwm_values_fram, 32); } } /** - * @brief Sets the IP address and updates it in EEPROM. + * @brief Sets the IP address and updates it in FRAM. * * @param address The IP address to set. */ void set_ip(String address) { IP.fromString(address); - eeprom_ip_update(EEPROM_ADDRESS_IP, IP[0], IP[1], IP[2], IP[3]); + fram_ip_update(FRAM_ADDRESS_IP, IP[0], IP[1], IP[2], IP[3]); } /** @@ -1597,7 +1597,7 @@ void set_ip(String address) void set_netmask(String address) { SUBNET.fromString(address); - eeprom_ip_update(EEPROM_ADDRESS_SUBNET, SUBNET[0], SUBNET[1], SUBNET[2], SUBNET[3]); + fram_ip_update(FRAM_ADDRESS_SUBNET, SUBNET[0], SUBNET[1], SUBNET[2], SUBNET[3]); } /** @@ -1607,33 +1607,33 @@ void set_netmask(String address) void set_dns(String address) { DNS.fromString(address); - eeprom_ip_update(EEPROM_ADDRESS_DNS, DNS[0], DNS[1], DNS[2], DNS[3]); + fram_ip_update(FRAM_ADDRESS_DNS, DNS[0], DNS[1], DNS[2], DNS[3]); } /** - * @brief Sets the gateway IP address and updates the EEPROM. + * @brief Sets the gateway IP address and updates the FRAM. * * @param address The gateway IP address as a String. */ void set_gw(String address) { GATEWAY.fromString(address); - eeprom_ip_update(EEPROM_ADDRESS_GATEWAY, GATEWAY[0], GATEWAY[1], GATEWAY[2], GATEWAY[3]); + fram_ip_update(FRAM_ADDRESS_GATEWAY, GATEWAY[0], GATEWAY[1], GATEWAY[2], GATEWAY[3]); } /** - * @brief Sets the MQTT server address and updates the EEPROM. + * @brief Sets the MQTT server address and updates the FRAM. * * @param address The MQTT server address as a String. */ void set_mqtt_server(String address) { MQTT_SERVER.fromString(address); - eeprom_ip_update(EEPROM_ADDRESS_MQTT_SERVER, MQTT_SERVER[0], MQTT_SERVER[1], MQTT_SERVER[2], MQTT_SERVER[3]); + fram_ip_update(FRAM_ADDRESS_MQTT_SERVER, MQTT_SERVER[0], MQTT_SERVER[1], MQTT_SERVER[2], MQTT_SERVER[3]); } /** - * @brief Updates the IP address in EEPROM at the specified ROM address. + * @brief Updates the IP address in FRAM at the specified ROM address. * * @param rom_address The ROM address where the IP address is stored. * @param byte1 The first byte of the IP address. @@ -1641,19 +1641,19 @@ void set_mqtt_server(String address) * @param byte3 The third byte of the IP address. * @param byte4 The fourth byte of the IP address. */ -void eeprom_ip_update(uint16_t rom_address, uint8_t byte1, uint8_t byte2, uint8_t byte3, uint8_t byte4) +void fram_ip_update(uint16_t rom_address, uint8_t byte1, uint8_t byte2, uint8_t byte3, uint8_t byte4) { uint8_t addressblock[4] = {byte1, byte2, byte3, byte4}; ESPMega_FRAM.write(rom_address, addressblock, 4); } /** - * @brief Retrieves an IP address from EEPROM memory. + * @brief Retrieves an IP address from FRAM memory. * - * @param rom_address The address in EEPROM memory where the IP address is stored. + * @param rom_address The address in FRAM memory where the IP address is stored. * @return The retrieved IP address. */ -IPAddress eeprom_ip_retrieve(uint16_t rom_address) +IPAddress fram_ip_retrieve(uint16_t rom_address) { uint8_t addressblock[4]; ESPMega_FRAM.read(rom_address, addressblock, 4); @@ -1668,40 +1668,40 @@ IPAddress eeprom_ip_retrieve(uint16_t rom_address) void set_hostname(String hostname) { hostname.toCharArray(HOSTNAME, 15); - ESPMega_FRAM.write(EEPROM_ADDRESS_HOSTNAME, (uint8_t *)HOSTNAME, 15); + ESPMega_FRAM.write(FRAM_ADDRESS_HOSTNAME, (uint8_t *)HOSTNAME, 15); } /** - * @brief Retrieves the hostname from EEPROM and stores it in the HOSTNAME variable. + * @brief Retrieves the hostname from FRAM and stores it in the HOSTNAME variable. * */ -void eeprom_hostname_retrieve() +void fram_hostname_retrieve() { - ESPMega_FRAM.read(EEPROM_ADDRESS_HOSTNAME, (uint8_t *)HOSTNAME, 15); + ESPMega_FRAM.read(FRAM_ADDRESS_HOSTNAME, (uint8_t *)HOSTNAME, 15); } /** - * @brief Sets the base topic for MQTT communication and writes it to EEPROM. + * @brief Sets the base topic for MQTT communication and writes it to FRAM. * * @param topic The base topic to set. */ void set_basetopic(String topic) { topic.toCharArray(MQTT_BASE_TOPIC, 20); - ESPMega_FRAM.write(EEPROM_ADDRESS_TOPIC, (uint8_t *)MQTT_BASE_TOPIC, 20); + ESPMega_FRAM.write(FRAM_ADDRESS_TOPIC, (uint8_t *)MQTT_BASE_TOPIC, 20); } /** - * @brief Retrieves the MQTT base topic from EEPROM and stores it in MQTT_BASE_TOPIC array. + * @brief Retrieves the MQTT base topic from FRAM and stores it in MQTT_BASE_TOPIC array. * */ -void eeprom_basetopic_retrieve() +void fram_basetopic_retrieve() { - ESPMega_FRAM.read(EEPROM_ADDRESS_TOPIC, (uint8_t *)MQTT_BASE_TOPIC, 20); + ESPMega_FRAM.read(FRAM_ADDRESS_TOPIC, (uint8_t *)MQTT_BASE_TOPIC, 20); } /** - * @brief Sets the MQTT port in the EEPROM. + * @brief Sets the MQTT port in the FRAM. * * @param port The MQTT port to be set. */ @@ -1709,16 +1709,16 @@ void mqtt_port_set(uint16_t port) { uint8_t port_arr[2]; memcpy(port_arr, &port, 2); - ESPMega_FRAM.write(EEPROM_ADDRESS_MQTT_PORT, port_arr, 2); + ESPMega_FRAM.write(FRAM_ADDRESS_MQTT_PORT, port_arr, 2); } /** - * @brief Retrieves the MQTT port from EEPROM and stores it in the MQTT_PORT variable. + * @brief Retrieves the MQTT port from FRAM and stores it in the MQTT_PORT variable. * */ -void eeprom_mqtt_port_retrieve() +void fram_mqtt_port_retrieve() { uint8_t port_arr[2]; - ESPMega_FRAM.read(EEPROM_ADDRESS_MQTT_PORT, port_arr, 2); + ESPMega_FRAM.read(FRAM_ADDRESS_MQTT_PORT, port_arr, 2); memcpy(&MQTT_PORT, port_arr, 2); } @@ -1786,67 +1786,67 @@ uint8_t ac_get_fan_speed() #endif /** - * @brief Retrieves the MQTT username from EEPROM and stores it in the MQTT_USERNAME global variable. + * @brief Retrieves the MQTT username from FRAM and stores it in the MQTT_USERNAME global variable. * */ -void eeprom_mqtt_username_retrieve() +void fram_mqtt_username_retrieve() { - ESPMega_FRAM.read(EEPROM_ADDRESS_MQTT_USERNAME, (uint8_t *)MQTT_USERNAME, 32); + ESPMega_FRAM.read(FRAM_ADDRESS_MQTT_USERNAME, (uint8_t *)MQTT_USERNAME, 32); } /** - * @brief Retrieves the MQTT password from EEPROM and stores it in the MQTT_PASSWORD global variable. + * @brief Retrieves the MQTT password from FRAM and stores it in the MQTT_PASSWORD global variable. * */ -void eeprom_mqtt_password_retrieve() +void fram_mqtt_password_retrieve() { - ESPMega_FRAM.read(EEPROM_ADDRESS_MQTT_PASSWORD, (uint8_t *)MQTT_PASSWORD, 32); + ESPMega_FRAM.read(FRAM_ADDRESS_MQTT_PASSWORD, (uint8_t *)MQTT_PASSWORD, 32); } /** - * @brief Sets the MQTT username and writes it to the EEPROM. + * @brief Sets the MQTT username and writes it to the FRAM. * * @param username The MQTT username to set. */ void set_mqtt_username(String username) { username.toCharArray(MQTT_USERNAME, 32); - ESPMega_FRAM.write(EEPROM_ADDRESS_MQTT_USERNAME, (uint8_t *)MQTT_USERNAME, 20); + ESPMega_FRAM.write(FRAM_ADDRESS_MQTT_USERNAME, (uint8_t *)MQTT_USERNAME, 20); } /** - * @brief Sets the MQTT password and writes it to the EEPROM. + * @brief Sets the MQTT password and writes it to the FRAM. * * @param password The MQTT password to set. */ void set_mqtt_password(String password) { password.toCharArray(MQTT_PASSWORD, 32); - ESPMega_FRAM.write(EEPROM_ADDRESS_MQTT_PASSWORD, (uint8_t *)MQTT_PASSWORD, 20); + ESPMega_FRAM.write(FRAM_ADDRESS_MQTT_PASSWORD, (uint8_t *)MQTT_PASSWORD, 20); } -void eeprom_mqtt_useauth_retrieve() +void fram_mqtt_useauth_retrieve() { - MQTT_USE_AUTH = ESPMega_FRAM.read8(EEPROM_ADDRESS_MQTT_USEAUTH); + MQTT_USE_AUTH = ESPMega_FRAM.read8(FRAM_ADDRESS_MQTT_USEAUTH); } /** - * @brief Sets the MQTT_USE_AUTH flag and writes it to the EEPROM. + * @brief Sets the MQTT_USE_AUTH flag and writes it to the FRAM. * * @param use_auth A boolean value indicating whether to use authentication for MQTT. */ void set_mqtt_useauth(bool use_auth) { MQTT_USE_AUTH = use_auth; - ESPMega_FRAM.write8(EEPROM_ADDRESS_MQTT_USEAUTH, MQTT_USE_AUTH); + ESPMega_FRAM.write8(FRAM_ADDRESS_MQTT_USEAUTH, MQTT_USE_AUTH); } void set_webui_username(String username) { username.toCharArray(WEBUI_USERNAME, 32); - ESPMega_FRAM.write(EEPROM_ADDRESS_WEBUI_USERNAME, (uint8_t *)WEBUI_USERNAME, 32); + ESPMega_FRAM.write(FRAM_ADDRESS_WEBUI_USERNAME, (uint8_t *)WEBUI_USERNAME, 32); } void set_webui_password(String password) { password.toCharArray(WEBUI_PASSWORD, 32); - ESPMega_FRAM.write(EEPROM_ADDRESS_WEBUI_PASSWORD, (uint8_t *)WEBUI_PASSWORD, 32); + ESPMega_FRAM.write(FRAM_ADDRESS_WEBUI_PASSWORD, (uint8_t *)WEBUI_PASSWORD, 32); } /** @@ -1920,20 +1920,20 @@ void check_boot_reset() void enable_adc(int id) { adc_report_enable[id] = true; - ESPMega_FRAM.write8(EEPROM_ADDRESS_ADC_REPORT_STATE + id, 1); + ESPMega_FRAM.write8(FRAM_ADDRESS_ADC_REPORT_STATE + id, 1); publish_adc_state(id); } /** * @brief Disables the ADC reporting for the specified ID. * - * This function sets the adc_report_enable flag to false for the specified ID and writes the state to the EEPROM. + * This function sets the adc_report_enable flag to false for the specified ID and writes the state to the FRAM. * * @param id The ID of the ADC to disable reporting for. */ void disable_adc(int id) { adc_report_enable[id] = false; - ESPMega_FRAM.write8(EEPROM_ADDRESS_ADC_REPORT_STATE + id, 0); + ESPMega_FRAM.write8(FRAM_ADDRESS_ADC_REPORT_STATE + id, 0); publish_adc_state(id); } @@ -2122,7 +2122,7 @@ void dac_set_value(int id, int value) { dac_values[id] = value; ESPMega_dacWrite(id, dac_values[id] * dac_states[id]); - ESPMega_FRAM.write16(EEPROM_ADDRESS_DAC_VALUE + id * 2, dac_values[id]); + ESPMega_FRAM.write16(FRAM_ADDRESS_DAC_VALUE + id * 2, dac_values[id]); publish_dac_value(id); } @@ -2130,7 +2130,7 @@ void dac_set_value(int id, int value) * @brief Sets the state of a DAC channel. * * This function updates the state of a DAC channel and writes the new state to the DAC output. - * It also saves the state to the EEPROM for persistence across power cycles. + * It also saves the state to the FRAM for persistence across power cycles. * * @param id The ID of the DAC channel. * @param state The new state of the DAC channel. @@ -2139,7 +2139,7 @@ void dac_set_state(int id, bool state) { dac_states[id] = state; ESPMega_dacWrite(id, dac_values[id] * dac_states[id]); - ESPMega_FRAM.write8(EEPROM_ADDRESS_DAC_STATE + id, dac_states[id]); + ESPMega_FRAM.write8(FRAM_ADDRESS_DAC_STATE + id, dac_states[id]); publish_dac_state(id); } diff --git a/src/espmega_iot_core.hpp b/src/espmega_iot_core.hpp index bf277ec..f7cd015 100644 --- a/src/espmega_iot_core.hpp +++ b/src/espmega_iot_core.hpp @@ -105,8 +105,8 @@ void trigger13(); void trigger14(); void trigger15(); -void eeprom_retrieve_init(); -void eeprom_pwm_update(); +void fram_retrieve_init(); +void fram_pwm_update(); void lcd_ac_refresh_fan(); void lcd_ac_refresh_mode(); @@ -116,19 +116,19 @@ void set_netmask(String address); void set_dns(String address); void set_gw(String address); void set_mqtt_server(String address); -void eeprom_ip_update(uint16_t rom_address, uint8_t byte1, uint8_t byte2, uint8_t byte3, uint8_t byte4); -IPAddress eeprom_ip_retrieve(uint16_t rom_address); +void fram_ip_update(uint16_t rom_address, uint8_t byte1, uint8_t byte2, uint8_t byte3, uint8_t byte4); +IPAddress fram_ip_retrieve(uint16_t rom_address); void set_hostname(String hostname); -void eeprom_hostname_retrieve(); +void fram_hostname_retrieve(); void set_basetopic(String topic); -void eeprom_basetopic_retrieve(); +void fram_basetopic_retrieve(); void mqtt_port_set(uint16_t port); -void eeprom_mqtt_port_retrieve(); -void eeprom_mqtt_username_retrieve(); -void eeprom_mqtt_password_retrieve(); +void fram_mqtt_port_retrieve(); +void fram_mqtt_username_retrieve(); +void fram_mqtt_password_retrieve(); void set_mqtt_username(String username); void set_mqtt_password(String password); -void eeprom_mqtt_useauth_retrieve(); +void fram_mqtt_useauth_retrieve(); void set_mqtt_useauth(bool use_auth); void factory_reset();