WebSVN – ChibiGauge – Diff – /trunk/main.c

 //#include "test.h"
 #include "shell.h"
 #include "evtimer.h"
 #include "chprintf.h"
 #if (HAL_USE_SERIAL_USB == TRUE)
 #include "usbcfg.h"
 #endif
 #include "useAdc.h"
 #include "shellCmds.h"
+#include "ap_math.h"
+#include "spiInterface.h"
+#include "SSD1306.h"
+#include "font.h"
+#include "vl53l0x_api.h"
+#include "vl53l0x_platform.h"
+#include "required_version.h"
-static MUTEX_DECL(mutexDisplay);
+static MUTEX_DECL( mutexDisplay);
+unsigned lidar = 0;
 /*===========================================================================*/
 /* Command line related.                                                     */
 /*===========================================================================*/
-#define SHELL_WA_SIZE   THD_WORKING_AREA_SIZE(2048)
+#define SHELL_WA_SIZE   THD_WORKING_AREA_SIZE(1024)
 #define TEST_WA_SIZE    THD_WORKING_AREA_SIZE(256)
 static const ShellConfig shell_cfg1 = {
 #if (HAL_USE_SERIAL_USB == TRUE)
-  (BaseSequentialStream *)&SDU1,
+                (BaseSequentialStream*) &SDU1,
 #else
   (BaseSequentialStream *)&SD1,
 #endif
-  shellCommands
+                shellCommands };
-};
 ////////
 // end of shell stuff
 uint16_t sampIndex;
-void setDriveA(uint8_t bit)
+void setDriveA(uint8_t bit) {
-{
-        if(bit)
+        if (bit) {
-        {
-            palSetPad(GPIOA, GPIOA_A1);
+                palSetPad(GPIOA, GPIOA_A1);
-           palClearPad(GPIOA, GPIOA_A2);
+                palClearPad(GPIOA, GPIOA_A2);
-        }
-        else
+        } else {
-        {
                 palClearPad(GPIOA, GPIOA_A1);
                 palSetPad(GPIOA, GPIOA_A2);
+        }
+}
-void setDriveB(uint8_t bit)
+void setDriveB(uint8_t bit) {
-{
-        if(bit)
+        if (bit) {
-        {
-           palSetPad(GPIOA, GPIOA_B1);
+                palSetPad(GPIOA, GPIOA_B1);
-           palClearPad(GPIOA, GPIOA_B2);
+                palClearPad(GPIOA, GPIOA_B2);
-        }
-        else
+        } else {
-        {
                 palClearPad(GPIOA, GPIOA_B1);
                 palSetPad(GPIOA, GPIOA_B2);
+        }
+}
+// dial settings
-volatile int origin = 0;;
+volatile int origin = 0;
+;
-volatile int target = 630;
+volatile int target = 0;
 volatile int count = 0;
+volatile bool pause;
+//
+void setPause(bool p) {
+        pause = p;
+}
 static THD_WORKING_AREA(waThread1, 512);
-static msg_t Thread1(void *arg) {
+static void Thread1(void *arg) {
         (void) arg;
-        unsigned const fast=10 ;
+        unsigned const fast = 10;
-        unsigned const slow = 40;
+        unsigned const slow = 30;
-        unsigned const range = slow-fast;
+        unsigned const range = slow - fast;
-     unsigned  del = fast;
+        unsigned del = fast;
-     int step  = 1;
+        int step = 1;
-   chRegSetThreadName("Step");
+        chRegSetThreadName("Step");
         while (TRUE) {
+                while (pause)
+                        chThdSleep(1000);
-                switch  (count % 4)
+                switch (count % 4) {
+                case 0:
+                        setDriveA(1);
+                        setDriveB(0);
+                        break;
+                case 1:
+                        setDriveA(1);
+                        setDriveB(1);
-                {
+                        break;
+                case 2:
-                case 0: setDriveA(1); setDriveB(0); break;
+                        setDriveA(0);
-                case 1: setDriveA(1); setDriveB(1); break;
+                        setDriveB(1);
+                        break;
+                case 3:
-                case 2: setDriveA(0); setDriveB(1); break;
+                        setDriveA(0);
-                case 3: setDriveA(0); setDriveB(0); break;
+                        setDriveB(0);
+                        break;
+                }
-                chThdSleep(del);
-                count = count + step;
                 // all this calculates minimum distance from
                 // target or origin
-        int d1= count-origin;
+                int d1 = count - origin;
+                if (d1 < 0)
-        if(d1<0) d1 = -d1;
+                        d1 = -d1;
-        int d2= count-target;
+                int d2 = count - target;
+                if (d2 < 0)
-        if(d2<0) d2 = -d2;
+                        d2 = -d2;
-        // finally, minimum distance
+                // finally, minimum distance
-        int dist  = d1<d2 ? d1 : d2;
+                int dist = d1 < d2 ? d1 : d2;
-        del = fast ;
+                del = fast;
-        if(dist < range) // inside lower bound of distance
+                if (dist < range) // inside lower bound of distance
-        {
+                                {
-                del = slow-dist;
+                        del = slow - dist;
-        }
+                }
+                chThdSleep(del);
-                if(count < target ) { step = 1; }
+                if (count < target) {
+                        step = 1;
+                }
-                if(count > target ) { step =-1; }
+                if (count > target) {
+                        step = -1;
+                }
-                if(count == target) { step = 0; }
+                if (count == target) {
+                        step = 0;
+                }
+                count = count + step;
+        }
-        return 0;
+}
 /*
  * Command Shell Thread
  */
 static THD_WORKING_AREA(waThread2, 512);
-static msg_t Thread2(void *arg) {
+static void Thread2(void *arg) {
         thread_t *shelltp = NULL;
         chRegSetThreadName("Shell ");
-/*
+        /*
-           * in this demo it just performs
+         * in this demo it just performs
-           * a shell respawn upon its termination.
+         * a shell respawn upon its termination.
-           */
+         */
-          while (true) {
+        while (true) {
-            if (!shelltp) {
+                if (!shelltp) {
-        #if (HAL_USE_SERIAL_USB == TRUE)
+#if (HAL_USE_SERIAL_USB == TRUE)
-              if (SDU1.config->usbp->state == USB_ACTIVE) {
+                        if (SDU1.config->usbp->state == USB_ACTIVE) {
-                /* Spawns a new shell.*/
+                                /* Spawns a new shell.*/
-                shelltp = chThdCreateFromHeap(NULL, SHELL_WA_SIZE, "shell", NORMALPRIO, shellThread, (void *) &shell_cfg1);
+                                shelltp = chThdCreateFromHeap(NULL, SHELL_WA_SIZE, "shell",
+                                                NORMALPRIO, shellThread, (void*) &shell_cfg1);
-              }
+                        }
-        #else
+#else
                 shelltp = chThdCreateFromHeap(NULL, SHELL_WA_SIZE, "shell", NORMALPRIO, shellThread, (void *) &shell_cfg1);
         #endif
-            }
-            else {
+                } else {
-              /* If the previous shell exited.*/
+                        /* If the previous shell exited.*/
-              if (chThdTerminatedX(shelltp)) {
+                        if (chThdTerminatedX(shelltp)) {
-                /* Recovers memory of the previous shell.*/
+                                /* Recovers memory of the previous shell.*/
-                chThdRelease(shelltp);
+                                chThdRelease(shelltp);
-                shelltp = NULL;
+                                shelltp = NULL;
-              }
+                        }
-            }
+                }
-            chThdSleepMilliseconds(500);
+                chThdSleepMilliseconds(500);
-          }
+        }
-        return MSG_OK;
+}
+static THD_WORKING_AREA(waThread3, 1024);
+static void Thread3(void *arg) {
+    VL53L0X_Dev_t MyDevice;
+    VL53L0X_Dev_t *pMyDevice = &MyDevice;
+    setPause(true);
+    int Status = VL53L0XdeviceSetup(pMyDevice);
+    setPause(false);
+      VL53L0X_RangingMeasurementData_t RangingMeasurementData;
+        while(1){
+                chThdSleep(chTimeMS2I(100));
+                setPause(true);
+        Status = VL53L0X_PerformSingleRangingMeasurement(pMyDevice,
+                        &RangingMeasurementData);
+        setPause(false);
+         if (Status != VL53L0X_ERROR_NONE) continue;
+         lidar  =  RangingMeasurementData.RangeMilliMeter;
+        }
+}
 /*
  * Application entry point.
  */
 int main(void) {
 //  struct EventListener el0, el1;
          */
         halInit();
         chSysInit();
 #if (HAL_USE_SERIAL_USB == TRUE)
-  /*
+        /*
-   * Initializes a serial-over-USB CDC driver.
+         * Initializes a serial-over-USB CDC driver.
-   */
+         */
-  sduObjectInit(&SDU1);
+        sduObjectInit(&SDU1);
-  sduStart(&SDU1, &serusbcfg);
+        sduStart(&SDU1, &serusbcfg);
 #if  HAL_USE_USB_DUAL_CDC == TRUE
-  sduObjectInit(&SDU2);
+        sduObjectInit(&SDU2);
-  sduStart(&SDU2, &serusbcfg2);
+        sduStart(&SDU2, &serusbcfg2);
 #endif
-  /*
+        /*
-   * Activates the USB driver and then the USB bus pull-up on D+.
+         * Activates the USB driver and then the USB bus pull-up on D+.
-   * Note, a delay is inserted in order to not have to disconnect the cable
+         * Note, a delay is inserted in order to not have to disconnect the cable
-   * after a reset.
+         * after a reset.
-   */
+         */
-  usbDisconnectBus(serusbcfg.usbp);
+        usbDisconnectBus(serusbcfg.usbp);
-  chThdSleepMilliseconds(1000);
+        chThdSleepMilliseconds(1000);
-  usbStart(serusbcfg.usbp, &usbcfg);
+        usbStart(serusbcfg.usbp, &usbcfg);
-  usbConnectBus(serusbcfg.usbp);
+        usbConnectBus(serusbcfg.usbp);
 #else
   /*
    * Initializes serial port.
    */
   sdStart(&SD2, NULL);
 #endif /* HAL_USE_SERIAL_USB */
+        useAdc();
-   useAdc();
         /*
          * Shell manager initialization.
          */
-        shellInit();
+//      shellInit();
+        /*
+         * initialise approximate maths
+         */
+        ap_init();
+        chMtxLock(&mutexDisplay);
+        /* start the SPI hardware for display */
+        ssd1306spiInit();
+        ssd1306_begin( SSD1306_SWITCHCAPVCC, 0) ;
+        clearDisplay();
+        display();
+         chMtxUnlock(&mutexDisplay);
-         /*
+        /*
          * Creates the PLL thread
          */
         chThdCreateStatic(waThread1, sizeof(waThread1), NORMALPRIO, Thread1, NULL);
+        chThdCreateStatic(waThread2, sizeof(waThread2), NORMALPRIO, Thread2, NULL);
+//      chThdCreateStatic(waThread3, sizeof(waThread3), NORMALPRIO, Thread3, NULL);
+    // reset gauge
+        origin = 540;
+        count  = 540;
+        target = 0;
-        chThdCreateStatic(waThread2, sizeof(waThread2), NORMALPRIO, Thread2, NULL);
+        chThdSleepMilliseconds(1000);
+        target = 0;
+        int frac = 0;
         /* start the SPI hardware for display */
-        while(1)
+        while (1) {
-{
-        // read the dial
+           chThdSleepMilliseconds(100);
+        unsigned const SCALE = frac * 32 + 16;
-        adcSample();
+                frac = ++frac %10;
+                // read the dial
+                 adcSample();
+                origin = count;
-        origin = count;
+                target = target +1;
-    target = getAdc(0)*630L/4096L;
+                // target = lidar * 630L / 2000L;
+        if (target > 540) target = 0;
-         chThdSleep(chTimeMS2I(100));
+                chMtxLock(&mutexDisplay);
+            font_gotoxy(0,0);
+            clearDisplay();
+        //    print_scaled_string("cm:",0,16,4,SCALE);
-}
+            print_digits(0, 0, 4, 1, target,SCALE);
+            chMtxUnlock(&mutexDisplay);
+            display();
+        }
+}

Subversion Repositories ChibiGauge

(root)/trunk/main.c – Rev 2 → 6