/*---------------------------------------------------------------------------*/
static int
is_receiving(void)
{
if(timer_expired(&rxstate.timer)) {
restart_input();
}
return rxstate.receiving;
}
void zmq::stream_engine_t::zap_msg_available ()
{
zmq_assert (mechanism != NULL);
const int rc = mechanism->zap_msg_available ();
if (rc == -1) {
error (protocol_error);
return;
}
if (input_stopped)
restart_input ();
if (output_stopped)
restart_output ();
}
/*---------------------------------------------------------------------------*/
static void
flushrx(void)
{
restart_input();
LOCK_SPI();
if(state() == CC1101_STATE_RXFIFO_OVERFLOW) {
strobe(CC1101_SFRX);
}
strobe(CC1101_SIDLE);
BUSYWAIT_UNTIL((state() == CC1101_STATE_IDLE), RTIMER_SECOND / 10);
strobe(CC1101_SFRX);
strobe(CC1101_SRX);
RELEASE_SPI();
}
void zmq::stream_engine_t::zap_msg_available ()
{
zmq_assert (mechanism != NULL);
const int rc = mechanism->zap_msg_available ();
if (rc == -1) {
// TODO:
// if (errno == EACCES)
// return ERROR command to client
error ();
return;
}
if (input_stopped)
restart_input ();
if (output_stopped)
restart_output ();
}
/*---------------------------------------------------------------------------*/
static int
input_byte(uint8_t byte)
{
int crc;
if(timer_expired(&rxstate.timer)) {
restart_input();
}
PT_BEGIN(&rxstate.pt);
/* The first incoming byte is the length of the packet. */
rxstate.receiving = 1;
rxstate.len = byte;
if(byte == 0) {
#if DEBUG
printf("Bad len 0, state %d rxbytes %d\n", state(), read_rxbytes());
#endif /* DEBUG */
flushrx();
PT_EXIT(&rxstate.pt);
}
timer_set(&rxstate.timer, PACKET_LIFETIME);
for(rxstate.ptr = 0;
rxstate.ptr < rxstate.len;
rxstate.ptr++) {
/* Wait for the next data byte to be received. */
PT_YIELD(&rxstate.pt);
rxstate.buf[rxstate.ptr] = byte;
}
/* Receive two more bytes from the FIFO: the RSSI value and the LQI/CRC */
PT_YIELD(&rxstate.pt);
rxstate.buf[rxstate.ptr] = byte;
rxstate.ptr++;
PT_YIELD(&rxstate.pt);
rxstate.buf[rxstate.ptr] = byte;
crc = (byte & 0x80);
rxstate.ptr++;
if(crc == 0) {
#if DEBUG
printf("bad crc\n");
#endif /* DEBUG */
flushrx();
} else if(packet_rx_len > 0) {
#if DEBUG
printf("Packet in the buffer (%d), dropping %d bytes\n", packet_rx_len, rxstate.len);
#endif /* DEBUG */
flushrx();
process_poll(&cc1101_process);
} else if(rxstate.len < ACK_LEN) {
/* Drop packets that are way too small: less than ACK_LEN (3) bytes
long. */
#if DEBUG
printf("!");
#endif /* DEBUG */
} else {
/* Read out the first three bytes to determine if we should send an
ACK or not. */
/* Send a link-layer ACK before reading the full packet. */
if(rxstate.len >= ACK_LEN) {
/* Try to parse the incoming frame as a 802.15.4 header. */
frame802154_t info154;
if(frame802154_parse(rxstate.buf, rxstate.len, &info154) != 0) {
/* XXX Potential optimization here: we could check if the
frame is destined for us, or for the broadcast address and
discard the packet if it isn't for us. */
if(1) {
/* For dataframes that has the ACK request bit set and that
is destined for us, we send an ack. */
if(info154.fcf.frame_type == FRAME802154_DATAFRAME &&
info154.fcf.ack_required != 0 &&
rimeaddr_cmp((rimeaddr_t *)&info154.dest_addr,
&rimeaddr_node_addr)) {
send_ack(info154.seq);
/* Make sure that we don't put the radio in the IDLE state
before the ACK has been fully transmitted. */
BUSYWAIT_UNTIL((state() != CC1101_STATE_TX), RTIMER_SECOND / 10);
ENERGEST_OFF(ENERGEST_TYPE_TRANSMIT);
ENERGEST_ON(ENERGEST_TYPE_LISTEN);
if(state() == CC1101_STATE_TX) {
#if DEBUG
printf("didn't end ack tx (in %d, txbytes %d)\n", state(), txbytes());
#endif /* DEBUG */
check_txfifo();
flushrx();
}
}
memcpy((void *)packet_rx, rxstate.buf,
rxstate.len + AUX_LEN);
packet_rx_len = rxstate.len + AUX_LEN; /* including AUX */
process_poll(&cc1101_process);
#if DEBUG
printf("#");
#endif /* DEBUG */
}
}
}
}
rxstate.receiving = 0;
PT_END(&rxstate.pt);
}
