main.cpp

00001 #include "mbed.h"
00002 #include "stm32746g_discovery_lcd.h"
00003 
00004 #include "Interface.h"
00005 
00006 DigitalOut                      led(LED1);
00007 Serial                          serial(PA_9,PB_7);          // serial 1
00008 AnalogIn                        analogIn1(A0);
00009 AnalogIn                        analogIn2(A1);
00010 VALUES_STRUCT                   buffer[BUFFER_SIZE];
00011 uint8_t                         commandBuffer[100];
00012 uint32_t                        commandLength;
00013 
00014 void sendBuffer(uint8_t *buffer,uint32_t length)
00015 {
00016     while (length>0)
00017     {
00018         serial.putc(*buffer);
00019 
00020         buffer++;
00021         length--;
00022     }
00023 }
00024 
00025 void sendCommand(HEADER_TYPE_ENUM type,uint8_t *buffer,uint32_t length)
00026 {
00027     HEADER_STRUCT               header;
00028 
00029     header.magic=HEADER_MAGIC;
00030     header.type=type;
00031     header.length=length;
00032 
00033     sendBuffer((uint8_t *)&header,sizeof(header));
00034     sendBuffer(buffer,length);
00035 }
00036 
00037 bool readWithTimeout(uint8_t *buffer)
00038 {
00039     uint32_t counter;
00040 
00041     counter=0;
00042     while (counter<10000)
00043     {
00044         if (serial.readable())
00045         {
00046             (*buffer)=serial.getc();
00047             return true;
00048         }
00049 
00050         wait_us(50);
00051 
00052         counter++;
00053     }
00054 
00055     // re-init serial port
00056     serial.baud(115200);
00057 
00058     return false;
00059 }
00060 
00061 HEADER_TYPE_ENUM readCommand(void)
00062 {
00063     HEADER_STRUCT               *header;
00064     uint32_t                    index;
00065     HEADER_TYPE_ENUM            type;
00066 
00067     for (index=0;index<sizeof(HEADER_STRUCT);index++)
00068     {
00069         if (readWithTimeout(&commandBuffer[index])==false)
00070             return HT_NONE;
00071     }
00072 
00073     header=(HEADER_STRUCT *)commandBuffer;
00074     if (header->magic!=HEADER_MAGIC)
00075             return HT_NONE;
00076 
00077     type=(HEADER_TYPE_ENUM)header->type;
00078         
00079     if (header->length>0)
00080     {
00081         commandLength=header->length;
00082 
00083         for (index=0;index<commandLength;index++)
00084         {
00085             if (readWithTimeout(&commandBuffer[index])==false)
00086             return HT_NONE;
00087         }
00088     }
00089 
00090     return type;
00091 }
00092 
00093 int main()
00094 {
00095     int32_t                         index;
00096     int32_t                         indexPrevious;
00097     int32_t                         stop;
00098     HEADER_TYPE_ENUM                type;
00099     bool                            capture;
00100     float                           triggerLevel;
00101     uint8_t                         triggerMode;
00102     uint16_t                        delay;
00103     bool                            triggered;
00104 
00105     serial.baud(115200);
00106 
00107     BSP_LCD_Init();
00108     BSP_LCD_DisplayOff();
00109 
00110     capture=false;
00111     triggerLevel=0.0;
00112     triggerMode=TM_NONE;
00113     delay=0;
00114 
00115     for (;;)
00116     {
00117         if (serial.readable())
00118         {
00119             type=readCommand();
00120             switch (type)
00121             {
00122                 case HT_INFO_REQUEST:
00123                     {
00124                         INTERFACE_INFO_RESPONSE_STRUCT              InfoResponse;
00125                         
00126                         memset(&InfoResponse,0,sizeof(InfoResponse));
00127                         InfoResponse.versionMajor=1;
00128                         InfoResponse.versionMinor=0;
00129                         snprintf(InfoResponse.name,sizeof(InfoResponse.name),"Scope");
00130                         sendCommand(HT_INFO_RESPONSE,(uint8_t *)&InfoResponse,sizeof(InfoResponse));
00131                     }
00132                     break;
00133                     
00134                 case HT_CAPTURE_START:
00135                     {
00136                         INTERFACE_CAPTURE_START_STRUCT              *captuerStart;
00137                         
00138                         if (commandLength==sizeof(INTERFACE_CAPTURE_START_STRUCT))
00139                         {
00140                             captuerStart=(INTERFACE_CAPTURE_START_STRUCT *)commandBuffer;
00141     
00142                             triggerLevel=captuerStart->triggerLevel;
00143                             triggerMode=captuerStart->triggerMode;
00144                             delay=captuerStart->delay;
00145 
00146                             // seems our measurement loop needs 5 µs per loop
00147                             if (delay>5)
00148                                 delay-=5;
00149     
00150                             capture=true;
00151                         }
00152                     }
00153                     break;
00154             }
00155         }
00156         
00157         if (capture==true)
00158         {
00159             led=1;
00160     
00161             // dummy read for nicer results
00162             for (index=0;index<5;index++)
00163             {
00164                 analogIn1.read();
00165                 analogIn2.read();
00166             }
00167      
00168             stop=0;
00169             index=0;
00170             indexPrevious=0;
00171             triggered=false;
00172             for (;;)
00173             {
00174                 buffer[index].values[0]=analogIn1.read();
00175                 buffer[index].values[1]=analogIn2.read();
00176         
00177                 // check for trigger
00178                 if ((triggered==false) && (index>(BUFFER_SIZE/2)))
00179                 {
00180                     // we trigger only on channel 1
00181                     if ((triggerMode & TM_RAISING)!=0)
00182                         if (buffer[indexPrevious].values[0]<triggerLevel)
00183                             if (buffer[index].values[0]>=triggerLevel)
00184                                 triggered=true;
00185                     if ((triggerMode & TM_FALLING)!=0)
00186                         if (buffer[indexPrevious].values[0]>triggerLevel)
00187                             if (buffer[index].values[0]<=triggerLevel)
00188                                 triggered=true;
00189 
00190                     if (triggered==true)
00191                         stop=(index + (BUFFER_SIZE / 2)) % BUFFER_SIZE;
00192                 }
00193 
00194                 indexPrevious=index;
00195 
00196                 index++;
00197                 if (index>=BUFFER_SIZE)
00198                     index=0;
00199 
00200                 if (index==stop)
00201                     break;
00202 
00203                 wait_us(delay);
00204             }
00205 
00206             led=0;
00207             capture=false;
00208 
00209             if ((triggered==true) || ((triggerMode & TM_AUTO)!=0))
00210             {
00211                 HEADER_STRUCT               header;
00212 
00213                 header.magic=HEADER_MAGIC;
00214                 header.type=HT_DATA;
00215                 header.length=sizeof(buffer);
00216 
00217                 // send header
00218                 sendBuffer((uint8_t *)&header,sizeof(header));
00219                 // send part 1
00220                 sendBuffer((uint8_t *)&buffer[stop],((BUFFER_SIZE-stop)*sizeof(VALUES_STRUCT)));
00221                 // send part 2
00222                 if (stop>0)
00223                     sendBuffer((uint8_t *)&buffer[0],(stop*sizeof(VALUES_STRUCT)));
00224             }
00225             else
00226                 sendCommand(HT_DATA,(uint8_t *)&buffer,0);
00227         }
00228     }
00229 }