File content as of revision 77:0b505d1e15f4:

#define MBED_CONF_MBED_TRACE_ENABLE 1

#include "select-demo.h"

#if DEMO == DEMO_HTTPS

//#include "mbed.h"
#include <events/mbed_events.h>
#include <mbed.h>
#include "ble/BLE.h"
//#include "BLE.h"
#include "ATCmdParser.h"
//#include "BLEDevice.h"

#include "LEDService.h"
#include "ble/services/UARTService.h"
#include "common_config.h"
#include "ATCmdManager.h"
#include "BleManager.h"
UARTService *uart;

DigitalOut alivenessLED(LED1, 0);
DigitalOut actuatedLED(LED2, 0);


static RawSerial *device; // tx, rx
static UARTSerial *_serial; // tx, rx
static ATCmdParser *_parser;
static SMDevicePeripheral *peripheral;
const static char     DEVICE_NAME_MAIN[] = "BLE-UART";
static const uint16_t uuid16_list[] = {LEDService::LED_SERVICE_UUID};
char buffer[BUFFER_LEN];
uint8_t TxBuffer[TX_BUFFER_LEN];
uint8_t RxBuffer[RX_BUFFER_LEN];
static EventQueue eventQueue(/* event count */ 20 * EVENTS_EVENT_SIZE);
//static EventQueue eventQueue2(/* event count */ 10 * EVENTS_EVENT_SIZE);

LEDService *ledServicePtr;


/* allocate statically stacks for the three threads */
//unsigned char rt_stk[1024];
//unsigned char hp_stk[1024];
//unsigned char lp_stk[1024];
unsigned char btle_stk[8*1024];
unsigned char wifi_stk[1024];
unsigned char atcmd_stk[8*1024];
static bool bleInitializationCompleted = false;

/* creates three tread objects with different priorities */
//Thread real_time_thread(osPriorityRealtime, 1024, &rt_stk[0]);
//Thread high_prio_thread(osPriorityHigh, 1024, &hp_stk[0]);
//Thread low_prio_thread(osPriorityNormal, 1024, &lp_stk[0]);
Thread btle_thread(BTLE_THREAD_PRIORITY, 1024, &btle_stk[0]);
Thread wifi_thread(WIFI_THREAD_PRIORITY, 1024, &wifi_stk[0]);
Thread atcmd_thread(ATCMD_THREAD_PRIORITY, 1024, &atcmd_stk[0]);


/* create a semaphore to synchronize the threads */
Semaphore sync_sema;

Thread t;
#include "network-helper.h"

/* List of trusted root CA certificates
 * currently two: GlobalSign, the CA for os.mbed.com and Let's Encrypt, the CA for httpbin.org
 *
 * To add more root certificates, just concatenate them.
 */
#include "https_certificates.h"

// wifi demo
#include "wifi_demo.h"

Mutex _smutex; // Protect memory access
// check free memory

void performFreeMemoryCheck()
{
    _smutex.lock();
       // perform free memory check
    int blockSize = 16;
    int i = 1;
    printf("Checking memory with blocksize %d char ...\n", blockSize);
    while (true) {
        char *p = (char *) malloc(i * blockSize);
        if (p == NULL)
            break;
        free(p);
        ++i;
    }
    printf("Ok for %d char\n", (i - 1) * blockSize);
    _smutex.unlock();

}

void disconnectionCallback(const Gap::DisconnectionCallbackParams_t *params)
{
    (void) params;
    BLE::Instance().gap().startAdvertising();
}

void blinkCallback(void)
{
    alivenessLED = !alivenessLED; /* Do blinky on LED1 to indicate system aliveness. */
}

void EchoBleUartReceived()
{
    uart->writeString(buffer);
    uart->writeString("\n");    //flushes uart output buffer and sends data
}

/**
 * This callback allows the LEDService to receive updates to the ledState Characteristic.
 *
 * @param[in] params
 *     Information about the characterisitc being updated.
 */
void onDataWrittenCallback(const GattWriteCallbackParams *params) {
    if ((params->handle == ledServicePtr->getValueHandle()) && (params->len == 1)) {
        actuatedLED = *(params->data);
    }
    else if ((uart != NULL) && (params->handle == uart->getTXCharacteristicHandle())) {
        uint16_t bytesRead = params->len;

        printf("received %u bytes\n\r ", bytesRead);

        if(bytesRead >= 255){
            printf("Overflow command %u n\r ", bytesRead);
            bytesRead = 255;
        }

        unsigned index = 0;
        for (; index < bytesRead; index++) {
            buffer[index] = params->data[index];
        }

        buffer[index++] = 0;

        printf("Data : %s ",buffer);
        printf("\r\n");
        eventQueue.call(EchoBleUartReceived);

    }
}


/**
 * This function is called when the ble initialization process has failled
 */
void onBleInitError(BLE &ble, ble_error_t error)
{
    printf("\n BLE Initialization failed!! \n");
    
    /* Initialization error handling should go here */
}


/*  handle BLE timouts  */
static int bleTimoutCount = 0;

void printBleTimeoutMsg()
{
    bleTimoutCount++;
    device->printf("\n --- BLE Times out!! bleTimoutCount = %d --- \n", bleTimoutCount);
}

//void timeoutCallback(Gap::TimeoutEventCallback_t* context) {
void timeoutCallback(Gap::TimeoutSource_t timeoutSource) {
    BLE &ble = BLE::Instance();
    eventQueue.call(printBleTimeoutMsg);
}



void printMacAddress()
{
    /* Print out device MAC address to the console*/
    Gap::AddressType_t addr_type;
    Gap::Address_t address;
    BLE::Instance().gap().getAddress(&addr_type, address);
    printf("\nDEVICE MAC ADDRESS: ");
    for (int i = 5; i >= 1; i--){
        printf("%02x:", address[i]);
    }
    printf("%02x\r\n", address[0]);
}

/**
 * Callback triggered when the ble initialization process has finished
 */
void bleInitComplete(BLE::InitializationCompleteCallbackContext *params)
{
    BLE&        ble   = params->ble;
    ble_error_t error = params->error;

    if (error != BLE_ERROR_NONE) {
        /* In case of error, forward the error handling to onBleInitError */
        onBleInitError(ble, error);
        return;
    }

    /* Ensure that it is the default instance of BLE */
    if(ble.getInstanceID() != BLE::DEFAULT_INSTANCE) {
        return;
    }

    ble.gap().onDisconnection(disconnectionCallback);
    ble.gattServer().onDataWritten(onDataWrittenCallback);
    ble.gap().onTimeout(timeoutCallback);

    bool initialValueForLEDCharacteristic = false;
    ledServicePtr = new LEDService(ble, initialValueForLEDCharacteristic);
    /* Setup primary service */
    uart = new UARTService(ble);

    /* setup advertising */
    ble.gap().accumulateAdvertisingPayload(GapAdvertisingData::BREDR_NOT_SUPPORTED | GapAdvertisingData::LE_GENERAL_DISCOVERABLE);
    ble.gap().accumulateAdvertisingPayload(GapAdvertisingData::COMPLETE_LIST_16BIT_SERVICE_IDS, (uint8_t *)uuid16_list, sizeof(uuid16_list));
    ble.gap().accumulateAdvertisingPayload(GapAdvertisingData::COMPLETE_LOCAL_NAME, (uint8_t *)DEVICE_NAME_MAIN, sizeof(DEVICE_NAME_MAIN));
    /* set up the services that can be discovered */
    ble.gap().accumulateAdvertisingPayload(GapAdvertisingData::COMPLETE_LIST_128BIT_SERVICE_IDS,(const uint8_t *)UARTServiceUUID_reversed, sizeof(UARTServiceUUID_reversed));
    ble.gap().setAdvertisingType(GapAdvertisingParams::ADV_CONNECTABLE_UNDIRECTED);
    ble.gap().setAdvertisingInterval(1000); /* 1000ms. */
    ble.gap().setAdvertisingTimeout(300); /* 16 * 1000ms. */
    ble.gap().startAdvertising();

    printMacAddress();
    bleInitializationCompleted = true;
}

void scheduleBleEventsProcessing(BLE::OnEventsToProcessCallbackContext* context) {
    BLE &ble = BLE::Instance();
    eventQueue.call(Callback<void()>(&ble, &BLE::processEvents));
}


void bleInitialization()
{
    BLE &ble = BLE::Instance();
    device->printf("\n --- BLE Instance Instantiated --- \n");
    ble.onEventsToProcess(scheduleBleEventsProcessing);
    device->printf("\n --- BLE scheduleBleEventsProcessing setup --- \n");
    ble.init(bleInitComplete);
}


void restartBleAdvertising()
{
    BLE &ble = BLE::Instance();
    
    //ble.init(bleInitComplete);
     // clear advertising payload
    ble.gap().clearAdvertisingPayload();
    /* setup advertising */
    ble.gap().accumulateAdvertisingPayload(GapAdvertisingData::BREDR_NOT_SUPPORTED | GapAdvertisingData::LE_GENERAL_DISCOVERABLE);
    ble.gap().accumulateAdvertisingPayload(GapAdvertisingData::COMPLETE_LIST_16BIT_SERVICE_IDS, (uint8_t *)uuid16_list, sizeof(uuid16_list));
    ble.gap().accumulateAdvertisingPayload(GapAdvertisingData::COMPLETE_LOCAL_NAME, (uint8_t *)DEVICE_NAME_MAIN, sizeof(DEVICE_NAME_MAIN));
    /* set up the services that can be discovered */
    ble.gap().accumulateAdvertisingPayload(GapAdvertisingData::COMPLETE_LIST_128BIT_SERVICE_IDS,(const uint8_t *)UARTServiceUUID_reversed, sizeof(UARTServiceUUID_reversed));
    ble.gap().setAdvertisingType(GapAdvertisingParams::ADV_CONNECTABLE_UNDIRECTED);
    ble.gap().setAdvertisingInterval(1000); /* 1000ms. */
    ble.gap().startAdvertising();
    eventQueue.dispatch(1000);        // Dispatch time - 1000msec
}

static int uartExpectedRcvCount = 0;
static int uartCharRcvCount = 0;
static bool UartBusy = false;
int WriteUartBytes(const uint8_t * txBuffer, size_t bufSize, int txLen)
{
    if(txLen > bufSize)
    {
        txLen = bufSize;
    }
    //int goodTxLen;
    //goodTxLen = _parser.write((const char *) txBuffer, txLen);
    for(int i=0;i<txLen;i++)
    {
        device->putc(txBuffer[i]);
    }
    // return number of bytes written to UART
    return (int) txLen;
}

void printUartRxResult()
{
    
    if(uartCharRcvCount == 0)
    {
        device->printf("\nFirst Call to UART attach callback!!\n");
    }
    else if(uartCharRcvCount >= uartExpectedRcvCount)
    {
        device->printf("\nNumber of Received Bytes = %d\n\n", uartCharRcvCount);
        device->printf("--- Writing back received bytes --- \n");
        int n;
        n = WriteUartBytes(RxBuffer, TX_BUFFER_LEN, uartCharRcvCount);
        UartBusy = false;
    }
}


void UartRxcallback_ex() {
    if(uartCharRcvCount >= uartExpectedRcvCount)
    {
        int x = device->getc();
        return;
    }
    if(uartCharRcvCount == 0)
    {
        eventQueue.call(printUartRxResult);
    }
    // Note: you need to actually read from the serial to clear the RX interrupt
    RxBuffer[uartCharRcvCount] = (uint8_t) device->getc();
    uartCharRcvCount++;
    if(uartCharRcvCount >= uartExpectedRcvCount)
    {
        alivenessLED = !alivenessLED; /* Do blinky on LED1 to indicate system aliveness. */
        eventQueue.call(printUartRxResult);
    }
}

void BackGndUartRead(uint8_t * rxBuffer, size_t bufSize, int rxLen)
{
    UartBusy = true;
    device->printf("Setting up background UART read -  rxLen = %d\n", rxLen);
    uartCharRcvCount = 0;
    if(rxLen > bufSize)
    {
        rxLen = bufSize;
    }
    uartExpectedRcvCount = rxLen;
    device->printf("\nattaching to device UART\n\n");
    device->attach(&UartRxcallback_ex);
    device->printf("\nBackground UART read setup completed\n\n");
}

int ReadUartBytes(uint8_t * rxBuffer, size_t bufSize, int rxLen, bool echo)
{
    UartBusy = true;
    if(rxLen > bufSize)
    {
        rxLen = bufSize;
    }
    for(int i=0;i<rxLen;i++)
    {
        rxBuffer[i] = (uint8_t) device->getc();
        if(echo)device->putc(rxBuffer[i]);
    }
    UartBusy = false;
    //return number of bytes written to UART
    return rxLen;
}


void checkUartReceive()
{
    //device->printf("Hello World!\n\r");
    char cbuf[100];
    int rxCnt=0;
    while(device->readable()) {
        //device->printf("uartCharRcvCount = %d\n\r", uartCharRcvCount++);
        cbuf[rxCnt++] = device->getc();
        //putc(getc() + 1); // echo input back to terminal
    }
    cbuf[rxCnt] = NULL;
    if(rxCnt > 0)
    {
        device->printf("received %d chars\n", rxCnt);
        device->printf("%s\n", cbuf);
    }

}
uint64_t lastTime = 0;
uint64_t now = 0;
uint32_t callCount = 0;
void HelloUart()
{
    //if(UartBusy)return;
    // 64-bit time doesn't wrap for half a billion years, at least
    lastTime = now;
    now = Kernel::get_ms_count();
    callCount++;
    device->printf("\nHello : %d secs elapsed : CallCount = %d \n", uint32_t(now - lastTime), callCount);
}




//Serial device(USBTX, USBRX); // tx, rx
//RawSerial device(MBED_CONF_APP_UART1_TX, MBED_CONF_APP_UART1_RX); // tx, rx




// Wifi-demo
void wifi_demo(NetworkInterface* network){
    int n = wifi_demo_func(network);
    if(n > 0)// error
    {
        device->printf("\n --- Error running wifi demo --- \n");
    }
}

// Wifi-demo2
void wifi_demo2(){
    //int n = wifi_demo_func(network);
    int n =5;
    if(n > 0)// error
    {
        device->printf("\n --- Error running wifi demo --- \n");
    }
}

void reportGapState()
{
     BLE &ble = BLE::Instance();
     Gap::GapState_t gapState = ble.gap().getState();
     char connStr[20] = " Not Connected ";
     char advStr[20] = " Not Advertising ";
     char devName[20] = "";
     if(gapState.advertising){
         strncpy(advStr, " Advertising ", 20);
     }
     if(gapState.connected){
         strncpy(connStr, " Connected ", 20);
     }
     device->printf("\n Advertising Status = %s\n Connection Status = %s\n", advStr, connStr);
     unsigned nLen;
     ble_error_t error;
     error =  ble.gap().getDeviceName((uint8_t *) devName, &nLen);
     if(error != BLE_ERROR_NONE)
     {
        device->printf("\n Error Reading BLE device Name \n");
        return;
     }
     devName[nLen] = NULL;
     device->printf("\n BLE Device name = %s : Name Len %d\n", devName, nLen);
     for(int i=0;i<8;i++)
     device->putc(devName[i]);
     
}

void printWait(int numSecs)
{
    printf("Waiting for %d seconds...\n", numSecs);
    for(int i=0;i<numSecs;i++){
        printf("%d", i);
        printf("\n");
        wait(0.5);
        eventQueue.dispatch(500);        // Dispatch time - 500msec
    }
}

static int reset_counter = 0;




#define MAX_LOOP_COUNT 3
int ble_security_main()
{
    BLE& ble = BLE::Instance();
    events::EventQueue queue;

#if MBED_CONF_APP_FILESYSTEM_SUPPORT
    /* if filesystem creation fails or there is no filesystem the security manager
     * will fallback to storing the security database in memory */
    if (!create_filesystem()) {
        printf("Filesystem creation failed, will use memory storage\r\n");
    }
#endif
    int loopCount = 0; 
    while(1) {
        {
            printf("\r\n PERIPHERAL \r\n\r\n");
            SMDevicePeripheral peripheral(ble, queue, peer_address);
            peripheral.run();
            return 0;
        }
        if(loopCount >= MAX_LOOP_COUNT)
        {
            return 0;
        }

        {
            printf("\r\n CENTRAL \r\n\r\n");
            SMDeviceCentral central(ble, queue, peer_address);
            central.run();
        }
        loopCount++;
        printf("loop Cycle #%d\r\n", loopCount);
    }

    return 0;
}

void print_memory_info() {
    // allocate enough room for every thread's stack statistics
    int cnt = osThreadGetCount();
    mbed_stats_stack_t *stats = (mbed_stats_stack_t*) malloc(cnt * sizeof(mbed_stats_stack_t));
 
    cnt = mbed_stats_stack_get_each(stats, cnt);
    for (int i = 0; i < cnt; i++) {
        printf("Thread: 0x%lX, Stack size: %lu / %lu\r\n", stats[i].thread_id, stats[i].max_size, stats[i].reserved_size);
    }
    free(stats);
 
    // Grab the heap statistics
    mbed_stats_heap_t heap_stats;
    mbed_stats_heap_get(&heap_stats);
    printf("Heap size: %lu / %lu bytes\r\n", heap_stats.current_size, heap_stats.reserved_size);
}

#define DISABLE_WIFI_DEMO
int main() {
    reset_counter++;
    //performFreeMemoryCheck();
    print_memory_info();
    printf("\r\n ++++++ PROGRAM STARTING -- reset count = %d ++++++ \r\n", reset_counter);
    device = new RawSerial(USBTX, USBRX, DEFAULT_BAUD_RATE);
    //ble_security_main();
    
    BLE& ble = BLE::Instance();
    events::EventQueue queue(/* event count */ 10 * EVENTS_EVENT_SIZE);
#if MBED_CONF_APP_FILESYSTEM_SUPPORT
    /* if filesystem creation fails or there is no filesystem the security manager
     * will fallback to storing the security database in memory */
    if (!create_filesystem()) {
        printf("Filesystem creation failed, will use memory storage\r\n");
    }
#endif
    print_memory_info();
    printf("\r\n PERIPHERAL \r\n\r\n");
    //SMDevicePeripheral peripheral(ble, queue, peer_address);
    peripheral = new SMDevicePeripheral(ble, queue, peer_address);
    print_memory_info();

    peripheral->run();
    btle_thread.start(callback(&queue, &EventQueue::dispatch_forever));
    //btle_thread.start(callback(peripheral, &SMDevicePeripheral::run));
    //performFreeMemoryCheck();
    //reportGapState();
    print_memory_info();
    printWait(60); // lets give time to see BLE advertising... 
    //reportGapState();
    peripheral->stopAdvertising();
    //queue.break_dispatch();
    //reportGapState();
    //btle_thread.join();
    //performFreeMemoryCheck();
    printf("\r\n BTLE THREAD HAS RETURNED \r\n\r\n");

#ifndef DISABLE_WIFI_DEMO // comment out wifi part
    printMacAddress();  
    //reportGapState();
    int start = Kernel::get_ms_count();
    NetworkInterface* network = connect_to_default_network_interface();
    int stop = Kernel::get_ms_count();
    device->printf("\n The Wifi Network scan took %d ms or %4.1f seconds\n", (stop - start), (float)((stop - start)/1000.0));
    // run on separate thread;
    t.start(callback(wifi_demo, network));
    t.join(); 
    network->disconnect(); 
    delete network;
    printMacAddress();  
    //reportGapState();
    device->printf("\n Wifi-Demo completed - restarting BLE  \n\n");
#else
    device->printf("\n Wifi Demo disabled so just waiting it out...  \n\n");
    printWait(60); // lets wait for a minute before turning BLE back on
    device->printf("\n ++++++ restarting BLE ++++++ \n\n");
#endif
    peripheral->startAdvertising();
    //peripheral->run();
    //btle_thread.start(callback(&queue, &EventQueue::dispatch_forever));
    //peripheral.run();
    //btle_thread.start(callback(peripheral, &SMDevicePeripheral::run));
    //t.start(callback(&queue, &EventQueue::dispatch_forever));
    printWait(60);
    //reportGapState();
#ifdef ENABLE_UART_BACKGRND_DEMO
    for(int i=0;i<255;i++)
    {
        device->putc(i);
    }
    //int n;
    //ReadUartBytes(RxBuffer, RX_BUFFER_LEN, 4);
    reportGapState();
    device->printf("\n\n\nEnter # of expected bytes: ");
    ReadUartBytes(RxBuffer, RX_BUFFER_LEN, 4, true);
    uint8_t rxLen = (uint8_t) (100*(RxBuffer[0]-'0') + 10*(RxBuffer[1]-'0') + (RxBuffer[2]-'0')) %256;
    device->printf("\n\nExpected # of Received Bytes = %d\n", rxLen);
    BackGndUartRead(RxBuffer, RX_BUFFER_LEN, (int) rxLen);

    device->printf("\n Waiting for 5 seconds ");
    printWait(5);
    device->printf("\n Waiting finished!!!\n Now waiting for expected bytes to be received \n\n");
    while(UartBusy){
        wait(0.1);
    }
#endif 
    device->printf("\r\n++++++ Starting ATCmdmanager ++++++ \r\n");
    ATCmdManager *aTCmdManager = new ATCmdManager(USBTX, USBRX, true);
    aTCmdManager->runMain();
    atcmd_thread.start(callback(aTCmdManager, &ATCmdManager::runMain));
    //performFreeMemoryCheck();

    //eventQueue.dispatch_forever();
    //t.start(callback(&eventQueue, &EventQueue::dispatch_forever));
    //eventQueue2.dispatch_forever();

    return 0;
}

#endif