More examples prior to releasing properly hello example still to be tested.

Author: dave

examples/mbedClock/NTPTimeEvent.cpp

@@ -0,0 +1,76 @@
+//
+// Created by David Cherry on 25/06/2020.
+//
+
+#include <IoLogging.h>
+#include "NTPTimeEvent.h"
+
+void acquireNtpTimeThreadProc(NTPTimeEvent *ntpTime) {
+    ntpTime->acquireNtpOnThread();
+}
+
+NTPTimeEvent::NTPTimeEvent(NetworkInterface *nwInterface, const char *serverName, int port)
+        : timeServer(serverName), timePort(port), interface(nwInterface),
+          ntpThread(), _presentValue(0) {
+    ntpThread.start(callback(acquireNtpTimeThreadProc, this));
+}
+
+void NTPTimeEvent::acquireNtpOnThread() {
+    int retriesLeft = 20;
+    while(--retriesLeft > 0) {
+        // wait a second before trying to avoid a tight loop.
+        ThisThread::sleep_for((20 - retriesLeft) * 1000);
+
+        serdebugF2("Starting ntp loop retries = ", retriesLeft);
+
+        SocketAddress serverAddr;
+        if (interface->gethostbyname(timeServer, &serverAddr) < 0) {
+            continue;
+        }
+        serverAddr.set_port(timePort);
+
+        serdebugF("Found NTP host");
+
+        int32_t ntpRx[12] = {0};
+        char ntpTx[48] = {0};
+        ntpTx[0] = 0x1b;
+
+        UDPSocket socket;
+        socket.open(interface);
+        socket.set_blocking(true);
+        socket.set_timeout(10);
+
+        int sendCount = 0;
+        nsapi_size_or_error_t sendRet;
+        while((sendRet = socket.sendto(serverAddr, ntpTx, sizeof(ntpTx))) <= 0) {
+            if(sendRet != NSAPI_ERROR_WOULD_BLOCK || ++sendCount > 20) break;
+            ThisThread::sleep_for(500);
+        }
+
+        serdebugF("Sent NTP message");
+
+        SocketAddress sourceAddr;
+        sendCount = 0;
+        while(sendRet > 0 && ++sendCount < 20) {
+            int n = socket.recvfrom(&sourceAddr, ntpRx, sizeof(ntpRx));
+
+            if (n > 10) {
+                uint32_t tmNowRaw = ntpRx[10];
+                uint32_t ret = (tmNowRaw & 0xffU) << 24U;
+                ret |= (tmNowRaw & 0xff00U) << 8U;
+                ret |= (tmNowRaw & 0xff0000UL) >> 8U;
+                ret |= (tmNowRaw & 0xff000000UL) >> 24U;
+                _presentValue = ret - EPOCH_CONVERT_OFFSET;
+                markTriggeredAndNotify();
+                serdebugF2("Time was set to ", (unsigned long) _presentValue);
+                return;
+            }
+        }
+        // finally close the socket
+        socket.close();
+    }
+}
+
+uint32_t NTPTimeEvent::timeOfNextCheck() {
+    return secondsToMicros(1);
+}

examples/mbedClock/NTPTimeEvent.h

@@ -0,0 +1,42 @@
+
+
+#ifndef TCMENUEXAMPLE_NTPTIMEEVENT_H
+#define TCMENUEXAMPLE_NTPTIMEEVENT_H
+
+#include <mbed.h>
+#include <ctime>
+#include <EthernetInterface.h>
+#include <TaskManagerIO.h>
+
+/**
+ * Provides an easy way to get the time from an NTP server as an event, the exec method is not implemented on this
+ * so that you can implement it how you see fit. This class works by starting a thread to acquire the time from an
+ * NTP server, and when the time is obtained, it triggers the event.
+ */
+class NTPTimeEvent : public BaseEvent {
+public:
+    /**
+     * Create the event for a given interface, server and port.
+     * @param interface the interface to use
+     * @param timeServer the NTP server name
+     * @param timePort the port to connect on
+     */
+    NTPTimeEvent(NetworkInterface* interface, const char* timeServer, int timePort);
+
+    uint32_t timeOfNextCheck() override;
+
+private:
+    const time_t EPOCH_CONVERT_OFFSET = (time_t)2208988800UL;
+    const char* const  timeServer;
+    const int volatile timePort;
+    NetworkInterface* const interface;
+    Thread ntpThread;
+
+    void acquireNtpOnThread();
+    friend void acquireNtpTimeThreadProc(NTPTimeEvent *ntpTime);
+protected:
+    volatile time_t _presentValue;
+};
+
+
+#endif //TCMENUEXAMPLE_NTPTIMEEVENT_H

examples/mbedClock/analogClock.cpp

@@ -0,0 +1,119 @@
+/**
+ * A more complex example that acquires time from the network using NTP and displays it on the screen
+ * The NTP class is apache licensed, and can be used directly in your code
+ *
+ * MBED 6 RTOS example.
+ */
+
+#include <cstdio>
+#include "mbed.h"
+#include <TaskManager.h>
+#include <IoLogging.h>
+#include <NetworkInterface.h>
+//#include "Adafruit_SSD1306_I2c.h" (for i2c displays)
+#include "Adafruit_SSD1306_Spi.h"
+#include "NTPTimeEvent.h"
+
+// Host PC Communication channels
+BufferedSerial pc(USBTX, USBRX);
+MBedLogger LoggingPort(pc);
+
+bool running = true;
+
+//I2C i2c(PF_0,PF_1);
+//Adafruit_SSD1306_I2c gfx(i2c, NC, SSD_I2C_ADDRESS, 64, 132, SH_1106);
+
+SPI spi(PB_5, PB_4, PB_3);
+Adafruit_SSD1306_Spi gfx(spi, PD_15, PF_12, PF_13, 64, 128, SSD_1306);
+
+// we are going to use NTP, we need to enable the network device to get a reading.
+NetworkInterface* defNetwork = NetworkInterface::get_default_instance();
+
+// here we calculate teh centre points of the screen in terms of the clock.
+float offsetY = 20.0F + (float(gfx.height() - 20.0F) / 2.0F);
+float offsetX = float(gfx.width()) / 2.0F;
+float magFactor = (float(gfx.height()) / 2.0F) - 12.0F;
+
+// we need to know the position of the hour hand at each interval, and also the minute / second hand
+float degsPerHour = 360.0F / 12.0F;
+float degsPerMinute = 360.0F / 60.0F;
+#define MATH_PI_FLT 3.141593F
+
+//
+// couple of forward declarations
+//
+void dealWithHand(float degMultiplier, int value, float mag);
+void prepareRealtimeClock();
+
+inline float toRadian(float deg) {
+    if(deg > 360.0F) deg = deg - 360.0F;
+    return (deg * MATH_PI_FLT) / 180.F;
+}
+
+int main()
+{
+    //i2c.frequency(400000);
+
+    gfx.begin();
+
+    prepareRealtimeClock();
+
+    taskManager.scheduleFixedRate(1, [] {
+        auto timeNow = time(nullptr);
+        auto tm = gmtime(&timeNow);
+
+        gfx.clearDisplay();
+
+        for(int i=0; i<12; i++) {
+            float deg = float(i) * degsPerHour;
+            float rads = toRadian(deg);
+            gfx.fillCircle(offsetX + (magFactor * sin(rads)), offsetY + (magFactor * cos(rads)), 2, WHITE);
+        }
+
+        dealWithHand(degsPerHour, 12 - (tm->tm_hour % 12), magFactor * 0.65F);
+        dealWithHand(degsPerMinute, 60 - tm->tm_min,  magFactor * 0.75F);
+        dealWithHand(degsPerMinute, 60 - tm->tm_sec,  magFactor * 0.95F);
+
+        char sz[30];
+        sprintf(sz, "Time: %02d:%02d:%02d", tm->tm_hour, tm->tm_min, tm->tm_sec);
+        gfx.setCursor(0,0);
+        gfx.print(sz);
+
+        gfx.display();
+    }, TIME_SECONDS);
+
+    while(running) {
+        taskManager.runLoop();
+    }
+}
+
+void dealWithHand(float degMultiplier, int value, float mag) {
+    float deg = (float(value) * degMultiplier);
+    float rads = toRadian(deg);
+
+    float xEnd = offsetX - (mag * sin(rads));
+    float yEnd = offsetY - (mag * cos(rads));
+    gfx.drawLine(offsetX, offsetY, xEnd, yEnd, WHITE);
+}
+
+class ClockNtpTimeEvent : public NTPTimeEvent {
+public:
+
+    ClockNtpTimeEvent(NetworkInterface *interface, const char *timeServer, int timePort)
+            : NTPTimeEvent(interface, timeServer, timePort) {
+    }
+
+    void exec() override {
+        set_time(_presentValue);
+        setCompleted(true);
+    }
+};
+
+void prepareRealtimeClock() {
+    if(defNetwork->connect() != NSAPI_ERROR_IS_CONNECTED) {
+        taskManager.scheduleOnce(250, prepareRealtimeClock);
+        return;
+    }
+
+    taskManager.registerEvent(new ClockNtpTimeEvent(defNetwork,"2.pool.ntp.org", 123),  true);
+}

examples/mbedHello/mbedHello.cpp

@@ -0,0 +1,46 @@
+/**
+ * the simplest possible example of using an OLED display with our library
+ */
+
+#include <cstdio>
+#include "mbed.h"
+#include <TaskManager.h>
+//#include "Adafruit_SSD1306_I2c.h" (for i2c displays)
+#include "Adafruit_SSD1306_Spi.h"
+
+bool running = true;
+
+//I2C i2c(PF_0,PF_1);
+//Adafruit_SSD1306_I2c gfx(i2c, NC, SSD_I2C_ADDRESS, 64, 132, SH_1106);
+
+SPI spi(PB_5, PB_4, PB_3);
+Adafruit_SSD1306_Spi gfx(spi, PD_15, PF_12, PF_13, 64, 128, SSD_1306);
+
+int main()
+{
+    //i2c.frequency(400000);
+
+    gfx.begin();
+
+    gfx.clearDisplay();
+    gfx.setCursor(0, 0);
+    gfx.setTextColor(WHITE);
+    gfx.print("Hello mbed");
+
+
+    // actually cause the write to take place.
+    gfx.display();
+
+    taskManager.scheduleFixedRate(1, [] {
+        gfx.fillRect(0, 20, gfx.width(), 20);
+        gfx.setCursor(0, 20);
+        gfx.print(millis());
+
+        // actually cause the write to take place.
+        gfx.display();
+    }, TIME_SECONDS);
+
+    while(running) {
+        taskManager.runLoop();
+    }
+}