void chb_frame_write(U8 *hdr, U8 hdr_len, U8 *data, U8 data_len)
{
U8 i, dummy;
// dont allow transmission longer than max frame size
if ((hdr_len + data_len) > 127)
{
return;
}
// initiate spi transaction
CHB_ENTER_CRIT();
CHB_SPI_ENABLE();
// send fifo write command
dummy = chb_xfer_byte(CHB_SPI_CMD_FW);
// write hdr contents to fifo
for (i=0; i<hdr_len; i++)
{
dummy = chb_xfer_byte(*hdr++);
}
// write data contents to fifo
for (i=0; i<data_len; i++)
{
dummy = chb_xfer_byte(*data++);
}
// terminate spi transaction
CHB_SPI_DISABLE();
CHB_LEAVE_CRIT();
}
static void chb_frame_read()
{
U8 i, len, data;
CHB_ENTER_CRIT();
CHB_SPI_ENABLE();
/*Send frame read command and read the length.*/
chb_xfer_byte(CHB_SPI_CMD_FR);
len = chb_xfer_byte(0);
/*Check for correct frame length.*/
// TODO: CHECK FOR THE CRC VALID BIT TO QUALIFY THE FRAME
// check the length of the frame to make sure the incoming frame
// doesn't overflow the buffer
if ((len >= CHB_MIN_FRAME_LENGTH) && (len <= CHB_MAX_FRAME_LENGTH))
{
chb_buf_write(len);
for (i=0; i<len; i++)
{
data = chb_xfer_byte(0);
chb_buf_write(data);
}
}
CHB_SPI_DISABLE();
CHB_LEAVE_CRIT();
}
static void chb_frame_read()
{
U8 i, len, data;
CHB_ENTER_CRIT();
RadioCS(TRUE);
/*Send frame read command and read the length.*/
SPID_write(CHB_SPI_CMD_FR);
len = SPID_write(0);
/*Check for correct frame length.*/
if ((len >= CHB_MIN_FRAME_LENGTH) && (len <= CHB_MAX_FRAME_LENGTH))
{
// check to see if there is room to write the frame in the buffer. if not, then drop it
if (len < (CHB_BUF_SZ - chb_buf_get_len()))
{
chb_buf_write(len);
for (i=0; i<len; i++)
{
data = SPID_write(0);
chb_buf_write(data);
}
//generate message received event here
//EVSYS.STROBE = 0x04; //generate event on channel 3
//generate interrupt on port E by toggling pin 2
//PORTE.OUTSET = PIN2_bm;
//PORTE.OUTCLR = PIN2_bm;
}
else
{
// we've overflowed the buffer. toss the data and do some housekeeping
pcb_t *pcb = chb_get_pcb();
//char buf[50];
// read out the data and throw it away
for (i=0; i<len; i++)
{
data = SPID_write(0);
}
// Increment the overflow stat
pcb->overflow++;
// grab the message from flash & print it out
//strcpy_P(buf, chb_err_overflow);
//printf(buf);
}
}
RadioCS(FALSE);
CHB_LEAVE_CRIT();
}
static void chb_frame_read()
{
U8 i, len, data;
CHB_ENTER_CRIT();
CHB_SPI_ENABLE();
/*Send frame read command and read the length.*/
chb_xfer_byte(CHB_SPI_CMD_FR);
len = chb_xfer_byte(0);
// check the length of the frame to make sure its within the correct size limits
if ((len >= CHB_MIN_FRAME_LENGTH) && (len <= CHB_MAX_FRAME_LENGTH))
{
// check to see if there is room to write the frame in the buffer. if not, then drop it
if (len < (CHB_BUF_SZ - chb_buf_get_len()))
{
chb_buf_write(len);
for (i=0; i<len; i++)
{
data = chb_xfer_byte(0);
chb_buf_write(data);
}
}
else
{
// this frame will overflow the buffer. toss the data and do some housekeeping
pcb_t *pcb = chb_get_pcb();
char buf[50];
// read out the data and throw it away
for (i=0; i<len; i++)
{
data = chb_xfer_byte(0);
}
// Increment the overflow stat, and print a message.
pcb->overflow++;
// grab the message from flash & print it out
strcpy_P(buf, chb_err_overflow);
Serial.print(buf);
}
}
CHB_SPI_DISABLE();
CHB_LEAVE_CRIT();
}
void chb_reg_write(U8 addr, U8 val)
{
/* Add the Register Write command to the address. */
addr |= 0xC0;
CHB_ENTER_CRIT();
CHB_SPI_ENABLE();
/*Send Register address and write register content.*/
chb_xfer_byte(addr);
chb_xfer_byte(val);
CHB_SPI_DISABLE();
CHB_LEAVE_CRIT();
}
U8 chb_reg_read(U8 addr)
{
U8 val = 0;
/* Add the register read command to the register address. */
addr |= 0x80;
CHB_ENTER_CRIT();
CHB_SPI_ENABLE();
/*Send Register address and read register content.*/
val = chb_xfer_byte(addr);
val = chb_xfer_byte(val);
CHB_SPI_DISABLE();
CHB_LEAVE_CRIT();
return val;
}
void chb_reg_write(U8 addr, U8 val)
{
//U8 dummy;
/* Add the Register Write command to the address. */
addr |= 0xC0;
CHB_ENTER_CRIT();
RadioCS(TRUE);
/*Send Register address and write register content.*/
//dummy = SPID_write(addr);
SPID_write(addr);
//dummy = SPID_write(val);
SPID_write(val);
RadioCS(FALSE);
CHB_LEAVE_CRIT();
}
U8 chb_reg_read(U8 addr)
{
U8 val = 0;
/* Add the register read command to the register address. */
addr |= 0x80;
CHB_ENTER_CRIT();
RadioCS(TRUE);
/*Send Register address and read register content.*/
val = SPID_write(addr);
val = SPID_write(val);
RadioCS(FALSE);
CHB_LEAVE_CRIT();
return val;
}
void chb_sram_write(U8 addr, U8 len, U8 *data)
{
U8 i, dummy;
CHB_ENTER_CRIT();
CHB_SPI_ENABLE();
/*Send SRAM write command.*/
dummy = chb_xfer_byte(CHB_SPI_CMD_SW);
/*Send address where to start writing to.*/
dummy = chb_xfer_byte(addr);
for (i=0; i<len; i++)
{
dummy = chb_xfer_byte(*data++);
}
CHB_SPI_DISABLE();
CHB_LEAVE_CRIT();
}
void chb_sram_read(U8 addr, U8 len, U8 *data)
{
U8 i, dummy;
CHB_ENTER_CRIT();
CHB_SPI_ENABLE();
/*Send SRAM read command.*/
dummy = chb_xfer_byte(CHB_SPI_CMD_SR);
/*Send address where to start reading.*/
dummy = chb_xfer_byte(addr);
for (i=0; i<len; i++)
{
*data++ = chb_xfer_byte(0);
}
CHB_SPI_DISABLE();
CHB_LEAVE_CRIT();
}
void chb_sram_write(U8 addr, U8 len, U8 *data)
{
U8 i, dummy;
CHB_ENTER_CRIT();
RadioCS(TRUE);
/*Send SRAM write command.*/
dummy = SPID_write(CHB_SPI_CMD_SW);
/*Send address where to start writing to.*/
dummy = SPID_write(addr);
for (i=0; i<len; i++)
{
dummy = SPID_write(*data++);
}
RadioCS(FALSE);
CHB_LEAVE_CRIT();
}
void chb_sram_read(U8 addr, U8 len, U8 *data)
{
U8 i, dummy;
CHB_ENTER_CRIT();
RadioCS(TRUE);
/*Send SRAM read command.*/
dummy = SPID_write(CHB_SPI_CMD_SR);
/*Send address where to start reading.*/
dummy = SPID_write(addr);
for (i=0; i<len; i++)
{
*data++ = SPID_write(0);
}
RadioCS(FALSE);
CHB_LEAVE_CRIT();
}
void chb_frame_write_raw(U8 *data, U8 data_len)
{
U8 i;
// initiate spi transaction
CHB_ENTER_CRIT();
CHB_SPI_ENABLE();
// send fifo write command
chb_xfer_byte(CHB_SPI_CMD_FW);
// write data contents to fifo
for (i=0; i<data_len; i++)
{
if(i > 127)
break;
chb_xfer_byte(*data++);
}
// terminate spi transaction
CHB_SPI_DISABLE();
CHB_LEAVE_CRIT();
}
void chb_frame_write(U8 *hdr, U8 hdr_len, U8 *data, U8 data_len)
{
U8 i;
//U8 dummy;
// dont allow transmission longer than max frame size
if ((hdr_len + data_len) > 127)
{
return;
}
// initiate spi transaction
CHB_ENTER_CRIT();
RadioCS(TRUE);
// send fifo write command
//dummy = SPID_write(CHB_SPI_CMD_FW);
SPID_write(CHB_SPI_CMD_FW);
// write hdr contents to fifo
for (i=0; i<hdr_len; i++)
{
//dummy = SPID_write(*hdr++);
SPID_write(*hdr++);
}
// write data contents to fifo
for (i=0; i<data_len; i++)
{
//dummy = SPID_write(*data++);
SPID_write(*data++);
}
// terminate spi transaction
RadioCS(FALSE);
CHB_LEAVE_CRIT();
}
void chb_ISR_Handler (void)
{
U8 dummy, state, intp_src = 0;
chb_pcb_t *pcb = chb_get_pcb();
CHB_ENTER_CRIT();
/*Read Interrupt source.*/
CHB_SPI_ENABLE();
/*Send Register address and read register content.*/
dummy = chb_xfer_byte(IRQ_STATUS | CHB_SPI_CMD_RR);
intp_src = chb_xfer_byte(0);
CHB_SPI_DISABLE();
while (intp_src)
{
/*Handle the incomming interrupt. Prioritized.*/
if ((intp_src & CHB_IRQ_RX_START_MASK))
{
intp_src &= ~CHB_IRQ_RX_START_MASK;
}
else if (intp_src & CHB_IRQ_TRX_END_MASK)
{
state = chb_get_state();
if ((state == RX_ON) || (state == RX_AACK_ON) || (state == BUSY_RX_AACK))
{
// get the ed measurement
pcb->ed = chb_reg_read(PHY_ED_LEVEL);
// get the crc
pcb->crc = (chb_reg_read(PHY_RSSI) & (1<<7)) ? 1 : 0;
// if the crc is not valid, then do not read the frame and set the rx flag
if (pcb->crc)
{
// get the data
chb_frame_read();
pcb->rcvd_xfers++;
pcb->data_rcv = true;
}
}
else
{
pcb->tx_end = true;
}
intp_src &= ~CHB_IRQ_TRX_END_MASK;
while (chb_set_state(RX_STATE) != RADIO_SUCCESS);
}
else if (intp_src & CHB_IRQ_TRX_UR_MASK)
{
intp_src &= ~CHB_IRQ_TRX_UR_MASK;
pcb->underrun++;
}
else if (intp_src & CHB_IRQ_PLL_UNLOCK_MASK)
{
intp_src &= ~CHB_IRQ_PLL_UNLOCK_MASK;
}
else if (intp_src & CHB_IRQ_PLL_LOCK_MASK)
{
intp_src &= ~CHB_IRQ_PLL_LOCK_MASK;
}
else if (intp_src & CHB_IRQ_BAT_LOW_MASK)
{
intp_src &= ~CHB_IRQ_BAT_LOW_MASK;
pcb->battlow++;
}
else
{
}
}
CHB_LEAVE_CRIT();
}