Mark Radbourne / Mbed 2 deprecated FXOS8700CQ_To_Azure_IoT

Simple sample that demonstrates reading the FXOS8700CQ accelerometer, convert the data to JSON and send to an Azure IoT Hub.

Dependencies:   azure_umqtt_c iothub_mqtt_transport mbed-rtos mbed wolfSSL Socket lwip-eth lwip-sys lwip

main.cpp@7:2564d95cbf81, 2017-04-25 (annotated)

Committer:
markrad
Date:
Tue Apr 25 01:33:13 2017 +0000
Revision:
7:2564d95cbf81
Parent:
6:0bffe8529f60 
Fix bug in NTP library. Clean up code some.

Who changed what in which revision?

UserRevisionLine numberNew contents of line
markrad 0:6c46c366f500 1 // Copyright (c) Microsoft. All rights reserved.
markrad 0:6c46c366f500 2 // Licensed under the MIT license. See LICENSE file at https://github.com/Azure/azure-iot-sdks/blob/master/LICENSE for full license information.
markrad 0:6c46c366f500 3
markrad 0:6c46c366f500 4 /* -------------------------------------------------------------------------- *\
markrad 0:6c46c366f500 5
markrad 0:6c46c366f500 6 Simple progam to demonstrate reading the FRDM-K64F FXOS8700CQ
markrad 0:6c46c366f500 7 accelerometer, convert the data to JSON and send to an Azure IoT Hub. You
markrad 0:6c46c366f500 8 must provide your hub's connection string in the variable
markrad 0:6c46c366f500 9 'connectionString'.
markrad 0:6c46c366f500 10
markrad 0:6c46c366f500 11 markrad
markrad 0:6c46c366f500 12
markrad 0:6c46c366f500 13 \* -------------------------------------------------------------------------- */
markrad 0:6c46c366f500 14
markrad 0:6c46c366f500 15 #include <string.h>
markrad 4:9b3da9969b1b 16 #include <limits.h>
markrad 0:6c46c366f500 17
markrad 0:6c46c366f500 18 #include "SingletonFXOS8700CQ.h"
markrad 0:6c46c366f500 19
markrad 0:6c46c366f500 20 #include "iothub_client.h"
markrad 0:6c46c366f500 21 #include "iothub_message.h"
markrad 0:6c46c366f500 22 #include "azure_c_shared_utility/threadapi.h"
markrad 0:6c46c366f500 23 #include "azure_c_shared_utility/crt_abstractions.h"
markrad 0:6c46c366f500 24 #include "azure_c_shared_utility/platform.h"
markrad 0:6c46c366f500 25 #include "iothubtransportmqtt.h"
markrad 2:2b9acda15ef0 26 #include "lock.h"
markrad 0:6c46c366f500 27
markrad 0:6c46c366f500 28 #include "certs.h"
markrad 5:3d814faa2b2e 29 #include "NTPClient.h"
markrad 5:3d814faa2b2e 30
markrad 5:3d814faa2b2e 31 NTPClient ntp;
markrad 0:6c46c366f500 32
markrad 4:9b3da9969b1b 33 /*
markrad 0:6c46c366f500 34 int readingToJSON(char *buffer, int bufferlen, READING &reading)
markrad 0:6c46c366f500 35 {
markrad 0:6c46c366f500 36 static const char READING[] = "\"reading\"";
markrad 0:6c46c366f500 37 static const char ACCELEROMETER[] = "\"accelerometer\"";
markrad 0:6c46c366f500 38 static const char MAGNOMETER[] = "\"magnometer\"";
markrad 0:6c46c366f500 39 static const char X[] = "\"X\"";
markrad 0:6c46c366f500 40 static const char Y[] = "\"Y\"";
markrad 0:6c46c366f500 41 static const char Z[] = "\"Z\"";
markrad 0:6c46c366f500 42 static const char STARTOBJ[] = " : {\n";
markrad 0:6c46c366f500 43 static const char ENDOBJ[] = "}\n";
markrad 0:6c46c366f500 44 static const char PREPEND[] = "{\n";
markrad 0:6c46c366f500 45 static const int MINBUFFERLEN =
markrad 0:6c46c366f500 46 sizeof(READING) +
markrad 0:6c46c366f500 47 sizeof(ACCELEROMETER) +
markrad 0:6c46c366f500 48 sizeof(MAGNOMETER) +
markrad 0:6c46c366f500 49 2 * (sizeof(X) + sizeof(Y) + sizeof(Z)) +
markrad 0:6c46c366f500 50 3 * sizeof(STARTOBJ) +
markrad 0:6c46c366f500 51 4 * sizeof(ENDOBJ) +
markrad 0:6c46c366f500 52 sizeof(PREPEND) +
markrad 0:6c46c366f500 53 6 * 9;
markrad 0:6c46c366f500 54 static const char numConvert[] = "%d";
markrad 0:6c46c366f500 55
markrad 0:6c46c366f500 56 char toNum[10];
markrad 0:6c46c366f500 57 char work[MINBUFFERLEN + 1];
markrad 0:6c46c366f500 58
markrad 0:6c46c366f500 59 if (buffer == NULL)
markrad 0:6c46c366f500 60 return 0;
markrad 0:6c46c366f500 61
markrad 0:6c46c366f500 62 buffer[0] = '\0';
markrad 0:6c46c366f500 63
markrad 0:6c46c366f500 64 strcpy(work, PREPEND);
markrad 0:6c46c366f500 65 strcat(work, READING);
markrad 0:6c46c366f500 66 strcat(work, STARTOBJ);
markrad 0:6c46c366f500 67 strcat(work, ACCELEROMETER);
markrad 0:6c46c366f500 68 strcat(work, STARTOBJ);
markrad 0:6c46c366f500 69 strcat(work, X);
markrad 0:6c46c366f500 70 strcat(work, " : ");
markrad 0:6c46c366f500 71 sprintf(toNum, numConvert, reading.accelerometer.x);
markrad 0:6c46c366f500 72 strcat(work, toNum);
markrad 0:6c46c366f500 73 strcat(work, ",\n");
markrad 0:6c46c366f500 74 strcat(work, Y);
markrad 0:6c46c366f500 75 strcat(work, " : ");
markrad 0:6c46c366f500 76 sprintf(toNum, numConvert, reading.accelerometer.y);
markrad 0:6c46c366f500 77 strcat(work, toNum);
markrad 0:6c46c366f500 78 strcat(work, ",\n");
markrad 0:6c46c366f500 79 strcat(work, Z);
markrad 0:6c46c366f500 80 strcat(work, " : ");
markrad 0:6c46c366f500 81 sprintf(toNum, numConvert, reading.accelerometer.z);
markrad 0:6c46c366f500 82 strcat(work, toNum);
markrad 0:6c46c366f500 83 strcat(work, "\n");
markrad 0:6c46c366f500 84 strcat(work, ENDOBJ);
markrad 0:6c46c366f500 85 strcat(work, MAGNOMETER);
markrad 0:6c46c366f500 86 strcat(work, STARTOBJ);
markrad 0:6c46c366f500 87 strcat(work, X);
markrad 0:6c46c366f500 88 strcat(work, " : ");
markrad 0:6c46c366f500 89 sprintf(toNum, numConvert, reading.magnometer.x);
markrad 0:6c46c366f500 90 strcat(work, toNum);
markrad 0:6c46c366f500 91 strcat(work, ",\n");
markrad 0:6c46c366f500 92 strcat(work, Y);
markrad 0:6c46c366f500 93 strcat(work, " : ");
markrad 0:6c46c366f500 94 sprintf(toNum, numConvert, reading.magnometer.y);
markrad 0:6c46c366f500 95 strcat(work, toNum);
markrad 0:6c46c366f500 96 strcat(work, ",\n");
markrad 0:6c46c366f500 97 strcat(work, Z);
markrad 0:6c46c366f500 98 strcat(work, " : ");
markrad 0:6c46c366f500 99 sprintf(toNum, numConvert, reading.magnometer.z);
markrad 0:6c46c366f500 100 strcat(work, toNum);
markrad 0:6c46c366f500 101 strcat(work, "\n");
markrad 0:6c46c366f500 102 strcat(work, ENDOBJ);
markrad 0:6c46c366f500 103 strcat(work, ENDOBJ);
markrad 0:6c46c366f500 104 strcat(work, ENDOBJ);
markrad 0:6c46c366f500 105
markrad 0:6c46c366f500 106 if (strlen(work) + 1 < bufferlen)
markrad 0:6c46c366f500 107 strcpy(buffer, work);
markrad 0:6c46c366f500 108
markrad 0:6c46c366f500 109 return strlen(work);
markrad 0:6c46c366f500 110 }
markrad 4:9b3da9969b1b 111 */
markrad 4:9b3da9969b1b 112
markrad 4:9b3da9969b1b 113 static int JSONifyData(char *buffer, int bufferlen, int reading)
markrad 4:9b3da9969b1b 114 {
markrad 7:2564d95cbf81 115 static const char *format = "{ \"device\": \"%s\", \"timestamp\": \"%s\", \"epochoffset\": %d, \"reading\": %f }";
markrad 5:3d814faa2b2e 116 static const char *timeFormat = "%FT%X";
markrad 5:3d814faa2b2e 117 char timeOut[80];
markrad 4:9b3da9969b1b 118 double work;
markrad 4:9b3da9969b1b 119 int rc;
markrad 5:3d814faa2b2e 120 time_t rawtime = 0;
markrad 5:3d814faa2b2e 121 struct tm *ptm;
markrad 4:9b3da9969b1b 122
markrad 5:3d814faa2b2e 123 // gmtime() does not work on the FRDM K64F - set RTC to UTC
markrad 7:2564d95cbf81 124 rawtime = time(NULL);
markrad 5:3d814faa2b2e 125 ptm = localtime(&rawtime);
markrad 5:3d814faa2b2e 126
markrad 5:3d814faa2b2e 127 strftime(timeOut, sizeof(timeOut), timeFormat, ptm);
markrad 7:2564d95cbf81 128 printf("rawtime=%d;time=%s\r\n", rawtime, timeOut);
markrad 4:9b3da9969b1b 129 work = sqrt((double)reading);
markrad 7:2564d95cbf81 130 rc = snprintf(buffer, bufferlen, format, "mydevice", timeOut, rawtime, work);
markrad 4:9b3da9969b1b 131
markrad 4:9b3da9969b1b 132 if (rc < 0)
markrad 4:9b3da9969b1b 133 printf("*** ERROR *** out of buffer space\r\n");
markrad 4:9b3da9969b1b 134
markrad 4:9b3da9969b1b 135 return rc;
markrad 4:9b3da9969b1b 136 }
markrad 0:6c46c366f500 137
markrad 2:2b9acda15ef0 138 static LOCK_HANDLE msgLock;
markrad 2:2b9acda15ef0 139 static int msgCount = 0;
markrad 3:c0556ff7b8e3 140 static Timer t;
markrad 3:c0556ff7b8e3 141 static int CONNECTIONTIMEOUT = (20 * 1000);
markrad 2:2b9acda15ef0 142
markrad 0:6c46c366f500 143 static IOTHUBMESSAGE_DISPOSITION_RESULT ReceiveMessageCallback(IOTHUB_MESSAGE_HANDLE message, void* userContextCallback)
markrad 0:6c46c366f500 144 {
markrad 0:6c46c366f500 145 int* counter = (int*)userContextCallback;
markrad 0:6c46c366f500 146 const char* buffer;
markrad 0:6c46c366f500 147 size_t size;
markrad 0:6c46c366f500 148
markrad 0:6c46c366f500 149 if (IoTHubMessage_GetByteArray(message, (const unsigned char**)&buffer, &size) != IOTHUB_MESSAGE_OK)
markrad 0:6c46c366f500 150 {
markrad 0:6c46c366f500 151 (void)printf("unable to retrieve the message data\r\n");
markrad 0:6c46c366f500 152 }
markrad 0:6c46c366f500 153 else
markrad 0:6c46c366f500 154 {
markrad 0:6c46c366f500 155 (void)printf("Received Message [%d] with Data: <<<%.*s>>> & Size=%d\r\n", *counter, (int)size, buffer, (int)size);
markrad 0:6c46c366f500 156 }
markrad 0:6c46c366f500 157
markrad 0:6c46c366f500 158 // Some device specific action code goes here...
markrad 0:6c46c366f500 159 (*counter)++;
markrad 0:6c46c366f500 160
markrad 0:6c46c366f500 161 return IOTHUBMESSAGE_ACCEPTED;
markrad 0:6c46c366f500 162 }
markrad 0:6c46c366f500 163
markrad 0:6c46c366f500 164 static void SendConfirmationCallback(IOTHUB_CLIENT_CONFIRMATION_RESULT result, void* userContextCallback)
markrad 0:6c46c366f500 165 {
markrad 2:2b9acda15ef0 166 int* messageTrackingId = (int*)userContextCallback;
markrad 0:6c46c366f500 167
markrad 0:6c46c366f500 168 (void)printf("Confirmation received for message tracking id = %d with result = %s\r\n",
markrad 2:2b9acda15ef0 169 *messageTrackingId, ENUM_TO_STRING(IOTHUB_CLIENT_CONFIRMATION_RESULT, result));
markrad 0:6c46c366f500 170
markrad 2:2b9acda15ef0 171 free(userContextCallback);
markrad 2:2b9acda15ef0 172 Lock(msgLock);
markrad 2:2b9acda15ef0 173 msgCount--;
markrad 3:c0556ff7b8e3 174
markrad 3:c0556ff7b8e3 175 if (result == IOTHUB_CLIENT_CONFIRMATION_OK)
markrad 3:c0556ff7b8e3 176 {
markrad 3:c0556ff7b8e3 177 t.stop();
markrad 3:c0556ff7b8e3 178 t.reset();
markrad 3:c0556ff7b8e3 179 }
markrad 3:c0556ff7b8e3 180
markrad 2:2b9acda15ef0 181 Unlock(msgLock);
markrad 2:2b9acda15ef0 182
markrad 0:6c46c366f500 183 }
markrad 0:6c46c366f500 184
markrad 0:6c46c366f500 185 void stall(Serial &pc, char *message)
markrad 0:6c46c366f500 186 {
markrad 0:6c46c366f500 187 printf(message);
markrad 0:6c46c366f500 188 printf("stalled ");
markrad 0:6c46c366f500 189
markrad 4:9b3da9969b1b 190 while(true)
markrad 4:9b3da9969b1b 191 {
markrad 0:6c46c366f500 192 pc.putc('.'); // idle dots
markrad 0:6c46c366f500 193 wait(1.0);
markrad 0:6c46c366f500 194 }
markrad 0:6c46c366f500 195 }
markrad 0:6c46c366f500 196
markrad 3:c0556ff7b8e3 197 IOTHUB_CLIENT_HANDLE setupConnection(Serial &pc, const char *connectionString, IOTHUB_CLIENT_TRANSPORT_PROVIDER protocol, void *receiveContext)
markrad 3:c0556ff7b8e3 198 {
markrad 3:c0556ff7b8e3 199 IOTHUB_CLIENT_HANDLE iotHubClientHandle = NULL;
markrad 3:c0556ff7b8e3 200
markrad 3:c0556ff7b8e3 201 printf("Calling platform_init\r\n");
markrad 3:c0556ff7b8e3 202
markrad 3:c0556ff7b8e3 203 while (platform_init())
markrad 3:c0556ff7b8e3 204 {
markrad 3:c0556ff7b8e3 205 pc.putc('P');
markrad 3:c0556ff7b8e3 206 wait(1.0);
markrad 3:c0556ff7b8e3 207 platform_deinit();
markrad 3:c0556ff7b8e3 208 }
markrad 3:c0556ff7b8e3 209
markrad 3:c0556ff7b8e3 210 // if (platform_init() != 0)
markrad 3:c0556ff7b8e3 211 // stall(pc, "Failed to initialize platform\n");
markrad 3:c0556ff7b8e3 212
markrad 3:c0556ff7b8e3 213 printf("Calling IoTHubClient_CreateFromConnectionString\r\n");
markrad 3:c0556ff7b8e3 214 if ((iotHubClientHandle = IoTHubClient_CreateFromConnectionString(connectionString, protocol)) == NULL)
markrad 3:c0556ff7b8e3 215 stall(pc, "ERROR: Could not create iotHubClientHandle\n");
markrad 3:c0556ff7b8e3 216
markrad 3:c0556ff7b8e3 217 bool traceOn = false;
markrad 3:c0556ff7b8e3 218 //bool traceOn = true;
markrad 3:c0556ff7b8e3 219
markrad 3:c0556ff7b8e3 220 printf("Calling IoTHubClient_SetOption logtrace with %d\r\n", traceOn);
markrad 3:c0556ff7b8e3 221 IoTHubClient_SetOption(iotHubClientHandle, "logtrace", &traceOn);
markrad 3:c0556ff7b8e3 222
markrad 3:c0556ff7b8e3 223 // For mbed add the certificate information
markrad 3:c0556ff7b8e3 224 printf("Calling IoTHubClient_SetOption TrustedCerts\r\n");
markrad 3:c0556ff7b8e3 225
markrad 3:c0556ff7b8e3 226 if (IoTHubClient_SetOption(iotHubClientHandle, "TrustedCerts", certificates) != IOTHUB_CLIENT_OK)
markrad 3:c0556ff7b8e3 227 stall(pc, "ERROR: failure to set option \"TrustedCerts\"\n");
markrad 3:c0556ff7b8e3 228
markrad 3:c0556ff7b8e3 229 printf("Calling IoTHubClient_SetMessageCallback\r\n");
markrad 3:c0556ff7b8e3 230
markrad 3:c0556ff7b8e3 231 if (IoTHubClient_SetMessageCallback(iotHubClientHandle, ReceiveMessageCallback, receiveContext) != IOTHUB_CLIENT_OK)
markrad 3:c0556ff7b8e3 232 stall(pc, "ERROR: IoTHubClient_SetMessageCallback failed\r\n");
markrad 3:c0556ff7b8e3 233
markrad 3:c0556ff7b8e3 234 return iotHubClientHandle;
markrad 3:c0556ff7b8e3 235 }
markrad 3:c0556ff7b8e3 236
markrad 3:c0556ff7b8e3 237 void terminateConnection(Serial &pc, IOTHUB_CLIENT_HANDLE iotHubClientHandle)
markrad 3:c0556ff7b8e3 238 {
markrad 3:c0556ff7b8e3 239 printf("Calling IoTHubClient_Destroy\r\n");
markrad 3:c0556ff7b8e3 240 IoTHubClient_Destroy(iotHubClientHandle);
markrad 3:c0556ff7b8e3 241 printf("Calling platform_deinit\r\n");
markrad 3:c0556ff7b8e3 242 platform_deinit();
markrad 3:c0556ff7b8e3 243 printf("Connection terminated\r\n");
markrad 3:c0556ff7b8e3 244 }
markrad 3:c0556ff7b8e3 245
markrad 5:3d814faa2b2e 246 void calibrate(double *pmean, double *pdeviation)
markrad 5:3d814faa2b2e 247 {
markrad 5:3d814faa2b2e 248 READING reading;
markrad 5:3d814faa2b2e 249 const int calibrationPeriod = 10; // in seconds
markrad 5:3d814faa2b2e 250 SingletonFXOS8700CQ &sfxos = SingletonFXOS8700CQ::getInstance();
markrad 5:3d814faa2b2e 251
markrad 6:0bffe8529f60 252 double *data = new double[calibrationPeriod * 50];
markrad 5:3d814faa2b2e 253 int i;
markrad 6:0bffe8529f60 254 double sum = 0.0;
markrad 6:0bffe8529f60 255 double mean = 0.0;
markrad 5:3d814faa2b2e 256 double temp;
markrad 5:3d814faa2b2e 257
markrad 5:3d814faa2b2e 258 printf("Calibrating...\r\n");
markrad 5:3d814faa2b2e 259
markrad 7:2564d95cbf81 260 i = calibrationPeriod * 50;
markrad 7:2564d95cbf81 261
markrad 7:2564d95cbf81 262 while (i > 0)
markrad 5:3d814faa2b2e 263 {
markrad 5:3d814faa2b2e 264 if (sfxos.getInt2Triggered())
markrad 5:3d814faa2b2e 265 {
markrad 5:3d814faa2b2e 266 sfxos.setInt2Triggered(false);
markrad 5:3d814faa2b2e 267 sfxos.getData(reading);
markrad 6:0bffe8529f60 268 data[i] = sqrt((double)(reading.accelerometer.x * reading.accelerometer.x) + (reading.accelerometer.y * reading.accelerometer.y));
markrad 6:0bffe8529f60 269 // data[i] = reading.accelerometer.x + reading.accelerometer.y;
markrad 6:0bffe8529f60 270 printf("x=%d\t\ty=%d\t\tsum=%f\r\n", reading.accelerometer.x, reading.accelerometer.y, data[i]);
markrad 5:3d814faa2b2e 271 sum += data[i];
markrad 7:2564d95cbf81 272 --i;
markrad 5:3d814faa2b2e 273 }
markrad 5:3d814faa2b2e 274 else
markrad 5:3d814faa2b2e 275 {
markrad 7:2564d95cbf81 276 printf("WARNING: Sensor was not ready in time during calibration\r\n");
markrad 5:3d814faa2b2e 277 }
markrad 7:2564d95cbf81 278 wait_ms(20);
markrad 5:3d814faa2b2e 279 }
markrad 5:3d814faa2b2e 280
markrad 5:3d814faa2b2e 281 mean = (double)sum / (double)(calibrationPeriod * 50);
markrad 5:3d814faa2b2e 282
markrad 5:3d814faa2b2e 283 for (i = 0; i < calibrationPeriod * 50; i++)
markrad 5:3d814faa2b2e 284 {
markrad 5:3d814faa2b2e 285 temp += ((float)data[i] - mean) * ((float)data[i] - mean);
markrad 5:3d814faa2b2e 286 }
markrad 5:3d814faa2b2e 287
markrad 5:3d814faa2b2e 288 temp /= (double)(calibrationPeriod * 50);
markrad 5:3d814faa2b2e 289
markrad 5:3d814faa2b2e 290 delete [] data;
markrad 5:3d814faa2b2e 291
markrad 5:3d814faa2b2e 292 *pmean = mean;
markrad 5:3d814faa2b2e 293 *pdeviation = sqrt(temp);
markrad 5:3d814faa2b2e 294
markrad 5:3d814faa2b2e 295 printf("Calibration complete - mean=%f; devation=%f\r\n", *pmean, *pdeviation);
markrad 5:3d814faa2b2e 296 }
markrad 3:c0556ff7b8e3 297
markrad 0:6c46c366f500 298 int main()
markrad 0:6c46c366f500 299 {
markrad 4:9b3da9969b1b 300 const char *connectionString = "HostName=MarkRadHub1.azure-devices.net;DeviceId=mrcc3200;SharedAccessKey=8pGKChTBsz0VGw234iLX7XDDKwcyWRC7hsrVZEHfZHs=";
markrad 7:2564d95cbf81 301 const char *ntpServer = "0.pool.ntp.org";
markrad 7:2564d95cbf81 302 const int ntpRefreshInterval = 60 * 60;
markrad 7:2564d95cbf81 303 const int ledInterval = 300 / 20;
markrad 0:6c46c366f500 304
markrad 0:6c46c366f500 305 READING reading;
markrad 0:6c46c366f500 306 Serial pc(USBTX, USBRX); // Primary output to demonstrate library
markrad 0:6c46c366f500 307 SingletonFXOS8700CQ &sfxos = SingletonFXOS8700CQ::getInstance();
markrad 0:6c46c366f500 308 IOTHUB_CLIENT_HANDLE iotHubClientHandle;
markrad 0:6c46c366f500 309 int receiveContext = 0;
markrad 0:6c46c366f500 310 int transmitCounter = 0;
markrad 5:3d814faa2b2e 311 double mean;
markrad 5:3d814faa2b2e 312 double deviation;
markrad 7:2564d95cbf81 313 DigitalOut ledBlue(LED_BLUE);
markrad 2:2b9acda15ef0 314
markrad 0:6c46c366f500 315 pc.baud(115200); // Print quickly! 200Hz x line of output data!
markrad 7:2564d95cbf81 316 ledBlue = 1;
markrad 0:6c46c366f500 317
markrad 6:0bffe8529f60 318 printf("\n\n\rFXOS8700CQ identity = %X\r\n", sfxos.getWhoAmI());
markrad 0:6c46c366f500 319
markrad 2:2b9acda15ef0 320 msgLock = Lock_Init(); // TODO: Check error code
markrad 2:2b9acda15ef0 321
markrad 0:6c46c366f500 322 sfxos.enable();
markrad 0:6c46c366f500 323 sfxos.getData(reading);
markrad 0:6c46c366f500 324
markrad 0:6c46c366f500 325 int rc;
markrad 0:6c46c366f500 326
markrad 1:0366fad6e60c 327 int LOOPCOUNT = -1; // Set to -1 to run forever
markrad 0:6c46c366f500 328
markrad 2:2b9acda15ef0 329 int localMsgCount;
markrad 2:2b9acda15ef0 330 int *userContext;
markrad 2:2b9acda15ef0 331 IOTHUB_MESSAGE_HANDLE msgHandle;
markrad 3:c0556ff7b8e3 332 int elapsedTime = 0;
markrad 2:2b9acda15ef0 333
markrad 0:6c46c366f500 334 char buffer[200];
markrad 0:6c46c366f500 335
markrad 3:c0556ff7b8e3 336 iotHubClientHandle = setupConnection(pc, connectionString, MQTT_Protocol, &receiveContext);
markrad 5:3d814faa2b2e 337 calibrate(&mean, &deviation);
markrad 5:3d814faa2b2e 338
markrad 4:9b3da9969b1b 339 int readCount = 0;
markrad 4:9b3da9969b1b 340 int32_t maxVal = LONG_MIN;
markrad 4:9b3da9969b1b 341 int32_t curVal;
markrad 7:2564d95cbf81 342 time_t lastUpdate = 0;
markrad 7:2564d95cbf81 343 int ntpRc;
markrad 7:2564d95cbf81 344 int ledOffAt = 0;
markrad 7:2564d95cbf81 345
markrad 7:2564d95cbf81 346 while (NTP_OK != (ntpRc = ntp.setTime("0.pool.ntp.org")))
markrad 7:2564d95cbf81 347 {
markrad 7:2564d95cbf81 348 printf("ERROR: Failed to set current time from NTP server - rc = %d\r\n", ntpRc);
markrad 7:2564d95cbf81 349 wait_ms(100);
markrad 7:2564d95cbf81 350 }
markrad 7:2564d95cbf81 351
markrad 7:2564d95cbf81 352 lastUpdate = time(NULL);
markrad 4:9b3da9969b1b 353
markrad 0:6c46c366f500 354 while (LOOPCOUNT)
markrad 0:6c46c366f500 355 {
markrad 0:6c46c366f500 356 if (sfxos.getInt2Triggered())
markrad 0:6c46c366f500 357 {
markrad 0:6c46c366f500 358 sfxos.setInt2Triggered(false);
markrad 0:6c46c366f500 359 sfxos.getData(reading);
markrad 4:9b3da9969b1b 360 curVal = (reading.accelerometer.x * reading.accelerometer.x) + (reading.accelerometer.y * reading.accelerometer.y);
markrad 4:9b3da9969b1b 361
markrad 4:9b3da9969b1b 362 if (curVal > maxVal)
markrad 5:3d814faa2b2e 363 {
markrad 4:9b3da9969b1b 364 maxVal = curVal;
markrad 6:0bffe8529f60 365 //printf("new maxVal=%d\r\n", maxVal);
markrad 5:3d814faa2b2e 366 }
markrad 4:9b3da9969b1b 367
markrad 4:9b3da9969b1b 368 //rc = readingToJSON(buffer, sizeof(buffer), reading);
markrad 4:9b3da9969b1b 369
markrad 4:9b3da9969b1b 370 //if (rc > sizeof(buffer))
markrad 4:9b3da9969b1b 371 //printf("ERROR: JSON buffer too small - require %d characters\n", rc);
markrad 0:6c46c366f500 372
markrad 4:9b3da9969b1b 373 if (++readCount >= 50)
markrad 0:6c46c366f500 374 {
markrad 4:9b3da9969b1b 375 Lock(msgLock);
markrad 4:9b3da9969b1b 376 localMsgCount = msgCount;
markrad 4:9b3da9969b1b 377 Unlock(msgLock);
markrad 4:9b3da9969b1b 378
markrad 4:9b3da9969b1b 379 if (localMsgCount < 2)
markrad 0:6c46c366f500 380 {
markrad 4:9b3da9969b1b 381 rc = JSONifyData(buffer, sizeof(buffer), maxVal);
markrad 6:0bffe8529f60 382 //printf("DATA >>>%s<<<\r\n", buffer);
markrad 2:2b9acda15ef0 383
markrad 4:9b3da9969b1b 384 if ((msgHandle = IoTHubMessage_CreateFromByteArray((const unsigned char*)buffer, rc)) == NULL)
markrad 4:9b3da9969b1b 385 {
markrad 4:9b3da9969b1b 386 (void)printf("ERROR: iotHubMessageHandle is NULL!\r\n");
markrad 4:9b3da9969b1b 387 }
markrad 4:9b3da9969b1b 388 else
markrad 0:6c46c366f500 389 {
markrad 4:9b3da9969b1b 390 userContext = (int *) malloc(sizeof(userContext));
markrad 4:9b3da9969b1b 391
markrad 4:9b3da9969b1b 392 if (userContext != NULL)
markrad 2:2b9acda15ef0 393 {
markrad 4:9b3da9969b1b 394 *userContext = transmitCounter;
markrad 4:9b3da9969b1b 395
markrad 4:9b3da9969b1b 396 if (IoTHubClient_SendEventAsync(iotHubClientHandle, msgHandle, SendConfirmationCallback, userContext) != IOTHUB_CLIENT_OK)
markrad 4:9b3da9969b1b 397 {
markrad 4:9b3da9969b1b 398 (void)printf("ERROR: IoTHubClient_LL_SendEventAsync..........FAILED!\r\n");
markrad 4:9b3da9969b1b 399 }
markrad 4:9b3da9969b1b 400 else
markrad 4:9b3da9969b1b 401 {
markrad 4:9b3da9969b1b 402 (void)printf("IoTHubClient_LL_SendEventAsync accepted message [%d] for transmission to IoT Hub.\r\n", (int)transmitCounter);
markrad 7:2564d95cbf81 403 ledBlue = 0;
markrad 7:2564d95cbf81 404 ledOffAt = ledInterval;
markrad 4:9b3da9969b1b 405 }
markrad 4:9b3da9969b1b 406
markrad 4:9b3da9969b1b 407 IoTHubMessage_Destroy(msgHandle);
markrad 4:9b3da9969b1b 408 Lock(msgLock);
markrad 4:9b3da9969b1b 409 msgCount++;
markrad 4:9b3da9969b1b 410 t.start();
markrad 4:9b3da9969b1b 411 Unlock(msgLock);
markrad 4:9b3da9969b1b 412
markrad 4:9b3da9969b1b 413 transmitCounter++;
markrad 2:2b9acda15ef0 414 }
markrad 2:2b9acda15ef0 415 else
markrad 2:2b9acda15ef0 416 {
markrad 4:9b3da9969b1b 417 (void)printf("ERROR: malloc - unable to allocate user context\r\n");
markrad 2:2b9acda15ef0 418 }
markrad 0:6c46c366f500 419 }
markrad 0:6c46c366f500 420 }
markrad 4:9b3da9969b1b 421 else
markrad 4:9b3da9969b1b 422 {
markrad 6:0bffe8529f60 423 (void)printf("WARNING: Message dropped queue length %d\r\n", localMsgCount);
markrad 4:9b3da9969b1b 424 }
markrad 4:9b3da9969b1b 425
markrad 4:9b3da9969b1b 426 Lock(msgLock);
markrad 4:9b3da9969b1b 427 elapsedTime = t.read_ms();
markrad 4:9b3da9969b1b 428 Unlock(msgLock);
markrad 4:9b3da9969b1b 429
markrad 4:9b3da9969b1b 430 if (elapsedTime > CONNECTIONTIMEOUT)
markrad 4:9b3da9969b1b 431 {
markrad 4:9b3da9969b1b 432 printf("No response for %d milliseconds - attempt reconnection\r\n", elapsedTime);
markrad 4:9b3da9969b1b 433 NVIC_SystemReset(); // Just blow it all away
markrad 4:9b3da9969b1b 434 terminateConnection(pc, iotHubClientHandle);
markrad 4:9b3da9969b1b 435 iotHubClientHandle = setupConnection(pc, connectionString, MQTT_Protocol, &receiveContext);
markrad 4:9b3da9969b1b 436 printf("Reconnection complete\r\n");
markrad 4:9b3da9969b1b 437 }
markrad 4:9b3da9969b1b 438
markrad 4:9b3da9969b1b 439 if (LOOPCOUNT > 0)
markrad 4:9b3da9969b1b 440 LOOPCOUNT--;
markrad 7:2564d95cbf81 441
markrad 4:9b3da9969b1b 442 readCount = 0;
markrad 4:9b3da9969b1b 443 maxVal = LONG_MIN;
markrad 7:2564d95cbf81 444
markrad 7:2564d95cbf81 445 if (time(NULL) - lastUpdate > ntpRefreshInterval)
markrad 7:2564d95cbf81 446 {
markrad 7:2564d95cbf81 447 while (NTP_OK != (ntpRc = ntp.setTime("0.pool.ntp.org")))
markrad 7:2564d95cbf81 448 {
markrad 7:2564d95cbf81 449 printf("ERROR: Failed to set current time from NTP server - rc = %d\r\n", ntpRc);
markrad 7:2564d95cbf81 450 wait_ms(100);
markrad 7:2564d95cbf81 451 }
markrad 7:2564d95cbf81 452
markrad 7:2564d95cbf81 453 lastUpdate = time(NULL);
markrad 7:2564d95cbf81 454 }
markrad 2:2b9acda15ef0 455 }
markrad 4:9b3da9969b1b 456 }
markrad 4:9b3da9969b1b 457 else
markrad 4:9b3da9969b1b 458 {
markrad 6:0bffe8529f60 459 printf("WARNING: Sensor was not ready in time\r\n");
markrad 0:6c46c366f500 460 }
markrad 0:6c46c366f500 461
markrad 7:2564d95cbf81 462 if (!((int)ledBlue) && --ledOffAt <= 0)
markrad 5:3d814faa2b2e 463 {
markrad 7:2564d95cbf81 464 ledBlue = 1;
markrad 5:3d814faa2b2e 465 }
markrad 7:2564d95cbf81 466
markrad 7:2564d95cbf81 467 // Read at 50 hz
markrad 4:9b3da9969b1b 468 wait_ms(20);
markrad 0:6c46c366f500 469 }
markrad 0:6c46c366f500 470
markrad 0:6c46c366f500 471 printf("Loop complete - clean up\n");
markrad 0:6c46c366f500 472
markrad 3:c0556ff7b8e3 473 terminateConnection(pc, iotHubClientHandle);
markrad 2:2b9acda15ef0 474 Lock_Deinit(msgLock);
markrad 2:2b9acda15ef0 475
markrad 0:6c46c366f500 476 printf("Test complete\n");
markrad 0:6c46c366f500 477
markrad 0:6c46c366f500 478
markrad 4:9b3da9969b1b 479 while(true)
markrad 4:9b3da9969b1b 480 {
markrad 0:6c46c366f500 481 pc.putc('.'); // idle dots
markrad 0:6c46c366f500 482 wait(1.0);
markrad 0:6c46c366f500 483 }
markrad 0:6c46c366f500 484 }