Diff: UART9BIT.CPP

Revision:

6:64f5dad70ee2

Parent:

5:b97a733f6ed8

Child:

7:af4ceb878eee

--- a/UART9BIT.CPP	Tue Aug 20 11:20:26 2019 +0800
+++ b/UART9BIT.CPP	Wed Aug 21 16:27:30 2019 +0800
@@ -15,15 +15,144 @@
  */
  
  #include "UART9BIT.h"
+ #include "serial_api9bit.h"
 
 
-UART9BIT::UART9BIT(PinName tx, PinName rx, int baud,bool en9bit) :SerialBase( tx,  rx,  baud)
+UART9BIT::UART9BIT(PinName tx, PinName rx, int baud,bool en9bit) :_thunk9_irq(this), SerialBase( tx,  rx,  baud)
 {
  Enable9Bit=en9bit;
  printf("Uart9bit init \r\n");
- 
+
+ if(en9bit)
+ format(9,UART9BIT::None,1);
+
+}
+
+void UART9BIT::format(int bits, Parity parity, int stop_bits) 
+{
+    lock();
+    serial_format_9bit(&_serial, bits, (SerialParity)parity, stop_bits);
+    unlock();
+}
+
+
+void UART9BIT::interrupt_handler_asynch(void)
+{
+    int event = serial_irq_handler_asynch(&_serial);
+    int rx_event = event & SERIAL_EVENT_RX_MASK;
+
+    if (_rx_asynch_set && rx_event) {
+        event_callback_t cb = _rx_callback;
+        _rx_asynch_set = false;
+        _rx_callback = NULL;
+        if (cb) {
+            cb.call(rx_event);
+        }
+        sleep_manager_unlock_deep_sleep();
+    }
+
+    int tx_event = event & SERIAL_EVENT_TX_MASK;
+    if (_tx_asynch_set && tx_event) {
+        event_callback_t cb = _tx_callback;
+        _tx_asynch_set = false;
+        _tx_callback = NULL;
+        if (cb) {
+            cb.call(tx_event);
+        }
+        sleep_manager_unlock_deep_sleep();
+    }
+}
+
+int UART9BIT::write(const uint16_t *buffer, int length, const event_callback_t &callback, int event)
+{
+    int result = 0;
+    printf("U9 01 \r\n");
+    lock();
+   //  printf("U9 Write 2\r\n");
+
+    if (!serial_tx_active(&_serial) && !_tx_asynch_set) {
+        start_write((void *)buffer, length, 16, callback, event);
+    } else {
+        result = -1; // transaction ongoing
+    }
+
+
+    unlock();
+     printf("U9 Write ok\r\n");
+    return result;
+}
+
+
+void UART9BIT::start_write(const void *buffer, int buffer_size, char buffer_width, const event_callback_t &callback, int event)
+{
+    _tx_asynch_set = true;
+    _tx_callback = callback;
+      printf("U9 10 \r\n");
+    _thunk9_irq.callback(&UART9BIT::interrupt_handler_asynch);
+
+    sleep_manager_lock_deep_sleep();
+     printf("U9 11 \r\n");
+
+    serial_tx_asynch9bit(&_serial, buffer, buffer_size, buffer_width, _thunk_irq.entry(), event, _tx_usage);
+     printf("U9 12 \r\n");
+}
+
+
+void UART9BIT::start_read(void *buffer, int buffer_size, char buffer_width, const event_callback_t &callback, int event, unsigned char char_match)
+{
+    _rx_asynch_set = true;
+    _rx_callback = callback;
+    _thunk9_irq.callback(&UART9BIT::interrupt_handler_asynch);
+    sleep_manager_lock_deep_sleep();
+    serial_rx_asynch(&_serial, buffer, buffer_size, buffer_width, _thunk_irq.entry(), event, char_match, _rx_usage);
+}
+
+
+
+int UART9BIT::read(uint16_t *buffer, int length, const event_callback_t &callback, int event, unsigned char char_match)
+{
+    int result = 0;
+    lock();
+    if (!serial_rx_active(&_serial) && !_rx_asynch_set) {
+        start_read((void *)buffer, length, 16, callback, event, char_match);
+    } else {
+        result = -1; // transaction ongoing
+    }
+    unlock();
+    return result;
 }
 
 
 
 
+void UART9BIT::GetUartName(void)
+{
+    switch(_serial.serial.uart)
+    {
+        case UART_0:
+            printf("Uart 0 init \r\n");
+        break;
+          case UART_1:
+            printf("Uart 1 init \r\n");
+        break;
+          case UART_2:
+            printf("Uart 2 init \r\n");
+        break;
+          case UART_3:
+            printf("Uart 3 init \r\n");
+        break;
+          case UART_4:
+            printf("Uart 4 init \r\n");
+        break;
+          case UART_5:
+            printf("Uart 5 init \r\n");
+        break;
+    }
+
+
+
+}
+
+
+
+