Important changes to repositories hosted on mbed.com
Mbed hosted mercurial repositories are deprecated and are due to be permanently deleted in July 2026.
To keep a copy of this software download the repository Zip archive or clone locally using Mercurial.
It is also possible to export all your personal repositories from the account settings page.
Dependencies: BLE_API mbed nRF51822
Revision 0:1538004cf391, committed 2018-10-03
- Comitter:
- omnipharious
- Date:
- Wed Oct 03 21:49:43 2018 +0000
- Commit message:
- 1st commit
Changed in this revision
diff -r 000000000000 -r 1538004cf391 BLE_API.lib --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/BLE_API.lib Wed Oct 03 21:49:43 2018 +0000 @@ -0,0 +1,1 @@ +http://mbed.org/teams/Bluetooth-Low-Energy/code/BLE_API/#a782d73aae68
diff -r 000000000000 -r 1538004cf391 DotStar.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/DotStar.cpp Wed Oct 03 21:49:43 2018 +0000 @@ -0,0 +1,129 @@ +#include "DotStar.h" + +SPI SPI1(P0_5,NC,P0_4); + +// Constructor for 'soft' (bitbang) SPI -- any two pins can be used +DotStar::DotStar(uint16_t n, uint8_t data, uint8_t clock) : + dataPin(data), clockPin(clock), brightness(0), pixels(NULL) +{ + updateLength(n); +} + +void DotStar::begin(void) { // Initialize SPI + //SPI1.begin(clockPin, dataPin, P0_29);//SCK, MOSI, MISO + //SPI1.transfer(0xFF); +} + +void DotStar::updateLength(uint16_t n) { + if(pixels) free(pixels); + uint16_t bytes = n * 3; // COLOR: 3 bytes/pixel + if((pixels = (uint8_t *)malloc(bytes))) { + numLEDs = n; + clear(); + } else { + numLEDs = 0; + } +} + +//------------------------------------------------------------------------------- +//------------------------------------------------------------------------------- +void DotStar::show(void) { + + if(!pixels) return; + + + uint8_t *ptr = pixels, i; // -> LED data + uint16_t n = numLEDs; // Counter + uint16_t b16 = (uint16_t)brightness; // Type-convert for fixed-point math + + // Soft (bitbang) SPI + + for(i=0; i<4; i++) SPI1.write(0x00); // Start-frame marker + if(brightness) { // Scale pixel brightness on output + do { // For each pixel... + SPI1.write(0xFF); // Pixel start + for(i=0; i<3; i++) SPI1.write((*ptr++ * b16) >> 8); // Scale, write + } while(--n); + } else { // Full brightness (no scaling) + do { // For each pixel... + SPI1.write(0xFF); // Pixel start + for(i=0; i<3; i++) SPI1.write(*ptr++); // R,G,B + } while(--n); + } + //Remove end-frame below if last led goes all white + //for(i=0; i<4; i++) SPI1.write(0xFF); // End-frame marker (see note above) + +} + + +void DotStar::clear() { // Write 0s (off) to full pixel buffer + memset(pixels, 0, numLEDs * 3); // COLOR: 3 bytes/pixel +} + +// Set pixel color, separate R,G,B values (0-255 ea.) +void DotStar::setPixelColor( + uint16_t n, uint8_t r, uint8_t g, uint8_t b) { + if(n < numLEDs) { + uint8_t *p = &pixels[n * 3]; + p[0] = r; + p[1] = g; + p[2] = b; + //SPI1.transfer(0xFF); + } +} + +// Set pixel color, 'packed' RGB value (0x000000 - 0xFFFFFF) +void DotStar::setPixelColor(uint16_t n, uint32_t c) { + if(n < numLEDs) { + uint8_t *p = &pixels[n * 3]; + p[0] = (uint8_t)(c >> 16); + p[1] = (uint8_t)(c >> 8); + p[2] = (uint8_t)c; + } +} + +// Convert separate R,G,B to packed value +uint32_t DotStar::Color(uint8_t r, uint8_t g, uint8_t b) { + return ((uint32_t)r << 16) | ((uint32_t)g << 8) | b; +} + +// Read color from previously-set pixel, returns packed RGB value. +uint32_t DotStar::getPixelColor(uint16_t n) const { + if(n >= numLEDs) return 0; + uint8_t *p = &pixels[n * 3]; + return ((uint32_t)p[0] << 16) | + ((uint32_t)p[1] << 8) | + (uint32_t)p[2]; +} + +uint16_t DotStar::numPixels(void) { // Ret. strip length + return numLEDs; +} + +// Set global strip brightness. This does not have an immediate effect; +// must be followed by a call to show(). Not a fan of this...for various +// reasons I think it's better handled in one's sketch, but it's here for +// parity with the NeoPixel library. Good news is that brightness setting +// in this library is 'non destructive' -- it's applied as color data is +// being issued to the strip, not during setPixel(), and also means that +// getPixelColor() returns the exact value originally stored. +void DotStar::setBrightness(uint8_t b) { + // Stored brightness value is different than what's passed. This + // optimizes the actual scaling math later, allowing a fast 8x8-bit + // multiply and taking the MSB. 'brightness' is a uint8_t, adding 1 + // here may (intentionally) roll over...so 0 = max brightness (color + // values are interpreted literally; no scaling), 1 = min brightness + // (off), 255 = just below max brightness. + brightness = b + 1; +} + +uint8_t DotStar::getBrightness(void) const { + return brightness - 1; // Reverse above operation +} + +// Return pointer to the library's pixel data buffer. Use carefully, +// much opportunity for mayhem. It's mostly for code that needs fast +// transfers, e.g. SD card to LEDs. Color data is in BGR order. +uint8_t *DotStar::getPixels(void) const { + return pixels; +} \ No newline at end of file
diff -r 000000000000 -r 1538004cf391 DotStar.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/DotStar.h Wed Oct 03 21:49:43 2018 +0000 @@ -0,0 +1,46 @@ +#ifndef _DOT_STAR_H_ +#define _DOT_STAR_H_ + +#include "mbed.h" + +class DotStar +{ + public: + + DotStar(uint16_t n, uint8_t d, uint8_t c); + + void begin(); // Prime pins/SPI for output + void clear(); // Set all pixel data to zero + void setBrightness(uint8_t); // Set global brightness 0-255 + void setPixelColor(uint16_t n, uint32_t c); + void setPixelColor(uint16_t n, uint8_t r, uint8_t g, uint8_t b); + void show(void); // Issue color data to strip + void updatePins(void); // Change pin assignments (HW) + void updatePins(uint8_t d, uint8_t c); // Change pin assignments (SW) + void updateLength(uint16_t n); // Change length + uint32_t + Color(uint8_t r, uint8_t g, uint8_t b), // R,G,B to 32-bit color + getPixelColor(uint16_t n) const; // Return 32-bit pixel color + uint16_t + numPixels(void); // Return number of pixels + uint8_t + getBrightness(void) const, // Return global brightness + *getPixels(void) const, // Return pixel data pointer + sine8(uint8_t) const, + gamma8(uint8_t) const; + + + private: + uint16_t + numLEDs; // Number of pixels + uint8_t + dataPin, // If soft SPI, data pin # + clockPin, // If soft SPI, clock pin # + brightness, // Global brightness setting + *pixels, // LED RGB values (3 bytes ea.) + rOffset, // Index of red in 3-byte pixel + gOffset, // Index of green byte + bOffset; // Index of blue byte +}; + +#endif \ No newline at end of file
diff -r 000000000000 -r 1538004cf391 main.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/main.cpp Wed Oct 03 21:49:43 2018 +0000 @@ -0,0 +1,830 @@ +/* + +Copyright (c) 2012-2014 RedBearLab + +Permission is hereby granted, free of charge, to any person obtaining a copy of this software +and associated documentation files (the "Software"), to deal in the Software without restriction, +including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, +and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, +subject to the following conditions: +The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, +ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +*/ + +#include "DotStar.h" +#include "BLE.h" +#include "mbed.h" +#include "pstorage.h" +#include "nrf_error.h" + +#define BLE_UUID_TXRX_SERVICE 0x0000 /**< The UUID of the Nordic UART Service. */ +#define BLE_UUID_TX_CHARACTERISTIC 0x0002 /**< The UUID of the TX Characteristic. */ +#define BLE_UUIDS_RX_CHARACTERISTIC 0x0003 /**< The UUID of the RX Characteristic. */ + +#define DATAPIN 0 +#define CLOCKPIN 0 + +#define TXRX_BUF_LEN 20 + +#define NUMPIXELS 4 +#define NAMELENGTH 8 +#define NAMEBLOCK 0 +#define PARAMSBLOCK 8 +#define PARAMSLENGTH 16 +#define ELEMSLENGTH 19 +#define ELEMSBLOCK 24 + +#define BLOCKSIZE 100 + +DotStar strip = DotStar(NUMPIXELS, DATAPIN, CLOCKPIN); +BLE ble; +Serial serial(USBTX, USBRX); // tx, rx + +uint8_t DEFAULTNAME[NAMELENGTH] = {'b','e','t','a',0,0,0,0}; +uint8_t elements[ELEMSLENGTH] = {0,}; +uint8_t parameters[PARAMSLENGTH] = {2,5,'4',1,0,1,0,0,'F','F','F','F',4,0,0,0}; +uint8_t masterMode[12]; + +Gap::AddressType_t type; +Gap::Address_t address; +uint32_t peerColor1,peerColor2,peerColor3; +int location; + +/*COLORS*/ +uint32_t RED = 0x0000FF; +uint32_t LIME = 0x00FF00; +uint32_t YELLOW = 0x00FFFF; +uint32_t BLUE = 0xFF0000; +uint32_t MAGENTA = 0xFF00FF; +uint32_t CYAN = 0xFFFF00; +uint32_t WHITE = 0xFFFFFF; +uint32_t ORANGE = 0x0055FF; +uint32_t FUSCIA = 0x5500FF; +uint32_t WATER = 0xFF5500; +uint32_t VIOLET = 0xFF0055; +uint32_t LIGHTGREEN = 0x00FF55; +uint32_t SEAFOAM = 0x55FF00; +uint32_t ROSEGOLD = 0x5555FF; +uint32_t LIGHTPURPLE = 0xFF5555; + +uint32_t retval; +pstorage_handle_t handle; +bool readvertise = false; + +int head, tail; // Index of first 'on' and 'off' pixels +uint32_t color = 0xFFFF00; // 'On' color (starts white) +uint32_t newColor = 0xFFFF00; +char mode = '4'; //starts solid +double brightness = 0, MAX = 10, speed = 640; +double duration = .06; +int direction = 1; +double step = 0, total = 300; +uint32_t c2 = MAGENTA, temp; +uint8_t everything[44]; +bool synergy = false; +int tick = 0; +bool resetTick = false; +uint8_t master = 0; +uint8_t showNum = 0; +int waterfallMax = 640, waterfallCounter = 0; +uint8_t threshold = 4; +bool showColor = false; +uint32_t deviceColor; + +uint8_t random = false, advertise = true, length = 5; + +uint8_t input[8] = {0,}; +uint8_t eventID = 1; + +uint32_t colors [15] = {WHITE,CYAN,BLUE,LIME,RED,MAGENTA,YELLOW,ORANGE,FUSCIA,WATER,VIOLET,LIGHTGREEN,SEAFOAM,ROSEGOLD,LIGHTPURPLE}; +uint8_t j = 0; + + +// The Nordic UART Service +static const uint8_t uart_base_uuid[] = {0x71, 0x3D, 0, 0, 0x50, 0x3E, 0x4C, 0x75, 0xBA, 0x94, 0x31, 0x48, 0xF1, 0x8D, 0x94, 0x1E}; +static const uint8_t uart_tx_uuid[] = {0x71, 0x3D, 0, 3, 0x50, 0x3E, 0x4C, 0x75, 0xBA, 0x94, 0x31, 0x48, 0xF1, 0x8D, 0x94, 0x1E}; +static const uint8_t uart_rx_uuid[] = {0x71, 0x3D, 0, 2, 0x50, 0x3E, 0x4C, 0x75, 0xBA, 0x94, 0x31, 0x48, 0xF1, 0x8D, 0x94, 0x1E}; +static const uint8_t uart_base_uuid_rev[] = {0x1E, 0x94, 0x8D, 0xF1, 0x48, 0x31, 0x94, 0xBA, 0x75, 0x4C, 0x3E, 0x50, 0, 0, 0x3D, 0x71}; + + +uint8_t txPayload[TXRX_BUF_LEN] = {0,}; +uint8_t rxPayload[TXRX_BUF_LEN] = {0,}; + +GattCharacteristic txCharacteristic (uart_tx_uuid, txPayload, 1, TXRX_BUF_LEN, GattCharacteristic::BLE_GATT_CHAR_PROPERTIES_WRITE | GattCharacteristic::BLE_GATT_CHAR_PROPERTIES_WRITE_WITHOUT_RESPONSE); + +GattCharacteristic rxCharacteristic (uart_rx_uuid, rxPayload, 1, TXRX_BUF_LEN, GattCharacteristic::BLE_GATT_CHAR_PROPERTIES_NOTIFY); + +GattCharacteristic *uartChars[] = {&txCharacteristic, &rxCharacteristic}; + +GattService uartService(uart_base_uuid, uartChars, sizeof(uartChars) / sizeof(GattCharacteristic *)); + + +void sendMsg(uint8_t *str, int length){ + ble.updateCharacteristicValue(rxCharacteristic.getValueAttribute().getHandle(), str, length); +} + + +/* ================================================================================================================================================== +** +** CLEAR PROGRAM MEMORY +** + ==================================================================================================================================================*/ + +// Request clearing of one block where block size is 16 bytes. +void ClearMemory() +{ + retval = pstorage_clear(&handle, BLOCKSIZE); + if (retval == NRF_SUCCESS) + { + // Clear successfully requested. Wait for operation result. + //serial.printf("Clear successfully performed.\r\n"); + } + else + { + // Failed to request clear, take corrective action. + //serial.printf("Clear unsuccessfully performed.\r\n"); + } +} + +/* ================================================================================================================================================== +** +** STORING DATA INTO MEMORY FROM PROGRAM SPACE +** +** ==================================================================================================================================================*/ + +// Store the name, device parameters, and elements +void StoreEverything(uint8_t *params) +{ + retval = pstorage_store(&handle, params, 44, 0); //store new name in block 0 with an offset of 16 + if (retval == NRF_SUCCESS) + { + //serial.printf("STORE Everything: %02x:%02x:%02x:%02x - %02x:%02x:%02x:%02x \r\n", params[0],params[1],params[2],params[3],params[4],params[5],params[6],params[7]); + //serial.printf("Everything Store successfully requested. Wait for operation result.\r\n"); + } + else {//serial.printf("Failed to request store, take corrective action.\r\n"); + } +} + +/* ================================================================================================================================================== +** +** LOADING DATA INTO PROGRAM SPACE FROM MEMORY +** +** ==================================================================================================================================================*/ + +//Load the name from memory into input address +void LoadName(uint8_t *name) +{ + retval = pstorage_load(name, &handle, NAMELENGTH, NAMEBLOCK); + if (retval == NRF_SUCCESS) + { + //serial.printf("Loading Advertising Name\n"); + } + else { + //serial.printf("Failed to load, take corrective action.\r\n"); + } + //serial.printf("LOAD: %02x:%02x:%02x:%02x - %02x:%02x:%02x:%02x \r\n",name[0],name[1],name[2],name[3], name[4],name[5],name[6],name[7]); +} + +//Load the name from memory into input address +void LoadParams(uint8_t *params) +{ + retval = pstorage_load(params, &handle, PARAMSLENGTH, PARAMSBLOCK); + if (retval == NRF_SUCCESS) + { + //serial.printf("Loading Parameters\n"); + } + else { + //serial.printf("Failed to load, take corrective action.\r\n"); + } + //serial.printf("LOAD: %02x:%02x:%02x:%02x - %02x:%02x:%02x:%02x \r\n",params[0],params[1],params[2],params[3], params[4],params[5],params[6],params[7]); +} + +//Load the name from memory into input address +void LoadElements(uint8_t *params) +{ + retval = pstorage_load(params, &handle, 20, ELEMSBLOCK); + if (retval == NRF_SUCCESS) + { + } + else { + } +} + +void scanCallback(const Gap::AdvertisementCallbackParams_t *params) { + /*serial.printf("adv peerAddr[%02x %02x %02x %02x %02x %02x] rssi %d, isScanResponse %u, AdvertisementType %u\r\n", + params->peerAddr[5], params->peerAddr[4], params->peerAddr[3], params->peerAddr[2], params->peerAddr[1], params->peerAddr[0], + params->rssi, params->isScanResponse, params->type); + + serial.printf("\n"); + for (uint8_t i = 0; i < params->advertisingDataLen; i++) { + serial.printf("%c",params->advertisingData[i]); + } + serial.printf("\n");*/ + + /* // MASTER COMMANDS DETECTED + if (!(params->isScanResponse) && params->advertisingData[4] == 0xff && params->advertisingData[5] == 'M' && params->advertisingData[6] == eventID) { + memcpy(masterMode,params->advertisingData+7,12); + } + // OTHER SPARK DETECTED + if (params->isScanResponse && params->advertisingData[1] == 0xff && params->advertisingData[2] == 0xAB && params->advertisingData[3] == eventID) { + if(advertise) { + uint8_t counter = 0; + for (uint8_t i = 4; i < 4+ELEMSLENGTH; i++) { + if(params->advertisingData[i] != 0 && params->advertisingData[i] == elements[i-4]){counter++;} + } + //serial.printf("There are %d elements in common\n",counter); + if(counter>=threshold){ + tick = 9600; + //SHIFT COLORS DOWN IF MULTIPLE SYNERGISTIC SPARKS + peerColor3=peerColor2; + peerColor2=peerColor1; + + peerColor1 = colors[params->peerAddr[0]%15]; + } + } + } */ +} + + +//Handles for Reading and Writing to Flash Memory +static void cb_handler(pstorage_handle_t * cllbck_handle, + uint8_t op_code, + uint32_t result, + uint8_t * p_data, + uint32_t data_len) +{ + + //serial.printf("Callback handler successful\r\n"); + + switch(op_code) + { + case PSTORAGE_CLEAR_OP_CODE: + if (result == NRF_SUCCESS) + { + //serial.printf("Clear operation successful in Callback\r\n"); + } + else + { + //serial.printf("Clear operation failed in Callback\r\n"); + } + break; + + + case PSTORAGE_LOAD_OP_CODE: + if (result == NRF_SUCCESS) + { + //serial.printf("Load operation successful in Callback\r\n"); + } + else + { + //serial.printf("Load operation failed in Callback\r\n"); + } + break; + case PSTORAGE_STORE_OP_CODE: + if (result == NRF_SUCCESS) + { + //serial.printf("Store operation successful in Callback\r\n"); + } + else + { + //serial.printf("Store operation failed in Callback\r\n"); + } + if (readvertise) { + readvertise = false; + ble.gap().clearScanResponse(); + //Load the data here to ensure that the store command is complete + uint8_t dest_data[8] = {0,}; + LoadName(dest_data); + //Start the advertising process with the new name + ble.clearAdvertisingPayload(); + ble.gap().accumulateAdvertisingPayload(GapAdvertisingData::BREDR_NOT_SUPPORTED); + ble.gap().setAdvertisingType(GapAdvertisingParams::ADV_CONNECTABLE_UNDIRECTED); + ble.gap().accumulateAdvertisingPayload(GapAdvertisingData::SHORTENED_LOCAL_NAME, + dest_data, NAMELENGTH); + ble.gap().accumulateAdvertisingPayload(GapAdvertisingData::COMPLETE_LIST_128BIT_SERVICE_IDS, + (const uint8_t *)uart_base_uuid_rev, sizeof(uart_base_uuid)); + ble.gap().startAdvertising(); + ble.gap().startScan(scanCallback); + if (advertise){ + uint8_t adv_elements[ELEMSLENGTH+2] = {0xAB,eventID,}; + memcpy(adv_elements+2,elements,ELEMSLENGTH); + ble.accumulateScanResponse(GapAdvertisingData::MANUFACTURER_SPECIFIC_DATA,adv_elements, sizeof(adv_elements)); + } else { + uint8_t adv_elements[ELEMSLENGTH+2] = {0xAB,eventID}; + ble.accumulateScanResponse(GapAdvertisingData::MANUFACTURER_SPECIFIC_DATA,adv_elements, sizeof(adv_elements)); + } + } + break; + } + +} + + +uint8_t char2hex (char nibble1, char nibble2) +{ + uint8_t number = 0; + if (nibble1>=48 && nibble1<=57) //MSN(0-9) + number = (nibble1-48)*16; + else if (nibble1 >= 65 && nibble1 <= 70) //MSN(A-F) + number = (nibble1 - 55)*16; + if(nibble2>=48 && nibble2<=57)//LSN(0-9) + number += (nibble2-48); + else if (nibble2 >= 65 && nibble2 <= 70) //LSN(A-F) + number += (nibble2 - 55); + + return number; + + +} + +bool fade(uint32_t start, uint32_t finish) { + + bool finished = false; + uint8_t b0, b1, g0, g1, r0, r1; + double blue,green,red; + b0 = (start >> 16); + b1 = (finish >> 16); + g0 = start >> 8; + g1 = finish >> 8; + r0 = start; + r1 = finish; + + + blue = (b1 - b0)*(step/total)+ b0; + green = (g1-g0)*(step/total)+g0; + red = (r1-r0)*(step/total)+r0; + + + temp = ((uint32_t) blue<<16)|((uint32_t) green<<8)|(uint32_t) red; + for (uint8_t i = 0; i < NUMPIXELS; i++) { + strip.setPixelColor(i,temp); + } + strip.show(); + if (step+1 <= total) + { + step++; + + } else { + //color = newColor; + step = 0; + finished = true; + } + return finished; +} + + +/** + * Callback triggered upon a connection event. Needs to halt scanning. + */ +void connectionCallback(const Gap::ConnectionCallbackParams_t *params) +{ + ble.gap().stopScan(); + masterMode[0] = 0; +} + +/** + * Callback triggered upon a disconnection event. Needs to re-enable advertisements. + */ +void disconnectionCallback(Gap::Handle_t gaphandle, Gap::DisconnectionReason_t reason) +{ + memset(everything, 0, 44); + memcpy(everything, input, NAMELENGTH); + memcpy(everything+PARAMSBLOCK, parameters, PARAMSLENGTH); + memcpy(everything+ELEMSBLOCK,elements,ELEMSLENGTH); + //serial.printf("Everything - %c,%c,%c,%c ... %02x:%02x:%02x:%02x\n",everything[0],everything[1],everything[2],everything[3],everything[8],everything[9],everything[10],everything[11]); + ClearMemory(); + readvertise = true; + StoreEverything(everything); +} + + + +uint32_t ble_advdata_parser(uint8_t type, uint8_t advdata_len, uint8_t *p_advdata, uint8_t *len, uint8_t *p_field_data) +{ + uint8_t index=0; + uint8_t field_length, field_type; + + while(index<advdata_len) + { + field_length = p_advdata[index]; + field_type = p_advdata[index+1]; + if(field_type == type) + { + memcpy(p_field_data, &p_advdata[index+2], (field_length-1)); + *len = field_length - 1; + return NRF_SUCCESS; + } + index += field_length + 1; + } + return NRF_ERROR_NOT_FOUND; +} + + +/** + * This Handler controls all information recevied via BT + */ +void WrittenHandler(const GattWriteCallbackParams *Handler) +{ + uint8_t buf[TXRX_BUF_LEN]; + uint16_t bytesRead; + + if (Handler->handle == txCharacteristic.getValueAttribute().getHandle()) + { + ble.readCharacteristicValue(txCharacteristic.getValueAttribute().getHandle(), buf, &bytesRead); + memset(txPayload, 0, TXRX_BUF_LEN); + memcpy(txPayload, buf, TXRX_BUF_LEN); + } + + char command = buf[0]; + serial.printf("The command is %c\n",command); + switch (command) { + case 'i': //initialization + //serial.printf("Send Data"); + uint8_t packet1[20]; + uint8_t packet2[20]; + memset(packet1,'p', 20); + memset(packet2,'e', 20); + memcpy(packet1+1, parameters, 19); + packet1[13] = threshold; + memcpy(packet2+1, elements, 19); + sendMsg(packet1,20); + sendMsg(packet2,20); + break; + case '1': //fade + mode = '1'; + parameters[2] = buf[0]; //save this to mode byte + break; + case '2': //pulse + mode = '2'; + parameters[2] = buf[0]; //save this to mode byte + break; + case '3': //rays + mode = '3'; + parameters[2] = buf[0]; //save this to mode byte + break; + case '4': //solid + mode = '4'; + parameters[2] = buf[0]; //save this to mode byte + break; + case '5': //sparks + mode = '5'; + waterfallCounter = 0; + parameters[2] = buf[0]; //save this to mode byte + break; + case 'b': //change brightness + MAX = buf[1]*4; + parameters[0] = buf[1]; + break; + case 's': //change speed + { + switch(buf[1]) { + case 0: //slow + speed = 960; + duration = .08; + break; + case 1: //medium + speed = 640; + duration = .06; + break; + case 2: //fast + speed = 320; + duration = .04; + break; + default: + } + parameters[3] = buf[1]; + } + break; + case 'l': //change length + length = buf[1]; + parameters[1] = buf[1]; + break; + case 'r': //set random flag + random = buf[1]; + parameters[4] = buf[1]; + break; + case 'c': + //serial.printf("Color Code - %c%c:%c%c:%c%c\n",buf[1],buf[2],buf[3],buf[4],buf[5],buf[6]); + + uint8_t red = char2hex(buf[1],buf[2]); + uint8_t green = char2hex(buf[3],buf[4]); + uint8_t blue = char2hex(buf[5],buf[6]); + + newColor = ((uint32_t) blue<<16)|((uint32_t) green<<8)|(uint32_t) red; + step = 0; + + parameters[6] = buf[1]; + parameters[7] = buf[2]; + parameters[8] = buf[3]; + parameters[9] = buf[4]; + parameters[10] = buf[5]; + parameters[11] = buf[6]; + break; + case '*': + memset(input, 0, NAMELENGTH); + memcpy(input,buf+1,NAMELENGTH); + break; + case 'a': //set advertising flag + advertise = buf[1]; + parameters[5] = buf[1]; + break; + case 'e': //elements + memcpy(elements,buf+1,ELEMSLENGTH); + //serial.printf("Elements - %d %d %d %d\n",elements[0],elements[1],elements[2],elements[3]); + break; + case '@': //show device color + deviceColor = colors[address[0]%15]; + strip.setBrightness(15); + step = 0; + total = 1200; + showColor = true; + serial.printf("Show Color\n"); + break; + case '&': //change threshold + threshold = buf[1]; + default: + } +} + + + +int main(void) +{ + //Initialize bluetooth module + ble.init(); + + /*Initialize Pstorage Module*/ + retval = pstorage_init(); + if(retval == NRF_SUCCESS) + { + //serial.printf("Module initialization successful\r\n"); + + pstorage_module_param_t param; + + param.block_size = BLOCKSIZE; + param.block_count = 1; + + param.cb = cb_handler; + + retval = pstorage_register(¶m, &handle); //register our pstorage and store store address in handle + if (retval == NRF_SUCCESS) + { + //serial.printf("Registration successful.\r\n"); + //serial.printf("Module id: %u , block: %u \r\n", handle.module_id, handle.block_id); + } else {//serial.printf("Failed to register, take corrective action.\r\n"); + } + } else {//serial.printf("Initialization failed, take corrective action.\r\n"); + } + + LoadElements(elements); + if (elements[0] == 255) { + memset(elements,0,ELEMSLENGTH); + } + + ble.gap().onDisconnection(disconnectionCallback); + ble.gap().onConnection(connectionCallback); + ble.gattServer().onDataWritten(WrittenHandler); + ble.gattServer().addService(uartService); + // set tx power,valid values are -40, -20, -16, -12, -8, -4, 0, 4 + ble.gap().setTxPower(-12); // tx power to -20 + // set adv_interval, 100ms in multiples of 0.625ms. + ble.gap().setAdvertisingInterval(100); + + ble.gap().setScanParams(1000,150,0,true); // (scan interval, scan time,timeout,send scan requests) + + + ble.gap().accumulateAdvertisingPayload(GapAdvertisingData::BREDR_NOT_SUPPORTED); + ble.gap().setAdvertisingType(GapAdvertisingParams::ADV_CONNECTABLE_UNDIRECTED); + + //Load Name + uint8_t dest_data[NAMELENGTH] = {0,}; + LoadName(dest_data); + + //Advertise the Loaded Name + if (dest_data[0] != 255) { + ble.gap().accumulateAdvertisingPayload(GapAdvertisingData::SHORTENED_LOCAL_NAME, + dest_data, NAMELENGTH); + } else { //This is first time powered on so initialize default name and advertise + //serial.printf("Factory Condition .... Loading Default Name\n"); + ble.gap().accumulateAdvertisingPayload(GapAdvertisingData::SHORTENED_LOCAL_NAME, + DEFAULTNAME, NAMELENGTH); + } + ble.gap().accumulateAdvertisingPayload(GapAdvertisingData::COMPLETE_LIST_128BIT_SERVICE_IDS, + (const uint8_t *)uart_base_uuid_rev, sizeof(uart_base_uuid)); + + + + + uint8_t temp_parameters[PARAMSLENGTH]; + //Load Parameters + LoadParams(temp_parameters); + if (temp_parameters[0] != 255) + { + memcpy(parameters,temp_parameters,PARAMSLENGTH); + MAX = parameters[0]*4; + length = parameters[1]; + mode = parameters[2]; + switch(parameters[3]) { + case 0: //slow + speed = 960; + duration = .08; + break; + case 1: //medium + speed = 640; + duration = .06; + break; + case 2: //fast + speed = 320; + duration = .04; + break; + default: + } + random = parameters[4]; + advertise = parameters[5]; + + uint8_t red = char2hex(parameters[6],parameters[7]); + uint8_t green = char2hex(parameters[8],parameters[9]); + uint8_t blue = char2hex(parameters[10],parameters[11]); + + newColor = ((uint32_t) blue<<16)|((uint32_t) green<<8)|(uint32_t) red; + } + + ble.gap().startAdvertising(); + ble.gap().startScan(scanCallback); + if (advertise){ + uint8_t adv_elements[ELEMSLENGTH+2] = {0xAB,eventID}; + memcpy(adv_elements+2,elements,ELEMSLENGTH); + ble.accumulateScanResponse(GapAdvertisingData::MANUFACTURER_SPECIFIC_DATA,adv_elements, sizeof(adv_elements)); + } + + strip.begin(); + + ble.gap().getAddress(&type,address); + + while(1) { + if (showColor) + { + total = 2400; + strip.setBrightness(15); + if (fade(deviceColor,deviceColor)) + showColor = false; + } + else if (masterMode[0]) { + strip.setBrightness(masterMode[1]); + total = 1200; + if (masterMode[2]) { + if (elements[masterMode[3]]) + fade(0,colors[elements[masterMode[3]]%15]); + else + fade(0,0); + } + else { + uint8_t red = char2hex(masterMode[4],masterMode[5]); + uint8_t green = char2hex(masterMode[6],masterMode[7]); + uint8_t blue = char2hex(masterMode[8],masterMode[9]); + uint32_t colour = ((uint32_t) blue<<16)|((uint32_t) green<<8)|(uint32_t) red; + + if(masterMode[3]) { //blink -1 or solid - 0 + fade(0,colour); + } + else{ + fade(colour,colour); + } + } + } + else if(tick>0){ + tick--; + + strip.setPixelColor(0,colors[address[0]%15]); + strip.setPixelColor(1,peerColor3); + strip.setPixelColor(2,peerColor2); + strip.setPixelColor(3,peerColor1); + + if (tick == 0) + { + peerColor1 = 0; + peerColor2 = 0; + peerColor3 = 0; + } + + strip.setBrightness(15); + strip.show(); + } else { + switch(mode) { + case '1': //color fade + { + brightness = MAX; + total = 1200; + if(fade(color, c2)){ + j = (j+1)%7; + color = c2; + c2 = colors[j]; + } + } + break; + case '2': //pulse + { + if (brightness >= MAX){direction = -1;} + else if(brightness <= 0){ + if (random) { + j = (j+1)%15; + color = colors[j]; + } else { + color = newColor; + } + direction = 1;} + + if (MAX == 0) + brightness = 0; + else + brightness += (MAX/speed)*direction; + for (uint8_t i = 0; i < NUMPIXELS; i++) { + strip.setPixelColor(i, color); + } + } + break; + case '3': //rays setup + { + tail = -NUMPIXELS*2; + head = 0; + mode = '['; + } + break; + case '[': //rays + { + brightness = MAX; + strip.setPixelColor(head, color); // 'On' pixel at head + strip.setPixelColor(tail, 0); // 'Off' pixel at tail + + if(++head >= NUMPIXELS*4) { // Increment head index. Off end of strip? + head = 0; + if (random) { + j = (j+1)%15; + color = colors[j]; + } else {color = newColor;} + } + if(++tail >= NUMPIXELS*4) tail = 0; // Increment, reset tail index + wait(duration); + } + break; + case '4': //solid + { + brightness = MAX; + total = 300; + if(fade(color, newColor)) + color = newColor; + } + break; + case '5': //waterfall + { + brightness = MAX; + + if((waterfallCounter)==speed*4) { + strip.setPixelColor(0,0); + strip.setPixelColor(1,color); + strip.setPixelColor(2,color); + strip.setPixelColor(3,0); + } else if ((waterfallCounter)==speed*3) { + strip.setPixelColor(0,color); + strip.setPixelColor(1,color); + strip.setPixelColor(2,color); + strip.setPixelColor(3,color); + } else if ((waterfallCounter)==speed*2) { + strip.setPixelColor(0,color); + strip.setPixelColor(1,0); + strip.setPixelColor(2,0); + strip.setPixelColor(3,color); + } else if ((waterfallCounter)==speed) { + strip.setPixelColor(0,0); + strip.setPixelColor(1,0); + strip.setPixelColor(2,0); + strip.setPixelColor(3,0); + } + if (--waterfallCounter<=0) { + if (random) { + j = (j+1)%15; + color = colors[j]; + } else { + color = newColor; + } + waterfallCounter = speed*4; + } + } + break; + default: + { + + } + break; + } + strip.setBrightness(brightness); + strip.show(); + } + } +} \ No newline at end of file
diff -r 000000000000 -r 1538004cf391 mbed.bld --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/mbed.bld Wed Oct 03 21:49:43 2018 +0000 @@ -0,0 +1,1 @@ +https://os.mbed.com/users/mbed_official/code/mbed/builds/994bdf8177cb \ No newline at end of file
diff -r 000000000000 -r 1538004cf391 nRF51822.lib --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/nRF51822.lib Wed Oct 03 21:49:43 2018 +0000 @@ -0,0 +1,1 @@ +http://mbed.org/teams/Nordic-Semiconductor/code/nRF51822/#a9ed252089c4