Diff: src/d7a_com.cpp

Revision:

25:aac250164497

Parent:

24:a8433b091764

Child:

26:9f0b9833cac6

--- a/src/d7a_com.cpp	Wed Mar 23 16:00:53 2016 +0000
+++ b/src/d7a_com.cpp	Fri Mar 25 16:48:02 2016 +0000
@@ -2,7 +2,49 @@
 #include "rtos.h"
 #include "dbg.h"
 #include "d7a_com.h"
+#include "d7a_common.h"
+#include "d7a_fs.h"
+#include "d7a_modem.h"
+#include "d7a_sys.h"
 
+typedef struct {
+    DigitalOut*             rts;
+    InterruptIn*            cts;
+        
+    // RX buffer address
+    uint8_t*                rx_buffer;
+    // RX buffer size
+    uint16_t                rx_buffer_size;
+    // Write index in RX buffer
+    volatile uint16_t       write_idx;
+    // Read index in RX buffer
+    uint16_t                read_idx;
+    // Number of bytes available in RX buffer
+    volatile uint16_t       data_available;
+    // Port TX sequence number
+    uint8_t                 tx_seq;
+    // Port RX sequence number
+    uint8_t                 rx_seq;
+    // Response to command maximum time
+    uint32_t                timeout;
+    
+    // Packet reception queue
+    Queue<d7a_com_rx_msg_t, 32> pkt_queue;
+    
+    // Waiting for data available in RX buffer
+    Semaphore*              data_parsing;
+    // CTS management
+    Semaphore*              cts_int;
+    
+    // Data treatment threads
+    Thread*                 thread;
+    Serial*                 serial;
+    
+    uint32_t                rx_pkt_count;
+    uint32_t                rx_byte_count;
+    uint32_t                tx_pkt_count;
+    uint32_t                tx_byte_count;
+} d7a_com_ctx_t;
 
 static d7a_com_ctx_t g_com_ctx;
 
@@ -12,7 +54,7 @@
     @param void
     @return void
 */
-void d7a_com_parse_thread( void const *p );
+void d7a_com_thread( void const *p );
 
 
 /**
@@ -35,7 +77,11 @@
     }
             
     // unlock data parsing thread
-    g_com_ctx.data_parsing->release();
+    // do not parse if minimum packet size is not available
+    if (g_com_ctx.data_available > KAL_COM_HEADER_LEN)
+    {
+        g_com_ctx.data_parsing->release();
+    }
     
     return;
 }
@@ -77,6 +123,27 @@
     *(g_com_ctx.rts) = 0;
 }
 
+static void d7a_com_new_pkt(d7a_com_rx_msg_t* pkt)
+{
+    FPRINT("\r\n");
+    // Distribute packet types to processes
+    switch (KAL_COM_FLOWID(pkt->id))
+    {
+        case KAL_COM_FLOWID_FS:
+            d7a_fs_new_pkt(pkt);
+            break;
+        case KAL_COM_FLOWID_CMD:
+            d7a_modem_new_pkt(pkt);
+            break;
+        case KAL_COM_FLOWID_SYS:
+            d7a_sys_new_pkt(pkt);
+            break;
+        default:
+            EPRINT("Untreated pkt type 0x%02X\r\n", pkt->id);
+            FREE(pkt);
+            break;
+    }
+}
 
 /**
     Reads the Rx buffer, parses the packets and adds them to _pkt_queue
@@ -140,7 +207,7 @@
             seqnum = data;
             if (g_com_ctx.rx_seq != seqnum)
             {
-                WARNING(false, "D7A COM Missing %d seqnum\r\n", seqnum - g_com_ctx.rx_seq);
+                WARNING(false, "COM Missing %d seqnum\r\n", seqnum - g_com_ctx.rx_seq);
                 g_com_ctx.rx_seq = seqnum;
             }
 
@@ -156,23 +223,23 @@
         // we got a full packet
         else if (5 == state)
         {
-            d7a_com_pkt_t* pkt = NULL;
-            pkt = (d7a_com_pkt_t*)MALLOC(sizeof(d7a_com_pkt_t) - 1 + len);
+            d7a_com_rx_msg_t* pkt = NULL;
+            pkt = (d7a_com_rx_msg_t*)MALLOC(sizeof(d7a_com_rx_msg_t) - 1 + len);
             
             //DPRINT("Got packet fid %d len %d\r\n", fid, len);
 
             // copy data to buffer
-            pkt->len = len;
+            pkt->blen = len;
             pkt->id = id;
             for (i=0 ; i<len ; i++)
             {
-                pkt->data[i] = g_com_ctx.rx_buffer[(g_com_ctx.read_idx + data_read + i - 1) % g_com_ctx.rx_buffer_size];
+                pkt->buffer[i] = g_com_ctx.rx_buffer[(g_com_ctx.read_idx + data_read + i - 1) % g_com_ctx.rx_buffer_size];
             }
             data_read += i - 1;
             
             // add packet to queue
-            DPRINT("New packet SIZE:%d\r\n", pkt->len);
-            ASSERT(g_com_ctx.pkt_queue.put(pkt) == osOK, "COM queue full!\r\n");
+            DPRINT("New packet SIZE:%d\r\n", pkt->blen);
+            d7a_com_new_pkt(pkt);
             
             pkt_found = true;
             
@@ -232,7 +299,7 @@
 // CTS-host <- RTS-modem
 void d7a_com_open( const d7a_com_config_t* config )
 {
-    FPRINT("d7a_com_open\r\n");
+    FPRINT("\r\n");
     
     g_com_ctx.rx_buffer_size = config->rx_buffer_size;
     g_com_ctx.rx_buffer = (uint8_t*)MALLOC(g_com_ctx.rx_buffer_size);
@@ -248,7 +315,7 @@
     g_com_ctx.cts =             new InterruptIn(config->cts);
     g_com_ctx.data_parsing =    new Semaphore(1);
     g_com_ctx.cts_int =         new Semaphore(1);
-    g_com_ctx.parse_thread =    new Thread(d7a_com_parse_thread, NULL, osPriorityNormal, DEFAULT_STACK_SIZE*2);
+    g_com_ctx.thread =          new Thread(d7a_com_thread, NULL, osPriorityBelowNormal, DEFAULT_STACK_SIZE*2);
         
     /* XXX: Unknown bug:
     Baud rate can be found with high error rate (> 4%).
@@ -263,8 +330,8 @@
 // Destructor
 void d7a_com_close()
 {
-    FPRINT("d7a_com_close\r\n");
-    g_com_ctx.parse_thread->terminate();
+    FPRINT("\r\n");
+    g_com_ctx.thread->terminate();
     delete g_com_ctx.data_parsing;
     delete g_com_ctx.cts_int;
     delete g_com_ctx.serial;
@@ -274,18 +341,12 @@
 }
 
 
-d7a_com_pkt_t* d7a_com_wait_pkt( uint32_t millisec )
-{
-    FPRINT("d7a_com_wait_pkt\r\n");
-    // wait for packet
-    osEvent evt = g_com_ctx.pkt_queue.get(millisec);
-    return (evt.status == osEventMessage)? (d7a_com_pkt_t*)evt.value.p : NULL;
-}
+
 
 // Formats and send packet throught Serial.
-void d7a_com_send_msg(kal_com_tx_msg_t* msg)
+void d7a_com_send_msg(d7a_com_tx_msg_t* msg)
 {
-    FPRINT("d7a_com_send_msg\r\n");
+    FPRINT("\r\n");
     uint8_t* buf;
     uint16_t len = msg->alen + msg->plen;
     
@@ -317,9 +378,9 @@
 
 
 // Thread for parsing packets from RX buffer.
-void d7a_com_parse_thread( void const *p )
+void d7a_com_thread( void const *p )
 {
-    FPRINT("d7a_com_parse_thread\r\n");
+    FPRINT("\r\n");
     while (true)
     {
         // wait for data available