master.cpp

00001 #include "master.h"
00002 #include "EthernetInterface.h"
00003 #include <string.h>
00004 #include <stdio.h>
00005 
00006 #define MAX_PACKET_SIZE 512
00007 
00008 namespace ProjectOne{
00009     
00010     Serial pc(USBTX, USBRX);
00011     
00012     const char* Master::MASK = "255.255.255.0";
00013     const char* Master::GATEWAY = "192.168.0.1";
00014     
00015     EthernetInterface eth_master;
00016     UDPSocket sock_master;
00017     Endpoint client;
00018      
00019     Master::Master(int master_id){
00020         masterId = master_id;
00021         CurrentMasterState = STATE_INIT;
00022     }
00023 
00024     void Master::handlePcData(void){
00025         char in_buffer[MAX_PACKET_SIZE];
00026         char client_ip[] =  {'1','9','2','.','1','6','8','.','0','.','x','x','x'};
00027         char ip_address[] = {'1','9','2','.','1','6','8','.','0','.','x','x','x'};
00028         switch(CurrentMasterState){
00029             case STATE_INIT:
00030             {
00031                 //serial init
00032                 pc.baud(9600);
00033                 sendMessageToPc("-----------------");
00034                 sendMessageToPc("Initiating master");
00035                 sendMessageToPc("-----------------");
00036                 
00037                 int temp[3];
00038                 int i = 0;
00039                 do{
00040                    temp[i] = masterId % 10;
00041                    masterId /= 10;
00042                    i++; 
00043                 }while(masterId !=0);
00044                 
00045                 char tempi[4];
00046                 sprintf(tempi, "%ld", temp[2]);
00047                 ip_address[10] = *tempi;
00048                 sprintf(tempi, "%ld", temp[1]);
00049                 ip_address[11] = *tempi;
00050                 sprintf(tempi, "%ld", temp[0]);
00051                 ip_address[12] = *tempi;
00052 
00053                 eth_master.init(ip_address, MASK, GATEWAY);
00054                 eth_master.connect();
00055 
00056                 CurrentMasterState = STATE_RECEIVING_FROM_PC;
00057                 break;
00058             }
00059             case STATE_RECEIVING_FROM_PC:
00060             {
00061                 sendMessageToPc("Enter your command.");
00062                 char temp1;
00063                 memset(&inputCommandArray[0], 0, sizeof(inputCommandArray));
00064                 char_counter_command = 0;
00065                 for(int i = 0; i <= MAX_PACKET_SIZE; i ++){
00066                     temp1 = pc.getc();
00067                     if((int)temp1 == 13){
00068                         CurrentMasterState = STATE_HANDLE_ID;
00069                         break;
00070                     }
00071                     inputCommandArray[char_counter_command] = temp1;
00072                     char_counter_command++;
00073                 }
00074                 printf("The command you entered is: '%s'\r\n", inputCommandArray);
00075                 CurrentMasterState = STATE_HANDLE_ID;  
00076 
00077                 break;
00078             }
00079             case STATE_HANDLE_ID:
00080             {
00081                 sendMessageToPc("Enter client ID:");
00082                 char_counter_id = 0;
00083                 char temp2;
00084                 for(int i = 0; i <= 3; i ++){
00085                     temp2 = pc.getc();
00086                     if((int)temp2 == 13){
00087                         CurrentMasterState = STATE_SEND_UDP_PACKET;
00088                         break;
00089                     }
00090                     client_id[char_counter_id] = temp2;
00091                     char_counter_id++;
00092                 }
00093                 
00094                 client_ip[10] = client_id[0];
00095                 client_ip[11] = client_id[1];
00096                 client_ip[12] = client_id[2];
00097                 
00098                 client_id[3] = '\0';
00099                 
00100                 client.set_address((const char *)client_ip,4000);
00101 
00102                 CurrentMasterState = STATE_SEND_UDP_PACKET;
00103                 break;
00104             }
00105             case STATE_SEND_UDP_PACKET:
00106             {
00107                 sock_master.init();
00108                 sock_master.sendTo(client, inputCommandArray, sizeof(inputCommandArray));
00109                 memset(&inputCommandArray[0], 0, sizeof(inputCommandArray)); //clear input array
00110                 CurrentMasterState = STATE_HANDLE_RESPONSE;
00111                 break;
00112             }
00113             case STATE_HANDLE_RESPONSE:
00114             {
00115                 memset(&in_buffer[0], 0, sizeof(in_buffer)); //buffer clear voor ontvangst
00116                 int n = sock_master.receiveFrom(client, in_buffer, sizeof(in_buffer));
00117                 sock_master.close();
00118                 //stop timer, niet voltooid -> error state
00119                 printf("Received response: '%s'\r\n", in_buffer);
00120                 memset(&in_buffer[0], 0, sizeof(in_buffer)); //buffer clear na ontvangst
00121                 CurrentMasterState = STATE_RECEIVING_FROM_PC;
00122                 break;
00123             }
00124             case STATE_ERROR_STATE:
00125             {   
00126                 sendMessageToPc("Error: did not receive a response from the client in time");
00127                 memset(&in_buffer[0], 0, sizeof(in_buffer)); //buffer clear
00128                 CurrentMasterState = STATE_RECEIVING_FROM_PC;
00129                 break;
00130             }
00131         }
00132     }
00133     
00134     void Master::sendMessageToPc(char *message_to_pc){
00135         printf(message_to_pc);
00136         printf("\r\n");
00137     }
00138     
00139 } 
00140 
00141 
00142     
00143 
00144    
00145