Andriy Makukha / Mbed 2 deprecated football_project_wo_output

football_project_wo_output

Dependencies:   mbed

Fork of football_project by MZJ

main.cpp@21:32f022efcc09, 2015-12-04 (annotated)

Committer:
AntonLS
Date:
Fri Dec 04 14:02:05 2015 +0000
Revision:
21:32f022efcc09
Parent:
20:d6c6099b60be
Child:
22:f58d4b441aba
Real battery levels.

Who changed what in which revision?

UserRevisionLine numberNew contents of line
AntonLS 0:28ca4562fe1a 1 /*
AntonLS 0:28ca4562fe1a 2 * TA test
AntonLS 0:28ca4562fe1a 3 *
AntonLS 19:afcbb425b3cf 4 * Updated for New TA Baseboard (rev Aug-Nov 2015.)
AntonLS 19:afcbb425b3cf 5 *
AntonLS 11:d3aa5fca2330 6 * TODO maybe have a mode where the serial port I/O can be swapped,
AntonLS 11:d3aa5fca2330 7 * such that what the nRF generates is sent out the serial port,
AntonLS 11:d3aa5fca2330 8 * and what comes in the serial port goes into the nRF.
AntonLS 11:d3aa5fca2330 9 * Maybe could use the now-unused CTS pin for that.
AntonLS 13:28332f65d14b 10 *
AntonLS 13:28332f65d14b 11 * Using
AntonLS 13:28332f65d14b 12 * rev 327 of BLE_API
AntonLS 13:28332f65d14b 13 * rev 102 of nRF51822 w/ modification--See below
AntonLS 15:b86c4b798aa1 14 * rev 97 of mbed lib
AntonLS 15:b86c4b798aa1 15 * corresponding to:
AntonLS 15:b86c4b798aa1 16 * rev 493 of mbed-src w/ modification to targets/hal/TARGET_NORDIC/TARGET_MCU_NRF51822/serial_api.c
AntonLS 19:afcbb425b3cf 17 * so things compile properly.*
AntonLS 19:afcbb425b3cf 18 * * Now using $Sub$$UART0_IRQHandler to override UART0_IRQHandler without needing to use lib source.
AntonLS 13:28332f65d14b 19 *
AntonLS 13:28332f65d14b 20 * Changed
AntonLS 13:28332f65d14b 21 * nRF51822/nordic/pstorage_platform.h PSTORAGE_MIN_BLOCK_SIZE changed from 0x010 to 4.
AntonLS 0:28ca4562fe1a 22 */
AntonLS 0:28ca4562fe1a 23
AntonLS 0:28ca4562fe1a 24 /* mbed Microcontroller Library
AntonLS 0:28ca4562fe1a 25 * Copyright (c) 2006-2013 ARM Limited
AntonLS 0:28ca4562fe1a 26 *
AntonLS 0:28ca4562fe1a 27 * Licensed under the Apache License, Version 2.0 (the "License");
AntonLS 0:28ca4562fe1a 28 * you may not use this file except in compliance with the License.
AntonLS 0:28ca4562fe1a 29 * You may obtain a copy of the License at
AntonLS 0:28ca4562fe1a 30 *
AntonLS 0:28ca4562fe1a 31 * http://www.apache.org/licenses/LICENSE-2.0
AntonLS 0:28ca4562fe1a 32 *
AntonLS 0:28ca4562fe1a 33 * Unless required by applicable law or agreed to in writing, software
AntonLS 0:28ca4562fe1a 34 * distributed under the License is distributed on an "AS IS" BASIS,
AntonLS 0:28ca4562fe1a 35 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
AntonLS 0:28ca4562fe1a 36 * See the License for the specific language governing permissions and
AntonLS 0:28ca4562fe1a 37 * limitations under the License.
AntonLS 0:28ca4562fe1a 38 */
elmbed 18:affef3a7db2a 39 #include <cstdarg>
elmbed 18:affef3a7db2a 40 #include <cstdio>
AntonLS 0:28ca4562fe1a 41
AntonLS 0:28ca4562fe1a 42 #include "mbed.h"
AntonLS 12:6d313d575f84 43 // #include "rtos.h"
AntonLS 0:28ca4562fe1a 44 #include "BLEDevice.h"
AntonLS 0:28ca4562fe1a 45
AntonLS 0:28ca4562fe1a 46 #include "DFUService.h"
AntonLS 0:28ca4562fe1a 47 #include "UARTService.h"
AntonLS 0:28ca4562fe1a 48 #include "DeviceInformationService.h"
AntonLS 19:afcbb425b3cf 49 #include "BatteryService.h"
AntonLS 0:28ca4562fe1a 50
AntonLS 0:28ca4562fe1a 51 #include "MTSSerialFlowControl.h"
AntonLS 5:1b9734e68327 52 #include "PhoneAppIO.h"
AntonLS 0:28ca4562fe1a 53
elmbed 18:affef3a7db2a 54 #include "TA.h"
elmbed 18:affef3a7db2a 55
AntonLS 0:28ca4562fe1a 56 #define NEED_CONSOLE_OUTPUT 0 /* Set this if you need debug messages on the console;
AntonLS 0:28ca4562fe1a 57 * it will have an impact on code-size and power consumption. */
AntonLS 0:28ca4562fe1a 58
AntonLS 11:d3aa5fca2330 59 #define LOOPBACK_MODE 0 // Loopback mode
AntonLS 4:17b8edf264c3 60
AntonLS 0:28ca4562fe1a 61 #if NEED_CONSOLE_OUTPUT
AntonLS 0:28ca4562fe1a 62 #define DEBUG(...) { printf(__VA_ARGS__); }
AntonLS 0:28ca4562fe1a 63 #else
AntonLS 0:28ca4562fe1a 64 #define DEBUG(...) /* nothing */
AntonLS 0:28ca4562fe1a 65 #endif /* #if NEED_CONSOLE_OUTPUT */
AntonLS 0:28ca4562fe1a 66
elmbed 17:d8b901d791fd 67 void loop();
elmbed 17:d8b901d791fd 68 void setup();
elmbed 17:d8b901d791fd 69 void getRadioInput(char *ibuffer, int size);
elmbed 17:d8b901d791fd 70
AntonLS 19:afcbb425b3cf 71 #define BLENANO 0 // BLE Nano vs. TA New Baseboard (rev Aug-Nov 2015.)
AntonLS 19:afcbb425b3cf 72
AntonLS 19:afcbb425b3cf 73 #if BLENANO
AntonLS 19:afcbb425b3cf 74 #define SERTX USBTX
AntonLS 19:afcbb425b3cf 75 #define SERRX USBRX
AntonLS 19:afcbb425b3cf 76 #else // Same RTS pin used by all (P0_08) and unused CTS (P0_10)
AntonLS 19:afcbb425b3cf 77 #define SERTX P0_18
AntonLS 19:afcbb425b3cf 78 #define SERRX P0_17
AntonLS 19:afcbb425b3cf 79 #endif
AntonLS 19:afcbb425b3cf 80
elmbed 18:affef3a7db2a 81 static Timer tmr;
elmbed 17:d8b901d791fd 82
elmbed 17:d8b901d791fd 83 unsigned long millis()
elmbed 17:d8b901d791fd 84 {
elmbed 17:d8b901d791fd 85 return tmr.read_ms();
elmbed 17:d8b901d791fd 86 }
elmbed 17:d8b901d791fd 87
elmbed 17:d8b901d791fd 88 unsigned long micros()
elmbed 17:d8b901d791fd 89 {
AntonLS 19:afcbb425b3cf 90 return tmr.read_us();
elmbed 17:d8b901d791fd 91 }
elmbed 17:d8b901d791fd 92
AntonLS 0:28ca4562fe1a 93 extern "C"
AntonLS 0:28ca4562fe1a 94 {
AntonLS 13:28332f65d14b 95 #include "softdevice_handler.h" // Attempt to get pstorage enqueued cmd callbacks.
AntonLS 13:28332f65d14b 96 #include "app_timer.h"
AntonLS 13:28332f65d14b 97 #include "pstorage.h"
AntonLS 13:28332f65d14b 98
AntonLS 16:3c873f2c8a27 99 // void My_UART0_IRQHandler();
AntonLS 12:6d313d575f84 100
AntonLS 0:28ca4562fe1a 101 void pin_mode( PinName, PinMode );
AntonLS 0:28ca4562fe1a 102 }
AntonLS 0:28ca4562fe1a 103
AntonLS 21:32f022efcc09 104 #if BLENANO
AntonLS 21:32f022efcc09 105 #define ADC_IN_BATT P0_6
AntonLS 21:32f022efcc09 106 #else
AntonLS 21:32f022efcc09 107 #define ADC_IN_BATT P0_4
AntonLS 21:32f022efcc09 108 DigitalIn notcharge( P0_2, PullUp );
AntonLS 21:32f022efcc09 109 #endif
AntonLS 21:32f022efcc09 110 AnalogIn batt( ADC_IN_BATT );
AntonLS 21:32f022efcc09 111
AntonLS 12:6d313d575f84 112 // DigitalOut rts( RTS_PIN_NUMBER );
AntonLS 19:afcbb425b3cf 113 DigitalIn cts( CTS_PIN_NUMBER, PullDown ); // We'll use as a mode switch for serial data source. TODO
AntonLS 12:6d313d575f84 114
AntonLS 12:6d313d575f84 115 // Check if we should swap serial Rx/Tx for early rev of "Little Brain"
AntonLS 19:afcbb425b3cf 116 DigitalIn trSwp( P0_30, PullUp );
AntonLS 12:6d313d575f84 117
AntonLS 12:6d313d575f84 118 // Wait to settle.
AntonLS 12:6d313d575f84 119 int foo = (wait( 0.1 ), 0);
AntonLS 12:6d313d575f84 120
AntonLS 14:76fb883a3cb8 121 // Not using "LED" or "LED1" because target NRF51822 for FOTA uses different pins.
AntonLS 20:d6c6099b60be 122 static DigitalOut led0( P0_19, 1 ); // TA New Baseboard LED High=On ("STATUS") (OK on Nano: LED Low=On)
AntonLS 19:afcbb425b3cf 123 static DigitalOut led1( P0_21, 0 ); // TA New Baseboard High=On (OK on Nano: NC)
AntonLS 19:afcbb425b3cf 124 DigitalOut led2( P0_22, 1 ); // TA New Baseboard High=On (OK on Nano: NC)
AntonLS 19:afcbb425b3cf 125
AntonLS 19:afcbb425b3cf 126 // DigitalOut led1( P0_3, 0 ); // TA Baseboard High=On (OK on Nano: Alt RxD)
AntonLS 14:76fb883a3cb8 127 // DigitalOut led1( (trSwp ? P0_4 : P0_3), 0 ); // TA Baseboard High=On (And don't use P0_4 on Nano)
AntonLS 14:76fb883a3cb8 128
AntonLS 19:afcbb425b3cf 129 DigitalOut buzz( P0_20, 1 ); // TA New Baseboard Low=On (OK on Nano: NC)
AntonLS 19:afcbb425b3cf 130
AntonLS 13:28332f65d14b 131 // App timer, app scheduler, and pstorage are already setup by bootloader.
AntonLS 13:28332f65d14b 132
elmbed 18:affef3a7db2a 133 static BLEDevice ble;
AntonLS 19:afcbb425b3cf 134
AntonLS 12:6d313d575f84 135
AntonLS 1:0ba687d4196f 136 // Note: From the datasheet:
AntonLS 1:0ba687d4196f 137 // PSELRXD, PSELRTS, PSELTRTS and PSELTXD must only be configured when the UART is disabled.
AntonLS 11:d3aa5fca2330 138 // But a version of serial_init() erroneously enabled the uart before the setting of those,
AntonLS 11:d3aa5fca2330 139 // which messed up flow control. Apparently the setting is ONCE per ON mode. ARGH!
AntonLS 11:d3aa5fca2330 140 // So we made our own versions of Serial and SerialBase (MySerial and MySerialBase)
AntonLS 7:205ef63d311a 141 // to not use serial_init() in serial_api.c, so flow control is setup correctly *
AntonLS 7:205ef63d311a 142 // MTSSerial now uses our MySerial instead of Serial, and now uses hw flow control by default *
AntonLS 15:b86c4b798aa1 143 // [* We can't change the uart interrupt vector, so we comment-out the handler in
AntonLS 15:b86c4b798aa1 144 // serial_api.c, and rebuild the mbed lib for low-level hw flow control to work.] - No need now.
AntonLS 15:b86c4b798aa1 145 // * Now using $Sub$$UART0_IRQHandler to override UART0_IRQHandler without needing to use lib source.
AntonLS 15:b86c4b798aa1 146 // NVIC_SetVector( UART0_IRQn, (uint32_t)My_UART0_IRQHandler ); // Might have worked--No need.
AntonLS 15:b86c4b798aa1 147 //
AntonLS 6:ef758ac3c928 148 // MTSSerialFlowControl uses "manual" (non-hardware-low-level) flow control based on its
AntonLS 11:d3aa5fca2330 149 // internal buffer--Rx servicing usually is fast enough not to need hw flow control, so it's okay.
AntonLS 1:0ba687d4196f 150 //
AntonLS 19:afcbb425b3cf 151 // mts::MTSSerialFlowControl pcfc( (trSwp ? SERRX : SERTX), (trSwp ? SERTX : SERRX), RTS_PIN_NUMBER, CTS_PIN_NUMBER, 384, 2688 );
AntonLS 19:afcbb425b3cf 152 //mts::MTSSerial pcfc( (trSwp ? SERRX : SERTX), (trSwp ? SERTX : SERRX), 128, 64, RTS_PIN_NUMBER, NC ); // 256, 1280 // 256, 2560
AntonLS 0:28ca4562fe1a 153
AntonLS 0:28ca4562fe1a 154 uint8_t txPayload[TXRX_BUF_LEN] = { 0 };
AntonLS 0:28ca4562fe1a 155
AntonLS 0:28ca4562fe1a 156
AntonLS 5:1b9734e68327 157 char deviceName[6]; // "TAF00";
AntonLS 5:1b9734e68327 158 Gap::address_t macAddr;
AntonLS 5:1b9734e68327 159 Gap::addr_type_t *pAdType;
AntonLS 19:afcbb425b3cf 160 static const uint16_t uuid16_list[] = { GattService::UUID_DEVICE_INFORMATION_SERVICE,
AntonLS 19:afcbb425b3cf 161 GattService::UUID_BATTERY_SERVICE };
AntonLS 20:d6c6099b60be 162 static uint8_t batt_and_id[] = { GattService::UUID_BATTERY_SERVICE & 0xff,
AntonLS 19:afcbb425b3cf 163 GattService::UUID_BATTERY_SERVICE >> 8,
AntonLS 19:afcbb425b3cf 164 99, // Batt level TODO
AntonLS 19:afcbb425b3cf 165 'T', 'X' }; // Custom ID trick
AntonLS 19:afcbb425b3cf 166
AntonLS 20:d6c6099b60be 167 UARTService *uartServicePtr;
AntonLS 20:d6c6099b60be 168 PhoneAppIO *phoneP;
AntonLS 20:d6c6099b60be 169 BatteryService *battServiceP;
AntonLS 5:1b9734e68327 170
elmbed 18:affef3a7db2a 171 // Buffer for holding data from the phone
elmbed 18:affef3a7db2a 172 // to the device
AntonLS 21:32f022efcc09 173 #define PHTODEV_BUF_LEN 30 /**/
AntonLS 19:afcbb425b3cf 174 /// static char phoneToDev[200] = {0};
AntonLS 19:afcbb425b3cf 175 static char phoneToDev[PHTODEV_BUF_LEN] = {0};
AntonLS 0:28ca4562fe1a 176
AntonLS 19:afcbb425b3cf 177 /// // Current position in the buffer
AntonLS 19:afcbb425b3cf 178 /// static int phoneToDevPos = 0;
AntonLS 0:28ca4562fe1a 179
elmbed 18:affef3a7db2a 180 extern TA ta;
elmbed 18:affef3a7db2a 181
elmbed 18:affef3a7db2a 182 extern void radio_init();
elmbed 18:affef3a7db2a 183 extern void radio_loop();
elmbed 18:affef3a7db2a 184
elmbed 18:affef3a7db2a 185 // True when connected to a phone
AntonLS 11:d3aa5fca2330 186 bool connected = false;
AntonLS 5:1b9734e68327 187
AntonLS 11:d3aa5fca2330 188 void connectionCallback( Gap::Handle_t, Gap::addr_type_t peerAddrType,
AntonLS 11:d3aa5fca2330 189 const Gap::address_t peerAddr, const Gap::ConnectionParams_t *connParams )
AntonLS 11:d3aa5fca2330 190 {
AntonLS 11:d3aa5fca2330 191 connected = true;
AntonLS 19:afcbb425b3cf 192
AntonLS 19:afcbb425b3cf 193 // DEBUG( "Connected!\n\r" );
AntonLS 11:d3aa5fca2330 194 }
AntonLS 5:1b9734e68327 195
AntonLS 0:28ca4562fe1a 196 void disconnectionCallback( Gap::Handle_t handle, Gap::DisconnectionReason_t reason )
AntonLS 0:28ca4562fe1a 197 {
AntonLS 11:d3aa5fca2330 198 connected = false;
AntonLS 11:d3aa5fca2330 199
AntonLS 19:afcbb425b3cf 200 // DEBUG( "Disconnected!\n\r" );
AntonLS 19:afcbb425b3cf 201 // DEBUG( "Restarting the advertising process\n\r" );
AntonLS 0:28ca4562fe1a 202 ble.startAdvertising();
elmbed 18:affef3a7db2a 203 ta.post_color(0);
AntonLS 0:28ca4562fe1a 204 }
AntonLS 0:28ca4562fe1a 205
AntonLS 5:1b9734e68327 206 bool updateCharacteristic( GattAttribute::Handle_t handle, const uint8_t *data, uint16_t bytesRead )
AntonLS 5:1b9734e68327 207 {
AntonLS 11:d3aa5fca2330 208 ble_error_t err = ble.updateCharacteristicValue( handle, data, bytesRead );
AntonLS 5:1b9734e68327 209
AntonLS 5:1b9734e68327 210 if( (err == BLE_ERROR_BUFFER_OVERFLOW) ||
AntonLS 5:1b9734e68327 211 (err == BLE_ERROR_PARAM_OUT_OF_RANGE ) )
AntonLS 7:205ef63d311a 212 {
AntonLS 19:afcbb425b3cf 213 // pcfc.printf( "\r\nBLE %d! ", err );
AntonLS 7:205ef63d311a 214
AntonLS 7:205ef63d311a 215 } else if ( err == BLE_STACK_BUSY )
AntonLS 7:205ef63d311a 216 {
AntonLS 11:d3aa5fca2330 217 // Common error when pumping data.
AntonLS 7:205ef63d311a 218 }
AntonLS 5:1b9734e68327 219
AntonLS 5:1b9734e68327 220 return (err != BLE_ERROR_NONE);
AntonLS 5:1b9734e68327 221 }
AntonLS 5:1b9734e68327 222
AntonLS 19:afcbb425b3cf 223 /// /* Writes the string given to the phone.
AntonLS 19:afcbb425b3cf 224 /// *
AntonLS 19:afcbb425b3cf 225 /// * @param *data - the string to send.
AntonLS 19:afcbb425b3cf 226 /// */
AntonLS 19:afcbb425b3cf 227 /***
elmbed 18:affef3a7db2a 228 static void writeToPhoneImpl(char *data)
elmbed 17:d8b901d791fd 229 {
elmbed 17:d8b901d791fd 230 if (phoneP != NULL)
elmbed 17:d8b901d791fd 231 {
elmbed 18:affef3a7db2a 232 for (int i = 0; i < strlen(data); ++i)
elmbed 18:affef3a7db2a 233 {
elmbed 18:affef3a7db2a 234 phoneP->putchar(data[i]);
elmbed 17:d8b901d791fd 235
elmbed 18:affef3a7db2a 236 // If we don't call maybeHandleWrite all hell breaks loose and
elmbed 18:affef3a7db2a 237 // the app crashes. :(
elmbed 18:affef3a7db2a 238 if (i != 0 && i % 10 == 0)
elmbed 18:affef3a7db2a 239 {
elmbed 18:affef3a7db2a 240 int counter = 0;
elmbed 18:affef3a7db2a 241 while(phoneP->maybeHandleWrite() == 0 && ++counter < 20)
elmbed 18:affef3a7db2a 242 {
elmbed 18:affef3a7db2a 243 wait_us(1);
elmbed 18:affef3a7db2a 244 }
elmbed 18:affef3a7db2a 245 }
elmbed 18:affef3a7db2a 246 }
elmbed 18:affef3a7db2a 247
elmbed 18:affef3a7db2a 248 phoneP->maybeHandleWrite();
elmbed 17:d8b901d791fd 249 }
elmbed 17:d8b901d791fd 250 }
AntonLS 19:afcbb425b3cf 251 ***/
elmbed 17:d8b901d791fd 252
AntonLS 19:afcbb425b3cf 253 /// static char wtp_buff[150] = {0};
elmbed 18:affef3a7db2a 254 extern "C" void writeToPhone(char *format, ...)
elmbed 18:affef3a7db2a 255 {
elmbed 18:affef3a7db2a 256 va_list arg;
elmbed 18:affef3a7db2a 257 va_start(arg, format );
elmbed 18:affef3a7db2a 258
AntonLS 19:afcbb425b3cf 259 /// vsnprintf(wtp_buff, sizeof(wtp_buff), format, arg);
AntonLS 19:afcbb425b3cf 260 /**/phoneP->vprintf( format, arg );
AntonLS 19:afcbb425b3cf 261
AntonLS 19:afcbb425b3cf 262 /// writeToPhoneImpl(wtp_buff);
AntonLS 19:afcbb425b3cf 263
AntonLS 19:afcbb425b3cf 264 /**/// Also write same to serial port... TODO
AntonLS 19:afcbb425b3cf 265 /**/ // pcfc.vprintf( format, arg );
AntonLS 19:afcbb425b3cf 266
elmbed 18:affef3a7db2a 267 va_end(arg);
elmbed 18:affef3a7db2a 268 }
elmbed 18:affef3a7db2a 269
AntonLS 19:afcbb425b3cf 270 /**/ // Byte bits to ASCII - Use until we convert protocol to ASCII-hex.
AntonLS 19:afcbb425b3cf 271 extern "C" void writeBitsToPhone( uint8_t byte, uint8_t minbits )
AntonLS 19:afcbb425b3cf 272 {
AntonLS 19:afcbb425b3cf 273 static char ascbits[9] = { 0 };
AntonLS 19:afcbb425b3cf 274 int pos = 0;
AntonLS 19:afcbb425b3cf 275 if( 0 == minbits ) minbits = 1;
AntonLS 19:afcbb425b3cf 276
AntonLS 19:afcbb425b3cf 277 uint16_t ibyt = byte & 0xFF;
AntonLS 19:afcbb425b3cf 278 bool leading0 = true;
AntonLS 19:afcbb425b3cf 279
AntonLS 19:afcbb425b3cf 280 for( short b=7; b >= 0; b-- )
AntonLS 19:afcbb425b3cf 281 {
AntonLS 19:afcbb425b3cf 282 ibyt<<=1;
AntonLS 19:afcbb425b3cf 283 if( ibyt & 0x100 )
AntonLS 19:afcbb425b3cf 284 {
AntonLS 19:afcbb425b3cf 285 leading0 = false;
AntonLS 19:afcbb425b3cf 286 ascbits[pos++] = '1';
AntonLS 19:afcbb425b3cf 287
AntonLS 19:afcbb425b3cf 288 } else if( !leading0 || (b < minbits) )
AntonLS 19:afcbb425b3cf 289 {
AntonLS 19:afcbb425b3cf 290 ascbits[pos++] = '0';
AntonLS 19:afcbb425b3cf 291 }
AntonLS 19:afcbb425b3cf 292 }
AntonLS 19:afcbb425b3cf 293 ascbits[pos] = '\0';
AntonLS 19:afcbb425b3cf 294
AntonLS 19:afcbb425b3cf 295 writeToPhone( "%s", ascbits );
AntonLS 19:afcbb425b3cf 296 }
AntonLS 19:afcbb425b3cf 297
AntonLS 0:28ca4562fe1a 298 void onDataWritten( const GattCharacteristicWriteCBParams *params )
AntonLS 0:28ca4562fe1a 299 {
AntonLS 11:d3aa5fca2330 300 if( phoneP != NULL )
AntonLS 0:28ca4562fe1a 301 {
AntonLS 11:d3aa5fca2330 302 uint16_t bytesRead = phoneP->maybeHandleRead( params ); // Also writes to txPayload
elmbed 18:affef3a7db2a 303
AntonLS 11:d3aa5fca2330 304 if( 0 != bytesRead )
AntonLS 11:d3aa5fca2330 305 {
AntonLS 19:afcbb425b3cf 306 /// memcpy(phoneToDev+phoneToDevPos, txPayload, bytesRead);
AntonLS 19:afcbb425b3cf 307 /// phoneToDevPos += bytesRead;
AntonLS 19:afcbb425b3cf 308
AntonLS 19:afcbb425b3cf 309 /*
AntonLS 19:afcbb425b3cf 310 DEBUG( "received %u bytes\n\r", bytesRead );
AntonLS 19:afcbb425b3cf 311
AntonLS 19:afcbb425b3cf 312 // Also write to serial port...
AntonLS 19:afcbb425b3cf 313 // pcfc.printf( "From app: " );
AntonLS 19:afcbb425b3cf 314 pcfc.write( (char *)txPayload, bytesRead );
AntonLS 19:afcbb425b3cf 315 // pcfc.printf( "\r\n" );
AntonLS 19:afcbb425b3cf 316 */
AntonLS 19:afcbb425b3cf 317
AntonLS 11:d3aa5fca2330 318 return;
AntonLS 11:d3aa5fca2330 319 }
AntonLS 0:28ca4562fe1a 320 }
AntonLS 0:28ca4562fe1a 321 }
AntonLS 0:28ca4562fe1a 322
AntonLS 0:28ca4562fe1a 323 void onDataSent( unsigned count )
AntonLS 0:28ca4562fe1a 324 {
AntonLS 0:28ca4562fe1a 325 }
AntonLS 0:28ca4562fe1a 326
AntonLS 11:d3aa5fca2330 327 void toPhoneChk( void )
AntonLS 0:28ca4562fe1a 328 {
AntonLS 19:afcbb425b3cf 329 if( phoneP != NULL )
AntonLS 19:afcbb425b3cf 330 {
AntonLS 19:afcbb425b3cf 331 /*
AntonLS 19:afcbb425b3cf 332 char ch;
AntonLS 19:afcbb425b3cf 333 // Get any data from serial port buffer--Full lines if avail--Last line after >= 20 chars.
AntonLS 19:afcbb425b3cf 334 for( int cnt=1; 0 != pcfc.atomicRead( ch ); cnt++ )
AntonLS 19:afcbb425b3cf 335 {
AntonLS 19:afcbb425b3cf 336 /// For from-serial straight to-phone.
AntonLS 19:afcbb425b3cf 337 /// if( 0 > phoneP->putchar( ch ) )
AntonLS 19:afcbb425b3cf 338 /// {
AntonLS 19:afcbb425b3cf 339 /// pcfc.printf( " * " );
AntonLS 19:afcbb425b3cf 340 /// break;
AntonLS 19:afcbb425b3cf 341 /// }
AntonLS 3:388e441be8df 342
AntonLS 19:afcbb425b3cf 343 // For from-serial inject-to-dev as-if from phone.
AntonLS 19:afcbb425b3cf 344 phoneP->injectHandleRead( &ch, 1 );
AntonLS 19:afcbb425b3cf 345
AntonLS 19:afcbb425b3cf 346 if( (cnt >= 20) && ('\n' == ch) ) break;
AntonLS 19:afcbb425b3cf 347 }
AntonLS 19:afcbb425b3cf 348 */
AntonLS 19:afcbb425b3cf 349 // Write to outgoing characteristic if anything is pending.
AntonLS 19:afcbb425b3cf 350 if( 0 != phoneP->maybeHandleWrite() )
AntonLS 19:afcbb425b3cf 351 {
AntonLS 19:afcbb425b3cf 352 // pcfc.printf( "ToPhoneHandler \r\n" );
AntonLS 19:afcbb425b3cf 353 }
AntonLS 19:afcbb425b3cf 354 }
AntonLS 0:28ca4562fe1a 355 }
AntonLS 19:afcbb425b3cf 356 /*
AntonLS 13:28332f65d14b 357 static uint32_t boot_cnt_data = 0;
AntonLS 13:28332f65d14b 358 static uint16_t data_block = 9*20 +75; // Last block -- Use for app-start count.
AntonLS 13:28332f65d14b 359 static uint16_t data_size = 4;
AntonLS 13:28332f65d14b 360 static uint16_t data_offset = 0; // 12 for 16-byte blocks.
AntonLS 13:28332f65d14b 361 static bool data_loaded = false;
AntonLS 13:28332f65d14b 362 static bool data_cleared = false;
AntonLS 13:28332f65d14b 363 static bool data_stored = false;
AntonLS 13:28332f65d14b 364 static pstorage_handle_t pstorage_id;
AntonLS 19:afcbb425b3cf 365
AntonLS 13:28332f65d14b 366 static uint32_t pstorage_read_test()
AntonLS 13:28332f65d14b 367 {
AntonLS 13:28332f65d14b 368 uint32_t err_code;
AntonLS 13:28332f65d14b 369
AntonLS 13:28332f65d14b 370 pstorage_handle_t p_block_id;
AntonLS 13:28332f65d14b 371
AntonLS 13:28332f65d14b 372 do
AntonLS 13:28332f65d14b 373 {
AntonLS 13:28332f65d14b 374 err_code = pstorage_block_identifier_get( &pstorage_id, data_block, &p_block_id );
AntonLS 13:28332f65d14b 375 if( NRF_SUCCESS != err_code ) break;
AntonLS 13:28332f65d14b 376
AntonLS 13:28332f65d14b 377 err_code = pstorage_load( (uint8_t *)&boot_cnt_data, &p_block_id, data_size, data_offset );
AntonLS 13:28332f65d14b 378 if( NRF_SUCCESS != err_code ) break;
AntonLS 13:28332f65d14b 379
AntonLS 13:28332f65d14b 380 } while( 0 );
AntonLS 13:28332f65d14b 381
AntonLS 13:28332f65d14b 382 return err_code;
AntonLS 13:28332f65d14b 383 }
AntonLS 13:28332f65d14b 384 static uint32_t pstorage_clear_test()
AntonLS 13:28332f65d14b 385 {
AntonLS 13:28332f65d14b 386 uint32_t err_code;
AntonLS 13:28332f65d14b 387
AntonLS 13:28332f65d14b 388 pstorage_handle_t p_block_id;
AntonLS 13:28332f65d14b 389
AntonLS 13:28332f65d14b 390 do
AntonLS 13:28332f65d14b 391 {
AntonLS 13:28332f65d14b 392 err_code = pstorage_block_identifier_get( &pstorage_id, data_block, &p_block_id );
AntonLS 13:28332f65d14b 393 if( NRF_SUCCESS != err_code ) break;
AntonLS 13:28332f65d14b 394
AntonLS 13:28332f65d14b 395 err_code = pstorage_clear( &p_block_id, PSTORAGE_MIN_BLOCK_SIZE );
AntonLS 13:28332f65d14b 396 if( NRF_SUCCESS != err_code ) break;
AntonLS 13:28332f65d14b 397
AntonLS 13:28332f65d14b 398 } while( 0 );
AntonLS 13:28332f65d14b 399
AntonLS 13:28332f65d14b 400 return err_code;
AntonLS 13:28332f65d14b 401 }
AntonLS 13:28332f65d14b 402 static uint32_t pstorage_write_test()
AntonLS 13:28332f65d14b 403 {
AntonLS 13:28332f65d14b 404 uint32_t err_code;
AntonLS 13:28332f65d14b 405
AntonLS 13:28332f65d14b 406 pstorage_handle_t p_block_id;
AntonLS 13:28332f65d14b 407
AntonLS 13:28332f65d14b 408 do
AntonLS 13:28332f65d14b 409 {
AntonLS 13:28332f65d14b 410 err_code = pstorage_block_identifier_get( &pstorage_id, data_block, &p_block_id );
AntonLS 13:28332f65d14b 411 if( NRF_SUCCESS != err_code ) break;
AntonLS 13:28332f65d14b 412
AntonLS 13:28332f65d14b 413 err_code = pstorage_store( &p_block_id, (uint8_t *)&boot_cnt_data, data_size, data_offset );
AntonLS 13:28332f65d14b 414
AntonLS 13:28332f65d14b 415 } while( 0 );
AntonLS 13:28332f65d14b 416
AntonLS 13:28332f65d14b 417 return err_code;
AntonLS 13:28332f65d14b 418 }
AntonLS 19:afcbb425b3cf 419
AntonLS 13:28332f65d14b 420 static void pstorage_cb_handler( pstorage_handle_t *handle, uint8_t op_code, uint32_t result, uint8_t *p_data, uint32_t data_len )
AntonLS 13:28332f65d14b 421 {
AntonLS 13:28332f65d14b 422 switch( op_code )
AntonLS 13:28332f65d14b 423 {
AntonLS 13:28332f65d14b 424 case PSTORAGE_LOAD_OP_CODE:
AntonLS 13:28332f65d14b 425 if( NRF_SUCCESS == result )
AntonLS 13:28332f65d14b 426 {
AntonLS 13:28332f65d14b 427 // Load operation successful.
AntonLS 13:28332f65d14b 428 data_loaded = true; // Flag to signal load is done.
AntonLS 13:28332f65d14b 429
AntonLS 13:28332f65d14b 430 } else
AntonLS 13:28332f65d14b 431 {
AntonLS 13:28332f65d14b 432 // Load operation failed.
elmbed 18:affef3a7db2a 433 //pcfc.printf( "\r\nWarn: pstorage load operation error: %x\r\n", result );
AntonLS 13:28332f65d14b 434 }
AntonLS 13:28332f65d14b 435 break;
AntonLS 13:28332f65d14b 436 case PSTORAGE_UPDATE_OP_CODE:
AntonLS 13:28332f65d14b 437 case PSTORAGE_STORE_OP_CODE:
AntonLS 13:28332f65d14b 438 if( NRF_SUCCESS == result )
AntonLS 13:28332f65d14b 439 {
AntonLS 13:28332f65d14b 440 // Store operation successful.
AntonLS 13:28332f65d14b 441 data_stored = true; // Flag to signal store is done.
AntonLS 13:28332f65d14b 442
AntonLS 13:28332f65d14b 443 } else
AntonLS 13:28332f65d14b 444 {
AntonLS 13:28332f65d14b 445 // Store operation failed.
elmbed 18:affef3a7db2a 446 //pcfc.printf( "\r\nWarn: pstorage store operation error: %x\r\n", result );
AntonLS 13:28332f65d14b 447 }
AntonLS 13:28332f65d14b 448 // Source memory can now be reused or freed.
AntonLS 13:28332f65d14b 449 break;
AntonLS 13:28332f65d14b 450 case PSTORAGE_CLEAR_OP_CODE:
AntonLS 13:28332f65d14b 451 if( NRF_SUCCESS == result )
AntonLS 13:28332f65d14b 452 {
AntonLS 13:28332f65d14b 453 // Clear operation successful.
AntonLS 13:28332f65d14b 454 data_cleared = true; // Flag to store to the same data area.
AntonLS 13:28332f65d14b 455
AntonLS 13:28332f65d14b 456 } else
AntonLS 13:28332f65d14b 457 {
AntonLS 13:28332f65d14b 458 // Clear operation failed.
elmbed 18:affef3a7db2a 459 //pcfc.printf( "\r\nWarn: pstorage clear operation error: %x\r\n", result );
AntonLS 13:28332f65d14b 460 }
AntonLS 13:28332f65d14b 461 break;
AntonLS 19:afcbb425b3cf 462 //default:
AntonLS 19:afcbb425b3cf 463 //pcfc.printf( "\r\nWarn: pstorage unknown op: %x error: %x\r\n", op_code, result );
AntonLS 13:28332f65d14b 464 }
AntonLS 13:28332f65d14b 465 }
AntonLS 19:afcbb425b3cf 466
AntonLS 13:28332f65d14b 467 static uint32_t pstorage_setup()
AntonLS 13:28332f65d14b 468 {
AntonLS 13:28332f65d14b 469 pstorage_module_param_t pstorage_param;
AntonLS 13:28332f65d14b 470
AntonLS 13:28332f65d14b 471 // Setup pstorage with 9*20 +76 blocks of 4 bytes each. (or 9*20/4 + 19 for 16 byte blocks)
AntonLS 13:28332f65d14b 472 pstorage_param.block_size = 4; // Recommended to be >= 4 bytes.
AntonLS 13:28332f65d14b 473 pstorage_param.block_count = 9*20 +76; // 9 Sequences x 20 Stations + 76 blocks to fill out to 1k.
AntonLS 13:28332f65d14b 474 pstorage_param.cb = pstorage_cb_handler;
AntonLS 13:28332f65d14b 475
AntonLS 13:28332f65d14b 476 return pstorage_register( &pstorage_param, &pstorage_id );
AntonLS 13:28332f65d14b 477 }
AntonLS 19:afcbb425b3cf 478 */
AntonLS 13:28332f65d14b 479
AntonLS 20:d6c6099b60be 480 void setAdvData()
AntonLS 20:d6c6099b60be 481 {
AntonLS 20:d6c6099b60be 482 ble.accumulateAdvertisingPayload( GapAdvertisingData::BREDR_NOT_SUPPORTED |
AntonLS 20:d6c6099b60be 483 GapAdvertisingData::LE_GENERAL_DISCOVERABLE );
AntonLS 20:d6c6099b60be 484 ble.setAdvertisingType( GapAdvertisingParams::ADV_CONNECTABLE_UNDIRECTED );
AntonLS 20:d6c6099b60be 485
AntonLS 20:d6c6099b60be 486 // Get MAC addr so we can create a device name using it.
AntonLS 20:d6c6099b60be 487 ble.getAddress( pAdType, macAddr );
AntonLS 20:d6c6099b60be 488 sprintf( deviceName, "T%02X%02X", macAddr[1], macAddr[0] );
AntonLS 20:d6c6099b60be 489
AntonLS 20:d6c6099b60be 490 ble.accumulateAdvertisingPayload( GapAdvertisingData::COMPLETE_LOCAL_NAME,
AntonLS 20:d6c6099b60be 491 (const uint8_t *)deviceName, strlen(deviceName) );
AntonLS 20:d6c6099b60be 492
AntonLS 20:d6c6099b60be 493 // Moved to scan response packet to give more room in AD packet...
AntonLS 20:d6c6099b60be 494 // ble.accumulateAdvertisingPayload( GapAdvertisingData::INCOMPLETE_LIST_128BIT_SERVICE_IDS,
AntonLS 20:d6c6099b60be 495 // (const uint8_t *)UARTServiceUUID_reversed, sizeof(UARTServiceUUID_reversed) );
AntonLS 20:d6c6099b60be 496
AntonLS 20:d6c6099b60be 497 ble.accumulateAdvertisingPayload( GapAdvertisingData::COMPLETE_LIST_16BIT_SERVICE_IDS,
AntonLS 20:d6c6099b60be 498 (uint8_t *)uuid16_list, sizeof( uuid16_list ) );
AntonLS 20:d6c6099b60be 499 ble.accumulateAdvertisingPayload( GapAdvertisingData::SERVICE_DATA,
AntonLS 20:d6c6099b60be 500 (uint8_t *)batt_and_id, sizeof( batt_and_id ) ); // Unused batt lev + "TX"
AntonLS 20:d6c6099b60be 501
AntonLS 20:d6c6099b60be 502 ble.accumulateScanResponse( GapAdvertisingData::INCOMPLETE_LIST_128BIT_SERVICE_IDS,
AntonLS 20:d6c6099b60be 503 (const uint8_t *)UARTServiceUUID_reversed, sizeof( UARTServiceUUID_reversed ) );
AntonLS 20:d6c6099b60be 504 }
AntonLS 20:d6c6099b60be 505
AntonLS 20:d6c6099b60be 506 void updateBatt( uint8_t pct )
AntonLS 20:d6c6099b60be 507 {
AntonLS 20:d6c6099b60be 508 static uint8_t prev;
AntonLS 21:32f022efcc09 509 static bool wasCharging;
AntonLS 20:d6c6099b60be 510
AntonLS 21:32f022efcc09 511 if( notcharge )
AntonLS 21:32f022efcc09 512 {
AntonLS 21:32f022efcc09 513 if( pct > 100 ) pct = 100;
AntonLS 21:32f022efcc09 514 if( !wasCharging && (abs( (int)prev -(int)pct ) < 3) ) return; // Don't register change of less than 3%.
AntonLS 21:32f022efcc09 515 prev = pct;
AntonLS 21:32f022efcc09 516 wasCharging = false;
AntonLS 21:32f022efcc09 517
AntonLS 21:32f022efcc09 518 } else
AntonLS 21:32f022efcc09 519 {
AntonLS 21:32f022efcc09 520 pct = 101; // Show 101% if charging.
AntonLS 21:32f022efcc09 521 wasCharging = true; // Force show when done charging.
AntonLS 21:32f022efcc09 522 }
AntonLS 20:d6c6099b60be 523
AntonLS 20:d6c6099b60be 524 batt_and_id[2] = pct;
AntonLS 20:d6c6099b60be 525 ble.clearAdvertisingPayload();
AntonLS 20:d6c6099b60be 526 setAdvData();
AntonLS 20:d6c6099b60be 527 ble.setAdvertisingPayload();
AntonLS 20:d6c6099b60be 528
AntonLS 20:d6c6099b60be 529 if( NULL != battServiceP ) battServiceP->updateBatteryLevel( pct );
AntonLS 21:32f022efcc09 530 }
AntonLS 20:d6c6099b60be 531
AntonLS 21:32f022efcc09 532 uint8_t getBattLevel()
AntonLS 21:32f022efcc09 533 {
AntonLS 21:32f022efcc09 534 return (uint8_t)(batt * 125.f);
AntonLS 20:d6c6099b60be 535 }
AntonLS 20:d6c6099b60be 536
AntonLS 13:28332f65d14b 537 void periodicCallback( void )
AntonLS 13:28332f65d14b 538 {
AntonLS 19:afcbb425b3cf 539 static int foo;
AntonLS 19:afcbb425b3cf 540 foo++;
AntonLS 19:afcbb425b3cf 541 #if BLENANO
elmbed 18:affef3a7db2a 542 led0 = !led0;
AntonLS 19:afcbb425b3cf 543 #endif
elmbed 18:affef3a7db2a 544 led1 = !led1;
AntonLS 19:afcbb425b3cf 545 led2 = !led2;
AntonLS 19:afcbb425b3cf 546 // buzz = (foo & 2)>>1;
AntonLS 13:28332f65d14b 547 // rts = !rts;
AntonLS 20:d6c6099b60be 548
AntonLS 21:32f022efcc09 549 // Check battery level every 30s.
AntonLS 21:32f022efcc09 550 if( 0 == (foo % 60) ) updateBatt( getBattLevel() );
AntonLS 13:28332f65d14b 551 }
AntonLS 13:28332f65d14b 552
AntonLS 12:6d313d575f84 553 /*
AntonLS 12:6d313d575f84 554 void led_thread( void const *args )
AntonLS 12:6d313d575f84 555 {
AntonLS 12:6d313d575f84 556 while( true )
AntonLS 12:6d313d575f84 557 {
AntonLS 12:6d313d575f84 558 led0 = !led0;
AntonLS 12:6d313d575f84 559 led1 = !led1;
AntonLS 12:6d313d575f84 560 Thread::wait( 1000 );
AntonLS 12:6d313d575f84 561 }
AntonLS 12:6d313d575f84 562 }
AntonLS 12:6d313d575f84 563 */
AntonLS 12:6d313d575f84 564
AntonLS 13:28332f65d14b 565
AntonLS 0:28ca4562fe1a 566 int main( void )
AntonLS 0:28ca4562fe1a 567 {
AntonLS 0:28ca4562fe1a 568 Ticker ticker;
AntonLS 19:afcbb425b3cf 569 ticker.attach( periodicCallback, 0.5 /*** 0.1 ***/ /* 1 */ );
AntonLS 19:afcbb425b3cf 570
AntonLS 19:afcbb425b3cf 571 /*
AntonLS 19:afcbb425b3cf 572 // Thread thread( led_thread );
AntonLS 19:afcbb425b3cf 573 */
AntonLS 19:afcbb425b3cf 574
AntonLS 19:afcbb425b3cf 575 /////pcfc.baud( 57600 );
AntonLS 19:afcbb425b3cf 576
AntonLS 19:afcbb425b3cf 577 /*
AntonLS 19:afcbb425b3cf 578 DEBUG( "Initialising the nRF51822\n\r" );
AntonLS 19:afcbb425b3cf 579 */
AntonLS 2:fe1566cdb6e7 580
AntonLS 0:28ca4562fe1a 581 ble.init();
elmbed 18:affef3a7db2a 582
AntonLS 11:d3aa5fca2330 583 ble.onConnection( connectionCallback );
AntonLS 0:28ca4562fe1a 584 ble.onDisconnection( disconnectionCallback );
AntonLS 0:28ca4562fe1a 585 ble.onDataWritten( onDataWritten );
AntonLS 0:28ca4562fe1a 586 ble.onDataSent( onDataSent );
AntonLS 0:28ca4562fe1a 587
AntonLS 0:28ca4562fe1a 588 /* setup advertising */
AntonLS 20:d6c6099b60be 589 setAdvData();
AntonLS 5:1b9734e68327 590
AntonLS 19:afcbb425b3cf 591 /////pcfc.printf( "\r\nNano nano! I am \"%s\"\r\n", deviceName );
AntonLS 19:afcbb425b3cf 592
AntonLS 19:afcbb425b3cf 593 /*
AntonLS 19:afcbb425b3cf 594 #if LOOPBACK_MODE
AntonLS 19:afcbb425b3cf 595 pcfc.printf( "\r\nIn BLE Loopback mode.\r\n" );
AntonLS 19:afcbb425b3cf 596 #endif
AntonLS 19:afcbb425b3cf 597 */
AntonLS 19:afcbb425b3cf 598
AntonLS 13:28332f65d14b 599 uint32_t p_count;
AntonLS 13:28332f65d14b 600 uint32_t pstorageErr = pstorage_init(); // This needs to be called, even though apparently called in bootloader--Check other stuff.
AntonLS 13:28332f65d14b 601 pstorage_access_status_get( &p_count );
AntonLS 13:28332f65d14b 602
AntonLS 19:afcbb425b3cf 603 /*
AntonLS 19:afcbb425b3cf 604 // pcfc.printf( "\r\nInitial pstorage count: %d\r\n", p_count );
AntonLS 19:afcbb425b3cf 605
AntonLS 19:afcbb425b3cf 606 if( NRF_SUCCESS != pstorageErr ) pcfc.printf( "\r\nWarn: pstorage init error: %x\r\n", pstorageErr );
AntonLS 19:afcbb425b3cf 607 else
AntonLS 19:afcbb425b3cf 608 {
AntonLS 19:afcbb425b3cf 609 pstorageErr = pstorage_setup();
AntonLS 19:afcbb425b3cf 610 if( NRF_SUCCESS != pstorageErr ) pcfc.printf( "\r\nWarn: pstorage setup error: %x\r\n", pstorageErr );
AntonLS 19:afcbb425b3cf 611 else
AntonLS 19:afcbb425b3cf 612 {
AntonLS 19:afcbb425b3cf 613 pstorageErr = pstorage_read_test();
AntonLS 19:afcbb425b3cf 614 if( NRF_SUCCESS != pstorageErr ) pcfc.printf( "\r\nWarn: pstorage read attempt error: %x\r\n", pstorageErr );
AntonLS 19:afcbb425b3cf 615 else
AntonLS 19:afcbb425b3cf 616 {
AntonLS 19:afcbb425b3cf 617 // In this test setup, we use the load callback to signal start to clear,
AntonLS 19:afcbb425b3cf 618 // then we use the clear callback to signal start to write.
AntonLS 19:afcbb425b3cf 619 }
AntonLS 19:afcbb425b3cf 620 }
AntonLS 19:afcbb425b3cf 621 }
AntonLS 19:afcbb425b3cf 622 */
AntonLS 19:afcbb425b3cf 623
AntonLS 0:28ca4562fe1a 624 DeviceInformationService deviceInfo( ble, "TRX", "TrueAgility", "SN0001", "hw-rev1", "fw-rev1" );
AntonLS 19:afcbb425b3cf 625 BatteryService battService( ble );
AntonLS 20:d6c6099b60be 626 battServiceP = &battService;
AntonLS 21:32f022efcc09 627 updateBatt( getBattLevel() );
AntonLS 0:28ca4562fe1a 628
AntonLS 19:afcbb425b3cf 629 /* Enable over-the-air firmware updates. Instantiating DFUService introduces a
AntonLS 0:28ca4562fe1a 630 * control characteristic which can be used to trigger the application to
AntonLS 0:28ca4562fe1a 631 * handover control to a resident bootloader. */
AntonLS 0:28ca4562fe1a 632 DFUService dfu( ble );
AntonLS 0:28ca4562fe1a 633
AntonLS 19:afcbb425b3cf 634 UARTService uartService( ble );
AntonLS 0:28ca4562fe1a 635 uartServicePtr = &uartService;
AntonLS 0:28ca4562fe1a 636
AntonLS 21:32f022efcc09 637 ble.setAdvertisingInterval( Gap::MSEC_TO_ADVERTISEMENT_DURATION_UNITS( 132 ) );
AntonLS 21:32f022efcc09 638 ble.startAdvertising();
AntonLS 21:32f022efcc09 639
AntonLS 19:afcbb425b3cf 640 PhoneAppIO *phone = new PhoneAppIO( ble,
AntonLS 19:afcbb425b3cf 641 uartServicePtr->getRXCharacteristicHandle(),
AntonLS 19:afcbb425b3cf 642 uartServicePtr->getTXCharacteristicHandle() );
AntonLS 19:afcbb425b3cf 643
elmbed 18:affef3a7db2a 644 phone->loopbackMode = LOOPBACK_MODE;
elmbed 18:affef3a7db2a 645 phoneP = phone;
elmbed 18:affef3a7db2a 646
AntonLS 19:afcbb425b3cf 647 // DigitalOut *buzzPin = new DigitalOut(p20);
AntonLS 19:afcbb425b3cf 648 // *buzzPin = 1;
elmbed 17:d8b901d791fd 649 setup();
elmbed 18:affef3a7db2a 650 //radio_init();
AntonLS 11:d3aa5fca2330 651 tmr.start();
elmbed 18:affef3a7db2a 652
AntonLS 11:d3aa5fca2330 653 // Main Loop
AntonLS 19:afcbb425b3cf 654 while( true ) // for( uint32_t loop=1; ;loop++ )
AntonLS 0:28ca4562fe1a 655 {
AntonLS 0:28ca4562fe1a 656 ble.waitForEvent();
AntonLS 19:afcbb425b3cf 657
AntonLS 19:afcbb425b3cf 658 /**/ toPhoneChk(); // Write any pending data to phone.
AntonLS 19:afcbb425b3cf 659
AntonLS 19:afcbb425b3cf 660 /*
AntonLS 19:afcbb425b3cf 661 while( 0 <= phone.getchar() ); // Eat input.
AntonLS 19:afcbb425b3cf 662
AntonLS 19:afcbb425b3cf 663 // if( !(loop % 50) ) phone.printf( "Post: %d\r\n", tmr.read_ms() );
AntonLS 19:afcbb425b3cf 664
AntonLS 19:afcbb425b3cf 665 app_sched_execute(); // Attempt to get pstorage enqueued cmd callbacks.
AntonLS 19:afcbb425b3cf 666 */
AntonLS 19:afcbb425b3cf 667
AntonLS 19:afcbb425b3cf 668 /***
elmbed 18:affef3a7db2a 669 if (phoneToDevPos > 0)
elmbed 18:affef3a7db2a 670 {
elmbed 18:affef3a7db2a 671 getRadioInput(phoneToDev, phoneToDevPos );
elmbed 18:affef3a7db2a 672 phoneToDevPos = 0;
elmbed 18:affef3a7db2a 673 }
AntonLS 19:afcbb425b3cf 674 ***/
AntonLS 19:afcbb425b3cf 675
AntonLS 19:afcbb425b3cf 676 /**/ int bytes = MIN( PHTODEV_BUF_LEN, phoneP->readable() );
AntonLS 19:afcbb425b3cf 677 /**/ getRadioInput( phoneToDev, phoneP->read( phoneToDev, bytes, 1 ) );
AntonLS 19:afcbb425b3cf 678
elmbed 17:d8b901d791fd 679 loop();
elmbed 18:affef3a7db2a 680 //radio_loop();
AntonLS 19:afcbb425b3cf 681
AntonLS 19:afcbb425b3cf 682 /***
elmbed 18:affef3a7db2a 683 if (connected)
AntonLS 13:28332f65d14b 684 {
elmbed 18:affef3a7db2a 685 phoneP->maybeHandleWrite();
elmbed 18:affef3a7db2a 686 }
AntonLS 13:28332f65d14b 687
elmbed 18:affef3a7db2a 688 while( 0 <= phone->getchar() ); // Eat input.
AntonLS 19:afcbb425b3cf 689 ***/
AntonLS 0:28ca4562fe1a 690 }
AntonLS 0:28ca4562fe1a 691 }
AntonLS 0:28ca4562fe1a 692
AntonLS 15:b86c4b798aa1 693 /**@brief Function for error handling, which is called when an error has occurred.
AntonLS 15:b86c4b798aa1 694 *
AntonLS 15:b86c4b798aa1 695 * @warning This handler is an example only and does not fit a final product. You need to analyze
AntonLS 15:b86c4b798aa1 696 * how your product is supposed to react in case of error.
AntonLS 15:b86c4b798aa1 697 *
AntonLS 15:b86c4b798aa1 698 * @param[in] error_code Error code supplied to the handler.
AntonLS 15:b86c4b798aa1 699 * @param[in] line_num Line number where the handler is called.
AntonLS 15:b86c4b798aa1 700 * @param[in] p_file_name Pointer to the file name.
AntonLS 15:b86c4b798aa1 701 */
AntonLS 15:b86c4b798aa1 702 void $Sub$$app_error_handler( uint32_t error_code, uint32_t line_num, const uint8_t * p_file_name )
AntonLS 15:b86c4b798aa1 703 {
AntonLS 15:b86c4b798aa1 704 // nrf_gpio_pin_set( ASSERT_LED_PIN_NO );
elmbed 18:affef3a7db2a 705 //led1 = 1;
AntonLS 15:b86c4b798aa1 706
AntonLS 15:b86c4b798aa1 707 // This call can be used for debug purposes during application development.
AntonLS 15:b86c4b798aa1 708 // @note CAUTION: Activating this code will write the stack to flash on an error.
AntonLS 15:b86c4b798aa1 709 // This function should NOT be used in a final product.
AntonLS 15:b86c4b798aa1 710 // It is intended STRICTLY for development/debugging purposes.
AntonLS 15:b86c4b798aa1 711 // The flash write will happen EVEN if the radio is active, thus interrupting
AntonLS 15:b86c4b798aa1 712 // any communication.
AntonLS 15:b86c4b798aa1 713 // Use with care. Uncomment the line below to use.
AntonLS 15:b86c4b798aa1 714 // ble_debug_assert_handler(error_code, line_num, p_file_name);
AntonLS 15:b86c4b798aa1 715
AntonLS 15:b86c4b798aa1 716 // On assert, the system can only recover with a reset.
AntonLS 15:b86c4b798aa1 717 NVIC_SystemReset();
AntonLS 15:b86c4b798aa1 718 }
AntonLS 15:b86c4b798aa1 719
AntonLS 0:28ca4562fe1a 720 /* EOF */