Line data    Source code

       1             : /*
       2             :   port for a script to access from a device perspective
       3             :  */
       4             : 
       5             : #include "AP_Scripting_config.h"
       6             : 
       7             : #if AP_SCRIPTING_ENABLED && AP_SCRIPTING_SERIALDEVICE_ENABLED
       8             : 
       9             : #include "AP_Scripting.h"
      10             : 
      11             : #include <AP_Math/AP_Math.h>
      12             : #include <AP_BoardConfig/AP_BoardConfig.h>
      13             : 
      14             : #ifndef AP_SCRIPTING_SERIALDEVICE_MIN_TXSIZE
      15             : #define AP_SCRIPTING_SERIALDEVICE_MIN_TXSIZE 2048
      16             : #endif
      17             : 
      18             : #ifndef AP_SCRIPTING_SERIALDEVICE_MIN_RXSIZE
      19             : #define AP_SCRIPTING_SERIALDEVICE_MIN_RXSIZE 2048
      20             : #endif
      21             : 
      22             : /*
      23             :   initialise scripting serial ports
      24             : */
      25          87 : void AP_Scripting_SerialDevice::init(void)
      26             : {
      27          87 :     if (enable == 0) {
      28          86 :         return;
      29             :     }
      30             : 
      31           4 :     for (uint8_t i=0; i<ARRAY_SIZE(ports); i++) {
      32           3 :         auto &p = ports[i];
      33           3 :         p.state.idx = AP_SERIALMANAGER_SCR_PORT_1 + i;
      34           3 :         p.init();
      35           3 :         AP::serialmanager().register_port(&p);
      36             :     }
      37             : }
      38             : 
      39         153 : void AP_Scripting_SerialDevice::clear(void)
      40             : {
      41         612 :     for (auto &p : ports) {
      42         459 :         p.clear();
      43             :     }
      44         153 : }
      45             : 
      46             : /*
      47             :   initialise port
      48             :  */
      49           3 : void AP_Scripting_SerialDevice::Port::init(void)
      50             : {
      51           3 :     begin(1000000, 0, 0); // assume 1MBaud rate even though it's a bit meaningless
      52           3 : }
      53             : 
      54         459 : void AP_Scripting_SerialDevice::Port::clear(void)
      55             : {
      56         459 :     WITH_SEMAPHORE(sem);
      57         459 :     if (readbuffer) {
      58           6 :         readbuffer->clear();
      59             :     }
      60         459 :     if (writebuffer) {
      61           6 :         writebuffer->clear();
      62             :     }
      63         459 : }
      64             : 
      65           1 : size_t AP_Scripting_SerialDevice::Port::device_write(const uint8_t *buffer, size_t size)
      66             : {
      67           1 :     WITH_SEMAPHORE(sem);
      68           1 :     if (readbuffer) {
      69           1 :         return readbuffer->write(buffer, size);
      70             :     }
      71           0 :     return 0;
      72           1 : }
      73             : 
      74           1 : ssize_t AP_Scripting_SerialDevice::Port::device_read(uint8_t *buffer, uint16_t count)
      75             : {
      76           1 :     WITH_SEMAPHORE(sem);
      77           1 :     if (writebuffer) {
      78           1 :         return writebuffer->read(buffer, count);
      79             :     }
      80           0 :     return 0;
      81           1 : }
      82             : 
      83           0 : uint32_t AP_Scripting_SerialDevice::Port::device_available(void)
      84             : {
      85           0 :     WITH_SEMAPHORE(sem);
      86           0 :     if (writebuffer) {
      87           0 :         return writebuffer->available();
      88             :     }
      89           0 :     return 0;
      90           0 : }
      91             : 
      92             : /*
      93             :   available space in outgoing buffer
      94             :  */
      95           0 : uint32_t AP_Scripting_SerialDevice::Port::txspace(void)
      96             : {
      97           0 :     WITH_SEMAPHORE(sem);
      98           0 :     return writebuffer != nullptr ? writebuffer->space() : 0;
      99           0 : }
     100             : 
     101           4 : void AP_Scripting_SerialDevice::Port::_begin(uint32_t b, uint16_t rxS, uint16_t txS)
     102             : {
     103           4 :     rxS = MAX(rxS, AP_SCRIPTING_SERIALDEVICE_MIN_RXSIZE);
     104           4 :     txS = MAX(txS, AP_SCRIPTING_SERIALDEVICE_MIN_TXSIZE);
     105           4 :     init_buffers(rxS, txS);
     106           4 : }
     107             : 
     108          12 : size_t AP_Scripting_SerialDevice::Port::_write(const uint8_t *buffer, size_t size)
     109             : {
     110          12 :     WITH_SEMAPHORE(sem);
     111          12 :     return writebuffer != nullptr ? writebuffer->write(buffer, size) : 0;
     112          12 : }
     113             : 
     114           1 : ssize_t AP_Scripting_SerialDevice::Port::_read(uint8_t *buffer, uint16_t count)
     115             : {
     116           1 :     WITH_SEMAPHORE(sem);
     117           1 :     return readbuffer != nullptr ? readbuffer->read(buffer, count) : -1;
     118           1 : }
     119             : 
     120           0 : uint32_t AP_Scripting_SerialDevice::Port::_available()
     121             : {
     122           0 :     WITH_SEMAPHORE(sem);
     123           0 :     return readbuffer != nullptr ? readbuffer->available() : 0;
     124           0 : }
     125             : 
     126             : 
     127           0 : bool AP_Scripting_SerialDevice::Port::_discard_input()
     128             : {
     129           0 :     WITH_SEMAPHORE(sem);
     130           0 :     if (readbuffer != nullptr) {
     131           0 :         readbuffer->clear();
     132             :     }
     133           0 :     return true;
     134           0 : }
     135             : 
     136             : /*
     137             :   initialise read/write buffers
     138             :  */
     139           4 : bool AP_Scripting_SerialDevice::Port::init_buffers(const uint32_t size_rx, const uint32_t size_tx)
     140             : {
     141           4 :     if (size_tx == last_size_tx &&
     142           1 :         size_rx == last_size_rx) {
     143           1 :         return true;
     144             :     }
     145           3 :     WITH_SEMAPHORE(sem);
     146           3 :     if (readbuffer == nullptr) {
     147           3 :         readbuffer = NEW_NOTHROW ByteBuffer(size_rx);
     148             :     } else {
     149           0 :         readbuffer->set_size_best(size_rx);
     150             :     }
     151           3 :     if (writebuffer == nullptr) {
     152           3 :         writebuffer = NEW_NOTHROW ByteBuffer(size_tx);
     153             :     } else {
     154           0 :         writebuffer->set_size_best(size_tx);
     155             :     }
     156           3 :     last_size_rx = size_rx;
     157           3 :     last_size_tx = size_tx;
     158           3 :     return readbuffer != nullptr && writebuffer != nullptr;
     159           3 : }
     160             : 
     161             : #endif // AP_SCRIPTING_ENABLED && AP_SCRIPTING_SERIALDEVICE_ENABLED