hey there, i have a project which uses nrf9151 with a pressures sensor from BOSCH which uses SENT protocol to transfer data, my question is
1. Is it possible to configure the SENT protocol on the nrf9151
2. if yes, how am i gonna configure what should i use?
#include <stdbool.h>
#include <stdint.h>
#include "nrf.h"
#include "nordic_common.h"
#include "boards.h"
#include "nrf_delay.h"
#include "nrf_log.h"
#include "nrf_log_ctrl.h"
#include "nrf_log_default_backends.h"
// SENT protocol
// SENT tick ranges from 3us to about 90us, with clock-rate tolerances as high as +-25%. Each
// nibble begins with a 5us logic low followed by a variable-width logic-high pulse
//
// A SENT message frame includes a sync signal followed by eight nibbles and an optional pause,
// the latter to make up fixed-length messages
// A nibble ranges from 12 to 27 ticks (representing 0x0 to 0xF), optional Pause is 12-768 ticks
// PPI channels 0-19 are programmable, channels 20-31 are fixed
#define PPI_SENT_SYNC 0 // Sync
#define PPI_SENT_STATUS 1 // Status
#define PPI_SENT_DN1 2 // DN1
#define PPI_SENT_DN2 3 // DN2
#define PPI_SENT_DN3 4 // DN3
#define PPI_SENT_DN4 5 // DN4
#define PPI_SENT_DN5 6 // DN5
#define PPI_SENT_DN6 7 // DN6
#define PPI_SENT_CRC 8 // CRC
#define PPI_SENT_PAUSE 9 // PAUSE
#define PPI_SENT_INPUT 10 // Input SENT signal
#define PPI_SENT_TEST_HI 11 // Test output SENT signal high level
#define PPI_SENT_TEST_LO 12 // Test output SENT signal low level
#define PPI_SENT_START 13 // Use Input SENT signal to start timers
// 8 GPIOTE channels available
#define GPIOTE_SENT_INPUT 0 // Input SENT signal
#define GPIOTE_SENT_TEST 1 // Test output SENT signal
// Port pins to test SENT using PWM on output pin connected to SENT input pin
#define PIN_SENT_INPUT 3 // Input SENT signal
#define PIN_SENT_TEST 4 // Test output SENT signal, connect to Input SENT signal
// TIMER0 is used by the RADIO, so don't use for now
#define SENT_TIMER_IRQn TIMER3_IRQn
static NRF_TIMER_Type * const pTimerSent = NRF_TIMER4; // 6 x CC
static NRF_TIMER_Type * const pCounterSent = NRF_TIMER3; // 6 x CC
// Sync is 56 Ticks, nibbles are between 12-27 Ticks
static const uint32_t SyncTicks = 56;
static const uint32_t Data0Ticks = 12;
static uint32_t PulseWidth[10];
static volatile uint32_t PulseTimes[10];
static void SentRxProtocolT2(void)
{
NRF_P0->OUTSET = (1 << PIN_SENT_INPUT);
NRF_P0->OUTSET = (1 << PIN_SENT_TEST);
// Configuration Direction Input Pullup Drive Level Sense Level
// ================================ ========== ============== ============ ============== =============
//NRF_P0->PIN_CNF[PIN_SENT_TEST] = (PIN_OUTPUT | PIN_CONNECT | PIN_PULLNONE | PIN_DRIVE_S0S1 | PIN_SENSE_OFF);
//NRF_P0->PIN_CNF[PIN_SENT_INPUT] = (PIN_INPUT | PIN_CONNECT | PIN_PULLUP | PIN_DRIVE_S0S1 | PIN_SENSE_LOW);
// Configuration for PIN_SENT_TEST (output)
NRF_P0->PIN_CNF[PIN_SENT_TEST] = (GPIO_PIN_CNF_DIR_Output << GPIO_PIN_CNF_DIR_Pos) |
(GPIO_PIN_CNF_INPUT_Connect << GPIO_PIN_CNF_INPUT_Pos) |
(GPIO_PIN_CNF_PULL_Disabled << GPIO_PIN_CNF_PULL_Pos) |
(GPIO_PIN_CNF_DRIVE_S0S1 << GPIO_PIN_CNF_DRIVE_Pos) |
(GPIO_PIN_CNF_SENSE_Disabled << GPIO_PIN_CNF_SENSE_Pos);
// Configuration for PIN_SENT_INPUT (input with pull-up)
NRF_P0->PIN_CNF[PIN_SENT_INPUT] = (GPIO_PIN_CNF_DIR_Input << GPIO_PIN_CNF_DIR_Pos) |
(GPIO_PIN_CNF_INPUT_Connect << GPIO_PIN_CNF_INPUT_Pos) |
(GPIO_PIN_CNF_PULL_Pullup << GPIO_PIN_CNF_PULL_Pos) |
(GPIO_PIN_CNF_DRIVE_S0S1 << GPIO_PIN_CNF_DRIVE_Pos) |
(GPIO_PIN_CNF_SENSE_Low << GPIO_PIN_CNF_SENSE_Pos);
// 32-bit timers
pTimerSent->MODE = TIMER_MODE_MODE_Timer;
pTimerSent->BITMODE = TIMER_BITMODE_BITMODE_32Bit << TIMER_BITMODE_BITMODE_Pos;
// 1us timer period
pTimerSent->PRESCALER = 0; // 16MHz timer clock
// Now clear timer registers
pTimerSent->TASKS_CLEAR = 1;
// 32-bit counters
pCounterSent->MODE = TIMER_MODE_MODE_Counter;
pCounterSent->BITMODE = TIMER_BITMODE_BITMODE_32Bit << TIMER_BITMODE_BITMODE_Pos;
// Prescaler not used in counter mode
pCounterSent->PRESCALER = 0;
// Enable IRQ on EVENTS_COMPARE[] 3 and 5
pCounterSent->INTENSET = (TIMER_INTENSET_COMPARE3_Enabled << TIMER_INTENSET_COMPARE3_Pos) |
(TIMER_INTENSET_COMPARE5_Enabled << TIMER_INTENSET_COMPARE5_Pos);
// Clear the counter when COMPARE5 event is triggered - doesn't work, so clear in interrupt
//pCounterSent->SHORTS = (TIMER_SHORTS_COMPARE5_CLEAR_Enabled << TIMER_SHORTS_COMPARE5_CLEAR_Pos);
// Set interrupt priority and enable interrupt
NVIC_SetPriority(SENT_TIMER_IRQn, 6);
NVIC_ClearPendingIRQ(SENT_TIMER_IRQn);
//nrf_delay_us(100);
NVIC_EnableIRQ(SENT_TIMER_IRQn);
// Configure input event for count on falling edge
NRF_GPIOTE->CONFIG[GPIOTE_SENT_INPUT] = GPIOTE_CONFIG_MODE_Event << GPIOTE_CONFIG_MODE_Pos |
GPIOTE_CONFIG_POLARITY_HiToLo << GPIOTE_CONFIG_POLARITY_Pos |
PIN_SENT_INPUT << GPIOTE_CONFIG_PSEL_Pos |
GPIOTE_CONFIG_OUTINIT_High << GPIOTE_CONFIG_OUTINIT_Pos;
// Configure test output task pin for use with PWM
NRF_GPIOTE->CONFIG[GPIOTE_SENT_TEST] = GPIOTE_CONFIG_MODE_Task << GPIOTE_CONFIG_MODE_Pos |
GPIOTE_CONFIG_POLARITY_LoToHi << GPIOTE_CONFIG_POLARITY_Pos |
PIN_SENT_TEST << GPIOTE_CONFIG_PSEL_Pos |
GPIOTE_CONFIG_OUTINIT_High << GPIOTE_CONFIG_OUTINIT_Pos;
// Count on falling edge of pulse via PPI
NRF_PPI->CH[PPI_SENT_INPUT].EEP = (uint32_t)&NRF_GPIOTE->EVENTS_IN[GPIOTE_SENT_INPUT];
NRF_PPI->CH[PPI_SENT_INPUT].TEP = (uint32_t)&pCounterSent->TASKS_COUNT;
// Start timers on falling edge of pulse via PPI
NRF_PPI->CH[PPI_SENT_START].EEP = (uint32_t)&NRF_GPIOTE->EVENTS_IN[GPIOTE_SENT_INPUT];
NRF_PPI->CH[PPI_SENT_START].TEP = (uint32_t)&pTimerSent->TASKS_START;
// Capture elapsed time on falling edge of compare count match via PPI
for (uint32_t CC_Index=0, PPI_Index=PPI_SENT_SYNC; CC_Index<6; CC_Index++, PPI_Index++)
{
// Clear edge time compare events
pTimerSent->CC[CC_Index] = 0;
// Set compare edge count events from 2 to 7
pCounterSent->CC[CC_Index] = CC_Index+2;
// Link edge event to time capture task
NRF_PPI->CH[PPI_Index].EEP = (uint32_t)&pCounterSent->EVENTS_COMPARE[CC_Index]; // Event
NRF_PPI->CH[PPI_Index].TEP = (uint32_t)&pTimerSent->TASKS_CAPTURE[CC_Index]; // Task
}
// Enable PPI channels
NRF_GPIOTE->EVENTS_PORT = 0;
NRF_PPI->CHENSET = (1UL << PPI_SENT_SYNC ) | // 0
(1UL << PPI_SENT_STATUS ) | // 1
(1UL << PPI_SENT_DN1 ) | // 2
(1UL << PPI_SENT_DN2 ) | // 3
(1UL << PPI_SENT_DN3 ) | // 4
(1UL << PPI_SENT_DN4 ) | // 5
(1UL << PPI_SENT_DN5 ) | // 6
(1UL << PPI_SENT_DN6 ) | // 7
(1UL << PPI_SENT_CRC ) | // 8
(1UL << PPI_SENT_PAUSE ) | // 9
(1UL << PPI_SENT_INPUT ) | // 10
(1UL << PPI_SENT_TEST_HI ) | // 11
(1UL << PPI_SENT_TEST_LO ) | // 12
(1UL << PPI_SENT_START);; // 13
// Now clear counter registers and start counters
pCounterSent->TASKS_CLEAR = 1;
pCounterSent->TASKS_START = 1;
// Uart test data at 230400 baud
uint8_t SentTestPacket[] = {0xFF,0xB7,0xEF,0xBB, 0x7F};
//
// 1 2 3 4 5 6 7 8 9 10 11 <== Falling edge number
// ! ! ! | ! ! ! ! ! ! ! <== Negative-going edges
// |-----0xFF-|| |-----0xB7-|| |-----0xEF-|| |-----0xBB-|| |-----0x7F-| <== uart 8-bit data
// 0 11111111 11 0 11101101 11 0 11110111 11 0 11011101 11 0 11111110 1 <== uart 10-bit data with start & stop, LSB first
// | 11 4 3 3 5 5 3 4 3 8 <== uart bit count between edges with start & stop
// | 691 276 207 207 345 345 207 276 207 552 <== Received 16MHz counts between edges
// | 56 22 16 16 27 27 16 22 16 44 <== Ticks Synch=56, data-12 to 27
// | | A 4 4 F F 4 A 4 | <== SENT decoded 8-bit data 0x0-0xF
// | | | | | | | | | | |
// | | | | | | | | | | +--- PAUSE Edge 11
// | | | | | | | | | +------------ CRC Edge 10
// | | | | | | | | +------------------- DN5 Edge 9
// | | | | | | | +----------------------- DN5 Edge 8
// | | | | | | +--------------------------- DN4 Edge 7
// | | | | | +------------------------------------ DN3 Edge 6
// | | | | +------------------------------------------ DN2 Edge 5
// | | | +------------------------------------------------- DN1 Edge 4
// | | +---------------------------------------------------- STATUS Edge 3
// | +--------------------------------------------------------- SYNC Edge 2
// +------------------------------------------------------------------------ START Edge 1 (if already started)
// Decodes as SENT data A44FF4A4
//
//uartSend(SentTestPacket, sizeof(SentTestPacket));
NRF_LOG_INFO("hehe\n");
// Sync is 56 Ticks, nibbles are between 12-27 Ticks
uint32_t SyncWidth = PulseTimes[0];
PulseWidth[0] = PulseTimes[0];
for (uint32_t i=1; i<sizeof(PulseTimes)/sizeof(PulseTimes[0]); i++)
{
PulseWidth[i] = PulseTimes[i] - PulseTimes[i-1];
NRF_LOG_INFO("Pulsewidth[%d] == %d\n", i, PulseWidth[i]);
}
// Calculate decoded SENT 4-bit nibbles
uint8_t Nibbles[9];
for (uint32_t i=0; i<sizeof(Nibbles)/sizeof(Nibbles[0]); i++)
{
Nibbles[i] = (uint8_t)(((PulseWidth[i+1] * SyncTicks)) / SyncWidth) - Data0Ticks;
NRF_LOG_INFO("Nibble[%d] == %d\n", i, Nibbles[i]);
}
// Stop before next repeat
pCounterSent->TASKS_STOP = 1;
pTimerSent->TASKS_STOP = 1;
__DSB();
// Errata: [78] TIMER: High current consumption when using timer STOP task only
// - Workaround: Use the SHUTDOWN task after the STOP task or instead of the STOP task
// - this also stops the Timer from hanging after a time change
// - affects nRF52832, nRF52840
pCounterSent->TASKS_SHUTDOWN = 1;
pTimerSent->TASKS_SHUTDOWN = 1;
// There is no STOPPED Event, and this register is read-only, so add a delay to ensure it is stopped before changes
__DSB();
while(1)
{
}
}
// Counter CC0-3 will be used twice
static volatile bool RepeatEdges = false;
// This IRQ handler will trigger every 3rd and 5th SENT falling edge
void TIMER3_IRQHandler(void)
{
// Every 3rd SENT negative-going edge
if (pCounterSent->EVENTS_COMPARE[3] == 1)
{
pCounterSent->EVENTS_COMPARE[0] = 0;
pCounterSent->EVENTS_COMPARE[1] = 0;
pCounterSent->EVENTS_COMPARE[2] = 0;
pCounterSent->EVENTS_COMPARE[3] = 0;
if (!RepeatEdges)
{
RepeatEdges = true;
PulseTimes[0] = pTimerSent->CC[0];
PulseTimes[1] = pTimerSent->CC[1];
PulseTimes[2] = pTimerSent->CC[2];
PulseTimes[3] = pTimerSent->CC[3];
// Set compare edge count events from 8 to 11
pCounterSent->CC[0] = 8;
pCounterSent->CC[1] = 9;
pCounterSent->CC[2] = 10;
pCounterSent->CC[3] = 11;
}
else
{
PulseTimes[6] = pTimerSent->CC[0];
PulseTimes[7] = pTimerSent->CC[1];
PulseTimes[8] = pTimerSent->CC[2];
PulseTimes[9] = pTimerSent->CC[3];
}
}
// Every 5th SENT negative-going edge
if (pCounterSent->EVENTS_COMPARE[5] == 1)
{
pCounterSent->EVENTS_COMPARE[4] = 0;
pCounterSent->EVENTS_COMPARE[5] = 0;
PulseTimes[4] = pTimerSent->CC[4];
PulseTimes[5] = pTimerSent->CC[5];
// This works whereas SHORTS clear doesn't ..
pCounterSent->TASKS_CLEAR;
}
__DSB();
}
int main(void)
{
APP_ERROR_CHECK(NRF_LOG_INIT(NULL));
NRF_LOG_DEFAULT_BACKENDS_INIT();
NRF_LOG_INFO("hello\n\n");
SentRxProtocolT2();
while (true)
{
NRF_LOG_INFO("hello\n\n");
nrf_delay_ms(500);
}
}
this is the signal i captured using logic analyzer. the signal above is continuous. this is from the sensor.