Devin Alexander / Mbed OS Low_Power_Long_Distance_IR_Vision_Robot

This is example code that can get you started with building your own IR vision robot that communicates over LoRa

Dependencies:   Adafruit-MotorShield Adafruit-PWM-Servo-Driver Adafruit_GFX BufferedSerial MAX17055_EZconfig NEO-6m-GPS SX1276GenericLib USBDeviceHT max32630fthr max77650_charger_sample

Fork of MAX326xxFTHR_LoRa_Example_test by Devin Alexander

SX1276GenericPingPong/GenericPingPong.cpp@27:6b549f838f0a, 2018-07-20 (annotated)

Committer:
dev_alexander
Date:
Fri Jul 20 21:29:53 2018 +0000
Revision:
27:6b549f838f0a
Parent:
26:69aba05f010f
Child:
28:0ed92c590607
Trying to unify how the buffers were loaded and unloaded seemed to have broke how the buffer on the MAX32630FTHR. It was working much better when the buffers were loaded in the main(). I am probably going to revert to the previous method.

Who changed what in which revision?

UserRevisionLine numberNew contents of line
Helmut64 0:c43b6919ae15 1 /*
Helmut64 0:c43b6919ae15 2 * This file contains a copy of the master content sx1276PingPong
Helmut64 0:c43b6919ae15 3 * with adaption for the SX1276Generic environment
Helmut64 0:c43b6919ae15 4 * (c) 2017 Helmut Tschemernjak
Helmut64 0:c43b6919ae15 5 * 30826 Garbsen (Hannover) Germany
Helmut64 0:c43b6919ae15 6 */
Helmut64 0:c43b6919ae15 7
Helmut64 0:c43b6919ae15 8 #include "mbed.h"
Helmut64 0:c43b6919ae15 9 #include "PinMap.h"
Helmut64 0:c43b6919ae15 10 #include "GenericPingPong.h"
Helmut64 0:c43b6919ae15 11 #include "sx1276-mbed-hal.h"
Helmut64 0:c43b6919ae15 12 #include "main.h"
dev_alexander 24:e8d03912f303 13 #include "global_buffers.h"
Helmut64 0:c43b6919ae15 14
Helmut64 0:c43b6919ae15 15 #ifdef FEATURE_LORA
Helmut64 0:c43b6919ae15 16
Helmut64 0:c43b6919ae15 17 /* Set this flag to '1' to display debug messages on the console */
Helmut64 0:c43b6919ae15 18 #define DEBUG_MESSAGE 1
Helmut64 0:c43b6919ae15 19
Helmut64 0:c43b6919ae15 20 /* Set this flag to '1' to use the LoRa modulation or to '0' to use FSK modulation */
Helmut64 0:c43b6919ae15 21 #define USE_MODEM_LORA 1
Helmut64 0:c43b6919ae15 22 #define USE_MODEM_FSK !USE_MODEM_LORA
dev_alexander 19:9f035b9e65ec 23 #define RF_FREQUENCY RF_FREQUENCY_915_0 // Hz
Helmut64 0:c43b6919ae15 24 #define TX_OUTPUT_POWER 14 // 14 dBm
Helmut64 0:c43b6919ae15 25
Helmut64 0:c43b6919ae15 26 #if USE_MODEM_LORA == 1
Helmut64 0:c43b6919ae15 27
Helmut64 7:6a8a82bfb0c6 28 #define LORA_BANDWIDTH 125000 // LoRa default, details in SX1276::BandwidthMap
Helmut64 0:c43b6919ae15 29 #define LORA_SPREADING_FACTOR LORA_SF7
Helmut64 0:c43b6919ae15 30 #define LORA_CODINGRATE LORA_ERROR_CODING_RATE_4_5
Helmut64 0:c43b6919ae15 31
Helmut64 0:c43b6919ae15 32 #define LORA_PREAMBLE_LENGTH 8 // Same for Tx and Rx
Helmut64 0:c43b6919ae15 33 #define LORA_SYMBOL_TIMEOUT 5 // Symbols
Helmut64 0:c43b6919ae15 34 #define LORA_FIX_LENGTH_PAYLOAD_ON false
Helmut64 0:c43b6919ae15 35 #define LORA_FHSS_ENABLED false
Helmut64 0:c43b6919ae15 36 #define LORA_NB_SYMB_HOP 4
Helmut64 0:c43b6919ae15 37 #define LORA_IQ_INVERSION_ON false
Helmut64 0:c43b6919ae15 38 #define LORA_CRC_ENABLED true
Helmut64 0:c43b6919ae15 39
Helmut64 0:c43b6919ae15 40 #elif USE_MODEM_FSK == 1
Helmut64 0:c43b6919ae15 41
Helmut64 0:c43b6919ae15 42 #define FSK_FDEV 25000 // Hz
Helmut64 0:c43b6919ae15 43 #define FSK_DATARATE 19200 // bps
Helmut64 0:c43b6919ae15 44 #define FSK_BANDWIDTH 50000 // Hz
Helmut64 0:c43b6919ae15 45 #define FSK_AFC_BANDWIDTH 83333 // Hz
Helmut64 0:c43b6919ae15 46 #define FSK_PREAMBLE_LENGTH 5 // Same for Tx and Rx
Helmut64 0:c43b6919ae15 47 #define FSK_FIX_LENGTH_PAYLOAD_ON false
Helmut64 0:c43b6919ae15 48 #define FSK_CRC_ENABLED true
Helmut64 0:c43b6919ae15 49
Helmut64 0:c43b6919ae15 50 #else
Helmut64 0:c43b6919ae15 51 #error "Please define a modem in the compiler options."
Helmut64 0:c43b6919ae15 52 #endif
Helmut64 0:c43b6919ae15 53
Helmut64 0:c43b6919ae15 54
Helmut64 0:c43b6919ae15 55 #define RX_TIMEOUT_VALUE 3500 // in ms
Helmut64 0:c43b6919ae15 56
dev_alexander 24:e8d03912f303 57 //#define BUFFER_SIZE 64 // Define the payload size here
Helmut64 0:c43b6919ae15 58
Helmut64 0:c43b6919ae15 59 /*
Helmut64 0:c43b6919ae15 60 * Global variables declarations
Helmut64 0:c43b6919ae15 61 */
Helmut64 0:c43b6919ae15 62 typedef enum
Helmut64 0:c43b6919ae15 63 {
Helmut64 0:c43b6919ae15 64 LOWPOWER = 0,
Helmut64 0:c43b6919ae15 65 IDLE,
Helmut64 0:c43b6919ae15 66
Helmut64 0:c43b6919ae15 67 RX,
Helmut64 0:c43b6919ae15 68 RX_TIMEOUT,
Helmut64 0:c43b6919ae15 69 RX_ERROR,
Helmut64 0:c43b6919ae15 70
Helmut64 0:c43b6919ae15 71 TX,
Helmut64 0:c43b6919ae15 72 TX_TIMEOUT,
Helmut64 0:c43b6919ae15 73
Helmut64 0:c43b6919ae15 74 CAD,
Helmut64 0:c43b6919ae15 75 CAD_DONE
Helmut64 0:c43b6919ae15 76 } AppStates_t;
Helmut64 0:c43b6919ae15 77
Helmut64 0:c43b6919ae15 78 volatile AppStates_t State = LOWPOWER;
Helmut64 0:c43b6919ae15 79
Helmut64 0:c43b6919ae15 80 /*!
Helmut64 0:c43b6919ae15 81 * Radio events function pointer
Helmut64 0:c43b6919ae15 82 */
Helmut64 0:c43b6919ae15 83 static RadioEvents_t RadioEvents;
Helmut64 0:c43b6919ae15 84
Helmut64 0:c43b6919ae15 85 /*
Helmut64 0:c43b6919ae15 86 * Global variables declarations
Helmut64 0:c43b6919ae15 87 */
Helmut64 0:c43b6919ae15 88 SX1276Generic *Radio;
Helmut64 0:c43b6919ae15 89
dev_alexander 27:6b549f838f0a 90
dev_alexander 27:6b549f838f0a 91 uint8_t * BufferTxAlias;
dev_alexander 27:6b549f838f0a 92 uint8_t * BufferRxAlias;
Helmut64 0:c43b6919ae15 93
Helmut64 0:c43b6919ae15 94 DigitalOut *led3;
Helmut64 0:c43b6919ae15 95
Helmut64 0:c43b6919ae15 96
dev_alexander 26:69aba05f010f 97 int SX1276PingPongSetup(uint8_t * PointerToBufferTx, uint8_t * PointerToBufferRx)
Helmut64 0:c43b6919ae15 98 {
dev_alexander 19:9f035b9e65ec 99 dprintf("TEST" );
Helmut64 0:c43b6919ae15 100 #if( defined ( TARGET_KL25Z ) || defined ( TARGET_LPC11U6X ) )
Helmut64 0:c43b6919ae15 101 DigitalOut *led = new DigitalOut(LED2);
Helmut64 13:5a32a1922fbc 102 #elif defined(TARGET_NUCLEO_L073RZ) || defined(TARGET_DISCO_L072CZ_LRWAN1)
Helmut64 0:c43b6919ae15 103 DigitalOut *led = new DigitalOut(LED4); // RX red
Helmut64 0:c43b6919ae15 104 led3 = new DigitalOut(LED3); // TX blue
Helmut64 0:c43b6919ae15 105 #else
Helmut64 0:c43b6919ae15 106 DigitalOut *led = new DigitalOut(LED1);
Helmut64 0:c43b6919ae15 107 led3 = led;
Helmut64 0:c43b6919ae15 108 #endif
Helmut64 0:c43b6919ae15 109
dev_alexander 26:69aba05f010f 110 /* Store aliases of pointers that were passed in that are pointeres to buffers that
dev_alexander 26:69aba05f010f 111 * exist in the main program. The BufferTx is used in the SX1276PingPong function below
dev_alexander 26:69aba05f010f 112 * when sending a buffer to the other microcontroller. The BufferRx is what holds
dev_alexander 26:69aba05f010f 113 * data from a message that is received.
dev_alexander 26:69aba05f010f 114 */
dev_alexander 27:6b549f838f0a 115 BufferTxAlias = PointerToBufferTx;
dev_alexander 27:6b549f838f0a 116 BufferRxAlias = PointerToBufferRx;
Helmut64 0:c43b6919ae15 117 *led3 = 1;
Helmut64 0:c43b6919ae15 118
Helmut64 0:c43b6919ae15 119 #ifdef B_L072Z_LRWAN1_LORA
Helmut64 0:c43b6919ae15 120 Radio = new SX1276Generic(NULL, MURATA_SX1276,
Helmut64 0:c43b6919ae15 121 LORA_SPI_MOSI, LORA_SPI_MISO, LORA_SPI_SCLK, LORA_CS, LORA_RESET,
Helmut64 0:c43b6919ae15 122 LORA_DIO0, LORA_DIO1, LORA_DIO2, LORA_DIO3, LORA_DIO4, LORA_DIO5,
Helmut64 0:c43b6919ae15 123 LORA_ANT_RX, LORA_ANT_TX, LORA_ANT_BOOST, LORA_TCXO);
Helmut64 0:c43b6919ae15 124 #else // RFM95
Helmut64 0:c43b6919ae15 125 Radio = new SX1276Generic(NULL, RFM95_SX1276,
Helmut64 0:c43b6919ae15 126 LORA_SPI_MOSI, LORA_SPI_MISO, LORA_SPI_SCLK, LORA_CS, LORA_RESET,
Helmut64 0:c43b6919ae15 127 LORA_DIO0, LORA_DIO1, LORA_DIO2, LORA_DIO3, LORA_DIO4, LORA_DIO5);
Helmut64 0:c43b6919ae15 128
Helmut64 0:c43b6919ae15 129 #endif
Helmut64 0:c43b6919ae15 130
Helmut64 0:c43b6919ae15 131 dprintf("SX1276 Ping Pong Demo Application" );
Helmut64 0:c43b6919ae15 132 dprintf("Freqency: %.1f", (double)RF_FREQUENCY/1000000.0);
Helmut64 0:c43b6919ae15 133 dprintf("TXPower: %d dBm", TX_OUTPUT_POWER);
Helmut64 0:c43b6919ae15 134 #if USE_MODEM_LORA == 1
Helmut64 8:3b0d7b4ff28f 135 dprintf("Bandwidth: %d Hz", LORA_BANDWIDTH);
Helmut64 0:c43b6919ae15 136 dprintf("Spreading factor: SF%d", LORA_SPREADING_FACTOR);
Helmut64 0:c43b6919ae15 137 #elif USE_MODEM_FSK == 1
Helmut64 0:c43b6919ae15 138 dprintf("Bandwidth: %d kHz", FSK_BANDWIDTH);
Helmut64 0:c43b6919ae15 139 dprintf("Baudrate: %d", FSK_DATARATE);
Helmut64 0:c43b6919ae15 140 #endif
Helmut64 0:c43b6919ae15 141 // Initialize Radio driver
Helmut64 0:c43b6919ae15 142 RadioEvents.TxDone = OnTxDone;
Helmut64 0:c43b6919ae15 143 RadioEvents.RxDone = OnRxDone;
Helmut64 0:c43b6919ae15 144 RadioEvents.RxError = OnRxError;
Helmut64 0:c43b6919ae15 145 RadioEvents.TxTimeout = OnTxTimeout;
Helmut64 6:1b598b0e52e4 146 RadioEvents.RxTimeout = OnRxTimeout;
Helmut64 6:1b598b0e52e4 147 if (Radio->Init( &RadioEvents ) == false) {
Helmut64 6:1b598b0e52e4 148 while(1) {
Helmut64 6:1b598b0e52e4 149 dprintf("Radio could not be detected!");
Helmut64 6:1b598b0e52e4 150 wait( 1 );
Helmut64 6:1b598b0e52e4 151 }
Helmut64 0:c43b6919ae15 152 }
Helmut64 6:1b598b0e52e4 153
Helmut64 0:c43b6919ae15 154
Helmut64 0:c43b6919ae15 155 switch(Radio->DetectBoardType()) {
Helmut64 0:c43b6919ae15 156 case SX1276MB1LAS:
Helmut64 0:c43b6919ae15 157 if (DEBUG_MESSAGE)
Helmut64 0:c43b6919ae15 158 dprintf(" > Board Type: SX1276MB1LAS <");
Helmut64 0:c43b6919ae15 159 break;
Helmut64 0:c43b6919ae15 160 case SX1276MB1MAS:
Helmut64 0:c43b6919ae15 161 if (DEBUG_MESSAGE)
Helmut64 0:c43b6919ae15 162 dprintf(" > Board Type: SX1276MB1LAS <");
Helmut64 0:c43b6919ae15 163 case MURATA_SX1276:
Helmut64 0:c43b6919ae15 164 if (DEBUG_MESSAGE)
Helmut64 0:c43b6919ae15 165 dprintf(" > Board Type: MURATA_SX1276_STM32L0 <");
Helmut64 0:c43b6919ae15 166 break;
Helmut64 0:c43b6919ae15 167 case RFM95_SX1276:
Helmut64 0:c43b6919ae15 168 if (DEBUG_MESSAGE)
Helmut64 0:c43b6919ae15 169 dprintf(" > HopeRF RFM95xx <");
Helmut64 0:c43b6919ae15 170 break;
Helmut64 0:c43b6919ae15 171 default:
Helmut64 0:c43b6919ae15 172 dprintf(" > Board Type: unknown <");
Helmut64 0:c43b6919ae15 173 }
Helmut64 0:c43b6919ae15 174
Helmut64 0:c43b6919ae15 175 Radio->SetChannel(RF_FREQUENCY );
Helmut64 0:c43b6919ae15 176
Helmut64 0:c43b6919ae15 177 #if USE_MODEM_LORA == 1
Helmut64 0:c43b6919ae15 178
Helmut64 0:c43b6919ae15 179 if (LORA_FHSS_ENABLED)
Helmut64 0:c43b6919ae15 180 dprintf(" > LORA FHSS Mode <");
Helmut64 0:c43b6919ae15 181 if (!LORA_FHSS_ENABLED)
Helmut64 0:c43b6919ae15 182 dprintf(" > LORA Mode <");
dev_alexander 25:1a031add188a 183
dev_alexander 25:1a031add188a 184
dev_alexander 25:1a031add188a 185 // Without this line, the default max payload length is only 64 bytes
dev_alexander 25:1a031add188a 186 Radio->SetMaxPayloadLength(MODEM_LORA, 255);
Helmut64 0:c43b6919ae15 187
Helmut64 0:c43b6919ae15 188 Radio->SetTxConfig( MODEM_LORA, TX_OUTPUT_POWER, 0, LORA_BANDWIDTH,
Helmut64 0:c43b6919ae15 189 LORA_SPREADING_FACTOR, LORA_CODINGRATE,
Helmut64 0:c43b6919ae15 190 LORA_PREAMBLE_LENGTH, LORA_FIX_LENGTH_PAYLOAD_ON,
Helmut64 0:c43b6919ae15 191 LORA_CRC_ENABLED, LORA_FHSS_ENABLED, LORA_NB_SYMB_HOP,
Helmut64 0:c43b6919ae15 192 LORA_IQ_INVERSION_ON, 2000 );
Helmut64 0:c43b6919ae15 193
Helmut64 0:c43b6919ae15 194 Radio->SetRxConfig( MODEM_LORA, LORA_BANDWIDTH, LORA_SPREADING_FACTOR,
Helmut64 0:c43b6919ae15 195 LORA_CODINGRATE, 0, LORA_PREAMBLE_LENGTH,
Helmut64 0:c43b6919ae15 196 LORA_SYMBOL_TIMEOUT, LORA_FIX_LENGTH_PAYLOAD_ON, 0,
Helmut64 0:c43b6919ae15 197 LORA_CRC_ENABLED, LORA_FHSS_ENABLED, LORA_NB_SYMB_HOP,
Helmut64 0:c43b6919ae15 198 LORA_IQ_INVERSION_ON, true );
Helmut64 0:c43b6919ae15 199
Helmut64 0:c43b6919ae15 200 #elif USE_MODEM_FSK == 1
Helmut64 0:c43b6919ae15 201
Helmut64 0:c43b6919ae15 202 dprintf(" > FSK Mode <");
Helmut64 0:c43b6919ae15 203 Radio->SetTxConfig( MODEM_FSK, TX_OUTPUT_POWER, FSK_FDEV, 0,
Helmut64 0:c43b6919ae15 204 FSK_DATARATE, 0,
Helmut64 0:c43b6919ae15 205 FSK_PREAMBLE_LENGTH, FSK_FIX_LENGTH_PAYLOAD_ON,
Helmut64 0:c43b6919ae15 206 FSK_CRC_ENABLED, 0, 0, 0, 2000 );
Helmut64 0:c43b6919ae15 207
Helmut64 0:c43b6919ae15 208 Radio->SetRxConfig( MODEM_FSK, FSK_BANDWIDTH, FSK_DATARATE,
Helmut64 0:c43b6919ae15 209 0, FSK_AFC_BANDWIDTH, FSK_PREAMBLE_LENGTH,
Helmut64 0:c43b6919ae15 210 0, FSK_FIX_LENGTH_PAYLOAD_ON, 0, FSK_CRC_ENABLED,
Helmut64 0:c43b6919ae15 211 0, 0, false, true );
Helmut64 0:c43b6919ae15 212
Helmut64 0:c43b6919ae15 213 #else
Helmut64 0:c43b6919ae15 214
Helmut64 0:c43b6919ae15 215 #error "Please define a modem in the compiler options."
Helmut64 0:c43b6919ae15 216
Helmut64 0:c43b6919ae15 217 #endif
Helmut64 0:c43b6919ae15 218
Helmut64 0:c43b6919ae15 219 if (DEBUG_MESSAGE)
Helmut64 0:c43b6919ae15 220 dprintf("Starting Ping-Pong loop");
Helmut64 0:c43b6919ae15 221
Helmut64 0:c43b6919ae15 222
Helmut64 0:c43b6919ae15 223 Radio->Rx( RX_TIMEOUT_VALUE );
dev_alexander 25:1a031add188a 224
dev_alexander 22:abca9d17d13d 225 }
dev_alexander 22:abca9d17d13d 226
dev_alexander 25:1a031add188a 227 /****************************************************************************************************************************************
dev_alexander 25:1a031add188a 228 *
dev_alexander 25:1a031add188a 229 ****************************************************************************************************************************************/
dev_alexander 22:abca9d17d13d 230 int SX1276PingPong(void)
dev_alexander 22:abca9d17d13d 231 {
dev_alexander 22:abca9d17d13d 232 #if defined(TARGET_MAX32630FTHR) // Master Device: Bluetooth Gateway
dev_alexander 22:abca9d17d13d 233 bool isMaster = true;
dev_alexander 23:f74a50977593 234 #elif defined(TARGET_MAX32620FTHR) // Slave Device: Robot
dev_alexander 22:abca9d17d13d 235 bool isMaster = false;
Helmut64 0:c43b6919ae15 236 #endif
dev_alexander 25:1a031add188a 237
dev_alexander 22:abca9d17d13d 238 switch( State )
dev_alexander 22:abca9d17d13d 239 {
dev_alexander 22:abca9d17d13d 240 case RX:
dev_alexander 26:69aba05f010f 241 *led3 = 0;
dev_alexander 22:abca9d17d13d 242 if( isMaster == true )
Helmut64 0:c43b6919ae15 243 {
dev_alexander 24:e8d03912f303 244 if( BufferSizeRx > 0 )
Helmut64 0:c43b6919ae15 245 {
dev_alexander 27:6b549f838f0a 246 if( memcmp(&BufferRxAlias[rx_idx_signature], PongMsg, sizeof(PongMsg)) == 0 )
Helmut64 0:c43b6919ae15 247 {
dev_alexander 22:abca9d17d13d 248 // *led = !*led;
dev_alexander 22:abca9d17d13d 249 dprintf( "...Pong" );
dev_alexander 22:abca9d17d13d 250 // Send the next PING frame
dev_alexander 25:1a031add188a 251 // memcpy(BufferTx, PingMsg, sizeof(PingMsg));
dev_alexander 25:1a031add188a 252 /*
dev_alexander 22:abca9d17d13d 253 // We fill the buffer with numbers for the payload
dev_alexander 24:e8d03912f303 254 for( i = sizeof(PingMsg); i < BufferSizeTx; i++ )
Helmut64 0:c43b6919ae15 255 {
dev_alexander 24:e8d03912f303 256 BufferTx[i] = i - sizeof(PingMsg);
Helmut64 0:c43b6919ae15 257 }
dev_alexander 25:1a031add188a 258 */
dev_alexander 25:1a031add188a 259 /* Construct the payload buffer so data can be transmited. */
dev_alexander 27:6b549f838f0a 260 fillPayloadWithGlobalBufs();
dev_alexander 22:abca9d17d13d 261 wait_ms( 10 );
dev_alexander 27:6b549f838f0a 262 Radio->Send( BufferTxAlias, BufferSizeTx );
dev_alexander 22:abca9d17d13d 263 }
dev_alexander 22:abca9d17d13d 264 /* else if( memcmp(Buffer, PingMsg, sizeof(PingMsg)) == 0 )
dev_alexander 22:abca9d17d13d 265 { // A master already exists then become a slave
dev_alexander 22:abca9d17d13d 266 dprintf( "...Ping" );
dev_alexander 22:abca9d17d13d 267 // *led = !*led;
dev_alexander 22:abca9d17d13d 268 isMaster = false;
dev_alexander 22:abca9d17d13d 269 // Send the next PONG frame
dev_alexander 22:abca9d17d13d 270 memcpy(Buffer, PongMsg, sizeof(PongMsg));
dev_alexander 22:abca9d17d13d 271 // We fill the buffer with numbers for the payload
dev_alexander 22:abca9d17d13d 272 for( i = sizeof(PongMsg); i < BufferSize; i++ )
dev_alexander 22:abca9d17d13d 273 {
dev_alexander 22:abca9d17d13d 274 Buffer[i] = i - sizeof(PongMsg);
Helmut64 0:c43b6919ae15 275 }
dev_alexander 22:abca9d17d13d 276 wait_ms( 10 );
dev_alexander 22:abca9d17d13d 277 Radio->Send( Buffer, BufferSize );
dev_alexander 22:abca9d17d13d 278 }
dev_alexander 22:abca9d17d13d 279 */
dev_alexander 22:abca9d17d13d 280 else // valid reception but neither a PING or a PONG message
dev_alexander 22:abca9d17d13d 281 { // Set device as master ans start again
dev_alexander 24:e8d03912f303 282 //isMaster = true;
dev_alexander 22:abca9d17d13d 283 Radio->Rx( RX_TIMEOUT_VALUE );
Helmut64 0:c43b6919ae15 284 }
Helmut64 0:c43b6919ae15 285 }
dev_alexander 22:abca9d17d13d 286 }
dev_alexander 22:abca9d17d13d 287 else
dev_alexander 22:abca9d17d13d 288 {
dev_alexander 24:e8d03912f303 289 if( BufferSizeRx > 0 )
Helmut64 0:c43b6919ae15 290 {
dev_alexander 27:6b549f838f0a 291 if( memcmp(BufferRxAlias, PingMsg, sizeof(PingMsg)) == 0 )
Helmut64 0:c43b6919ae15 292 {
dev_alexander 22:abca9d17d13d 293 // *led = !*led;
dev_alexander 22:abca9d17d13d 294 dprintf( "...Ping" );
dev_alexander 22:abca9d17d13d 295 // Send the reply to the PING string
dev_alexander 25:1a031add188a 296 // memcpy(BufferTx, PongMsg, sizeof(PongMsg));
dev_alexander 25:1a031add188a 297 /*
dev_alexander 22:abca9d17d13d 298 // We fill the buffer with numbers for the payload
dev_alexander 24:e8d03912f303 299 for( i = sizeof(PongMsg); i < BufferSizeTx; i++ )
dev_alexander 22:abca9d17d13d 300 {
dev_alexander 24:e8d03912f303 301 BufferTx[i] = i - sizeof(PongMsg);
dev_alexander 22:abca9d17d13d 302 }
dev_alexander 25:1a031add188a 303 */
dev_alexander 26:69aba05f010f 304 //fillPayloadWithGlobalBufs(BufferTx);
dev_alexander 22:abca9d17d13d 305 wait_ms( 10 );
dev_alexander 27:6b549f838f0a 306 Radio->Send( BufferTxAlias, BufferSizeTx );
Helmut64 0:c43b6919ae15 307 }
dev_alexander 22:abca9d17d13d 308 else // valid reception but not a PING as expected
dev_alexander 22:abca9d17d13d 309 { // Set device as master and start again
dev_alexander 22:abca9d17d13d 310 //isMaster = true;
dev_alexander 22:abca9d17d13d 311 Radio->Rx( RX_TIMEOUT_VALUE );
dev_alexander 22:abca9d17d13d 312 }
Helmut64 0:c43b6919ae15 313 }
dev_alexander 22:abca9d17d13d 314 }
dev_alexander 22:abca9d17d13d 315 State = LOWPOWER;
dev_alexander 22:abca9d17d13d 316 break;
dev_alexander 22:abca9d17d13d 317 case TX:
dev_alexander 26:69aba05f010f 318 *led3 = 1;
dev_alexander 22:abca9d17d13d 319 if( isMaster == true )
dev_alexander 22:abca9d17d13d 320 {
dev_alexander 22:abca9d17d13d 321 dprintf("Ping..." );
dev_alexander 22:abca9d17d13d 322 }
dev_alexander 22:abca9d17d13d 323 else
dev_alexander 22:abca9d17d13d 324 {
dev_alexander 22:abca9d17d13d 325 dprintf("Pong..." );
dev_alexander 22:abca9d17d13d 326 }
dev_alexander 22:abca9d17d13d 327 Radio->Rx( RX_TIMEOUT_VALUE );
dev_alexander 22:abca9d17d13d 328 State = LOWPOWER;
dev_alexander 22:abca9d17d13d 329 break;
dev_alexander 22:abca9d17d13d 330 case RX_TIMEOUT:
dev_alexander 22:abca9d17d13d 331 if( isMaster == true )
dev_alexander 22:abca9d17d13d 332 {
dev_alexander 22:abca9d17d13d 333 // Send the next PING frame
dev_alexander 25:1a031add188a 334 // memcpy(BufferTx, PingMsg, sizeof(PingMsg));
dev_alexander 25:1a031add188a 335 /*
dev_alexander 24:e8d03912f303 336 for( i = sizeof(PingMsg); i < BufferSizeTx; i++ )
Helmut64 0:c43b6919ae15 337 {
dev_alexander 24:e8d03912f303 338 BufferTx[i] = i - sizeof(PingMsg);
Helmut64 0:c43b6919ae15 339 }
dev_alexander 25:1a031add188a 340 */
dev_alexander 27:6b549f838f0a 341 fillPayloadWithGlobalBufs();
dev_alexander 22:abca9d17d13d 342 wait_ms( 10 );
dev_alexander 27:6b549f838f0a 343 Radio->Send( BufferTxAlias, BufferSizeTx );
dev_alexander 22:abca9d17d13d 344 }
dev_alexander 22:abca9d17d13d 345 else
dev_alexander 22:abca9d17d13d 346 {
dev_alexander 22:abca9d17d13d 347 Radio->Rx( RX_TIMEOUT_VALUE );
dev_alexander 22:abca9d17d13d 348 }
dev_alexander 22:abca9d17d13d 349 State = LOWPOWER;
dev_alexander 22:abca9d17d13d 350 break;
dev_alexander 22:abca9d17d13d 351 case RX_ERROR:
dev_alexander 22:abca9d17d13d 352 // We have received a Packet with a CRC error, send reply as if packet was correct
dev_alexander 22:abca9d17d13d 353 if( isMaster == true )
dev_alexander 22:abca9d17d13d 354 {
dev_alexander 22:abca9d17d13d 355 // Send the next PING frame
dev_alexander 27:6b549f838f0a 356 // memcpy(BufferTxAlias, PingMsg, sizeof(PingMsg));
dev_alexander 25:1a031add188a 357 /*
dev_alexander 24:e8d03912f303 358 for( i = 4; i < BufferSizeTx; i++ )
Helmut64 0:c43b6919ae15 359 {
dev_alexander 24:e8d03912f303 360 BufferTx[i] = i - 4;
Helmut64 0:c43b6919ae15 361 }
dev_alexander 25:1a031add188a 362 */
dev_alexander 27:6b549f838f0a 363 fillPayloadWithGlobalBufs();
dev_alexander 22:abca9d17d13d 364 wait_ms( 10 );
dev_alexander 27:6b549f838f0a 365 Radio->Send( BufferTxAlias, BufferSizeTx );
dev_alexander 22:abca9d17d13d 366 }
dev_alexander 22:abca9d17d13d 367 else
dev_alexander 22:abca9d17d13d 368 {
dev_alexander 22:abca9d17d13d 369 // Send the next PONG frame
dev_alexander 25:1a031add188a 370 // memcpy(BufferTx, PongMsg, sizeof(PongMsg));
dev_alexander 25:1a031add188a 371 /*
dev_alexander 24:e8d03912f303 372 for( i = sizeof(PongMsg); i < BufferSizeTx; i++ )
dev_alexander 22:abca9d17d13d 373 {
dev_alexander 24:e8d03912f303 374 BufferTx[i] = i - sizeof(PongMsg);
dev_alexander 22:abca9d17d13d 375 }
dev_alexander 25:1a031add188a 376 */
dev_alexander 27:6b549f838f0a 377 fillPayloadWithGlobalBufs();
dev_alexander 22:abca9d17d13d 378 wait_ms( 10 );
dev_alexander 27:6b549f838f0a 379 Radio->Send( BufferTxAlias, BufferSizeTx );
dev_alexander 22:abca9d17d13d 380 }
dev_alexander 22:abca9d17d13d 381 State = LOWPOWER;
dev_alexander 22:abca9d17d13d 382 break;
dev_alexander 22:abca9d17d13d 383 case TX_TIMEOUT:
dev_alexander 22:abca9d17d13d 384 Radio->Rx( RX_TIMEOUT_VALUE );
dev_alexander 22:abca9d17d13d 385 State = LOWPOWER;
dev_alexander 22:abca9d17d13d 386 break;
dev_alexander 22:abca9d17d13d 387 case LOWPOWER:
dev_alexander 22:abca9d17d13d 388 sleep();
dev_alexander 22:abca9d17d13d 389 break;
dev_alexander 22:abca9d17d13d 390 default:
dev_alexander 22:abca9d17d13d 391 State = LOWPOWER;
dev_alexander 22:abca9d17d13d 392 break;
dev_alexander 22:abca9d17d13d 393 }
Helmut64 0:c43b6919ae15 394 }
Helmut64 0:c43b6919ae15 395
Helmut64 11:d3a591c20cd7 396 void OnTxDone(void *radio, void *userThisPtr, void *userData)
Helmut64 0:c43b6919ae15 397 {
Helmut64 0:c43b6919ae15 398 Radio->Sleep( );
dev_alexander 25:1a031add188a 399 State = TX;
Helmut64 0:c43b6919ae15 400 if (DEBUG_MESSAGE)
Helmut64 0:c43b6919ae15 401 dprintf("> OnTxDone");
Helmut64 0:c43b6919ae15 402 }
Helmut64 0:c43b6919ae15 403
Helmut64 11:d3a591c20cd7 404 void OnRxDone(void *radio, void *userThisPtr, void *userData, uint8_t *payload, uint16_t size, int16_t rssi, int8_t snr)
Helmut64 0:c43b6919ae15 405 {
Helmut64 0:c43b6919ae15 406 Radio->Sleep( );
dev_alexander 26:69aba05f010f 407 uint16_t ActualBufferSizeRx = size;
dev_alexander 27:6b549f838f0a 408 memcpy( BufferRxAlias, payload, ActualBufferSizeRx );
Helmut64 0:c43b6919ae15 409 State = RX;
dev_alexander 25:1a031add188a 410
dev_alexander 25:1a031add188a 411 // Call function that deconstructs payload
dev_alexander 27:6b549f838f0a 412 fillGlobalBufsWithPayload();
dev_alexander 25:1a031add188a 413
Helmut64 0:c43b6919ae15 414 if (DEBUG_MESSAGE)
Helmut64 0:c43b6919ae15 415 dprintf("> OnRxDone: RssiValue=%d dBm, SnrValue=%d", rssi, snr);
Helmut64 0:c43b6919ae15 416 dump("Data:", payload, size);
Helmut64 0:c43b6919ae15 417 }
Helmut64 0:c43b6919ae15 418
Helmut64 11:d3a591c20cd7 419 void OnTxTimeout(void *radio, void *userThisPtr, void *userData)
Helmut64 0:c43b6919ae15 420 {
dev_alexander 26:69aba05f010f 421 *led3 = 0;
Helmut64 0:c43b6919ae15 422 Radio->Sleep( );
Helmut64 0:c43b6919ae15 423 State = TX_TIMEOUT;
Helmut64 0:c43b6919ae15 424 if(DEBUG_MESSAGE)
Helmut64 0:c43b6919ae15 425 dprintf("> OnTxTimeout");
Helmut64 0:c43b6919ae15 426 }
Helmut64 0:c43b6919ae15 427
Helmut64 11:d3a591c20cd7 428 void OnRxTimeout(void *radio, void *userThisPtr, void *userData)
Helmut64 0:c43b6919ae15 429 {
dev_alexander 26:69aba05f010f 430 *led3 = 0;
Helmut64 0:c43b6919ae15 431 Radio->Sleep( );
dev_alexander 27:6b549f838f0a 432 BufferRxAlias[BufferSizeRx-1] = 0;
Helmut64 0:c43b6919ae15 433 State = RX_TIMEOUT;
Helmut64 0:c43b6919ae15 434 if (DEBUG_MESSAGE)
Helmut64 0:c43b6919ae15 435 dprintf("> OnRxTimeout");
Helmut64 0:c43b6919ae15 436 }
Helmut64 0:c43b6919ae15 437
Helmut64 11:d3a591c20cd7 438 void OnRxError(void *radio, void *userThisPtr, void *userData)
Helmut64 0:c43b6919ae15 439 {
Helmut64 0:c43b6919ae15 440 Radio->Sleep( );
Helmut64 0:c43b6919ae15 441 State = RX_ERROR;
Helmut64 0:c43b6919ae15 442 if (DEBUG_MESSAGE)
Helmut64 0:c43b6919ae15 443 dprintf("> OnRxError");
Helmut64 0:c43b6919ae15 444 }
Helmut64 0:c43b6919ae15 445
Helmut64 0:c43b6919ae15 446 #endif