main.cpp

00001 /*
00002  * Author: Edoardo De Marchi
00003  * Date: 05/04/14
00004  * Notes: This firmware required "OV7670 Grabber v2.0"
00005 */
00006 
00007 #include "main.h"
00008 
00009 #define VGA     307200         //640*480
00010 #define QVGA    76800          //320*240
00011 #define QQVGA   19200          //160*120
00012 
00013 
00014 int Init()
00015 {
00016     led1 = 0;               
00017     led2 = 0;        // mbed status       
00018     led3 = 0;        // Ethernet link enable/disable      
00019     led4 = 0;        // Snap status       
00020       
00021     //ETHERNET
00022     //Static IP
00023     eth.init(ip, mask, gateway);
00024     //DHCP
00025     //eth.init();
00026     
00027     eth.connect();
00028     server.bind(ECHO_SERVER_PORT);
00029     server.listen(1);
00030     
00031     printf("IP Address is %s\r\n", eth.getIPAddress());
00032     
00033     //THREAD 
00034     osThreadCreate(osThread(Net_Thread), NULL);
00035     tencid = osThreadCreate(osThread(Grab_Thread), NULL);  
00036     
00037     return 0;
00038 }
00039 
00040 
00041 void Net_Thread(void const *argument)
00042 {
00043     while (true) 
00044     {
00045         led3 = 1;
00046         server.accept(client);
00047         printf("Connection from: %s\r\n", client.get_address());
00048         
00049         while (true) 
00050         {
00051             led3 = 0;
00052             int n = client.receive(bufferRX, sizeof(bufferRX));  
00053             if (n <= 0) break;
00054             
00055             bufferRX[n]=0; // make terminater
00056             parse_cmd(n);
00057         }
00058         client.close();
00059     } 
00060 } 
00061 
00062 
00063 void Send()
00064 {
00065         client.send_all(bufferTX, sizeof(bufferTX));
00066         memset(bufferTX, 0, sizeof(bufferTX));
00067 }
00068 
00069 
00070 void Grab_Thread(void const *argument)
00071 {
00072     while(true)
00073     {    
00074         osSignalWait(0x1, osWaitForever);
00075                     
00076         while(bSnap_on || bGrab_on)
00077         {
00078             CameraSnap();
00079             bSnap_on = false;
00080         }
00081     }
00082 }
00083 
00084 
00085 void CameraSnap()
00086 {
00087         led4 = 1;
00088         int p = 0;  
00089 
00090         camera.CaptureNext();
00091         while(camera.CaptureDone() == false);      
00092                                  
00093         camera.ReadStart();                             // Start reading in the image data from the camera hardware buffer  
00094         
00095         t1 = t.read_ms(); 
00096                   
00097         client.send_all(StartCondition, sizeof(StartCondition));
00098                     
00099         if(strcmp("BAW", CMDCamera.format) == 0 || strcmp("RAW", CMDCamera.format) == 0)                   // B&W  
00100         {  
00101             for(int x = 0; x<CMDCamera.resolution/sizeof(bufferTX); x++)
00102             {
00103                 for(int q = 0; q<sizeof(bufferTX); q++)
00104                 {               
00105                    if(CMDCamera.resolution != VGA)
00106                         camera.ReadOnebyte();                   // Read in the first half of the image
00107                    
00108                    bufferTX[q] = camera.ReadOnebyte();          // Y only      // Read in the Second half of the image                                  
00109                 }  
00110                 Send();       
00111             } 
00112         }     
00113         
00114         if(strcmp("YUV", CMDCamera.format) == 0 || strcmp("RGB", CMDCamera.format) == 0)                    // Color
00115         {
00116             for(int x = 0; x<(CMDCamera.resolution/sizeof(bufferTX))*2; x++)
00117             {
00118                 for(int q = 0; q<sizeof(bufferTX)/2; q++)
00119                 {
00120                        p = q*2;                               
00121                        bufferTX[p] = camera.ReadOnebyte();          // Read in the first half of the image                       
00122                        bufferTX[p+1] = camera.ReadOnebyte();        // Read in the Second half of the image                      
00123                 }  
00124                 Send();       
00125             }         
00126         }       
00127            
00128         camera.ReadStop();               
00129         t2 = t.read_ms(); 
00130                                       
00131         led4 = 0;
00132 }
00133 
00134 
00135 int main (void) 
00136 {
00137     led3 = 0;
00138     int iRet=Init();
00139 
00140     if (iRet<0)
00141     {
00142         printf("Init Error!");
00143         return iRet;
00144     }
00145     t.start();
00146     
00147     while (true)
00148     {
00149         //mbed is alive?
00150         led2 = !led2;
00151         osDelay(500);
00152     }     
00153 }
00154 
00155 
00156 void parse_cmd(int sizeCMD)
00157 {
00158             new_send = false;
00159             //printf("bufferRX: %s\r\n", bufferRX);
00160             
00161             if(strcmp("snap", bufferRX) == 0)              
00162             {
00163                     bSnap_on = true;
00164                     osSignalSet(tencid, 0x1);
00165                     memset(bufferRX, 0, sizeof(bufferRX));      
00166             }else
00167             if(strncmp("grab", bufferRX, 4) == 0)               // grab start       grab stop  
00168             {
00169                     if(strncmp("start", &bufferRX[5], 5) == 0)
00170                     {
00171                         bGrab_on = true;
00172                         osSignalSet(tencid, 0x1);
00173                         memset(bufferRX, 0, sizeof(bufferRX));
00174                     }else
00175                     {
00176                         bGrab_on = false;
00177                         memset(bufferRX, 0, sizeof(bufferRX));
00178                     }      
00179             }else
00180             if(strncmp("init", bufferRX, 4) == 0)               // init RGB 19200
00181             {
00182                     char word[10];
00183                     strncpy(CMDCamera.format, &bufferRX[5], 3);
00184                     strncpy(word, &bufferRX[9], sizeCMD-9);                  
00185                     CMDCamera.resolution = atoi(word);
00186                     
00187                     printf("CMDCamera.format: %s\r\n", CMDCamera.format);
00188                     printf("CMDCamera.resolution: %d\r\n", CMDCamera.resolution); 
00189 
00190                     if(camera.Init(CMDCamera.format, CMDCamera.resolution) != 1)
00191                     {
00192                       printf("Init Fail\r\n");
00193                     }
00194                     
00195                     sprintf(bufferTX, "OV Init OK\r\n");
00196                     client.send_all(bufferTX, sizeof(bufferTX));
00197                     memset(bufferRX, 0, sizeof(bufferRX));
00198             }else 
00199             if(strncmp("reg", bufferRX, 3) == 0)                // reg r 018       reg w 018 004        reg 
00200             {        
00201                     if(!bGrab_on)
00202                     {
00203                         strncpy(&Reg.type, &bufferRX[4], 1);
00204                         char word[3];                    
00205                     
00206         
00207                         if(Reg.type == 'r')
00208                         {
00209                             strncpy(word, &bufferRX[6], 3);
00210                             Reg.addr = atoi(word);
00211                             memset(word, 0, sizeof(word));
00212                             sprintf(bufferTX, "reg: %x", camera.ReadReg(Reg.addr));  
00213                         }else
00214                         {
00215                             strncpy(word, &bufferRX[6], 3);
00216                             Reg.addr = atoi(word);
00217                             strncpy(word, &bufferRX[10], 3);
00218                             Reg.value = atoi(word);
00219                             memset(word, 0, sizeof(word));
00220                             camera.WriteReg(Reg.addr, Reg.value);
00221                             sprintf(bufferTX, "%x", camera.ReadReg(Reg.addr));
00222                         }
00223                         if(sizeCMD == 3)
00224                         {
00225                             int n = 0;
00226                             int g = 0;
00227                             int c = 650;
00228                             sprintf(bufferTX, "reg_tab: ");
00229                             for (int i=0;i<201;i++) 
00230                             {
00231                                 n = snprintf(9+bufferTX+g, c, "%02X", camera.ReadReg(i));
00232                                 g = g + n; 
00233                                 c = c - n - 1;                                          
00234                             }                  
00235                             client.send_all(bufferTX, sizeof(bufferTX));                      
00236                         }
00237                   
00238                         client.send_all(bufferTX, sizeof(bufferTX));
00239                     }
00240             }else
00241             if(strncmp("w_bit", bufferRX, 5) == 0)                  //  w_bit0 018 001         w_bit1 018 001 
00242             {        
00243                     int type;
00244                     int reg_addr = 0;                
00245                     int reg_value = 0;
00246                     char word[3];
00247                     strncpy(word, &bufferRX[5], 1); 
00248                     type = atoi(word);
00249                     strncpy(word, &bufferRX[7], 3);  
00250                     reg_addr = atoi(word);
00251                     memset(word, 0, sizeof(word));
00252                     strncpy(word, &bufferRX[11], 3); 
00253                     reg_value = atoi(word); 
00254                     //printf("reg read write: addr: %x - value %x\r\n", reg_addr, reg_value);
00255                     int reg_value_now = camera.ReadReg(reg_addr);
00256                     
00257                     if(type == 0)
00258                     {
00259                         reg_value = reg_value_now ^ reg_value; 
00260                     }else
00261                     {
00262                         reg_value = reg_value_now | reg_value;
00263                     }
00264                     //printf("reg value new: reg_value_now: %x - reg_value %x\r\n", reg_value_now, reg_value);                   
00265                     camera.WriteReg(reg_addr, reg_value);
00266                     memset(word, 0, sizeof(word));
00267                     memset(bufferTX, 0, sizeof(bufferRX));
00268             }else
00269             if(strcmp("reset", bufferRX) == 0)              
00270             {
00271                     mbed_reset();        
00272             }else
00273             if(strcmp("time", bufferRX) == 0)              
00274             {
00275                     sprintf(bufferTX, "OV Tot time acq + send (mbed): %dms\r\n", t2-t1);                  
00276                     client.send_all(bufferTX, sizeof(bufferTX));
00277                     memset(bufferTX, 0, sizeof(bufferTX));
00278             }else   
00279             if(strcmp("ciao", bufferRX) == 0)              
00280             {
00281                     sprintf(bufferTX, "OV Test OK\r\n");                   
00282                     client.send_all(bufferTX, sizeof(bufferTX));
00283                     memset(bufferTX, 0, sizeof(bufferTX));                         
00284             }            
00285             memset(bufferRX, 0, sizeof(bufferRX));           
00286 }