ECH_V004.cpp

00001 #include "select-demo.h"
00002 
00003 #if DEMO == DEMO_HTTP
00004 
00005 #include "rtos.h"
00006 #include "mbed.h"
00007 #include "http_request.h"
00008 #include "network-helper.h"
00009 #include "mbed_mem_trace.h"
00010 #include "PinDetect.h"
00011 
00012 
00013 
00014 
00015 //FINITE STATE MACHINE EVENTS
00016 #define NO_EVENT 0
00017 #define TIME_OUT 1
00018 #define BUTTON_PRESS_1 2
00019 #define BUTTON_PRESS_2 3
00020 #define TILT 3
00021 #define PUSH 4
00022 
00023 //STATES
00024 #define STATE_0 0
00025 #define STATE_1 1
00026 #define STATE_2 2
00027 
00028 
00029 //pass event via message queue
00030 typedef struct {
00031     int    event;   /* AD result of measured voltage */
00032 } message_t;
00033 
00034 MemoryPool<message_t, 16> mpool;
00035 Queue<message_t, 16> queue;
00036 
00037 //Digital input
00038 //DigitalIn coin(p14);
00039 PinDetect button_1(p23);
00040 PinDetect button_2(p24);
00041 
00042 //Global varible
00043 int button_press_1=0;
00044 int button_press_2=0;
00045 int button_press_Wait=0;
00046 
00047 
00048 //leds for debug
00049 DigitalOut led4(LED4); //LED
00050 DigitalOut led3(LED3); //LED
00051 DigitalOut led2(LED2); //LED
00052 DigitalOut myled(LED1);
00053 
00054 //Relays:
00055 
00056 DigitalOut Relay_1(p11);
00057 DigitalOut Relay_2(p12);
00058 
00059 
00060 
00061 //Mutex
00062 Mutex flag_mutex;
00063 
00064 
00065 void button_1_event_thread(void const *argument)
00066 {
00067 
00068    
00069     while (true)
00070      {
00071         //Thread::wait(10);
00072         if (button_press_1 == 1 && button_press_2 == 0 && button_press_Wait==0) {
00073 
00074             //event via a message queue
00075             button_press_Wait=1;
00076             message_t *message = mpool.alloc();
00077             message->event = BUTTON_PRESS_1;
00078             queue.put(message);
00079 
00080             led3 = !led3;
00081             Thread::wait(5000);
00082         }
00083 
00084     }
00085 }
00086 
00087 
00088 void button_2_event_thread(void const *argument)
00089 {
00090 
00091     
00092     while (true)
00093      {
00094         //Thread::wait(10);
00095         if (button_press_2 == 1 && button_press_1 == 0 && button_press_Wait==0) {
00096 
00097             //event via a message queue
00098             button_press_Wait = 1;
00099             message_t *message = mpool.alloc();
00100             message->event = BUTTON_PRESS_2;
00101             queue.put(message);
00102 
00103             led2 = !led2;
00104             Thread::wait(5000);
00105 
00106         }
00107 
00108     }
00109 }
00110 
00111 
00112 void timeout_event(void const *n)
00113 {
00114 
00115     //event via a message queue
00116     message_t *message = mpool.alloc();
00117     message->event = TIME_OUT;
00118     queue.put(message);
00119 
00120     led4 =  !led4;
00121 
00122 }
00123 
00124 
00125 void  button_1_hit_callback()
00126 {
00127 //Flash_LED_Thread.signal_set(0x1);
00128 
00129     button_press_1=1;   
00130 
00131 }
00132 
00133 void  button_2_hit_callback()
00134 {
00135 //Flash_LED_Thread.signal_set(0x1);
00136 
00137     button_press_2=1;
00138 
00139 }
00140 
00141 
00142 
00143 
00144 
00145 void dump_response_1(HttpResponse* res) 
00146 {
00147    
00148     Relay_1=0;
00149     Relay_2=1;
00150     
00151 
00152     printf("Status: %d - %s\n", res->get_status_code(), res->get_status_message().c_str());
00153 
00154     printf("Headers:\n");
00155     for (size_t ix = 0; ix < res->get_headers_length(); ix++)
00156     {
00157         printf("\t%s: %s\n", res->get_headers_fields()[ix]->c_str(), res->get_headers_values()[ix]->c_str());
00158     }
00159     printf("\nBody (%d bytes):\n\n%s\n", res->get_body_length(), res->get_body_as_string().c_str());
00160     
00161     Thread::wait(5000);
00162     Relay_1=1;
00163    
00164     Thread::wait(5000);
00165     button_press_2 = 0;
00166     button_press_1 = 0;
00167    button_press_Wait = 0;
00168     
00169 }
00170 
00171 
00172 void dump_response_2(HttpResponse* res)
00173 {
00174     Relay_1=1;
00175     Relay_2=0;
00176     
00177     printf("Status: %d - %s\n", res->get_status_code(), res->get_status_message().c_str());
00178 
00179     printf("Headers:\n");
00180     for (size_t ix = 0; ix < res->get_headers_length(); ix++) {
00181         printf("\t%s: %s\n", res->get_headers_fields()[ix]->c_str(), res->get_headers_values()[ix]->c_str());
00182     }
00183     printf("\nBody (%d bytes):\n\n%s\n", res->get_body_length(), res->get_body_as_string().c_str());
00184     
00185     
00186     Thread::wait(5000);
00187     Relay_2=1;
00188     
00189     Thread::wait(5000);
00190     button_press_2 = 0;
00191     button_press_1 = 0;
00192    
00193    button_press_Wait = 0;
00194  
00195 
00196 }
00197 
00198 
00199 int main() 
00200 {
00201     
00202     
00203     Relay_1=1;
00204     
00205     Relay_2=1;
00206     //Thread fsm(fsm_thread);
00207     Thread button_1_event(button_1_event_thread);
00208     Thread button_2_event(button_2_event_thread);
00209     
00210     
00211     
00212     RtosTimer timer(timeout_event, osTimerPeriodic, (void *)0);
00213     
00214     
00215     button_1.mode(PullUp);
00216     button_2.mode(PullUp);
00217     
00218     //Interrupts
00219    /* button_1.fall(&Button_1_Inter);
00220     button_2.fall(&Button_2_Inter);*/
00221     
00222      // Setup Interrupt callback function for a pb hit
00223     button_1.attach_deasserted(& button_1_hit_callback);
00224     // Start sampling pb input using interrupts
00225     button_1.setSampleFrequency();
00226     
00227     // Setup Interrupt callback function for a pb hit
00228     button_2.attach_deasserted(& button_2_hit_callback);
00229     // Start sampling pb input using interrupts
00230     button_2.setSampleFrequency();
00231  
00232 
00233     
00234     
00235     int state = STATE_0;
00236     while (true) 
00237     {
00238         Thread::wait(4000);
00239         
00240         //network setup
00241         NetworkInterface* network = connect_to_default_network_interface();
00242         if (!network)
00243         {
00244             printf("Cannot connect to the network, see serial output\n");
00245                     //return 1;
00246             for(int j = 0 ; j<20;j++)
00247             {
00248                 led4=1;
00249                 Thread::wait(100);
00250                 led4=0;
00251                 Thread::wait(100);
00252             }
00253         }
00254         else
00255         {
00256             led4=1;
00257         
00258             while (true) {
00259         
00260         
00261                 switch(state) {
00262                     case STATE_0:
00263                         osEvent evt = queue.get();
00264                         if (evt.status == osEventMessage) 
00265                         {
00266                             message_t *message = (message_t*)evt.value.p;
00267         
00268         
00269                             if(message->event == BUTTON_PRESS_1) 
00270                             {
00271                                 printf("HttpRequest Sending");
00272                                 //printf(network->get_gateway);
00273                                 HttpRequest* post_req = new HttpRequest(network, HTTP_POST, "http://10.5.248.2:5600/mch/kick");
00274                                 
00275                                 post_req->set_header("Content-Type", "application/json");
00276                              
00277                                 
00278                                 const char body[] = "{\"hello\":\"Nada\"}";
00279                                     
00280                                 HttpResponse* post_res = post_req->send(body, strlen(body));
00281                                 if (!post_res)
00282                                 {
00283                                     printf("HttpRequest failed (error code %d)\n", post_req->get_error());
00284                                    // return 1;
00285                                    
00286                                     button_press_2 = 0;
00287                                     button_press_1 = 0;
00288                                 }
00289                                 else
00290                                 {
00291                                 
00292                                     printf("\n----- HTTP POST response 1-----\n");
00293                                     
00294                                     dump_response_1(post_res);
00295                                     
00296                                     //Thread::wait(5000);
00297                                     
00298         
00299                                         
00300                                      delete post_req;
00301                                  }
00302                                  
00303                                  state = STATE_0;
00304                             }
00305                             else if(message->event == BUTTON_PRESS_2) 
00306                             {
00307                                 
00308                                 HttpRequest* post_req = new HttpRequest(network, HTTP_POST, "http://10.5.248.2:5600/mch/call");
00309                                 
00310                                 post_req->set_header("Content-Type", "application/json");
00311                              
00312                                 
00313                                 const char body[] = "{\"hello\":\"World\"}";
00314                                     
00315                                 HttpResponse* post_res = post_req->send(body, strlen(body));
00316                                 if (!post_res)
00317                                 {
00318                                     printf("HttpRequest failed (error code %d)\n", post_req->get_error());
00319                                    // return 1;
00320                                    
00321                                     button_press_2 = 0;
00322                                     button_press_1 = 0;                           
00323                                 }
00324                                 else
00325                                 {
00326                             
00327                                     printf("\n----- HTTP POST response 2-----\n");
00328                                     
00329                                     dump_response_2(post_res);
00330                                         
00331                                     delete post_req;
00332                                     //Thread::wait(5000);
00333                                     
00334         
00335         
00336                     
00337                                 }
00338                                  state = STATE_0;
00339                             }
00340         
00341                             mpool.free(message);
00342                         }
00343         
00344                         timer.start(15000);
00345         
00346                         break;
00347         
00348                     case STATE_1:
00349         
00350                         evt = queue.get();
00351                         if (evt.status == osEventMessage) 
00352                         {
00353                             message_t *message = (message_t*)evt.value.p;
00354         
00355         
00356                             if(message->event == BUTTON_PRESS_1) 
00357                             {
00358                                 
00359                                 state = STATE_0;
00360                             }
00361                             
00362                             mpool.free(message);
00363                         }
00364         
00365                         timer.start(10000);
00366         
00367                         break;
00368         
00369         
00370                 }//End of switch
00371         
00372                 //toggle led for local testing
00373                 //led2= !led2;
00374         
00375             }//end of while(1)
00376         }
00377     }            
00378 }
00379 
00380 #endif