static int ssp_drv_pio_read(mdev_t *dev, uint8_t *data, uint32_t num)
{
int len = 0;
sspdev_data_t *ssp_data_p;
ssp_data_p = (sspdev_data_t *) dev->private_data;
if (ssp_data_p->slave == SSP_SLAVE) {
while (num > 0) {
if (!is_rx_buf_empty(ssp_data_p))
*data = (uint8_t)read_rx_buf(ssp_data_p);
else
break;
num--;
len++;
data++;
}
} else {
/* In master mode, first send dummy data in TX line and read
* simultaneously. If nothing is on RX line then it can read
* 0x0 or 0xff. Application should check whether data is
* vaild or not.
*/
while (num > 0) {
while (SSP_GetStatus(dev->port_id, SSP_STATUS_TFNF)
!= SET)
os_thread_relinquish();
SSP_SendData(dev->port_id, SPI_DUMMY_BYTE);
while (SSP_GetStatus(dev->port_id, SSP_STATUS_RFNE)
!= SET)
os_thread_relinquish();
*data = (uint8_t)SSP_RecvData(dev->port_id);
data++;
len++;
num--;
}
}
return len;
}
/* ------------------------------------------------------------------------------------------------------
* mac_handle
*
* Describtion : RF event handle.
*
*/
void mac_event_handle(void)
{
mac_buf_t *rxbuf = read_rx_buf();
/* RX buffer has data.*/
if(rxbuf->alloc == true)
{
/* Random wake mode.*/
if ((rxbuf->len == 2) && (sys_mode == SYS_MODE_RAND_WAKE))
{
mac_syn_t syn;
syn.msgType = BROADCAST_SYN; /* Broadcast message type.*/
syn.routeCnt = (*rxbuf->dptr)&0x0F + 1; /* Route count.*/
syn.offset = halRfGetRandomByte(); /* Time offset number.*/
// DOTO: Rande delay(using Sleep Timer), send syn time frame.
mac_gen_syn_frm(&syn); /* Generate time syn frame.*/
}
reset_rx_buf();
}
}
static int ssp_drv_pio_write(mdev_t *dev, const uint8_t *data, uint8_t *din,
uint32_t num, bool flag)
{
uint32_t len = 0;
sspdev_data_t *ssp_data_p;
ssp_data_p = (sspdev_data_t *) dev->private_data;
while (num > 0) {
/* Wait if fifo is full */
while (SSP_GetStatus(dev->port_id, SSP_STATUS_TFNF) != SET)
os_thread_relinquish();
SSP_SendData(dev->port_id, *data);
/* Enable read RXFIFO during write operation if flag is set */
if (flag) {
/* read data while write operation is on to enable
* full duplex support in SPI protocol*/
/*
* Read rxfifo and store data, provided valid din
* buffer is provided by user else discard it.
*/
if (ssp_data_p->slave == SSP_MASTER) {
/* SSP_STATUS_BIT == SET when SSPx port is
* currently transmitting or receiving framed
* data.
* */
while (SSP_GetStatus(dev->port_id,
SSP_STATUS_BUSY) == SET)
os_thread_relinquish();
/* SSP_STATUS_RFNE == SET when RXFIFO is
* non-empty
*/
while (SSP_GetStatus(dev->port_id,
SSP_STATUS_RFNE) != SET)
os_thread_relinquish();
if (din)
*din++ = (uint8_t)
SSP_RecvData(dev->port_id);
else
SSP_RecvData(dev->port_id);
} else {
/* if slave mode is enabled read from software
* fifo*/
while (is_rx_buf_empty(ssp_data_p) == true)
os_thread_relinquish();
if (!is_rx_buf_empty(ssp_data_p) && din)
*din++ = (uint8_t)
read_rx_buf(ssp_data_p);
}
}
data++;
num--;
len++;
}
return len;
}
void IridiumSBD::standby_loop(void)
{
if (_test_pending) {
_test_pending = false;
if (!strcmp(_test_command, "s")) {
write(0, "kreczmer", 8);
} else if (!strcmp(_test_command, "read")) {
_rx_session_pending = true;
} else {
_test_timer = hrt_absolute_time();
start_test();
return;
}
}
// check for incoming SBDRING, handled inside read_at_command()
read_at_command();
if (_param_read_interval_s > 0
&& ((hrt_absolute_time() - _last_read_time) > (uint64_t)_param_read_interval_s * 1000000)) {
_rx_session_pending = true;
}
// write the MO buffer when the message stacking time expires
if (_tx_buf_write_pending && ((hrt_absolute_time() - _last_write_time) > (uint64_t)_param_stacking_time_ms * 1000)) {
write_tx_buf();
}
// do not start an SBD session if there is still data in the MT buffer, or it will be lost
if ((_tx_session_pending || _rx_session_pending) && !_rx_read_pending) {
if (_signal_quality > 0) {
// clear the MO buffer if we only want to read a message
if (_rx_session_pending && !_tx_session_pending) {
if (clear_mo_buffer()) {
start_sbd_session();
return;
}
} else {
start_sbd_session();
return;
}
} else {
start_csq();
return;
}
}
// start a signal check if requested and not a switch to another mode is scheduled
if (((hrt_absolute_time() - _last_signal_check) > SATCOM_SIGNAL_REFRESH_DELAY)
&& (_new_state == SATCOM_STATE_STANDBY)) {
start_csq();
return;
}
// only read the MT buffer if the higher layer (mavlink app) read the previous message
if (_rx_read_pending && (_rx_msg_read_idx == _rx_msg_end_idx) && (_new_state == SATCOM_STATE_STANDBY)) {
read_rx_buf();
return;
}
}
