File content as of revision 10:f37acffddef9:

#include "mbed.h"
#include "my_eeprom_funcs.h"


/*!
 * Debug option
 */
#if 1
//Enable debug
#include <cstdio>
#define DBG(x, ...) std::printf("[eeprom : DBG]"x"\r\n", ##__VA_ARGS__); 
#define WARN(x, ...) std::printf("[eeprom : WARN]"x"\r\n", ##__VA_ARGS__); 
#define ERR(x, ...) std::printf("[eeprom : ERR]"x"\r\n", ##__VA_ARGS__); 

#else
//Disable debug
#define DBG(x, ...) 
#define WARN(x, ...)
#define ERR(x, ...) 

#endif


/*!
 * Function to write module network configuration
 * @param <char *buf> configuration buffer
 * @note 4-byte IP address
 * @note 4-byte subnet
 * @note 4-byte gateway
 * @note 3-byte MAC
 */
void write_eeprom_network(char *buf) {
    // Write network configuration
    // 4-byte IP address + 4-byte subnet + 4-byte gateway + 3-byte MAC
    
    DBG("Saving network configuration for this device...");
    
    // Unlock the Flash Program Erase controller */
    FLASH_Unlock();
    // EEPROM Init
    EE_Init();
    
    // erase first_run flag
    EE_WriteVariable(VirtAddVarTab[CONFIGURED_IP_FLAG_POS], DEFAULT_ENABLE_FLAG_VALUE);
    
    // IP address
    EE_WriteVariable(VirtAddVarTab[IP_ADDRESS_POS+0], *buf++);
    EE_WriteVariable(VirtAddVarTab[IP_ADDRESS_POS+1], *buf++);
    EE_WriteVariable(VirtAddVarTab[IP_ADDRESS_POS+2], *buf++);
    EE_WriteVariable(VirtAddVarTab[IP_ADDRESS_POS+3], *buf++);
    
    // IP subnet
    EE_WriteVariable(VirtAddVarTab[IP_SUBNET_POS+0], *buf++);
    EE_WriteVariable(VirtAddVarTab[IP_SUBNET_POS+1], *buf++);
    EE_WriteVariable(VirtAddVarTab[IP_SUBNET_POS+2], *buf++);
    EE_WriteVariable(VirtAddVarTab[IP_SUBNET_POS+3], *buf++);
    
    // IP gateway
    EE_WriteVariable(VirtAddVarTab[IP_GATEWAY_POS+0], *buf++);
    EE_WriteVariable(VirtAddVarTab[IP_GATEWAY_POS+1], *buf++);
    EE_WriteVariable(VirtAddVarTab[IP_GATEWAY_POS+2], *buf++);
    EE_WriteVariable(VirtAddVarTab[IP_GATEWAY_POS+3], *buf++);
    
    //// TCP server port, not used
    //EE_WriteVariable(VirtAddVarTab[TCP_SERVER_LOCAL_PORT_POS], *buf++);
    //// UDP server port, not used
    //EE_WriteVariable(VirtAddVarTab[UDP_SERVER_LOCAL_PORT_POS], *buf++);
    
    // MAC address
    EE_WriteVariable(VirtAddVarTab[MAC_ADDRESS_POS+0], *buf++);
    EE_WriteVariable(VirtAddVarTab[MAC_ADDRESS_POS+1], *buf++);
    EE_WriteVariable(VirtAddVarTab[MAC_ADDRESS_POS+2], *buf++);
    FLASH_Lock();
    
    DBG("Successful");
}

/*!
 * Function to load module network configuration
 */
void load_eeprom_network(void) {
    mbed_mac_address((char *)u8mac);
    
    DBG("Loading network configuration...");
    
    EE_Init();
    
    // check if 1st run
    EE_ReadVariable(VirtAddVarTab[CONFIGURED_IP_FLAG_POS], &configured_ip);
    // if not first run, load network config
    if (configured_ip == DEFAULT_ENABLE_FLAG_VALUE) {
        DBG("User settings");
        
        // IP address
        EE_ReadVariable(VirtAddVarTab[IP_ADDRESS_POS+0], &u16ip_addr[0]);
        EE_ReadVariable(VirtAddVarTab[IP_ADDRESS_POS+1], &u16ip_addr[1]);
        EE_ReadVariable(VirtAddVarTab[IP_ADDRESS_POS+2], &u16ip_addr[2]);
        EE_ReadVariable(VirtAddVarTab[IP_ADDRESS_POS+3], &u16ip_addr[3]);
        u8ip_addr[0] = (uint8_t)(u16ip_addr[0] & 0x00FF);
        u8ip_addr[1] = (uint8_t)(u16ip_addr[1] & 0x00FF);
        u8ip_addr[2] = (uint8_t)(u16ip_addr[2] & 0x00FF);
        u8ip_addr[3] = (uint8_t)(u16ip_addr[3] & 0x00FF);
        
        // IP subnet
        EE_ReadVariable(VirtAddVarTab[IP_SUBNET_POS+0], &u16ip_subnet[0]);
        EE_ReadVariable(VirtAddVarTab[IP_SUBNET_POS+1], &u16ip_subnet[1]);
        EE_ReadVariable(VirtAddVarTab[IP_SUBNET_POS+2], &u16ip_subnet[2]);
        EE_ReadVariable(VirtAddVarTab[IP_SUBNET_POS+3], &u16ip_subnet[3]);
        
        // IP gateway
        EE_ReadVariable(VirtAddVarTab[IP_GATEWAY_POS+0], &u16ip_gateway[0]);
        EE_ReadVariable(VirtAddVarTab[IP_GATEWAY_POS+1], &u16ip_gateway[1]);
        EE_ReadVariable(VirtAddVarTab[IP_GATEWAY_POS+2], &u16ip_gateway[2]);
        EE_ReadVariable(VirtAddVarTab[IP_GATEWAY_POS+3], &u16ip_gateway[3]);
        
        //// TCP server port
        //EE_ReadVariable(VirtAddVarTab[TCP_SERVER_LOCAL_PORT_POS], &tcp_server_local_port);
        //// UDP server port
        //EE_ReadVariable(VirtAddVarTab[UDP_SERVER_LOCAL_PORT_POS], &udp_server_local_port);

        // MAC address
        EE_ReadVariable(VirtAddVarTab[MAC_ADDRESS_POS+0], &u16mac_addr[0]);
        EE_ReadVariable(VirtAddVarTab[MAC_ADDRESS_POS+1], &u16mac_addr[1]);
        EE_ReadVariable(VirtAddVarTab[MAC_ADDRESS_POS+2], &u16mac_addr[2]);
        u8mac[0] = DEFAULT_MAC0; u8mac[1] = DEFAULT_MAC1; u8mac[2] = DEFAULT_MAC2;
        u8mac[3] = (uint8_t)(u16mac_addr[0] & 0x00FF);
        u8mac[4] = (uint8_t)(u16mac_addr[1] & 0x00FF);
        u8mac[5] = (uint8_t)(u16mac_addr[2] & 0x00FF);
        //FLASH_Lock();
        
        sprintf(str_ip_addr, "%d.%d.%d.%d", u8ip_addr[0], u8ip_addr[1], u8ip_addr[2], u8ip_addr[3]);
        sprintf(str_ip_subnet, "%d.%d.%d.%d", (uint8_t)u16ip_subnet[0], (uint8_t)u16ip_subnet[1], (uint8_t)u16ip_subnet[2], (uint8_t)u16ip_subnet[3]);
        sprintf(str_ip_gateway, "%d.%d.%d.%d", (uint8_t)u16ip_gateway[0], (uint8_t)u16ip_gateway[1], (uint8_t)u16ip_gateway[2], (uint8_t)u16ip_gateway[3]);
    }
    // if ip is not configured, use default addresses
    else {
        DBG("No user settings, load defaults");
        u8mac[0] = DEFAULT_MAC0; u8mac[1] = DEFAULT_MAC1; u8mac[2] = DEFAULT_MAC2;
        u8mac[3] = DEFAULT_MAC3; u8mac[4] = DEFAULT_MAC4; u8mac[5] = DEFAULT_MAC5; 
        sprintf(str_ip_addr, DEFAULT_IP_ADDRESS);
        sprintf(str_ip_subnet, DEFAULT_IP_SUBNET);
        sprintf(str_ip_gateway, DEFAULT_IP_GATEWAY);
    }
    
    DBG("Successful");
    DBG("IP: %s", str_ip_addr);
    DBG("MASK: %s", str_ip_subnet);
    DBG("GW: %s", str_ip_gateway);
    DBG("TCP server local port: %d", tcp_server_local_port);
    DBG("UDP server local port: %d", udp_server_local_port);
}


/*!
 * Function to write settings of remote TCP server. It is only used when this device in TCP client mode.
 * When enabled, this device will periodically transmit data to TCP server.
 * @param <char* buf> buffer as following
 *      1-byte Auto transmit flag: 'Y'
 *      1-byte Auto transmit period: in seconds
 *      4-byte TCP server IP address
 *      2-byte TCP server port (LSB MSB)
 */
void write_eeprom_tcpserver(char* buf) {
    // Write network configuration
    // 1-byte Auto transmit flag + 1-byte Auto transmit period + 4-byte TCP server IP address + 2-byte TCP server port (LSB msb)
    
    DBG("Saving TCP server settings...");
    
    // Unlock the Flash Program Erase controller
    FLASH_Unlock();
    // EEPROM Init
    EE_Init();
    
    // Auto transmit flag
    if (*buf == 'Y') {
        EE_WriteVariable(VirtAddVarTab[AUTO_TRANSMIT_FLAG_POS], DEFAULT_ENABLE_FLAG_VALUE);
    }
    else {
        EE_WriteVariable(VirtAddVarTab[AUTO_TRANSMIT_FLAG_POS], DEFAULT_DISABLE_FLAG_VALUE);
    }
    buf++;
    // Auto transmit period
    EE_WriteVariable(VirtAddVarTab[AUTO_TRANSMIT_TIME_PERIOD_POS], *buf++);
    // IP address
    EE_WriteVariable(VirtAddVarTab[TCP_SERVER_IP_ADDR_POS+0], *buf++);
    EE_WriteVariable(VirtAddVarTab[TCP_SERVER_IP_ADDR_POS+1], *buf++);
    EE_WriteVariable(VirtAddVarTab[TCP_SERVER_IP_ADDR_POS+2], *buf++);
    EE_WriteVariable(VirtAddVarTab[TCP_SERVER_IP_ADDR_POS+3], *buf++);
    // TCP server port
    uint16_t port;
    memcpy(&port, buf, 2);
    EE_WriteVariable(VirtAddVarTab[TCP_SERVER_PORT_POS], port);
    
    FLASH_Lock();
    
    DBG("Successful");
}

/*!
 * Function to load remote TCP server configuration
 */
void load_eeprom_tcpserver(void) {
    DBG("Checking auto update mode...");
    
    EE_Init();
    
    // check if 1st run
    EE_ReadVariable(VirtAddVarTab[AUTO_TRANSMIT_FLAG_POS], &auto_transmit_flag);
    // if not auto transmit, exit
    if (auto_transmit_flag == DEFAULT_ENABLE_FLAG_VALUE) {
        // Time period for transmitting to server
        EE_ReadVariable(VirtAddVarTab[AUTO_TRANSMIT_TIME_PERIOD_POS], &transmit_time_period);
        // TCP server/client enable flags, not in used
        EE_ReadVariable(VirtAddVarTab[ENABLE_TCP_CLIENT], &u16enable_tcp_client);
        EE_ReadVariable(VirtAddVarTab[ENABLE_TCP_SERVER], &u16enable_tcp_server);
        // IP address
        EE_ReadVariable(VirtAddVarTab[TCP_SERVER_IP_ADDR_POS+0], &u16server_ip_addr[0]);
        EE_ReadVariable(VirtAddVarTab[TCP_SERVER_IP_ADDR_POS+1], &u16server_ip_addr[1]);
        EE_ReadVariable(VirtAddVarTab[TCP_SERVER_IP_ADDR_POS+2], &u16server_ip_addr[2]);
        EE_ReadVariable(VirtAddVarTab[TCP_SERVER_IP_ADDR_POS+3], &u16server_ip_addr[3]);
        u8server_ip_addr[0] = (uint8_t)(u16server_ip_addr[0] & 0x00FF);
        u8server_ip_addr[1] = (uint8_t)(u16server_ip_addr[1] & 0x00FF);
        u8server_ip_addr[2] = (uint8_t)(u16server_ip_addr[2] & 0x00FF);
        u8server_ip_addr[3] = (uint8_t)(u16server_ip_addr[3] & 0x00FF);
        // TCP server port
        EE_ReadVariable(VirtAddVarTab[TCP_SERVER_PORT_POS], &u16tcp_server_port);
        
        sprintf(str_server_ip_addr, "%d.%d.%d.%d", u8server_ip_addr[0], u8server_ip_addr[1], u8server_ip_addr[2], u8server_ip_addr[3]);
        DBG("Enabled auto update, module is a TCP client");
        DBG("Update every %ds to TCP server %s on port %d", transmit_time_period, str_server_ip_addr, u16tcp_server_port);
    }
    // if 1st run, use default addresses
    else {
        DBG("No auto update using TCP client");
    }
}