giomba/nes-proj
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Compiling and untested IEEE mode radio driver

Browse Source
This commit is contained in:
Edvard Pettersen 2018-02-14 17:56:35 +01:00
parent 2d198a7858
commit 7f813e8e0e
11 changed files with 1581 additions and 234 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
arch/cpu/simplelink/Makefile.simplelink
View File

@ -31,7 +31,9 @@ CFLAGS += -I$(SDK_KERNEL)/posix
LDFLAGS += --entry resetISR LDFLAGS += --entry resetISR
LDFLAGS += -static LDFLAGS += -static
LDFLAGS += --specs=nano.specs LDFLAGS += --specs=nano.specs
LDFLAGS += -Wl,--defsym=_stack_origin=__stack # NB! The symbol _stack, pointing to the stack start, is expected,
# but should already be defined in the linker script.
LDFLAGS += -Wl,--defsym=_stack_origin=__stack_end
LDFLAGS += -Wl,--defsym=_heap=__heap_start__ LDFLAGS += -Wl,--defsym=_heap=__heap_start__
LDFLAGS += -Wl,--defsym=_eheap=__heap_end__ LDFLAGS += -Wl,--defsym=_eheap=__heap_end__
@ -63,7 +65,9 @@ CONTIKI_CPU_DIRS += dev rf-settings
CONTIKI_CPU_SOURCEFILES += rtimer-arch.c clock-arch.c CONTIKI_CPU_SOURCEFILES += rtimer-arch.c clock-arch.c
CONTIKI_CPU_SOURCEFILES += watchdog-arch.c putchar-arch.c CONTIKI_CPU_SOURCEFILES += watchdog-arch.c putchar-arch.c
CONTIKI_CPU_SOURCEFILES += uart0-arch.c CONTIKI_CPU_SOURCEFILES += uart0-arch.c
CONTIKI_CPU_SOURCEFILES += proprietary-rf.c proprietary-rf-settings.c CONTIKI_CPU_SOURCEFILES += rf-core.c
CONTIKI_CPU_SOURCEFILES += rf-prop-mode.c rf-prop-settings.c
CONTIKI_CPU_SOURCEFILES += rf-ieee-mode.c rf-ieee-settings.c
CONTIKI_CPU_SOURCEFILES += ieee-addr.c CONTIKI_CPU_SOURCEFILES += ieee-addr.c
### CPU-dependent debug source files ### CPU-dependent debug source files

67
arch/cpu/simplelink/dev/proprietary-rf.h → arch/cpu/simplelink/dev/rf-core.c
View File

@ -1,5 +1,5 @@
/* /*
* Copyright (c) 2016, Texas Instruments Incorporated - http://www.ti.com/ * Copyright (c) 2015, Texas Instruments Incorporated - http://www.ti.com/
* All rights reserved. * All rights reserved.
* *
* Redistribution and use in source and binary forms, with or without * Redistribution and use in source and binary forms, with or without
@ -32,29 +32,58 @@
* \addtogroup rf-core * \addtogroup rf-core
* @{ * @{
* *
* \defgroup rf-core-prop CC13xx Prop mode driver
*
* @{
*
* \file * \file
* Header file for the CC13xx prop mode NETSTACK_RADIO driver * Implementation of the CC13xx/CC26xx RF core driver
*/ */
/*---------------------------------------------------------------------------*/ /*---------------------------------------------------------------------------*/
#ifndef PROP_MODE_H_
#define PROP_MODE_H_
/*---------------------------------------------------------------------------*/
#include "contiki.h" #include "contiki.h"
#include "dev/watchdog.h"
#include "sys/process.h"
#include "sys/clock.h"
#include "sys/ctimer.h"
#include "sys/energest.h"
#include "sys/cc.h"
#include "net/netstack.h"
#include "net/packetbuf.h"
/*---------------------------------------------------------------------------*/
#include <ti/drivers/rf/RF.h>
/*---------------------------------------------------------------------------*/
#include <stdint.h> #include <stdint.h>
#include <stdbool.h>
#include <stdio.h>
#include <string.h>
#include <assert.h>
/*---------------------------------------------------------------------------*/ /*---------------------------------------------------------------------------*/
typedef struct prop_mode_tx_power_config { #define DEBUG 0
radio_value_t dbm; #if DEBUG
uint16_t tx_power; /* Value for the PROP_DIV_RADIO_SETUP.txPower field */ #define PRINTF(...) printf(__VA_ARGS__)
} prop_mode_tx_power_config_t; #else
#define PRINTF(...)
#endif
/*---------------------------------------------------------------------------*/ /*---------------------------------------------------------------------------*/
#endif /* PROP_MODE_H_ */ PROCESS(RF_coreProcess, "SimpleLink RF driver");
/*---------------------------------------------------------------------------*/ /*---------------------------------------------------------------------------*/
/** PROCESS_THREAD(RF_coreProcess, ev, data)
* @} {
* @} int len;
*/
PROCESS_BEGIN();
while(1) {
PROCESS_YIELD_UNTIL(ev == PROCESS_EVENT_POLL);
do {
watchdog_periodic();
packetbuf_clear();
len = NETSTACK_RADIO.read(packetbuf_dataptr(), PACKETBUF_SIZE);
if(len > 0) {
packetbuf_set_datalen(len);
NETSTACK_MAC.input();
}
} while(len > 0);
}
PROCESS_END();
}
/*---------------------------------------------------------------------------*/
/** @} */

32
arch/cpu/simplelink/dev/rf-core.h
View File

@ -2,8 +2,36 @@
#define CONTIKI_NG_ARCH_CPU_SIMPLELINK_DEV_RF_CORE_H_ #define CONTIKI_NG_ARCH_CPU_SIMPLELINK_DEV_RF_CORE_H_
/*---------------------------------------------------------------------------*/ /*---------------------------------------------------------------------------*/
#define RF_CORE_CMD_ERROR 0 /* Contiki API */
#define RF_CORE_CMD_OK 1 #include <sys/rtimer.h>
#include <dev/radio.h>
/*---------------------------------------------------------------------------*/
#include <ti/drivers/rf/RF.h>
/*---------------------------------------------------------------------------*/
/* Standard library */
#include <stdint.h>
/*---------------------------------------------------------------------------*/
#ifdef RF_CORE_CONF_CHANNEL
# define RF_CORE_CHANNEL RF_CORE_CONF_CHANNEL
#else
# define RF_CORE_CHANNEL 25
#endif
/*---------------------------------------------------------------------------*/
typedef enum {
CMD_ERROR = 0,
CMD_OK = 1,
} CmdResult;
/*---------------------------------------------------------------------------*/
typedef struct {
radio_value_t dbm;
uint16_t power; /* Value for the PROP_DIV_RADIO_SETUP.txPower field */
} RF_TxPower;
#define TX_POWER_UNKNOWN 0xFFFF
/*---------------------------------------------------------------------------*/
#define RSSI_UNKNOWN -128
/*---------------------------------------------------------------------------*/
PROCESS_NAME(RF_coreProcess);
/*---------------------------------------------------------------------------*/ /*---------------------------------------------------------------------------*/
#endif /* CONTIKI_NG_ARCH_CPU_SIMPLELINK_DEV_RF_CORE_H_ */ #endif /* CONTIKI_NG_ARCH_CPU_SIMPLELINK_DEV_RF_CORE_H_ */

1095
arch/cpu/simplelink/dev/rf-ieee-mode.c Normal file
View File

File diff suppressed because it is too large Load Diff

321
arch/cpu/simplelink/dev/proprietary-rf.c → arch/cpu/simplelink/dev/rf-prop-mode.c
View File

@ -44,22 +44,19 @@
#include "sys/rtimer.h" #include "sys/rtimer.h"
#include "sys/cc.h" #include "sys/cc.h"
#include "dev/watchdog.h" #include "dev/watchdog.h"
#include "proprietary-rf.h"
#include "rf-core.h"
#include "dot-15-4g.h"
/*---------------------------------------------------------------------------*/
/* RF core and RF HAL API */
#include <inc/hw_rfc_dbell.h>
#include <inc/hw_rfc_pwr.h>
/*---------------------------------------------------------------------------*/ /*---------------------------------------------------------------------------*/
/* RF Core Mailbox API */ /* RF Core Mailbox API */
#include <driverlib/rf_mailbox.h> #include <driverlib/rf_mailbox.h>
#include <driverlib/rf_common_cmd.h> #include <driverlib/rf_common_cmd.h>
#include <driverlib/rf_data_entry.h> #include <driverlib/rf_data_entry.h>
#include <driverlib/rf_prop_mailbox.h>
#include <driverlib/rf_prop_cmd.h> #include <driverlib/rf_prop_cmd.h>
#include <rf-settings/proprietary-rf-settings.h> #include <driverlib/rf_prop_mailbox.h>
#include <ti/drivers/rf/RF.h> #include <ti/drivers/rf/RF.h>
#include <rf-settings/rf-prop-settings.h>
/*---------------------------------------------------------------------------*/
/* Platform RF dev */
#include "rf-core.h"
#include "dot-15-4g.h"
/*---------------------------------------------------------------------------*/ /*---------------------------------------------------------------------------*/
#include <stdint.h> #include <stdint.h>
#include <string.h> #include <string.h>
@ -67,20 +64,12 @@
#include <stdbool.h> #include <stdbool.h>
#include <assert.h> #include <assert.h>
/*---------------------------------------------------------------------------*/ /*---------------------------------------------------------------------------*/
#define DEBUG 0 #ifdef NDEBUG
#if DEBUG
#define PRINTF(...) printf(__VA_ARGS__)
#else
# define PRINTF(...) # define PRINTF(...)
#else
# define PRINTF(...) printf(__VA_ARGS__)
#endif #endif
/*---------------------------------------------------------------------------*/ /*---------------------------------------------------------------------------*/
/* Data entry status field constants */
#define DATA_ENTRY_STATUS_PENDING 0x00 /* Not in use by the Radio CPU */
#define DATA_ENTRY_STATUS_ACTIVE 0x01 /* Open for r/w by the radio CPU */
#define DATA_ENTRY_STATUS_BUSY 0x02 /* Ongoing r/w */
#define DATA_ENTRY_STATUS_FINISHED 0x03 /* Free to use and to free */
#define DATA_ENTRY_STATUS_UNFINISHED 0x04 /* Partial RX entry */
/*---------------------------------------------------------------------------*/
/* Data whitener. 1: Whitener, 0: No whitener */ /* Data whitener. 1: Whitener, 0: No whitener */
#ifdef PROP_MODE_CONF_DW #ifdef PROP_MODE_CONF_DW
# define PROP_MODE_DW PROP_MODE_CONF_DW # define PROP_MODE_DW PROP_MODE_CONF_DW
@ -169,14 +158,14 @@ static rfc_propRxOutput_t rx_stats;
#ifdef PROP_MODE_CONF_TX_POWER_431_527 #ifdef PROP_MODE_CONF_TX_POWER_431_527
#define PROP_MODE_TX_POWER_431_527 PROP_MODE_CONF_TX_POWER_431_527 #define PROP_MODE_TX_POWER_431_527 PROP_MODE_CONF_TX_POWER_431_527
#else #else
#define PROP_MODE_TX_POWER_431_527 prop_mode_tx_power_431_527 #define PROP_MODE_TX_POWER_431_527 RF_propTxPower431_527
#endif #endif
/*---------------------------------------------------------------------------*/ /*---------------------------------------------------------------------------*/
/* TX power table for the 779-930MHz band */ /* TX power table for the 779-930MHz band */
#ifdef PROP_MODE_CONF_TX_POWER_779_930 #ifdef PROP_MODE_CONF_TX_POWER_779_930
#define PROP_MODE_TX_POWER_779_930 PROP_MODE_CONF_TX_POWER_779_930 #define PROP_MODE_TX_POWER_779_930 PROP_MODE_CONF_TX_POWER_779_930
#else #else
#define PROP_MODE_TX_POWER_779_930 prop_mode_tx_power_779_930 #define PROP_MODE_TX_POWER_779_930 RF_propTxPower779_930
#endif #endif
/*---------------------------------------------------------------------------*/ /*---------------------------------------------------------------------------*/
/* Select power table based on the frequency band */ /* Select power table based on the frequency band */
@ -185,21 +174,12 @@ static rfc_propRxOutput_t rx_stats;
#else #else
#define TX_POWER_DRIVER PROP_MODE_TX_POWER_779_930 #define TX_POWER_DRIVER PROP_MODE_TX_POWER_779_930
#endif #endif
/*---------------------------------------------------------------------------*/
extern const prop_mode_tx_power_config_t TX_POWER_DRIVER[];
/* Max and Min Output Power in dBm */ /* Max and Min Output Power in dBm */
#define OUTPUT_POWER_MAX (TX_POWER_DRIVER[0].dbm) #define OUTPUT_POWER_MAX (TX_POWER_DRIVER[0].dbm)
#define OUTPUT_POWER_UNKNOWN 0xFFFF
/* Default TX Power - position in output_power[] */ /* Default TX Power - position in output_power[] */
static const prop_mode_tx_power_config_t *tx_power_current = &TX_POWER_DRIVER[1]; static const RF_TxPower *tx_power_current = &TX_POWER_DRIVER[0];
/*---------------------------------------------------------------------------*/
#ifdef PROP_MODE_CONF_LO_DIVIDER
#define PROP_MODE_LO_DIVIDER PROP_MODE_CONF_LO_DIVIDER
#else
#define PROP_MODE_LO_DIVIDER 0x05
#endif
/*---------------------------------------------------------------------------*/ /*---------------------------------------------------------------------------*/
#ifdef PROP_MODE_CONF_RX_BUF_CNT #ifdef PROP_MODE_CONF_RX_BUF_CNT
#define PROP_MODE_RX_BUF_CNT PROP_MODE_CONF_RX_BUF_CNT #define PROP_MODE_RX_BUF_CNT PROP_MODE_CONF_RX_BUF_CNT
@ -231,128 +211,110 @@ volatile static uint8_t *rx_read_entry;
static uint8_t tx_buf[TX_BUF_HDR_LEN + TX_BUF_PAYLOAD_LEN] CC_ALIGN(4); static uint8_t tx_buf[TX_BUF_HDR_LEN + TX_BUF_PAYLOAD_LEN] CC_ALIGN(4);
/*---------------------------------------------------------------------------*/ /*---------------------------------------------------------------------------*/
volatile static rfc_CMD_PROP_RADIO_DIV_SETUP_t *gvp_cmd_radio_div_setup = &rf_cmd_prop_radio_div_setup;
volatile static rfc_CMD_FS_t *gvp_cmd_fs = &rf_cmd_prop_fs;
volatile static rfc_CMD_PROP_TX_ADV_t *gvp_cmd_tx_adv = &rf_cmd_prop_tx_adv;
volatile static rfc_CMD_PROP_RX_ADV_t *gvp_cmd_rx_adv = &rf_cmd_prop_rx_adv;
/*---------------------------------------------------------------------------*/
/* RF driver */ /* RF driver */
static RF_Object rfObject; static RF_Object rfObject;
static RF_Handle rfHandle; static RF_Handle rfHandle;
static RF_CmdHandle rxCmdHandle = RF_ALLOC_ERROR;
/*---------------------------------------------------------------------------*/ /*---------------------------------------------------------------------------*/
PROCESS(rf_core_process, "CC13xx / CC26xx RF driver"); static inline bool rf_is_transmitting(void) { return gvp_cmd_tx_adv->status == ACTIVE; }
static inline bool rf_is_receiving(void) { return gvp_cmd_rx_adv->status == ACTIVE; }
static uint8_t static inline bool rf_is_on(void) { return rf_is_transmitting() || rf_is_receiving(); }
rf_transmitting(void)
{
return smartrf_settings_cmd_prop_tx_adv.status == ACTIVE;
}
/*---------------------------------------------------------------------------*/
static uint8_t
rf_receiving(void)
{
return smartrf_settings_cmd_prop_rx_adv.status == ACTIVE;
}
/*---------------------------------------------------------------------------*/
static uint8_t
rf_is_on(void)
{
return rf_receiving() | rf_transmitting();
}
/*---------------------------------------------------------------------------*/ /*---------------------------------------------------------------------------*/
static void static void
rf_rx_callback(RF_Handle client, RF_CmdHandle command, RF_EventMask events) rf_rx_callback(RF_Handle client, RF_CmdHandle command, RF_EventMask events)
{ {
if (events & RF_EventRxEntryDone) { if (events & RF_EventRxEntryDone) {
process_poll(&rf_core_process); process_poll(&RF_coreProcess);
} }
} }
/*---------------------------------------------------------------------------*/ /*---------------------------------------------------------------------------*/
static uint8_t static CmdResult
rf_start_rx() rf_start_rx()
{ {
rtimer_clock_t t0; gvp_cmd_rx_adv->status = IDLE;
volatile rfc_CMD_PROP_RX_ADV_t *cmd_rx_adv;
cmd_rx_adv = (rfc_CMD_PROP_RX_ADV_t *)&smartrf_settings_cmd_prop_rx_adv;
cmd_rx_adv->status = IDLE;
/* /*
* Set the max Packet length. This is for the payload only, therefore * Set the max Packet length. This is for the payload only, therefore
* 2047 - length offset * 2047 - length offset
*/ */
cmd_rx_adv->maxPktLen = DOT_4G_MAX_FRAME_LEN - cmd_rx_adv->lenOffset; gvp_cmd_rx_adv->maxPktLen = DOT_4G_MAX_FRAME_LEN - gvp_cmd_rx_adv->lenOffset;
rxCmdHandle = RF_postCmd(rfHandle, (RF_Op*)&smartrf_settings_cmd_prop_rx_adv, RF_PriorityNormal, &rf_rx_callback, RF_EventRxEntryDone); RF_CmdHandle rxCmdHandle = RF_postCmd(rfHandle, (RF_Op*)gvp_cmd_rx_adv, RF_PriorityNormal,
&rf_rx_callback, RF_EventRxEntryDone);
if (rxCmdHandle == RF_ALLOC_ERROR) { if (rxCmdHandle == RF_ALLOC_ERROR) {
return RF_CORE_CMD_ERROR; return CMD_ERROR;
} }
t0 = RTIMER_NOW();
while(cmd_rx_adv->status != ACTIVE &&
(RTIMER_CLOCK_LT(RTIMER_NOW(), t0 + ENTER_RX_WAIT_TIMEOUT)));
/* Wait to enter RX */ /* Wait to enter RX */
if(cmd_rx_adv->status != ACTIVE) { const rtimer_clock_t t0 = RTIMER_NOW();
PRINTF("rf_cmd_prop_rx: CMDSTA=0x%08lx, status=0x%04x\n", while (!rf_is_receiving() &&
md_status, cmd_rx_adv->status); (RTIMER_CLOCK_LT(RTIMER_NOW(), t0 + ENTER_RX_WAIT_TIMEOUT)));
if (!rf_is_receiving()) {
PRINTF("RF_cmdPropRxAdv: handle=0x%08lx, status=0x%04x\n",
(unsigned long)rxCmdHandle, gvp_cmd_rx_adv->status);
rf_switch_off(); rf_switch_off();
return RF_CORE_CMD_ERROR; return CMD_ERROR;
} }
return RF_CORE_CMD_OK; return CMD_OK;
} }
/*---------------------------------------------------------------------------*/ /*---------------------------------------------------------------------------*/
static int static CmdResult
rf_stop_rx(void) rf_stop_rx(void)
{ {
int ret;
/* If we are off, do nothing */ /* If we are off, do nothing */
if(!rf_receiving()) { if (!rf_is_receiving()) {
return RF_CORE_CMD_OK; return CMD_OK;
} }
/* Abort any ongoing operation. Don't care about the result. */ /* Abort any ongoing operation. Don't care about the result. */
RF_cancelCmd(rfHandle, RF_CMDHANDLE_FLUSH_ALL, 1); RF_cancelCmd(rfHandle, RF_CMDHANDLE_FLUSH_ALL, 1);
/* Todo: maybe do a RF_pendCmd() to synchronise with command execution. */ /* Todo: maybe do a RF_pendCmd() to synchronize with command execution. */
if(gvp_cmd_rx_adv->status != PROP_DONE_STOPPED &&
gvp_cmd_rx_adv->status != PROP_DONE_ABORT) {
PRINTF("RF_cmdPropRxAdv cancel: status=0x%04x\n",
gvp_cmd_rx_adv->status);
return CMD_ERROR;
}
if(smartrf_settings_cmd_prop_rx_adv.status == PROP_DONE_STOPPED ||
smartrf_settings_cmd_prop_rx_adv.status == PROP_DONE_ABORT) {
/* Stopped gracefully */ /* Stopped gracefully */
ENERGEST_OFF(ENERGEST_TYPE_LISTEN); ENERGEST_OFF(ENERGEST_TYPE_LISTEN);
ret = RF_CORE_CMD_OK; return CMD_OK;
} else {
PRINTF("rx_off_prop: status=0x%04x\n",
smartrf_settings_cmd_prop_rx_adv.status);
ret = RF_CORE_CMD_ERROR;
} }
/*---------------------------------------------------------------------------*/
return ret; static CmdResult
}/*---------------------------------------------------------------------------*/
static uint8_t
rf_run_setup() rf_run_setup()
{ {
RF_runCmd(rfHandle, (RF_Op*)&smartrf_settings_cmd_prop_radio_div_setup, RF_PriorityNormal, NULL, 0); RF_runCmd(rfHandle, (RF_Op*)gvp_cmd_radio_div_setup, RF_PriorityNormal, NULL, 0);
if (((volatile RF_Op*)&smartrf_settings_cmd_prop_radio_div_setup)->status != PROP_DONE_OK) { if (gvp_cmd_radio_div_setup->status != PROP_DONE_OK) {
return RF_CORE_CMD_ERROR; return CMD_ERROR;
} }
return RF_CORE_CMD_OK; return CMD_OK;
} }
/*---------------------------------------------------------------------------*/ /*---------------------------------------------------------------------------*/
static radio_value_t static radio_value_t
get_rssi(void) get_rssi(void)
{ {
int8_t rssi = RF_GET_RSSI_ERROR_VAL; if (rf_is_transmitting()) {
uint8_t was_off = 0; PRINTF("get_rssi: called while in TX\n");
return RF_GET_RSSI_ERROR_VAL;
if (rf_transmitting()) {
PRINTF("channel_clear: called while in TX\n");
return RF_CCA_CLEAR;
} else if (!rf_receiving()) {
was_off = 1;
rf_start_rx();
} }
const bool was_off = !rf_is_receiving();
if (was_off && rf_start_rx() == CMD_ERROR) {
PRINTF("get_rssi: unable to start RX\n");
return RF_GET_RSSI_ERROR_VAL;
}
int8_t rssi = RF_GET_RSSI_ERROR_VAL;
while(rssi == RF_GET_RSSI_ERROR_VAL || rssi == 0) { while(rssi == RF_GET_RSSI_ERROR_VAL || rssi == 0) {
rssi = RF_getRssi(rfHandle); rssi = RF_getRssi(rfHandle);
} }
@ -369,7 +331,7 @@ get_channel(void)
{ {
uint32_t freq_khz; uint32_t freq_khz;
freq_khz = smartrf_settings_cmd_prop_fs.frequency * 1000; freq_khz = gvp_cmd_fs->frequency * 1000;
/* /*
* For some channels, fractFreq * 1000 / 65536 will return 324.99xx. * For some channels, fractFreq * 1000 / 65536 will return 324.99xx.
@ -377,7 +339,7 @@ get_channel(void)
* function returning channel - 1 instead of channel. Thus, we do a quick * function returning channel - 1 instead of channel. Thus, we do a quick
* positive integer round up. * positive integer round up.
*/ */
freq_khz += (((smartrf_settings_cmd_prop_fs.fractFreq * 1000) + 65535) / 65536); freq_khz += (((gvp_cmd_fs->fractFreq * 1000) + 65535) / 65536);
return (freq_khz - DOT_15_4G_CHAN0_FREQUENCY) / DOT_15_4G_CHANNEL_SPACING; return (freq_khz - DOT_15_4G_CHAN0_FREQUENCY) / DOT_15_4G_CHANNEL_SPACING;
} }
@ -385,20 +347,17 @@ get_channel(void)
static void static void
set_channel(uint8_t channel) set_channel(uint8_t channel)
{ {
uint32_t new_freq; uint32_t new_freq = DOT_15_4G_CHAN0_FREQUENCY + (channel * DOT_15_4G_CHANNEL_SPACING);
uint16_t freq, frac;
new_freq = DOT_15_4G_CHAN0_FREQUENCY + (channel * DOT_15_4G_CHANNEL_SPACING); uint16_t freq = (uint16_t)(new_freq / 1000);
uint16_t frac = (new_freq - (freq * 1000)) * 65536 / 1000;
freq = (uint16_t)(new_freq / 1000); PRINTF("set_channel: %u = 0x%04x.0x%04x (%lu)\n",
frac = (new_freq - (freq * 1000)) * 65536 / 1000; channel, freq, frac, new_freq);
PRINTF("set_channel: %u = 0x%04x.0x%04x (%lu)\n", channel, freq, frac, gvp_cmd_radio_div_setup->centerFreq = freq;
new_freq); gvp_cmd_fs->frequency = freq;
gvp_cmd_fs->fractFreq = frac;
smartrf_settings_cmd_prop_radio_div_setup.centerFreq = freq;
smartrf_settings_cmd_prop_fs.frequency = freq;
smartrf_settings_cmd_prop_fs.fractFreq = frac;
// Todo: Need to re-run setup command when deviation from previous frequency // Todo: Need to re-run setup command when deviation from previous frequency
// is too large // is too large
@ -406,16 +365,16 @@ set_channel(uint8_t channel)
// We don't care whether the FS command is successful because subsequent // We don't care whether the FS command is successful because subsequent
// TX and RX commands will tell us indirectly. // TX and RX commands will tell us indirectly.
RF_postCmd(rfHandle, (RF_Op*)&smartrf_settings_cmd_prop_fs, RF_PriorityNormal, NULL, 0); RF_postCmd(rfHandle, (RF_Op*)gvp_cmd_fs, RF_PriorityNormal, NULL, 0);
} }
/*---------------------------------------------------------------------------*/ /*---------------------------------------------------------------------------*/
static uint8_t static size_t
get_tx_power_array_last_element(void) get_tx_power_array_last_element(void)
{ {
const prop_mode_tx_power_config_t *array = TX_POWER_DRIVER; const RF_TxPower *array = TX_POWER_DRIVER;
uint8_t count = 0; uint8_t count = 0;
while(array->tx_power != OUTPUT_POWER_UNKNOWN) { while(array->power != TX_POWER_UNKNOWN) {
count++; count++;
array++; array++;
} }
@ -434,21 +393,34 @@ get_tx_power(void)
* radio after calling this function. * radio after calling this function.
*/ */
static void static void
set_tx_power(radio_value_t power) set_tx_power(const radio_value_t power)
{ {
int i; if (power > OUTPUT_POWER_MAX)
{
for(i = get_tx_power_array_last_element(); i >= 0; --i) { tx_power_current = &TX_POWER_DRIVER[0];
if(power <= TX_POWER_DRIVER[i].dbm) {
/*
* Merely save the value. It will be used in all subsequent usages of
* CMD_PROP_RADIO_DIV_SETP, including one immediately after this function
* has returned
*/
tx_power_current = &TX_POWER_DRIVER[i];
return;
} }
else
{
size_t i;
for (i = 0; TX_POWER_DRIVER[i + 1].power != TX_POWER_UNKNOWN; ++i)
{
if (power > TX_POWER_DRIVER[i + 1].dbm)
{
break;
}
}
tx_power_current = &TX_POWER_DRIVER[i];
}
rfc_CMD_SET_TX_POWER_t cmd_set_tx_power;
memset(&cmd_set_tx_power, 0x00, sizeof(rfc_CMD_SET_TX_POWER_t));
cmd_set_tx_power.commandNo = CMD_SET_TX_POWER;
cmd_set_tx_power.txPower = tx_power_current->power;
RF_Stat stat = RF_runImmediateCmd(rfHandle, (uint32_t*)&cmd_set_tx_power);
if (stat != RF_StatCmdDoneSuccess) {
PRINTF("set_tx_power: stat=0x%02X\n", stat);
} }
} }
/*---------------------------------------------------------------------------*/ /*---------------------------------------------------------------------------*/
@ -460,7 +432,7 @@ init_rx_buffers(void)
for(i = 0; i < PROP_MODE_RX_BUF_CNT; i++) { for(i = 0; i < PROP_MODE_RX_BUF_CNT; i++) {
entry = (rfc_dataEntry_t *)rx_buf[i]; entry = (rfc_dataEntry_t *)rx_buf[i];
entry->status = DATA_ENTRY_STATUS_PENDING; entry->status = DATA_ENTRY_PENDING;
entry->config.type = DATA_ENTRY_TYPE_GEN; entry->config.type = DATA_ENTRY_TYPE_GEN;
entry->config.lenSz = DATA_ENTRY_LENSZ_WORD; entry->config.lenSz = DATA_ENTRY_LENSZ_WORD;
entry->length = RX_BUF_SIZE - 8; entry->length = RX_BUF_SIZE - 8;
@ -484,12 +456,11 @@ transmit(unsigned short transmit_len)
{ {
int ret; int ret;
uint8_t was_off = 0; uint8_t was_off = 0;
volatile rfc_CMD_PROP_TX_ADV_t *cmd_tx_adv;
if (rf_transmitting()) { if (rf_is_transmitting()) {
PRINTF("transmit: not allowed while transmitting\n"); PRINTF("transmit: not allowed while transmitting\n");
return RADIO_TX_ERR; return RADIO_TX_ERR;
} else if (rf_receiving()) { } else if (rf_is_receiving()) {
rf_stop_rx(); rf_stop_rx();
} else { } else {
was_off = 1; was_off = 1;
@ -511,18 +482,15 @@ transmit(unsigned short transmit_len)
tx_buf[0] = total_length & 0xFF; tx_buf[0] = total_length & 0xFF;
tx_buf[1] = (total_length >> 8) + DOT_4G_PHR_DW_BIT + DOT_4G_PHR_CRC_BIT; tx_buf[1] = (total_length >> 8) + DOT_4G_PHR_DW_BIT + DOT_4G_PHR_CRC_BIT;
/* Prepare the CMD_PROP_TX_ADV command */
cmd_tx_adv = (rfc_CMD_PROP_TX_ADV_t *)&smartrf_settings_cmd_prop_tx_adv;
/* /*
* pktLen: Total number of bytes in the TX buffer, including the header if * pktLen: Total number of bytes in the TX buffer, including the header if
* one exists, but not including the CRC (which is not present in the buffer) * one exists, but not including the CRC (which is not present in the buffer)
*/ */
cmd_tx_adv->pktLen = transmit_len + DOT_4G_PHR_LEN; gvp_cmd_tx_adv->pktLen = transmit_len + DOT_4G_PHR_LEN;
cmd_tx_adv->pPkt = tx_buf; gvp_cmd_tx_adv->pPkt = tx_buf;
// TODO: Register callback // TODO: Register callback
RF_runCmd(rfHandle, (RF_Op*)cmd_tx_adv, RF_PriorityNormal, NULL, 0); RF_runCmd(rfHandle, (RF_Op*)gvp_cmd_tx_adv, RF_PriorityNormal, NULL, 0);
// if (txHandle == RF_ALLOC_ERROR) // if (txHandle == RF_ALLOC_ERROR)
// { // {
// /* Failure sending the CMD_PROP_TX command */ // /* Failure sending the CMD_PROP_TX command */
@ -538,20 +506,20 @@ transmit(unsigned short transmit_len)
// /* Idle away while the command is running */ // /* Idle away while the command is running */
// RF_pendCmd(rfHandle, txHandle, RF_EventLastCmdDone); // RF_pendCmd(rfHandle, txHandle, RF_EventLastCmdDone);
if(cmd_tx_adv->status == PROP_DONE_OK) { if(gvp_cmd_tx_adv->status == PROP_DONE_OK) {
/* Sent OK */ /* Sent OK */
ret = RADIO_TX_OK; ret = RADIO_TX_OK;
} else { } else {
/* Operation completed, but frame was not sent */ /* Operation completed, but frame was not sent */
PRINTF("transmit: Not Sent OK status=0x%04x\n", PRINTF("transmit: Not Sent OK status=0x%04x\n",
cmd_tx_adv->status); gvp_cmd_tx_adv->status);
ret = RADIO_TX_ERR; ret = RADIO_TX_ERR;
} }
ENERGEST_OFF(ENERGEST_TYPE_TRANSMIT); ENERGEST_OFF(ENERGEST_TYPE_TRANSMIT);
/* Workaround. Set status to IDLE */ /* Workaround. Set status to IDLE */
cmd_tx_adv->status = IDLE; gvp_cmd_tx_adv->status = IDLE;
if (was_off) { if (was_off) {
RF_yield(rfHandle); RF_yield(rfHandle);
@ -576,7 +544,7 @@ read_frame(void *buf, unsigned short buf_len)
uint8_t *data_ptr = &entry->data; uint8_t *data_ptr = &entry->data;
int len = 0; int len = 0;
if(entry->status == DATA_ENTRY_STATUS_FINISHED) { if(entry->status == DATA_ENTRY_FINISHED) {
/* /*
* First 2 bytes in the data entry are the length. * First 2 bytes in the data entry are the length.
@ -598,7 +566,7 @@ read_frame(void *buf, unsigned short buf_len)
/* Move read entry pointer to next entry */ /* Move read entry pointer to next entry */
rx_read_entry = entry->pNextEntry; rx_read_entry = entry->pNextEntry;
entry->status = DATA_ENTRY_STATUS_PENDING; entry->status = DATA_ENTRY_PENDING;
} }
return len; return len;
@ -618,10 +586,10 @@ channel_clear(void)
// return RF_CCA_CLEAR; // return RF_CCA_CLEAR;
// } // }
if (rf_transmitting()) { if (rf_is_transmitting()) {
PRINTF("channel_clear: called while in TX\n"); PRINTF("channel_clear: called while in TX\n");
return RF_CCA_CLEAR; return RF_CCA_CLEAR;
} else if (!rf_receiving()) { } else if (!rf_is_receiving()) {
was_off = 1; was_off = 1;
rf_start_rx(); rf_start_rx();
} }
@ -644,7 +612,7 @@ channel_clear(void)
static int static int
receiving_packet(void) receiving_packet(void)
{ {
if(!rf_receiving()) { if(!rf_is_receiving()) {
return 0; return 0;
} }
@ -663,9 +631,9 @@ pending_packet(void)
/* Go through all RX buffers and check their status */ /* Go through all RX buffers and check their status */
do { do {
if(entry->status == DATA_ENTRY_STATUS_FINISHED) { if(entry->status == DATA_ENTRY_FINISHED) {
rv += 1; rv += 1;
process_poll(&rf_core_process); process_poll(&RF_coreProcess);
} }
entry = (rfc_dataEntry_t *)entry->pNextEntry; entry = (rfc_dataEntry_t *)entry->pNextEntry;
@ -690,7 +658,7 @@ rf_switch_off(void)
// * from within an interrupt context. Abort, but pretend everything is OK. // * from within an interrupt context. Abort, but pretend everything is OK.
// */ // */
// if(rf_ble_is_active() == RF_BLE_ACTIVE) { // if(rf_ble_is_active() == RF_BLE_ACTIVE) {
// return RF_CORE_CMD_OK; // return CMD_OK;
// } // }
// Force abort of any ongoing RF operation. // Force abort of any ongoing RF operation.
@ -700,9 +668,9 @@ rf_switch_off(void)
RF_yield(rfHandle); RF_yield(rfHandle);
/* We pulled the plug, so we need to restore the status manually */ /* We pulled the plug, so we need to restore the status manually */
smartrf_settings_cmd_prop_rx_adv.status = IDLE; gvp_cmd_rx_adv->status = IDLE;
return RF_CORE_CMD_OK; return CMD_OK;
} }
/*---------------------------------------------------------------------------*/ /*---------------------------------------------------------------------------*/
static radio_result_t static radio_result_t
@ -797,13 +765,13 @@ set_value(radio_param_t param, radio_value_t value)
} }
/* If we reach here we had no errors. Apply new settings */ /* If we reach here we had no errors. Apply new settings */
if (rf_receiving()) { if (rf_is_receiving()) {
rf_stop_rx(); rf_stop_rx();
if (rf_run_setup() != RF_CORE_CMD_OK) { if (rf_run_setup() != CMD_OK) {
return RADIO_RESULT_ERROR; return RADIO_RESULT_ERROR;
} }
rf_start_rx(); rf_start_rx();
} else if (rf_transmitting()) { } else if (rf_is_transmitting()) {
// Should not happen. TX is always synchronous and blocking. // Should not happen. TX is always synchronous and blocking.
// Todo: maybe remove completely here. // Todo: maybe remove completely here.
PRINTF("set_value: cannot apply new value while transmitting. \n"); PRINTF("set_value: cannot apply new value while transmitting. \n");
@ -833,10 +801,10 @@ rf_init(void)
{ {
RF_Params params; RF_Params params;
RF_Params_init(&params); RF_Params_init(&params);
params.nInactivityTimeout = 0; // disable automatic power-down // Disable automatic power-down just to not interfere with stack timing
// just to not interfere with stack timing params.nInactivityTimeout = 0;
rfHandle = RF_open(&rfObject, &RF_prop, (RF_RadioSetup*)&smartrf_settings_cmd_prop_radio_div_setup, &params); rfHandle = RF_open(&rfObject, &RF_propMode, (RF_RadioSetup*)gvp_cmd_radio_div_setup, &params);
assert(rfHandle != NULL); assert(rfHandle != NULL);
/* Initialise RX buffers */ /* Initialise RX buffers */
@ -849,39 +817,16 @@ rf_init(void)
/* Initialize current read pointer to first element (used in ISR) */ /* Initialize current read pointer to first element (used in ISR) */
rx_read_entry = rx_buf[0]; rx_read_entry = rx_buf[0];
smartrf_settings_cmd_prop_rx_adv.pQueue = &rx_data_queue; gvp_cmd_rx_adv->pQueue = &rx_data_queue;
smartrf_settings_cmd_prop_rx_adv.pOutput = (uint8_t *)&rx_stats; gvp_cmd_rx_adv->pOutput = (uint8_t *)&rx_stats;
set_channel(RF_CORE_CHANNEL); set_channel(RF_CORE_CHANNEL);
ENERGEST_ON(ENERGEST_TYPE_LISTEN); ENERGEST_ON(ENERGEST_TYPE_LISTEN);
process_start(&rf_core_process, NULL); process_start(&RF_coreProcess, NULL);
return 1; return CMD_OK;
}
/*---------------------------------------------------------------------------*/
PROCESS_THREAD(rf_core_process, ev, data)
{
int len;
PROCESS_BEGIN();
while(1) {
PROCESS_YIELD_UNTIL(ev == PROCESS_EVENT_POLL);
do {
watchdog_periodic();
packetbuf_clear();
len = NETSTACK_RADIO.read(packetbuf_dataptr(), PACKETBUF_SIZE);
if(len > 0) {
packetbuf_set_datalen(len);
NETSTACK_MAC.input();
}
} while(len > 0);
}
PROCESS_END();
} }
/*---------------------------------------------------------------------------*/ /*---------------------------------------------------------------------------*/
const struct radio_driver prop_mode_driver = { const struct radio_driver prop_mode_driver = {

5
arch/cpu/simplelink/dev/watchdog-arch.c
View File

@ -109,6 +109,7 @@ lock_config(uint32_t status)
void void
watchdog_init(void) watchdog_init(void)
{ {
return;
WatchdogReloadSet(CONTIKI_WATCHDOG_TIMER_TOP); WatchdogReloadSet(CONTIKI_WATCHDOG_TIMER_TOP);
lock_config(LOCK_REGISTERS_UNLOCKED); lock_config(LOCK_REGISTERS_UNLOCKED);
} }
@ -119,6 +120,7 @@ watchdog_init(void)
void void
watchdog_start(void) watchdog_start(void)
{ {
return;
uint32_t lock_status = unlock_config(); uint32_t lock_status = unlock_config();
watchdog_periodic(); watchdog_periodic();
@ -133,6 +135,7 @@ watchdog_start(void)
void void
watchdog_periodic(void) watchdog_periodic(void)
{ {
return;
WatchdogReloadSet(CONTIKI_WATCHDOG_TIMER_TOP); WatchdogReloadSet(CONTIKI_WATCHDOG_TIMER_TOP);
WatchdogIntClear(); WatchdogIntClear();
} }
@ -143,6 +146,7 @@ watchdog_periodic(void)
void void
watchdog_stop(void) watchdog_stop(void)
{ {
return;
uint32_t lock_status = unlock_config(); uint32_t lock_status = unlock_config();
WatchdogResetDisable(); WatchdogResetDisable();
@ -156,6 +160,7 @@ watchdog_stop(void)
void void
watchdog_reboot(void) watchdog_reboot(void)
{ {
return;
watchdog_start(); watchdog_start();
while(1); while(1);
} }

209
arch/cpu/simplelink/rf-settings/rf-ieee-settings.c Normal file
View File

@ -0,0 +1,209 @@
//*********************************************************************************
// Generated by SmartRF Studio version 2.8.0 ( build #41)
// Compatible with SimpleLink SDK version: CC13x2 SDK 1.60.xx.xx
// Device: CC1352 Rev. 1.0
//
//*********************************************************************************
//*********************************************************************************
// Parameter summary
// IEEE Channel: 11
// Frequency: 2405 MHz
// SFD: 0
// Preamble (32 bit): 01010101...
// TX Power: 5 dBm
#include <ti/devices/DeviceFamily.h>
#include DeviceFamily_constructPath(driverlib/rf_mailbox.h)
#include DeviceFamily_constructPath(driverlib/rf_common_cmd.h)
#include DeviceFamily_constructPath(driverlib/rf_ieee_cmd.h)
#include <ti/drivers/rf/RF.h>
#include DeviceFamily_constructPath(rf_patches/rf_patch_cpe_ieee_802_15_4.h)
#include DeviceFamily_constructPath(rf_patches/rf_patch_mce_ieee_802_15_4.h)
#include <contiki.h>
#include <dev/radio.h>
#include "rf-core.h"
/*---------------------------------------------------------------------------*/
/* Default TX power settings for the 2.4 GHz band */
RF_TxPower RF_ieeeTxPower[] = {
{ 5, 0x9330 },
{ 4, 0x9324 },
{ 3, 0x5a1c },
{ 2, 0x4e18 },
{ 1, 0x4214 },
{ 0, 0x3161 },
{ -3, 0x2558 },
{ -6, 0x1d52 },
{ -9, 0x194e },
{ -12, 0x144b },
{ -15, 0x0ccb },
{ -18, 0x0cc9 },
{ -21, 0x0cc7 },
{-128, 0xFFFF },
};
const size_t RF_ieeeTxPowerLen = sizeof(RF_ieeeTxPower) / sizeof(RF_ieeeTxPower[0]);
// TI-RTOS RF Mode Object
RF_Mode RF_ieeeMode =
{
.rfMode = RF_MODE_AUTO,
.cpePatchFxn = &rf_patch_cpe_ieee_802_15_4,
.mcePatchFxn = &rf_patch_mce_ieee_802_15_4,
.rfePatchFxn = 0,
};
// Overrides for CMD_RADIO_SETUP
static uint32_t pOverrides[] =
{
// override_use_patch_ieee_802_15_4.xml
// PHY: Use MCE RAM patch, RFE ROM bank 1
MCE_RFE_OVERRIDE(1,0,0,0,1,0),
// override_synth_ieee_802_15_4.xml
// Synth: Use 48 MHz crystal
(uint32_t)0x00408403,
// override_dcdc_rx_tx_common.xml
// DC/DC regulator: In Tx, use DCDCCTL5[3:0]=0xC (DITHER_EN=1 and IPEAK=4). In Rx, use DCDCCTL5[3:0]=0xC (DITHER_EN=1 and IPEAK=4).
(uint32_t)0xFCFC08C3,
(uint32_t)0xFFFFFFFF,
};
// CMD_RADIO_SETUP
// Radio Setup Command for Pre-Defined Schemes
rfc_CMD_RADIO_SETUP_t RF_cmdRadioSetup =
{
.commandNo = 0x0802,
.status = 0x0000,
.pNextOp = 0, // INSERT APPLICABLE POINTER: (uint8_t*)&xxx
.startTime = 0x00000000,
.startTrigger.triggerType = 0x0,
.startTrigger.bEnaCmd = 0x0,
.startTrigger.triggerNo = 0x0,
.startTrigger.pastTrig = 0x0,
.condition.rule = 0x1,
.condition.nSkip = 0x0,
.mode = 0x01,
.loDivider = 0x00,
.config.frontEndMode = 0x0,
.config.biasMode = 0x0,
.config.analogCfgMode = 0x0,
.config.bNoFsPowerUp = 0x0,
.txPower = 0x001F,
.pRegOverride = pOverrides,
};
// CMD_FS
// Frequency Synthesizer Programming Command
rfc_CMD_FS_t RF_cmdFs =
{
.commandNo = 0x0803,
.status = 0x0000,
.pNextOp = 0, // INSERT APPLICABLE POINTER: (uint8_t*)&xxx
.startTime = 0x00000000,
.startTrigger.triggerType = 0x0,
.startTrigger.bEnaCmd = 0x0,
.startTrigger.triggerNo = 0x0,
.startTrigger.pastTrig = 0x0,
.condition.rule = 0x1,
.condition.nSkip = 0x0,
.frequency = 0x0965,
.fractFreq = 0x0000,
.synthConf.bTxMode = 0x0,
.synthConf.refFreq = 0x0,
.__dummy0 = 0x00,
.__dummy1 = 0x00,
.__dummy2 = 0x00,
.__dummy3 = 0x0000,
};
// CMD_IEEE_RX
// IEEE 802.15.4 Receive Command
rfc_CMD_IEEE_RX_t RF_cmdIeeeRx =
{
.commandNo = CMD_IEEE_RX,
.status = IDLE,
.pNextOp = NULL,
.startTime = 0x00000000,
.startTrigger.triggerType = TRIG_NOW,
.condition.rule = COND_NEVER,
.channel = 0,
.rxConfig.bAutoFlushCrc = 0x1,
.rxConfig.bAutoFlushIgn = 0x0,
.rxConfig.bIncludePhyHdr = 0x0,
.rxConfig.bIncludeCrc = 0x1,
.rxConfig.bAppendRssi = 0x1,
.rxConfig.bAppendCorrCrc = 0x1,
.rxConfig.bAppendSrcInd = 0x0,
.rxConfig.bAppendTimestamp = 0x1,
.pRxQ = NULL,
.pOutput = NULL,
.frameFiltOpt.frameFiltEn = 0x0,
.frameFiltOpt.frameFiltStop = 0x1,
.frameFiltOpt.autoAckEn = 0x0,
.frameFiltOpt.slottedAckEn = 0x0,
.frameFiltOpt.autoPendEn = 0x0,
.frameFiltOpt.defaultPend = 0x0,
.frameFiltOpt.bPendDataReqOnly = 0x0,
.frameFiltOpt.bPanCoord = 0x0,
.frameFiltOpt.maxFrameVersion = 0x2,
.frameFiltOpt.bStrictLenFilter = 0x0,
.frameTypes.bAcceptFt0Beacon = 0x1,
.frameTypes.bAcceptFt1Data = 0x1,
.frameTypes.bAcceptFt2Ack = 0x1,
.frameTypes.bAcceptFt3MacCmd = 0x1,
.frameTypes.bAcceptFt4Reserved = 0x1,
.frameTypes.bAcceptFt5Reserved = 0x1,
.frameTypes.bAcceptFt6Reserved = 0x1,
.frameTypes.bAcceptFt7Reserved = 0x1,
.ccaOpt.ccaEnEnergy = 0x1,
.ccaOpt.ccaEnCorr = 0x1,
.ccaOpt.ccaEnSync = 0x1,
.ccaOpt.ccaCorrOp = 0x1,
.ccaOpt.ccaSyncOp = 0x0,
.ccaOpt.ccaCorrThr = 0x3,
.ccaRssiThr = 0x64,
.numExtEntries = 0x00,
.numShortEntries = 0x00,
.pExtEntryList = NULL,
.pShortEntryList = NULL,
.localExtAddr = 0x0000000012345678,
.localShortAddr = 0xABBA,
.localPanID = 0x0000,
.endTrigger.triggerType = TRIG_NEVER,
.endTrigger.bEnaCmd = 0x0,
.endTrigger.triggerNo = 0x0,
.endTrigger.pastTrig = 0x0,
.endTime = 0x00000000,
};
// CMD_IEEE_TX
// IEEE 802.15.4 Transmit Command
rfc_CMD_IEEE_TX_t RF_cmdIeeeTx =
{
.commandNo = 0x2C01,
.status = 0x0000,
.pNextOp = 0, // INSERT APPLICABLE POINTER: (uint8_t*)&xxx
.startTime = 0x00000000,
.startTrigger.triggerType = 0x0,
.startTrigger.bEnaCmd = 0x0,
.startTrigger.triggerNo = 0x0,
.startTrigger.pastTrig = 0x0,
.condition.rule = 0x1,
.condition.nSkip = 0x0,
.txOpt.bIncludePhyHdr = 0x0,
.txOpt.bIncludeCrc = 0x0,
.txOpt.payloadLenMsb = 0x0,
.payloadLen = 0x1E,
.pPayload = 0, // INSERT APPLICABLE POINTER: (uint8_t*)&xxx
.timeStamp = 0x00000000,
};

26
arch/cpu/simplelink/rf-settings/rf-ieee-settings.h Normal file
View File

@ -0,0 +1,26 @@
#ifndef IEEE_SETTINGS_H_
#define IEEE_SETTINGS_H_
#include <ti/devices/DeviceFamily.h>
#include DeviceFamily_constructPath(driverlib/rf_mailbox.h)
#include DeviceFamily_constructPath(driverlib/rf_common_cmd.h)
#include DeviceFamily_constructPath(driverlib/rf_prop_cmd.h)
#include <ti/drivers/rf/RF.h>
#include <rf-core.h>
// RF TX power table
extern RF_TxPower RF_ieeeTxPower[];
extern const size_t RF_ieeeTxPowerLen;
// TI-RTOS RF Mode Object
extern RF_Mode RF_ieeeMode;
// RF Core API commands
extern rfc_CMD_RADIO_SETUP_t RF_cmdRadioSetup;
extern rfc_CMD_FS_t RF_cmdFs;
extern rfc_CMD_IEEE_RX_t RF_cmdIeeeRx;
extern rfc_CMD_IEEE_TX_t RF_cmdIeeeTx;
#endif /* IEEE_SETTINGS_H_ */

22
arch/cpu/simplelink/rf-settings/proprietary-rf-settings.c → arch/cpu/simplelink/rf-settings/rf-prop-settings.c
View File

@ -34,11 +34,11 @@
#include DeviceFamily_constructPath(rf_patches/rf_patch_cpe_prop.h) #include DeviceFamily_constructPath(rf_patches/rf_patch_cpe_prop.h)
#include DeviceFamily_constructPath(rf_patches/rf_patch_rfe_genfsk.h) #include DeviceFamily_constructPath(rf_patches/rf_patch_rfe_genfsk.h)
#include DeviceFamily_constructPath(rf_patches/rf_patch_mce_genfsk.h) #include DeviceFamily_constructPath(rf_patches/rf_patch_mce_genfsk.h)
#include "proprietary-rf-settings.h"
#include "contiki.h" #include <contiki.h>
#include "dev/radio.h" #include <dev/radio.h>
#include <proprietary-rf.h>
#include "rf-core.h"
/*---------------------------------------------------------------------------*/ /*---------------------------------------------------------------------------*/
/** /**
@ -52,7 +52,7 @@
/*---------------------------------------------------------------------------*/ /*---------------------------------------------------------------------------*/
/* Default TX power settings for the 779-930MHz band */ /* Default TX power settings for the 779-930MHz band */
const prop_mode_tx_power_config_t prop_mode_tx_power_779_930[] = { RF_TxPower RF_propTxPower779_930[] = {
{ 14, 0xa73f }, { 14, 0xa73f },
{ 13, 0xa63f }, /* 12.5 */ { 13, 0xa63f }, /* 12.5 */
{ 12, 0xb818 }, { 12, 0xb818 },
@ -73,7 +73,7 @@ const prop_mode_tx_power_config_t prop_mode_tx_power_779_930[] = {
}; };
/*---------------------------------------------------------------------------*/ /*---------------------------------------------------------------------------*/
/* Default TX power settings for the 431-527MHz band */ /* Default TX power settings for the 431-527MHz band */
const prop_mode_tx_power_config_t prop_mode_tx_power_431_527[] = { RF_TxPower RF_propTxPower431_527[] = {
{ 15, 0x003f }, { 15, 0x003f },
{ 14, 0xbe3f }, /* 13.7 */ { 14, 0xbe3f }, /* 13.7 */
{ 13, 0x6a0f }, { 13, 0x6a0f },
@ -87,7 +87,7 @@ const prop_mode_tx_power_config_t prop_mode_tx_power_431_527[] = {
*/ */
// TI-RTOS RF Mode Object // TI-RTOS RF Mode Object
RF_Mode RF_prop = RF_Mode RF_propMode =
{ {
.rfMode = RF_MODE_AUTO, .rfMode = RF_MODE_AUTO,
.cpePatchFxn = &rf_patch_cpe_prop, .cpePatchFxn = &rf_patch_cpe_prop,
@ -136,7 +136,7 @@ static uint32_t pOverrides[] =
// CMD_PROP_RADIO_DIV_SETUP // CMD_PROP_RADIO_DIV_SETUP
// Proprietary Mode Radio Setup Command for All Frequency Bands // Proprietary Mode Radio Setup Command for All Frequency Bands
rfc_CMD_PROP_RADIO_DIV_SETUP_t smartrf_settings_cmd_prop_radio_div_setup = rfc_CMD_PROP_RADIO_DIV_SETUP_t rf_cmd_prop_radio_div_setup =
{ {
.commandNo = 0x3807, .commandNo = 0x3807,
.status = 0x0000, .status = 0x0000,
@ -175,7 +175,7 @@ rfc_CMD_PROP_RADIO_DIV_SETUP_t smartrf_settings_cmd_prop_radio_div_setup =
// CMD_FS // CMD_FS
// Frequency Synthesizer Programming Command // Frequency Synthesizer Programming Command
rfc_CMD_FS_t smartrf_settings_cmd_prop_fs = rfc_CMD_FS_t rf_cmd_prop_fs =
{ {
.commandNo = 0x0803, .commandNo = 0x0803,
.status = 0x0000, .status = 0x0000,
@ -198,7 +198,7 @@ rfc_CMD_FS_t smartrf_settings_cmd_prop_fs =
}; };
/* CMD_PROP_TX_ADV */ /* CMD_PROP_TX_ADV */
rfc_CMD_PROP_TX_ADV_t smartrf_settings_cmd_prop_tx_adv = rfc_CMD_PROP_TX_ADV_t rf_cmd_prop_tx_adv =
{ {
.commandNo = 0x3803, .commandNo = 0x3803,
.status = 0x0000, .status = 0x0000,
@ -229,7 +229,7 @@ rfc_CMD_PROP_TX_ADV_t smartrf_settings_cmd_prop_tx_adv =
}; };
/*---------------------------------------------------------------------------*/ /*---------------------------------------------------------------------------*/
/* CMD_PROP_RX_ADV */ /* CMD_PROP_RX_ADV */
rfc_CMD_PROP_RX_ADV_t smartrf_settings_cmd_prop_rx_adv = rfc_CMD_PROP_RX_ADV_t rf_cmd_prop_rx_adv =
{ {
.commandNo = 0x3804, .commandNo = 0x3804,
.status = 0x0000, .status = 0x0000,

23
arch/cpu/simplelink/rf-settings/proprietary-rf-settings.h → arch/cpu/simplelink/rf-settings/rf-prop-settings.h
View File

@ -1,5 +1,5 @@
#ifndef _PROPRIETARY_RF_SETTINGS_H_ #ifndef RF_PROP_SETTINGS_H_
#define _PROPRIETARY_RF_SETTINGS_H_ #define RF_PROP_SETTINGS_H_
//********************************************************************************* //*********************************************************************************
// Generated by SmartRF Studio version 2.8.0 ( build #41) // Generated by SmartRF Studio version 2.8.0 ( build #41)
@ -13,15 +13,20 @@
#include DeviceFamily_constructPath(driverlib/rf_prop_cmd.h) #include DeviceFamily_constructPath(driverlib/rf_prop_cmd.h)
#include <ti/drivers/rf/RF.h> #include <ti/drivers/rf/RF.h>
#include <rf-core.h>
// RF TX power table
extern RF_TxPower RF_propTxPower779_930[];
extern RF_TxPower RF_propTxPower431_527[];
// TI-RTOS RF Mode Object // TI-RTOS RF Mode Object
extern RF_Mode RF_prop; extern RF_Mode RF_propMode;
// RF Core API commands // RF Core API commands
extern rfc_CMD_PROP_RADIO_DIV_SETUP_t smartrf_settings_cmd_prop_radio_div_setup; extern rfc_CMD_PROP_RADIO_DIV_SETUP_t rf_cmd_prop_radio_div_setup;
extern rfc_CMD_FS_t smartrf_settings_cmd_prop_fs; extern rfc_CMD_FS_t rf_cmd_prop_fs;
extern rfc_CMD_PROP_TX_ADV_t smartrf_settings_cmd_prop_tx_adv; extern rfc_CMD_PROP_TX_ADV_t rf_cmd_prop_tx_adv;
extern rfc_CMD_PROP_RX_ADV_t smartrf_settings_cmd_prop_rx_adv; extern rfc_CMD_PROP_RX_ADV_t rf_cmd_prop_rx_adv;
#endif // _PROPRIETARY_RF_SETTINGS_H_ #endif /* RF_PROP_SETTINGS_H_ */

1
arch/platform/simplelink/platform.c
View File

@ -60,6 +60,7 @@
#include "leds.h" #include "leds.h"
//#include "gpio-interrupt.h" //#include "gpio-interrupt.h"
#include "ieee-addr.h" #include "ieee-addr.h"
#include "dev/rf-core.h"
#include "uart0-arch.h" #include "uart0-arch.h"
#include "sys/clock.h" #include "sys/clock.h"
#include "sys/rtimer.h" #include "sys/rtimer.h"