tm_stm32f4_ethernet.h

#ifndef TM_ETHERNET_H
#define TM_ETHERNET_H 110

/* C++ detection */
#ifdef __cplusplus
extern C {
#endif

#include "stm32f4xx.h"
#include "stm32f4xx_rcc.h"
#include "stm32f4xx_gpio.h"
#include "defines.h"
#include "attributes.h"
#include "tm_stm32f4_delay.h"
#include "tm_stm32f4_gpio.h"

/* Ethernet based includes */
#include "stm32f4x7_eth.h"
#include "stm32f4x7_eth_bsp.h"
#include "netconf.h"
#include "tcp_echoclient.h"
#include "lwip/ip_addr.h"
#include "lwip/dns.h"
#include "lwip/tcp.h"

/* C based includes */
#include "string.h"
#include "stdio.h"

#ifndef ETHERNET_PHY
#define ETHERNET_PHY                        0
#endif

#ifndef LINK_TIMER_INTERVAL
#define LINK_TIMER_INTERVAL                 1000
#endif

#ifndef ETHERNET_SERVER_PORT
#define ETHERNET_SERVER_PORT                80
#endif

/* Include server based options */
#include "httpd.h"
#include "fs.h"

/* MAC ADDRESS: MAC_ADDR0:MAC_ADDR1:MAC_ADDR2:MAC_ADDR3:MAC_ADDR4:MAC_ADDR5 */
/* In case you want to use custom MAC, use parameter in init function */
#ifndef MAC_ADDR0
#define MAC_ADDR0                           0x06
#define MAC_ADDR1                           0x05
#define MAC_ADDR2                           0x04
#define MAC_ADDR3                           0x03
#define MAC_ADDR4                           0x02
#define MAC_ADDR5                           0x01
#endif

/* Static IP ADDRESS: IP_ADDR0.IP_ADDR1.IP_ADDR2.IP_ADDR3 */
/* Used in case DHCP is not used or response failed */
/* In case you want to use custom IP, use parameter in init function */
#ifndef IP_ADDR0
#define IP_ADDR0                            192
#define IP_ADDR1                            168
#define IP_ADDR2                            0
#define IP_ADDR3                            120
#endif

#ifndef NETMASK_ADDR0
#define NETMASK_ADDR0                       255
#define NETMASK_ADDR1                       255
#define NETMASK_ADDR2                       255
#define NETMASK_ADDR3                       0
#endif

#ifndef GW_ADDR0
#define GW_ADDR0                            192
#define GW_ADDR1                            168
#define GW_ADDR2                            0
#define GW_ADDR3                            1
#endif

#ifndef ETHERNET_HOSTNAME_DHCP
#define ETHERNET_HOSTNAME_DHCP              "TM-ETH-Device"
#endif

/* RMII mode by default */
#if !defined(ETHERNET_MII_MODE) && !defined(ETHERNET_RMII_MODE)
    #define ETHERNET_RMII_MODE
#endif

/* Buffer size for ethernet headers when requesting as client */
/* Used for headers after you are connected to server, HTTP headers */
/* Ex: GET / HTTP/1.1\r\n...etc */
#ifndef ETHERNET_MAX_HEADER_SIZE
#define ETHERNET_MAX_HEADER_SIZE            1024
#endif  

#ifndef ETHERNET_MAX_CONNECTION_NAME
#define ETHERNET_MAX_CONNECTION_NAME        100
#endif

#ifndef ETHERNET_MAX_OPEN_FILES
#define ETHERNET_MAX_OPEN_FILES             10
#endif

#ifndef ETHERNET_SSI_MAX_TAG_LEN
#define ETHERNET_SSI_MAX_TAG_LEN            32
#endif

#ifndef ETHERNET_SSI_MAX_TAG_INSERT_LEN
#define ETHERNET_SSI_MAX_TAG_INSERT_LEN     512
#endif

/*
 * @brief  Internal structure which should not be used by user
 * @note   For private use
 */
typedef struct {
    uint8_t ip_addr[4];
    uint8_t mac_addr[6];
    uint8_t netmask[4];
    uint8_t gateway[4];
    uint8_t staticip;
    uint8_t ip_is_set;
    uint8_t link_is_up;
    uint32_t ClientSuccessfullConnections, ClientConnections;
    uint64_t Client_TX_Bytes, Client_RX_Bytes;
    uint32_t Server_Connections;
    uint64_t Server_TX_Bytes, Server_RX_Bytes;
    uint8_t server_active;
    uint16_t server_port;
    uint8_t speed_100m;
    uint8_t full_duplex;
    uint8_t timeout_detected;
} TM_ETHERNET_t;
extern TM_ETHERNET_t TM_ETHERNET;

typedef enum  {
    CLIENT_NOT_CONNECTED = 0,
    CLIENT_CONNECTED,
    CLIENT_RECEIVED,
    CLIENT_CLOSING,
} client_states;

typedef struct {
    char name[ETHERNET_MAX_CONNECTION_NAME]; 
    uint8_t active;                          
    uint8_t ip_addr[4];                      
    uint16_t port;                           
    uint8_t headers_done;                    
    uint8_t* active_connections_count;       
    void* user_parameters;                   
    /* Private use */
    struct tcp_pcb* pcb;                     
    client_states state;                     
    struct pbuf *p_tx;                       
} TM_TCPCLIENT_t;

typedef struct {
    void* connection;          
    const char* uri;           
    const char* http_request;  
    uint16_t http_request_len; 
    int content_len;           
    char* response_uri;        
    uint16_t response_uri_len; 
} TM_ETHERNETPOST_t;

typedef enum {
    TM_ETHERNET_Result_Ok = 0,               
    TM_ETHERNET_Result_Error,                
    TM_ETHERNET_Result_IPIsNotSetYet,        
    TM_ETHERNET_Result_LinkIsDown,           
    TM_ETHERNET_Result_NeedHardReset,        
    TM_ETHERNET_Result_LibraryNotInitialized 
} TM_ETHERNET_Result_t;

typedef const char * TM_ETHERNET_SSI_t;

typedef tCGI TM_ETHERNET_CGI_t;

TM_ETHERNET_Result_t TM_ETHERNET_Init(uint8_t* mac_addr, uint8_t* ip_addr, uint8_t* gateway, uint8_t* netmask);

TM_ETHERNET_Result_t TM_ETHERNET_Update(void);

TM_ETHERNET_Result_t TM_ETHERNET_TimeUpdate(uint16_t millis);

TM_ETHERNET_Result_t TM_ETHERNET_TestReady(void);

#define TM_ETHERNET_IsIPStatic()            (TM_ETHERNET.staticip)

#define TM_ETHERNET_Is100M()                (TM_ETHERNET.speed_100m)

#define TM_ETHERNET_IsFullDuplex()          (TM_ETHERNET.full_duplex)

#define TM_ETHERNET_GetLocalIP(x)           (((x) >= 0 && (x) < 4) ? TM_ETHERNET.ip_addr[(x)] : 0)

#define TM_ETHERNET_GetMACAddr(x)           (((x) >= 0 && (x) < 6) ? TM_ETHERNET.mac_addr[(x)] : 0)

#define TM_ETHERNET_GetGateway(x)           (((x) >= 0 && (x) < 4) ? TM_ETHERNET.gateway[(x)] : 0)

#define TM_ETHERNET_GetNetmask(x)           (((x) >= 0 && (x) < 4) ? TM_ETHERNET.netmask[(x)] : 0)

#define TM_ETHERNET_SetTimeoutDetected()    (TM_ETHERNET.timeout_detected = 1)

TM_ETHERNET_Result_t TM_ETHERNETSERVER_Enable(uint16_t server_port);

TM_ETHERNET_Result_t TM_ETHERNETSERVER_Disable(void);

#define TM_ETHERNETSERVER_Enabled()             (TM_ETHERNET.server_active)

#define TM_ETHERNETSERVER_GetPortNumber()       (TM_ETHERNET.server_port)

#define TM_ETHERNETSERVER_GetTXBytes()          (TM_ETHERNET.Server_TX_Bytes)

#define TM_ETHERNETSERVER_GetRXBytes()          (TM_ETHERNET.Server_RX_Bytes)

#define TM_ETHERNETSERVER_GetConnectionsCount() (TM_ETHERNET.Server_Connections)

TM_ETHERNET_Result_t TM_ETHERNETSERVER_SetSSITags(TM_ETHERNET_SSI_t* tags, uint16_t number_of_tags);

TM_ETHERNET_Result_t TM_ETHERNETSERVER_SetCGIHandlers(const TM_ETHERNET_CGI_t* cgis, uint16_t number_of_handlers);

TM_ETHERNET_Result_t TM_ETHERNETCLIENT_Connect(char* conn_name, uint8_t ip1, uint8_t ip2, uint8_t ip3, uint8_t ip4, uint16_t port, void* user_parameters);

#define TM_ETHERNETCLIENT_GetTXBytes()                      (TM_ETHERNET.Client_TX_Bytes)

#define TM_ETHERNETCLIENT_GetRXBytes()                      (TM_ETHERNET.Client_RX_Bytes)

#define TM_ETHERNETCLIENT_GetConnectionsCount()             (TM_ETHERNET.ClientConnections)

#define TM_ETHERNETCLIENT_GetSuccessfullConnectionsCount()  (TM_ETHERNET.ClientSuccessfullConnections)

TM_ETHERNET_Result_t TM_ETHERNETDNS_GetHostByName(char* host_name);

void TM_ETHERNET_IPIsSetCallback(uint8_t ip_addr1, uint8_t ip_addr2, uint8_t ip_addr3, uint8_t ip_addr4, uint8_t dhcp);

void TM_ETHERNET_DHCPStartCallback(void);

void TM_ETHERNET_LinkIsDownCallback(void);

void TM_ETHERNET_LinkIsUpCallback(void);

void TM_ETHERNET_SystemResetCallback(void);

uint16_t TM_ETHERNETCLIENT_CreateHeadersCallback(TM_TCPCLIENT_t* connection, char* buffer, uint16_t buffer_length);

void TM_ETHERNETCLIENT_ReceiveDataCallback(TM_TCPCLIENT_t* connection, uint8_t* buffer, uint16_t buffer_length, uint16_t total_length);

void TM_ETHERNETCLIENT_ConnectedCallback(TM_TCPCLIENT_t* connection);

void TM_ETHERNETCLIENT_ConnectionClosedCallback(TM_TCPCLIENT_t* connection, uint8_t success);

void TM_ETHERNETCLIENT_ErrorCallback(TM_TCPCLIENT_t* connection);

void TM_ETHERNETCLIENT_ConnectionStartedCallback(TM_TCPCLIENT_t* connection);

void TM_ETHERNETDNS_FoundCallback(char* host_name, uint8_t ip_addr1, uint8_t ip_addr2, uint8_t ip_addr3, uint8_t ip_addr4);

void TM_ETHERNETDNS_ErrorCallback(char* host_name);

uint16_t TM_ETHERNETSERVER_SSICallback(int iIndex, char *pcInsert, int iInsertLen);

uint8_t TM_ETHERNETSERVER_ClientConnectedCallback(struct tcp_pcb *pcb);

void TM_ETHERNETSERVER_ClientDisconnectedCallback(void);

int TM_ETHERNETSERVER_OpenFileCallback(struct fs_file* file, const char *name);

void TM_ETHERNETSERVER_CloseFileCallback(struct fs_file* file);

int TM_ETHERNETSERVER_ReadFileCallback(struct fs_file* file, char* buffer, int count);

uint8_t TM_ETHERNETSERVER_PostRequestBeginCallback(TM_ETHERNETPOST_t* params);

uint8_t TM_ETHERNETSERVER_PostRequestReceiveDataCallback(TM_ETHERNETPOST_t* params, struct pbuf* p);

void TM_ETHERNETSERVER_PostRequestEndCallback(void* connection, char* response_uri, u16_t response_uri_len);

void TM_ETHERNETPHY_CustomOptions(uint32_t PHYAddress);

uint8_t TM_ETHERNET_InitPinsCallback(void);

/* Private functions which should not be called from user */
void TM_ETHERNET_INT_CustomOptions(uint32_t PHYAddress);
void TM_ETHERNET_INT_SetIPAddress(uint8_t ip_addr1, uint8_t ip_addr2, uint8_t ip_addr3, uint8_t ip_addr4, uint8_t dhcp);
void TM_ETHERNET_INT_LinkIsDownCallback(void);
void TM_ETHERNET_INT_LinkIsUpCallback(void);

/* C++ detection */
#ifdef __cplusplus
}
#endif

#endif