Line data    Source code

       1             : 
       2             : #include "GPIO.h"
       3             : 
       4             : #if CONFIG_HAL_BOARD == HAL_BOARD_SITL
       5             : 
       6             : using namespace HALSITL;
       7             : 
       8             : extern const AP_HAL::HAL& hal;
       9             : 
      10             : #define SITL_WOW_ALTITUDE 0.01
      11             : 
      12           0 : void GPIO::init()
      13           0 : {}
      14             : 
      15        4856 : void GPIO::pinMode(uint8_t pin, uint8_t output)
      16             : {
      17        4856 :     if (pin > 7) {
      18        2097 :         return;
      19             :     }
      20        2759 :     if (output) {
      21        2029 :         pin_mode_is_write |= (1U<<pin);
      22             :     } else {
      23         730 :         pin_mode_is_write &= ~(1U<<pin);
      24             :     }
      25             : }
      26             : 
      27      178777 : uint8_t GPIO::read(uint8_t pin)
      28             : {
      29      178777 :     if (!_sitlState->_sitl) {
      30           0 :         return 0;
      31             :     }
      32      178777 :     if (!valid_pin(pin)) {
      33           0 :         return 0;
      34             :     }
      35             :     
      36             :     // weight on wheels pin support
      37      178777 :     if (pin == _sitlState->_sitl->wow_pin.get()) {
      38           0 :         return _sitlState->_sitl->state.altitude < SITL_WOW_ALTITUDE ? 1 : 0;
      39             :     }
      40             :     
      41      178777 :     uint16_t mask = static_cast<uint16_t>(_sitlState->_sitl->pin_mask.get());
      42      178777 :     return static_cast<uint16_t>((mask & (1U << pin)) ? 1 : 0);
      43             : }
      44             : 
      45        1334 : void GPIO::write(uint8_t pin, uint8_t value)
      46             : {
      47        1334 :     if (!_sitlState->_sitl) {
      48           0 :         return;
      49             :     }
      50             : 
      51        1334 :     if (!valid_pin(pin)) {
      52           0 :         return;
      53             :     }
      54        1334 :     if (pin < 8) {
      55        1324 :         if (!(pin_mode_is_write & (1U<<pin))) {
      56             :             // ignore setting of pull-up resistors
      57         730 :             return;
      58             :         }
      59             :     }
      60         604 :     uint16_t mask = static_cast<uint16_t>(_sitlState->_sitl->pin_mask.get());
      61         604 :     uint16_t new_mask = mask;
      62             : 
      63         604 :     if (pin == _sitlState->_sitl->wow_pin.get()) {
      64           0 :         return;
      65             :     }
      66             : 
      67         604 :     if (value) {
      68          43 :         new_mask |= (1U << pin);
      69             :     } else {
      70         561 :         new_mask &= ~(1U << pin);
      71             :     }
      72         604 :     if (mask != new_mask) {
      73         604 :         _sitlState->_sitl->pin_mask.set_and_notify(new_mask);
      74             :     }
      75             : }
      76             : 
      77           0 : void GPIO::toggle(uint8_t pin)
      78             : {
      79           0 :     write(pin, !read(pin));
      80           0 : }
      81             : 
      82             : /* Alternative interface: */
      83           0 : AP_HAL::DigitalSource* GPIO::channel(uint16_t n) {
      84           0 :     if (n < 16) {  // (ie. sizeof(pin_mask)*8)
      85           0 :         return NEW_NOTHROW DigitalSource(static_cast<uint8_t>(n));
      86             :     } else {
      87           0 :         return nullptr;
      88             :     }
      89             : 
      90             : }
      91             : 
      92    23245344 : bool GPIO::usb_connected(void)
      93             : {
      94    23245344 :     return false;
      95             : }
      96             : 
      97           0 : DigitalSource::DigitalSource(uint8_t pin) :
      98           0 :     _pin(pin)
      99           0 : {}
     100             : 
     101           0 : void DigitalSource::mode(uint8_t output)
     102           0 : {}
     103             : 
     104           0 : uint8_t DigitalSource::read()
     105             : {
     106           0 :     return hal.gpio->read(_pin);
     107             : }
     108             : 
     109           0 : void DigitalSource::write(uint8_t value)
     110             : {
     111           0 :     value = static_cast<uint8_t>(value ? 1 : 0);
     112           0 :     return hal.gpio->write(_pin, value);
     113             : }
     114             : 
     115           0 : void DigitalSource::toggle()
     116             : {
     117           0 :     return hal.gpio->write(_pin, !hal.gpio->read(_pin));
     118             : }
     119             : #endif