TCP_HA.c

Go to the documentation of this file.

 
//Library Include
#include <stdio.h>
#include <string.h>
 
//User Include
#include "tcp.h"
#include "main.h"
#include "lwip.h"
#include "TCP_HA.h"
#include "display.h"
 
 
 
/*static err_t errHaRecieve(void *, struct tcp_pcb ,struct pbuf, err_t);
static err_t errHaConnected (void *, struct tcp_pcb *, err_t );*/
 
 
//File scope variabele
 
typedef struct {
    char entity[30];
 
    char action[10];
 
    uint16_t usButton;
 
} PCB_HA_argument;
 
extern uint8_t globalReceive;
 
extern struct netif gnetif;
 
//Onder de typedef staan anders probelemen met compiler dat type niet bestaat
//Static function prototype
static PCB_HA_argument * prvHaMakePcbArgument(void);
static void prvHaFreePcbArgument (PCB_HA_argument *);
static void prvHaErrorHandelingRebootSystem(void);
static void prvHaErrorHandelingRoutingError(void);
 
 
err_t errHaRecieve(void *arg, struct tcp_pcb *tpcb,struct pbuf *p, err_t err){
 
    PCB_HA_argument *PCB_argument = tpcb->callback_arg;  
    static uint8_t cReadNextFrame = 0; 
    //er is data beschikbaar
    if(err == ERR_OK && p!=NULL){
 
        //Print de pbuf
        printf("Number of pbufs %d\n", pbuf_clen(p));
        printf("Contents of pbuf %.*s\n",p->len,(char *)p->payload);
        printf("Length of pbuf %d\n", p->len);
        //printf("total lent of pbuf %d\n", p->tot_len);
 
        //vorige frame moet payload hebben \r\n\r\n en houdig frame heeft deze niet
        if(strstr(p->payload,"\r\n\r\n") != NULL){
            cReadNextFrame = 1;
        }
        else{
            if(cReadNextFrame == 1){
                cReadNextFrame = 0;
                char state[10];
                strcpy(state, (char*) p->payload); //lees de state in
                printf("Payload: %s\n", state); //print de paylaad van de pbuf
                vDisplayBgButtonState(PCB_argument->usButton,state); //verwerk de data(PCB_argument->usButton,state); //verwerk de data
            }
        }
 
        //Ack de ontvangen data en geeft de pbuf terug vrij
        tcp_recved(tpcb,p->len);
        pbuf_free(p);
    }
 
    //connectie gesloten door server
    if(err == ERR_OK && p == NULL){
 
        printf("Connectie gesloten\n");
        printf("/************************ End ****************************/\n");
 
        globalReceive = 1;
 
        cReadNextFrame = 0;
        //verwijder de tpcb  en de PCB_HA wegens dat de connectie is gesloten
        prvHaFreePcbArgument(PCB_argument);
        tcp_sent(tpcb, NULL);
        tcp_recv(tpcb,NULL);
        tcp_close(tpcb);
    }
 
    return ERR_OK;
}
 
 
err_t errHaConnected (void *arg, struct tcp_pcb *tpcb, err_t err){
    printf("/************************ Begin ****************************/\n");
    printf("Verbinden is gelukt\n"); //\n belangrijk !!!!
    errHaSendPacket(tpcb);
    return ERR_OK;
}
 
 
 
err_t errHaSendPacket(struct tcp_pcb *tpcb)
{
    PCB_HA_argument *pArguments = tpcb->callback_arg;
    printf("args: %s\n",pArguments->action);
 
    char url[200] = "GET /ha?entity=";
    strcat(url,pArguments->entity);
    if(strcmp(pArguments->action,"") != 0){
        strcat(url,"&action=");
        strcat(url,pArguments->action);
    }
    strcat(url," HTTP/1.0\r\nHost: 192.168.0.10:5000\r\n\r\n ");
 
    printf("url: %s", url);
 
    err_t error;
    /* push to buffer */
    error = tcp_write(tpcb, url, strlen(url), TCP_WRITE_FLAG_COPY);
 
    // Error bij het schrijven naar de buffer
    if (error) {
        printf("ERROR: Code: %d (errHaSendPacket :: tcp_write)\n", error);
        vHaErrorHandling(error); //Behandel de fout
        return error;
    }
 
    /* now send */
    error = tcp_output(tpcb);
 
    //Error bij het verzenden?
    if (error) {
        printf("ERROR: Code: %d (errHaSendPacket :: tcp_output)\n", error);
        vHaErrorHandling(error); //Behandel de fout
        return error;
    }
 
    return ERR_OK;
}
 
 
void vHaError(void *arg, err_t err){
    printf("TCP_ha :: vHaError callback function\n");
    printf("%d",err);
    vHaErrorHandling(err);
}
 
 
void vHaErrorHandling(err_t err){
    printf("ERROR: Code: %d in function %pS\n",err,__builtin_return_address(0));
    switch (err){
        case ERR_MEM:
            vDisplayError("Out of memory error.");
            printf("Out of memory error");
            prvHaErrorHandelingRebootSystem();
            break;
        case ERR_BUF:
            vDisplayError("Buffer error.");
            printf("Buffer");
            prvHaErrorHandelingRebootSystem();
            break;
        case ERR_TIMEOUT:
            vDisplayError("Timeout.");
            printf("Timeout");
            prvHaErrorHandelingRebootSystem();
            break;
        case ERR_RTE:
            vDisplayError("Routing problem.");
            printf("Routing problem.");
            HAL_Delay(2000); //message anders niet zichtbaar
            prvHaErrorHandelingRoutingError();
            break;
        case ERR_INPROGRESS:
            vDisplayError("Operation in progress.");
            printf("Operation in progress.");
            prvHaErrorHandelingRebootSystem();
            break;
        case ERR_VAL:
            vDisplayError("Illegal value.");
            printf("Illegal value.");
            prvHaErrorHandelingRebootSystem();
            break;
        case ERR_CONN:
            vDisplayError("Not connected.");
            printf("Not connected.");
            prvHaErrorHandelingRebootSystem();
            break;
        default:
            prvHaErrorHandelingRebootSystem();
            break;
    }
 
}
 
 
static void prvHaErrorHandelingRebootSystem(void){
    HAL_Delay(5000);
    vDisplayError("Restart Pending");
    printf("Restart Pending");
    HAL_Delay(2000);
    NVIC_SystemReset();
}
 
 
static void prvHaErrorHandelingRoutingError(void){
    vHaWaitOnLink(ERR_RTE);
    vDisplaySetUpButtonStates();
    vDisplayMainScreen();
}
 
 
void vHaWaitOnLink(err_t err){
 
          //wait on interface
    printf("Waiting on interface\n");
          while(!netif_is_up(&gnetif)){
              MX_LWIP_Process();
              if(err == ERR_OK){
                  vDisplayMessage("Waiting on interface");
              }
              else{
                  vDisplayError("Waiting on interface");
              }
          }
 
          //wait on link (deze werkt :) ), gaat wachten op connectie
          printf("Waiting on link\n");
          while(!netif_is_link_up(&gnetif)){
              MX_LWIP_Process();
              if(err == ERR_OK){
                  vDisplayMessage("Waiting on link");
              }
              else{
                  vDisplayError("Waiting on link");
              }
 
          }
}
 
 
err_t errHaSend(char entity[], char action[], uint16_t usButton){
    struct tcp_pcb *pConnectie;
 
    PCB_HA_argument *PCB_argument;
 
    //PCB_argument maken
    PCB_argument = prvHaMakePcbArgument();
 
    //PCB_argument is niet aangemaakt
    if(PCB_argument == NULL){
        vHaErrorHandling(ERR_MEM);
        return ERR_MEM;
    }
    else{
        //Niet direct nodig, ga door met rest van programma
    }
 
    //Schrijf de data in de PCB_argument struct
    strcpy(PCB_argument->entity,entity);
    strcpy(PCB_argument->action,action );
    PCB_argument->usButton = usButton;
 
    //Maak een nieuwe tcp_pcb
    pConnectie = tcp_new();
 
    //Geef de PCB_argument mee aan de pcb
    tcp_arg(pConnectie, PCB_argument);
 
    //stel het IP van de server in
    ip_addr_t serverIP;
    IP_ADDR4(&serverIP,192,168,0,10);
 
    // Error callback
    err_t error;
    tcp_err(pConnectie,vHaError);
 
    //Maak een nieuwe TCP connectie
    error = tcp_connect(pConnectie,&serverIP, 5000, errHaConnected);
    if(error){
        printf("ERROR: Code %d (errHaSend :: tcp_connect)\n",error);
        vHaErrorHandling(error);
        return error;
    }
 
    //Callback functie instellen voor recieve
    tcp_recv(pConnectie,errHaRecieve);
 
    return ERR_OK;
}
 
 
static PCB_HA_argument * prvHaMakePcbArgument(){
    return (PCB_HA_argument *) malloc(sizeof(PCB_HA_argument));
}
 
 
static void prvHaFreePcbArgument(PCB_HA_argument * pcb_argument){
    free(pcb_argument);
}