main.cpp

00001 //RK: User enters mulitple characters from keyboard terminated with Enter/Return.
00002 //Only recognizes numbers. Limit of 10. Overrun caused negative results.
00003 /**********************************************************************************
00004 * @file    main.cpp
00005 * @author  Petr Dousa
00006 * @version V1.00
00007 * @date    22-March-2015
00008 * @brief   Every single second push to serial message and read from serial
00009 *          Serial speed is set to 9600.
00010 ***********************************************************************************/
00011 
00012 /* Includes ----------------------------------------------------------------------*/
00013 #include "mbed.h"
00014 
00015 /* Defines -----------------------------------------------------------------------*/
00016 #define buffer_size 256             // incoming buffer size
00017 #define buffer_fill buffer_size+1   // number, when buffer is ready
00018 
00019 /* Function prototypes -----------------------------------------------------------*/
00020 void serialRx();
00021 int serialGetBuffer(char * & data);
00022 
00023 /* Variables ---------------------------------------------------------------------*/
00024 // additional variables for incoming data
00025 char serial_buffer[buffer_size];    // buffer to save incoming data
00026 char serial_buffer2[buffer_size];   // second buffer to save incoming data
00027 int serial_buffer_where=0;          // index array for buffer
00028 int serial_buffer2_where=0;         // index array for second buffer
00029 bool serial_end_line = false;       // searching for end line
00030 
00031 //mbed - initialization of peripherals
00032 Serial pc(SERIAL_TX, SERIAL_RX);
00033 DigitalOut myled(LED1);
00034 
00035 /* Functions----------------------------------------------------------------------*/
00036 
00037 /*******************************************************************************
00038 * Function Name  : serialRx.
00039 * Description    : Incoming interruption fom serial. Fill two buffers with
00040 *                  incoming data and prepare it to serialGetBuffer.
00041 * Input          : None.
00042 * Output         : None.
00043 * Return         : None.
00044 *******************************************************************************/
00045 void serialRx()
00046 {
00047     while(pc.readable()) {                                                  // read all data from serial
00048         char character=pc.getc();                                           // get a char form serial
00049         if(((int)character==10 || (int)character==13) && serial_end_line) { // search for end line /r or /n
00050             serial_end_line=true;                                           // end was find in the previous charascter, skip
00051             continue;
00052         } else {
00053             serial_end_line=false;                                          // clear serial_end_line flag
00054         }
00055         if(serial_buffer_where!=buffer_fill && !(serial_buffer2_where != 0 && serial_buffer2_where!=buffer_fill)) {
00056             serial_buffer[serial_buffer_where++]=character;
00057             if(serial_buffer_where==buffer_size) {                          // check if incoming data are smaller than buffer size
00058                 serial_buffer[buffer_size-1]='\0';                          // posibility to lost data, if the incoming data are too big
00059                 serial_buffer_where=buffer_fill;                            // set index array to indicate buffer fill
00060                 continue;
00061             }
00062             if(character==13 || character==10) {                            // if end of line (\r \n) is indicated, prepare the buffer to serialGetBuffer
00063                 serial_buffer[serial_buffer_where-1]='\0';                  // set end of buffer with 0
00064                 serial_buffer_where=buffer_fill;                            // set index array to indicate buffer fill
00065                 serial_end_line=true;                                       // end of line was find, set serial_end_line flag
00066             }
00067         } else if(serial_buffer2_where!=buffer_fill) {                      // same for second buffer
00068             serial_buffer2[serial_buffer2_where++]=character;
00069             if(serial_buffer2_where==buffer_size) {
00070                 serial_buffer2[buffer_size-1]='\0';
00071                 serial_buffer2_where=buffer_fill;
00072                 continue;
00073             }
00074             if(character==13 || character==10) {
00075                 serial_buffer2[serial_buffer2_where-1]='\0';
00076                 serial_buffer2_where=buffer_fill;
00077                 serial_end_line=true;
00078             }
00079         } /*else {                                                      // the buffers are full and thedata are lost
00080             while(!pc.writeable());
00081             pc.printf("Code is too slow!\n");
00082             //pc.printf("I get: \"%c\", DEC: %d\n",character,(int)character);
00083         }*/
00084     }
00085 }
00086 
00087 /*******************************************************************************
00088 * Function Name  : serialGetBuffer.
00089 * Description    : Timer overflow handle. Blinks the LED.
00090 * Input          : Char array with size buffer_size.
00091 * Output         : Char array with incoming data.
00092 * Return         : 0 - on no data, 1 - one buffer is fill, 2 -two buffers are fill (posibility to lost data)
00093 *******************************************************************************/
00094 int serialGetBuffer(char * & data)
00095 {
00096     if(serial_buffer_where==buffer_fill && serial_buffer2_where==buffer_fill) {
00097         data=serial_buffer;
00098         //memcpy(data, serial_buffer, strlen(serial_buffer)+1);
00099         serial_buffer_where=0;
00100         return 2;
00101     } else if(serial_buffer2_where==buffer_fill) {
00102         data=serial_buffer2;
00103         //memcpy(data, serial_buffer2, strlen(serial_buffer2)+1);
00104         serial_buffer2_where=0;
00105         return 1;
00106     } else if(serial_buffer_where==buffer_fill) {
00107         data=serial_buffer;
00108         //memcpy(data, serial_buffer, strlen(serial_buffer)+1);
00109         serial_buffer_where=0;
00110         return 1;
00111     } else {
00112         return 0;
00113     }
00114 }
00115 
00116 /***********************************************************************************
00117 * Function Name  : main.
00118 * Description    : Main routine.
00119 * Input          : None.
00120 * Output         : None.
00121 * Return         : None.
00122 ***********************************************************************************/
00123 int main()
00124 {
00125     int i = 1;
00126     int j = 0;
00127     int k = 0;
00128 
00129     //array for data that are coming to user
00130     char * prijata_data;
00131 
00132     pc.baud(9600);                        // set serial speed to 9600
00133     pc.attach(&serialRx,Serial::RxIrq);     // attach serialRx to reception interrupt
00134     //pc.attach(&serialRx);
00135     pc.printf("Hello World !\r\n");
00136 
00137     while(1) {
00138         wait_ms(10);                        // wait 10 milliseconds
00139         if(serialGetBuffer(prijata_data)) { // get char array from serial
00140             sscanf (prijata_data,"%d",&j);  // sscanf for searching integer
00141             pc.printf("From PC:%d.\r\n" ,j);  // write to serial incoming integer
00142         }
00143         
00144         k++;
00145 
00146         if (k>=6000) { //print once per second
00147             pc.printf("This program running for %d minutess.\r\n", i++);    // write some string to serial
00148 
00149             myled = !myled;   // blink LED
00150             
00151             k=0;
00152         }
00153     }
00154 }
00155