mirror of
https://github.com/oliverschmidt/contiki.git
synced 2024-08-16 22:28:59 +00:00
732 lines
20 KiB
C
732 lines
20 KiB
C
/*
|
|
* Copyright (c) 2014, Analog Devices, Inc.
|
|
* All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions
|
|
* are met:
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
* documentation and/or other materials provided with the distribution.
|
|
*
|
|
* 3. Neither the name of the copyright holder nor the names of its
|
|
* contributors may be used to endorse or promote products derived
|
|
* from this software without specific prior written permission.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
* ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
|
|
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
|
|
* COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
|
|
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
|
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
|
|
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
|
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
|
|
* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
|
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
|
|
* OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
*/
|
|
/**
|
|
* \author Dragos Bogdan <Dragos.Bogdan@Analog.com>, Ian Martin <martini@redwirellc.com>
|
|
*/
|
|
|
|
#include <stdio.h>
|
|
#include <assert.h>
|
|
#include <string.h> /* for memcmp(). */
|
|
#include <stdbool.h>
|
|
|
|
#include "ADF7023.h"
|
|
#include "ADF7023_Config.h"
|
|
#include "Communication.h"
|
|
|
|
#include "sfrs.h"
|
|
#include "sfrs-ext.h"
|
|
|
|
#include "contiki.h" /* for clock_wait() and CLOCK_SECOND. */
|
|
#include "sys/cc.h"
|
|
|
|
/******************************************************************************/
|
|
/*************************** Macros Definitions *******************************/
|
|
/******************************************************************************/
|
|
/*
|
|
#define ADF7023_CS_ASSERT CS_PIN_LOW
|
|
#define ADF7023_CS_DEASSERT CS_PIN_HIGH
|
|
#define ADF7023_MISO MISO_PIN
|
|
*/
|
|
|
|
#ifndef ARRAY_SIZE
|
|
#define ARRAY_SIZE(a) (sizeof(a) / sizeof((a)[0]))
|
|
#endif
|
|
|
|
#undef BIT
|
|
#define BIT(n) (1 << (n))
|
|
|
|
#define ADF7023_CS_ASSERT (P2 &= ~BIT(2))
|
|
#define ADF7023_CS_DEASSERT (P2 |= BIT(2))
|
|
#define ADF7023_MISO (P0 & BIT(3))
|
|
|
|
#define ADF7023_SPI_BUS (CSI10)
|
|
|
|
#define LOOP_LIMIT 100
|
|
|
|
#ifndef ADF7023_VERBOSE
|
|
/* ADF7023_VERBOSE Values: */
|
|
/* 2 = Inidicate when breaking stuck while loops. */
|
|
/* 5 = Dump all received and transmitted packets. */
|
|
/* 7 = Dump the ADF7023 commands, interrupt and status words. */
|
|
/* 10 = Dump all SPI transactions. */
|
|
|
|
#define ADF7023_VERBOSE 0
|
|
#endif
|
|
|
|
#if (ADF7023_VERBOSE >= 2)
|
|
#define break_loop() if(++counter >= LOOP_LIMIT) { printf("Breaking stuck while loop at %s line %u." NEWLINE, __FILE__, __LINE__); break; }
|
|
#else
|
|
#define break_loop() if(++counter >= LOOP_LIMIT) break
|
|
#endif
|
|
|
|
#define ADF7023_While(condition, body) do { \
|
|
int counter = 0; \
|
|
while(condition) { body; break_loop(); } \
|
|
} while(0)
|
|
|
|
/******************************************************************************/
|
|
/************************ Variables Definitions *******************************/
|
|
/******************************************************************************/
|
|
struct ADF7023_BBRAM ADF7023_BBRAMCurrent;
|
|
|
|
#if (ADF7023_VERBOSE >= 7)
|
|
static unsigned char status_old = 0xff;
|
|
static unsigned char int0_old = 0xff;
|
|
#endif
|
|
|
|
const char *ADF7023_state_lookup[] = {
|
|
/* 0x00 */ "Busy, performing a state transition",
|
|
/* 0x01 */ "(unknown)",
|
|
/* 0x02 */ "(unknown)",
|
|
/* 0x03 */ "(unknown)",
|
|
/* 0x04 */ "(unknown)",
|
|
/* 0x05 */ "Performing CMD_GET_RSSI",
|
|
/* 0x06 */ "PHY_SLEEP",
|
|
/* 0x07 */ "Performing CMD_IR_CAL",
|
|
/* 0x08 */ "Performing CMD_AES_DECRYPT_INIT",
|
|
/* 0x09 */ "Performing CMD_AES_DECRYPT",
|
|
/* 0x0A */ "Performing CMD_AES_ENCRYPT",
|
|
/* 0x0B */ "(unknown)",
|
|
/* 0x0C */ "(unknown)",
|
|
/* 0x0D */ "(unknown)",
|
|
/* 0x0E */ "(unknown)",
|
|
/* 0x0F */ "Initializing",
|
|
/* 0x10 */ "(unknown)",
|
|
/* 0x11 */ "PHY_OFF",
|
|
/* 0x12 */ "PHY_ON",
|
|
/* 0x13 */ "PHY_RX",
|
|
/* 0x14 */ "PHY_TX",
|
|
};
|
|
|
|
const char *ADF7023_cmd_lookup[] = {
|
|
[CMD_SYNC] = "CMD_SYNC",
|
|
[CMD_PHY_OFF] = "CMD_PHY_OFF",
|
|
[CMD_PHY_ON] = "CMD_PHY_ON",
|
|
[CMD_PHY_RX] = "CMD_PHY_RX",
|
|
[CMD_PHY_TX] = "CMD_PHY_TX",
|
|
[CMD_PHY_SLEEP] = "CMD_PHY_SLEEP",
|
|
[CMD_CONFIG_DEV] = "CMD_CONFIG_DEV",
|
|
[CMD_GET_RSSI] = "CMD_GET_RSSI",
|
|
[CMD_BB_CAL] = "CMD_BB_CAL",
|
|
[CMD_HW_RESET] = "CMD_HW_RESET",
|
|
[CMD_RAM_LOAD_INIT] = "CMD_RAM_LOAD_INIT",
|
|
[CMD_RAM_LOAD_DONE] = "CMD_RAM_LOAD_DONE",
|
|
[CMD_IR_CAL] = "CMD_IR_CAL",
|
|
[CMD_AES_ENCRYPT] = "CMD_AES_ENCRYPT",
|
|
[CMD_AES_DECRYPT] = "CMD_AES_DECRYPT",
|
|
[CMD_AES_DECRYPT_INIT] = "CMD_AES_DECRYPT_INIT",
|
|
[CMD_RS_ENCODE_INIT] = "CMD_RS_ENCODE_INIT",
|
|
[CMD_RS_ENCODE] = "CMD_RS_ENCODE",
|
|
[CMD_RS_DECODE] = "CMD_RS_DECODE",
|
|
};
|
|
|
|
static int spi_busy = 0;
|
|
static uint8_t tx_rec[255];
|
|
static uint8_t rx_rec[255];
|
|
static uint8_t tx_pos;
|
|
static uint8_t rx_pos;
|
|
|
|
static void ADF7023_SetCommand_Assume_CMD_READY(unsigned char command);
|
|
|
|
void
|
|
hexdump(const void *data, size_t len)
|
|
{
|
|
size_t n;
|
|
if(len <= 0) {
|
|
return;
|
|
}
|
|
printf("%02x", ((const unsigned char *)data)[0]);
|
|
for(n = 1; n < len; n++) {
|
|
printf(" %02x", ((const unsigned char *)data)[n]);
|
|
}
|
|
}
|
|
void
|
|
ADF7023_SPI_Begin(void)
|
|
{
|
|
assert(spi_busy == 0);
|
|
spi_busy++;
|
|
|
|
tx_pos = 0;
|
|
rx_pos = 0;
|
|
|
|
ADF7023_CS_ASSERT;
|
|
}
|
|
void
|
|
ADF7023_SPI_End(void)
|
|
{
|
|
assert(spi_busy > 0);
|
|
spi_busy--;
|
|
ADF7023_CS_DEASSERT;
|
|
|
|
#if (ADF7023_VERBOSE >= 10)
|
|
printf("ADF7023_SPI_End(): wrote \"");
|
|
hexdump(tx_rec, tx_pos);
|
|
printf("\", read \"");
|
|
hexdump(rx_rec, rx_pos);
|
|
printf("\"." NEWLINE);
|
|
#endif
|
|
}
|
|
/***************************************************************************//**
|
|
* @brief Transfers one byte of data.
|
|
*
|
|
* @param writeByte - Write data.
|
|
* @param readByte - Read data.
|
|
*
|
|
* @return None.
|
|
*******************************************************************************/
|
|
void
|
|
ADF7023_WriteReadByte(unsigned char writeByte,
|
|
unsigned char *readByte)
|
|
{
|
|
unsigned char data = 0;
|
|
|
|
data = writeByte;
|
|
SPI_Read(ADF7023_SPI_BUS, 0, &data, 1);
|
|
if(readByte) {
|
|
*readByte = data;
|
|
}
|
|
|
|
assert(tx_pos < ARRAY_SIZE(tx_rec));
|
|
tx_rec[tx_pos] = writeByte;
|
|
tx_pos++;
|
|
|
|
assert(rx_pos < ARRAY_SIZE(rx_rec));
|
|
rx_rec[rx_pos] = data;
|
|
rx_pos++;
|
|
}
|
|
void
|
|
ADF7023_Wait_for_CMD_READY(void)
|
|
{
|
|
unsigned char status;
|
|
int counter = 0;
|
|
|
|
for(;;) {
|
|
break_loop();
|
|
|
|
ADF7023_GetStatus(&status);
|
|
|
|
if((status & STATUS_SPI_READY) == 0) {
|
|
/* The SPI bus is not ready. Continue polling the status word. */
|
|
continue;
|
|
}
|
|
|
|
if(status & STATUS_CMD_READY) {
|
|
/* The SPI bus is ready and CMD_READY == 1. This is the state we want. */
|
|
break;
|
|
}
|
|
|
|
if((status & STATUS_FW_STATE) == FW_STATE_PHY_OFF) {
|
|
/* SPI is ready, but CMD_READY == 0 and the radio is in state PHY_OFF. */
|
|
/* It seems that the ADF7023 gets stuck in this state sometimes (errata?), so transition to PHY_ON: */
|
|
ADF7023_SetCommand_Assume_CMD_READY(CMD_PHY_ON);
|
|
}
|
|
}
|
|
}
|
|
static void
|
|
ADF7023_Init_Procedure(void)
|
|
{
|
|
ADF7023_SPI_Begin();
|
|
ADF7023_While(!ADF7023_MISO, (void)0);
|
|
ADF7023_SPI_End();
|
|
ADF7023_Wait_for_CMD_READY();
|
|
}
|
|
/***************************************************************************//**
|
|
* @brief Initializes the ADF7023.
|
|
*
|
|
* @return retVal - Result of the initialization procedure.
|
|
* Example: 0 - if initialization was successful;
|
|
* -1 - if initialization was unsuccessful.
|
|
*******************************************************************************/
|
|
char
|
|
ADF7023_Init(void)
|
|
{
|
|
char retVal = 0;
|
|
|
|
ADF7023_CS_DEASSERT;
|
|
PM2 &= ~BIT(2); /* Configure ADF7023_CS as an output. */
|
|
|
|
ADF7023_BBRAMCurrent = ADF7023_BBRAMDefault;
|
|
SPI_Init(ADF7023_SPI_BUS,
|
|
0, /* MSB first. */
|
|
1000000, /* Clock frequency. */
|
|
0, /* Idle state for clock is a high level; active state is a low level. */
|
|
1); /* Serial output data changes on transition from idle clock state to active clock state. */
|
|
|
|
ADF7023_Init_Procedure();
|
|
|
|
ADF7023_SetCommand(CMD_HW_RESET);
|
|
clock_wait(MIN(CLOCK_SECOND / 1000, 1));
|
|
ADF7023_Init_Procedure();
|
|
|
|
ADF7023_SetRAM_And_Verify(0x100, 64, (unsigned char *)&ADF7023_BBRAMCurrent);
|
|
ADF7023_SetCommand(CMD_CONFIG_DEV);
|
|
|
|
return retVal;
|
|
}
|
|
/***************************************************************************//**
|
|
* @brief Reads the status word of the ADF7023.
|
|
*
|
|
* @param status - Status word.
|
|
*
|
|
* @return None.
|
|
*******************************************************************************/
|
|
void
|
|
ADF7023_GetStatus(unsigned char *status)
|
|
{
|
|
ADF7023_SPI_Begin();
|
|
ADF7023_WriteReadByte(SPI_NOP, 0);
|
|
ADF7023_WriteReadByte(SPI_NOP, status);
|
|
ADF7023_SPI_End();
|
|
|
|
#if (ADF7023_VERBOSE >= 7)
|
|
if(*status != status_old) {
|
|
printf("ADF7023_GetStatus: SPI_READY=%u, IRQ_STATUS=%u, CMD_READY=%u, FW_STATE=0x%02x",
|
|
(*status >> 7) & 1,
|
|
(*status >> 6) & 1,
|
|
(*status >> 5) & 1,
|
|
*status & STATUS_FW_STATE
|
|
);
|
|
if((*status & STATUS_FW_STATE) < ARRAY_SIZE(ADF7023_state_lookup)) {
|
|
printf("=\"%s\"", ADF7023_state_lookup[*status & STATUS_FW_STATE]);
|
|
}
|
|
printf("." NEWLINE);
|
|
status_old = *status;
|
|
}
|
|
#endif
|
|
}
|
|
static void
|
|
ADF7023_SetCommand_Assume_CMD_READY(unsigned char command)
|
|
{
|
|
#if (ADF7023_VERBOSE >= 7)
|
|
assert(ADF7023_cmd_lookup[command] != NULL);
|
|
printf("Sending command 0x%02x = \"%s\"." NEWLINE, command, ADF7023_cmd_lookup[command]);
|
|
#endif
|
|
ADF7023_SPI_Begin();
|
|
ADF7023_WriteReadByte(command, 0);
|
|
ADF7023_SPI_End();
|
|
}
|
|
/***************************************************************************//**
|
|
* @brief Initiates a command.
|
|
*
|
|
* @param command - Command.
|
|
*
|
|
* @return None.
|
|
*******************************************************************************/
|
|
void
|
|
ADF7023_SetCommand(unsigned char command)
|
|
{
|
|
ADF7023_Wait_for_CMD_READY();
|
|
ADF7023_SetCommand_Assume_CMD_READY(command);
|
|
}
|
|
void
|
|
ADF7023_SetFwState_NoWait(unsigned char fwState)
|
|
{
|
|
switch(fwState) {
|
|
case FW_STATE_PHY_OFF:
|
|
ADF7023_SetCommand(CMD_PHY_OFF);
|
|
break;
|
|
case FW_STATE_PHY_ON:
|
|
ADF7023_SetCommand(CMD_PHY_ON);
|
|
break;
|
|
case FW_STATE_PHY_RX:
|
|
ADF7023_SetCommand(CMD_PHY_RX);
|
|
break;
|
|
case FW_STATE_PHY_TX:
|
|
ADF7023_SetCommand(CMD_PHY_TX);
|
|
break;
|
|
default:
|
|
ADF7023_SetCommand(CMD_PHY_SLEEP);
|
|
}
|
|
}
|
|
/***************************************************************************//**
|
|
* @brief Sets a FW state and waits until the device enters in that state.
|
|
*
|
|
* @param fwState - FW state.
|
|
*
|
|
* @return None.
|
|
*******************************************************************************/
|
|
void
|
|
ADF7023_SetFwState(unsigned char fwState)
|
|
{
|
|
unsigned char status = 0;
|
|
ADF7023_SetFwState_NoWait(fwState);
|
|
ADF7023_While((status & STATUS_FW_STATE) != fwState, ADF7023_GetStatus(&status));
|
|
}
|
|
/***************************************************************************//**
|
|
* @brief Reads data from the RAM.
|
|
*
|
|
* @param address - Start address.
|
|
* @param length - Number of bytes to write.
|
|
* @param data - Read buffer.
|
|
*
|
|
* @return None.
|
|
*******************************************************************************/
|
|
void
|
|
ADF7023_GetRAM(unsigned long address,
|
|
unsigned long length,
|
|
unsigned char *data)
|
|
{
|
|
ADF7023_SPI_Begin();
|
|
ADF7023_WriteReadByte(SPI_MEM_RD | ((address & 0x700) >> 8), 0);
|
|
ADF7023_WriteReadByte(address & 0xFF, 0);
|
|
ADF7023_WriteReadByte(SPI_NOP, 0);
|
|
while(length--) {
|
|
ADF7023_WriteReadByte(SPI_NOP, data++);
|
|
}
|
|
ADF7023_SPI_End();
|
|
}
|
|
/***************************************************************************//**
|
|
* @brief Writes data to RAM.
|
|
*
|
|
* @param address - Start address.
|
|
* @param length - Number of bytes to write.
|
|
* @param data - Write buffer.
|
|
*
|
|
* @return None.
|
|
*******************************************************************************/
|
|
void
|
|
ADF7023_SetRAM(unsigned long address,
|
|
unsigned long length,
|
|
unsigned char *data)
|
|
{
|
|
ADF7023_Wait_for_CMD_READY();
|
|
|
|
ADF7023_SPI_Begin();
|
|
ADF7023_WriteReadByte(SPI_MEM_WR | ((address & 0x700) >> 8), 0);
|
|
ADF7023_WriteReadByte(address & 0xFF, 0);
|
|
while(length--) {
|
|
ADF7023_WriteReadByte(*(data++), 0);
|
|
}
|
|
ADF7023_SPI_End();
|
|
}
|
|
void
|
|
ADF7023_SetRAM_And_Verify(unsigned long address, unsigned long length, unsigned char *data)
|
|
{
|
|
unsigned char readback[256];
|
|
|
|
ADF7023_SetRAM(address, length, data);
|
|
|
|
assert(length <= sizeof(readback));
|
|
if(length > sizeof(readback)) {
|
|
return;
|
|
}
|
|
ADF7023_GetRAM(address, length, readback);
|
|
|
|
if(memcmp(data, readback, length)) {
|
|
printf("ADF7023_SetRAM_And_Verify failed. Wrote:" NEWLINE);
|
|
hexdump(data, length);
|
|
printf(NEWLINE "Read:" NEWLINE);
|
|
hexdump(readback, length);
|
|
printf(NEWLINE);
|
|
}
|
|
}
|
|
unsigned char
|
|
ADF7023_Wait_for_SPI_READY(void)
|
|
{
|
|
unsigned char status = 0;
|
|
ADF7023_While((status & STATUS_SPI_READY) == 0, ADF7023_GetStatus(&status));
|
|
return status; /* Return the status -- why not? */
|
|
}
|
|
void
|
|
ADF7023_PHY_ON(void)
|
|
{
|
|
unsigned char status;
|
|
unsigned int counter = 0;
|
|
|
|
for(;;) {
|
|
status = ADF7023_Wait_for_SPI_READY();
|
|
|
|
switch(status & STATUS_FW_STATE) {
|
|
default:
|
|
ADF7023_SetCommand(CMD_PHY_ON);
|
|
break;
|
|
|
|
case FW_STATE_BUSY:
|
|
/* Wait! */
|
|
break;
|
|
|
|
case FW_STATE_PHY_ON:
|
|
/* This is the desired state. */
|
|
return;
|
|
}
|
|
|
|
break_loop();
|
|
}
|
|
}
|
|
void
|
|
ADF7023_PHY_RX(void)
|
|
{
|
|
unsigned char status;
|
|
unsigned int counter = 0;
|
|
|
|
for(;;) {
|
|
status = ADF7023_Wait_for_SPI_READY();
|
|
|
|
switch(status & STATUS_FW_STATE) {
|
|
default:
|
|
/* Need to turn the PHY_ON. */
|
|
ADF7023_PHY_ON();
|
|
break;
|
|
|
|
case FW_STATE_BUSY:
|
|
/* Wait! */
|
|
break;
|
|
|
|
case FW_STATE_PHY_ON:
|
|
case FW_STATE_PHY_TX:
|
|
ADF7023_While((status & STATUS_CMD_READY) == 0, ADF7023_GetStatus(&status));
|
|
ADF7023_SetCommand(CMD_PHY_RX);
|
|
return;
|
|
|
|
case FW_STATE_PHY_RX:
|
|
/* This is the desired state. */
|
|
return;
|
|
}
|
|
|
|
break_loop();
|
|
}
|
|
}
|
|
void
|
|
ADF7023_PHY_TX(void)
|
|
{
|
|
unsigned char status;
|
|
unsigned int counter = 0;
|
|
|
|
for(;;) {
|
|
status = ADF7023_Wait_for_SPI_READY();
|
|
|
|
switch(status & STATUS_FW_STATE) {
|
|
default:
|
|
/* Need to turn the PHY_ON. */
|
|
ADF7023_PHY_ON();
|
|
break;
|
|
|
|
case FW_STATE_BUSY:
|
|
/* Wait! */
|
|
break;
|
|
|
|
case FW_STATE_PHY_ON:
|
|
case FW_STATE_PHY_RX:
|
|
ADF7023_While((status & STATUS_CMD_READY) == 0, ADF7023_GetStatus(&status));
|
|
ADF7023_SetCommand(CMD_PHY_TX);
|
|
return;
|
|
}
|
|
|
|
break_loop();
|
|
}
|
|
}
|
|
static unsigned char
|
|
ADF7023_ReadInterruptSource(void)
|
|
{
|
|
unsigned char interruptReg;
|
|
|
|
ADF7023_GetRAM(MCR_REG_INTERRUPT_SOURCE_0, 0x1, &interruptReg);
|
|
|
|
#if (ADF7023_VERBOSE >= 7)
|
|
if(interruptReg != int0_old) {
|
|
printf("ADF7023_ReadInterruptSource: %u%u%u%u%u%u%u%u." NEWLINE,
|
|
(interruptReg >> 7) & 1,
|
|
(interruptReg >> 6) & 1,
|
|
(interruptReg >> 5) & 1,
|
|
(interruptReg >> 4) & 1,
|
|
(interruptReg >> 3) & 1,
|
|
(interruptReg >> 2) & 1,
|
|
(interruptReg >> 1) & 1,
|
|
(interruptReg >> 0) & 1
|
|
);
|
|
int0_old = interruptReg;
|
|
}
|
|
#endif
|
|
return interruptReg;
|
|
}
|
|
unsigned char
|
|
ADF7023_ReceivePacketAvailable(void)
|
|
{
|
|
unsigned char status;
|
|
|
|
ADF7023_GetStatus(&status);
|
|
if((status & STATUS_SPI_READY) == 0) {
|
|
return false;
|
|
}
|
|
|
|
if((status & STATUS_FW_STATE) != FW_STATE_PHY_RX) {
|
|
ADF7023_PHY_RX();
|
|
return false;
|
|
}
|
|
|
|
if((status & STATUS_IRQ_STATUS) == 0) {
|
|
return false;
|
|
}
|
|
|
|
return ADF7023_ReadInterruptSource() & BBRAM_INTERRUPT_MASK_0_INTERRUPT_CRC_CORRECT;
|
|
}
|
|
/***************************************************************************//**
|
|
* @brief Receives one packet.
|
|
*
|
|
* @param packet - Data buffer.
|
|
* @param length - Number of received bytes.
|
|
*
|
|
* @return None.
|
|
*******************************************************************************/
|
|
void
|
|
ADF7023_ReceivePacket(unsigned char *packet, unsigned char *payload_length)
|
|
{
|
|
unsigned char length;
|
|
unsigned char interruptReg = 0;
|
|
|
|
ADF7023_While(!(interruptReg & BBRAM_INTERRUPT_MASK_0_INTERRUPT_CRC_CORRECT),
|
|
interruptReg = ADF7023_ReadInterruptSource());
|
|
|
|
interruptReg = BBRAM_INTERRUPT_MASK_0_INTERRUPT_CRC_CORRECT;
|
|
|
|
ADF7023_SetRAM(MCR_REG_INTERRUPT_SOURCE_0,
|
|
0x1,
|
|
&interruptReg);
|
|
|
|
ADF7023_GetRAM(ADF7023_RX_BASE_ADR, 1, &length);
|
|
|
|
*payload_length = length - 1 + LENGTH_OFFSET - 4;
|
|
|
|
ADF7023_GetRAM(ADF7023_RX_BASE_ADR + 1, *payload_length, packet);
|
|
|
|
#if (ADF7023_VERBOSE >= 5)
|
|
do {
|
|
unsigned char n;
|
|
printf("ADF7023_ReceivePacket, length=%u: ", *payload_length);
|
|
hexdump(packet, *payload_length);
|
|
printf(NEWLINE);
|
|
} while(false);
|
|
#endif
|
|
}
|
|
/***************************************************************************//**
|
|
* @brief Transmits one packet.
|
|
*
|
|
* @param packet - Data buffer.
|
|
* @param length - Number of bytes to transmit.
|
|
*
|
|
* @return None.
|
|
*******************************************************************************/
|
|
void
|
|
ADF7023_TransmitPacket(unsigned char *packet, unsigned char length)
|
|
{
|
|
unsigned char interruptReg = 0;
|
|
unsigned char status;
|
|
unsigned char length_plus_one;
|
|
|
|
for(;;) {
|
|
ADF7023_GetStatus(&status);
|
|
if((status & STATUS_SPI_READY) == 0) {
|
|
continue;
|
|
}
|
|
if((status & STATUS_CMD_READY) == 0) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
|
|
length_plus_one = length + 1;
|
|
ADF7023_SetRAM_And_Verify(ADF7023_TX_BASE_ADR, 1, &length_plus_one);
|
|
ADF7023_SetRAM_And_Verify(ADF7023_TX_BASE_ADR + 1, length, packet);
|
|
|
|
#if (ADF7023_VERBOSE >= 5)
|
|
do {
|
|
unsigned char n;
|
|
printf("ADF7023_TransmitPacket, length=%u: ", length);
|
|
hexdump(packet, length);
|
|
printf(NEWLINE);
|
|
} while(false);
|
|
#endif
|
|
|
|
ADF7023_PHY_TX();
|
|
|
|
ADF7023_While(!(interruptReg & BBRAM_INTERRUPT_MASK_0_INTERRUPT_TX_EOF),
|
|
ADF7023_GetRAM(MCR_REG_INTERRUPT_SOURCE_0, 0x1, &interruptReg));
|
|
|
|
ADF7023_PHY_RX();
|
|
}
|
|
/***************************************************************************//**
|
|
* @brief Sets the channel frequency.
|
|
*
|
|
* @param chFreq - Channel frequency.
|
|
*
|
|
* @return None.
|
|
*******************************************************************************/
|
|
void
|
|
ADF7023_SetChannelFrequency(unsigned long chFreq)
|
|
{
|
|
chFreq = (unsigned long)(((float)chFreq / 26000000) * 65535);
|
|
ADF7023_BBRAMCurrent.channelFreq0 = (chFreq & 0x0000FF) >> 0;
|
|
ADF7023_BBRAMCurrent.channelFreq1 = (chFreq & 0x00FF00) >> 8;
|
|
ADF7023_BBRAMCurrent.channelFreq2 = (chFreq & 0xFF0000) >> 16;
|
|
ADF7023_SetRAM_And_Verify(0x100, 64, (unsigned char *)&ADF7023_BBRAMCurrent);
|
|
}
|
|
/***************************************************************************//**
|
|
* @brief Sets the data rate.
|
|
*
|
|
* @param dataRate - Data rate.
|
|
*
|
|
* @return None.
|
|
*******************************************************************************/
|
|
void
|
|
ADF7023_SetDataRate(unsigned long dataRate)
|
|
{
|
|
dataRate = (unsigned long)(dataRate / 100);
|
|
ADF7023_BBRAMCurrent.radioCfg0 =
|
|
BBRAM_RADIO_CFG_0_DATA_RATE_7_0((dataRate & 0x00FF) >> 0);
|
|
ADF7023_BBRAMCurrent.radioCfg1 &= ~BBRAM_RADIO_CFG_1_DATA_RATE_11_8(0xF);
|
|
ADF7023_BBRAMCurrent.radioCfg1 |=
|
|
BBRAM_RADIO_CFG_1_DATA_RATE_11_8((dataRate & 0x0F00) >> 8);
|
|
ADF7023_SetRAM_And_Verify(0x100, 64, (unsigned char *)&ADF7023_BBRAMCurrent);
|
|
ADF7023_SetFwState(FW_STATE_PHY_OFF);
|
|
ADF7023_SetCommand(CMD_CONFIG_DEV);
|
|
}
|
|
/***************************************************************************//**
|
|
* @brief Sets the frequency deviation.
|
|
*
|
|
* @param freqDev - Frequency deviation.
|
|
*
|
|
* @return None.
|
|
*******************************************************************************/
|
|
void
|
|
ADF7023_SetFrequencyDeviation(unsigned long freqDev)
|
|
{
|
|
freqDev = (unsigned long)(freqDev / 100);
|
|
ADF7023_BBRAMCurrent.radioCfg1 &=
|
|
~BBRAM_RADIO_CFG_1_FREQ_DEVIATION_11_8(0xF);
|
|
ADF7023_BBRAMCurrent.radioCfg1 |=
|
|
BBRAM_RADIO_CFG_1_FREQ_DEVIATION_11_8((freqDev & 0x0F00) >> 8);
|
|
ADF7023_BBRAMCurrent.radioCfg2 =
|
|
BBRAM_RADIO_CFG_2_FREQ_DEVIATION_7_0((freqDev & 0x00FF) >> 0);
|
|
ADF7023_SetRAM_And_Verify(0x100, 64, (unsigned char *)&ADF7023_BBRAMCurrent);
|
|
ADF7023_SetFwState(FW_STATE_PHY_OFF);
|
|
ADF7023_SetCommand(CMD_CONFIG_DEV);
|
|
}
|