Diff: main.cpp

Revision:

1:4486f14a88ad

Parent:

0:2a0d1131965d

Child:

2:416bbbc23e82

--- a/main.cpp	Thu Mar 12 22:12:29 2015 +0000
+++ b/main.cpp	Sun Mar 22 13:31:00 2015 +0000
@@ -1,68 +1,68 @@
+/**********************************************************************************
+* @file    main.cpp
+* @author  Petr Dousa
+* @version V1.00
+* @date    22-March-2015
+* @brief   Every 1 second push to serial message and read from serial integer number
+*          Serial speed is set to 115200.
+***********************************************************************************/
+
+/* Includes ----------------------------------------------------------------------*/
 #include "mbed.h"
 
-//------------------------------------
-// Hyperterminal configuration
-// 9600 bauds, 8-bit data, no parity
-//------------------------------------
+/* Defines -----------------------------------------------------------------------*/
+#define buffer_size 256             // incoming buffer size
+#define buffer_fill buffer_size+1   // number, when buffer is ready
+
+/* Function prototypes -----------------------------------------------------------*/
+void serialRx();
+int serialGetBuffer(char * data);
 
+/* Variables ---------------------------------------------------------------------*/
+// help variables for incoming data
+char serial_buffer[buffer_size];    // buffer to save incoming data
+char serial_buffer2[buffer_size];   // second buffer to save incoming data
+int serial_buffer_where=0;          // index array for buffer
+int serial_buffer2_where=0;         // index array for second buffer
+bool serial_end_line = false;       // searching for end line
+
+//mbed - initialization of peripherals
 Serial pc(SERIAL_TX, SERIAL_RX);
 DigitalOut myled(LED1);
 
-// definice a promenne pro prijem dat
-#define buffer_size 256
-#define buffer_fill buffer_size+1
-char serial_buffer[buffer_size];
-char serial_buffer2[buffer_size];
-int serial_buffer_where=0;
-int serial_buffer2_where=0;
-void serialRx();
-int serialGetBuffer(char * data);
-bool serial_end_line = false;
-
-//pole prijatych znaku
-char prijata_data[buffer_size];
+/* Functions----------------------------------------------------------------------*/
 
-int main()
-{
-    int i = 1;
-    int j = 0;
-    pc.attach(&serialRx,Serial::RxIrq); // preruseni pro prijem znaku z UART
-
-    pc.printf("Hello World !\n");
-    while(1) {
-        wait(1);
-        if(serialGetBuffer(prijata_data)) { // prijmout char buffer z UART komunikace
-            sscanf (prijata_data,"%d",&j);  // pouziti sscanf pro hledani prvniho cisla
-            pc.printf("From PC:%d.\n" ,j);
-        } else {
-            pc.printf("This program runs since %d seconds.\n", i++);
-        }
-        myled = !myled;
-    }
-}
-
-// preruseni pro prijem dat z UART
+/*******************************************************************************
+* Function Name  : serialRx.
+* Description    : Incoming interruption fom serial. Fill two buffers with 
+*                   incoming data and prepare it to serialGetBuffer.
+* Input          : None.
+* Output         : None.
+* Return         : None.
+*******************************************************************************/
 void serialRx()
 {
-    while(pc.readable()) {
-        char character=pc.getc();
-        if(((int)character==10 || (int)character==13) && serial_end_line) { // jine konce radku, prizpusobeni
-            serial_end_line=false;
+    while(pc.readable()) {                                                  // read all data from serial
+        char character=pc.getc();                                           // get a char form serial
+        if(((int)character==10 || (int)character==13) && serial_end_line) { // search for end line /r or /n
+            serial_end_line=false;                                          // end was find in previous char, so skip it
             continue;
-        }else{serial_end_line=false;}
+        } else {
+            serial_end_line=false;                                          // clear serial_end_line flag
+        }
         if(serial_buffer_where!=buffer_fill) {
             serial_buffer[serial_buffer_where++]=character;
-            if(serial_buffer_where==buffer_size) { // kontrola nepreteceni bufferu
-                serial_buffer[buffer_size-1]='\0';
-                serial_buffer_where=buffer_fill;
+            if(serial_buffer_where==buffer_size) {                          // check if incoming data are smaller than buffe size
+                serial_buffer[buffer_size-1]='\0';                          // posibility to lost data, if the incoming data are too big
+                serial_buffer_where=buffer_fill;                            // set index array to indicate buffer fill
                 return;
             }
-            if(character==13 || character==10) {    // ukonceni a pripraveni bufferu
-                serial_buffer[serial_buffer_where-1]='\0';
-                serial_buffer_where=buffer_fill;
-                serial_end_line=true;
+                if(character==13 || character==10) {                        // if end of line (\r \n) is indicate, prepare the buffer to serialGetBuffer
+                serial_buffer[serial_buffer_where-1]='\0';                  // set end of buffer with 0
+                serial_buffer_where=buffer_fill;                            // set index array to indicate buffer fill
+                serial_end_line=true;                                       // end of line was find, set serial_end_line flag
             }
-        } else if(serial_buffer2_where!=buffer_fill) {
+        } else if(serial_buffer2_where!=buffer_fill) {                      // same for second buffer
             serial_buffer2[serial_buffer2_where++]=character;
             if(serial_buffer2_where==buffer_size) {
                 serial_buffer2[buffer_size-1]='\0';
@@ -74,23 +74,25 @@
                 serial_buffer2_where=buffer_fill;
                 serial_end_line=true;
             }
-        } /*else {
+        } /*else {                                                      // buffer are fill and data are lost
             while(!pc.writeable());
             pc.printf("Code is too slow!\n");
-            //pc.printf("I get: \"%c\", v deci: %d\n",character,(int)character);
+            //pc.printf("I get: \"%c\", DEC: %d\n",character,(int)character);
         }*/
     }
 }
 
-
-//vstup pole stejné velikosti jako buffery
-// návrat int   - 0 - žádná přijatá data
-//              - 1 - přijatá data
-//              - 2 - dvoje přijatá data, pravděpodobnost nezaznamenání dalších dat
+/*******************************************************************************
+* Function Name  : serialGetBuffer.
+* Description    : Timer overflow handle. Blinks the LED.
+* Input          : Char array with size buffer_size.
+* Output         : Char array with incoming data.
+* Return         : 0 - on no data, 1 - one buffer is fill, 2 -two buffers are fill (posibility to lost data)
+*******************************************************************************/
 int serialGetBuffer(char * data)
 {
     if(serial_buffer_where==buffer_fill && serial_buffer2_where==buffer_fill) {
-        memcpy(data, serial_buffer, strlen(serial_buffer)+1); 
+        memcpy(data, serial_buffer, strlen(serial_buffer)+1);
         serial_buffer_where=0;
         return 2;
     } else if(serial_buffer2_where==buffer_fill) {
@@ -106,3 +108,34 @@
     }
 }
 
+/***********************************************************************************
+* Function Name  : main.
+* Description    : Main routine.
+* Input          : None.
+* Output         : None.
+* Return         : None.
+***********************************************************************************/
+int main()
+{
+    int i = 1;
+    int j = 0;
+
+    //array for incomng data to user
+    char prijata_data[buffer_size];
+
+    pc.baud(115200);                    // set serial speed to 115200
+    pc.attach(&serialRx,Serial::RxIrq); // attach serialRx to incoming interruption
+    pc.printf("Hello World !\n");
+
+    while(1) {
+        wait(1);                            // wait 1 second
+        if(serialGetBuffer(prijata_data)) { // get char array from serial
+            sscanf (prijata_data,"%d",&j);  // sscanf for searching integer
+            pc.printf("From PC:%d.\n" ,j);  // write to serial incoming integer
+        } else {
+            pc.printf("This program runs since %d seconds.\n", i++);    // write to serial some string 
+        }
+        myled = !myled;                     // blink LED
+    }
+}
+