Programme complet de bâton de marche sauf capteur cardiaque

Dependencies:   mbed SimpleBLE X_NUCLEO_IDB0XA1 SDFileSystem MBed_Adafruit-GPS-Library Arduino USBDevice

Files at this revision

API Documentation at this revision

Comitter:
zmoutaou
Date:
Mon Jan 27 12:04:30 2020 +0000
Commit message:
BMC

Changed in this revision

Adafruit_GFX/Adafruit_GFX.cpp Show annotated file Show diff for this revision Revisions of this file
Adafruit_GFX/Adafruit_GFX.h Show annotated file Show diff for this revision Revisions of this file
Adafruit_GFX/Adafruit_GFX_Config.h Show annotated file Show diff for this revision Revisions of this file
Adafruit_GFX/Adafruit_SSD1306.cpp Show annotated file Show diff for this revision Revisions of this file
Adafruit_GFX/Adafruit_SSD1306.h Show annotated file Show diff for this revision Revisions of this file
Adafruit_GFX/glcdfont.h Show annotated file Show diff for this revision Revisions of this file
Arduino.lib Show annotated file Show diff for this revision Revisions of this file
LSM9DS1_registre.h Show annotated file Show diff for this revision Revisions of this file
MBed_Adafruit-GPS-Library.lib Show annotated file Show diff for this revision Revisions of this file
SDFileSystem.lib Show annotated file Show diff for this revision Revisions of this file
SimpleBLE.lib Show annotated file Show diff for this revision Revisions of this file
USBDevice.lib Show annotated file Show diff for this revision Revisions of this file
X_NUCLEO_IDB0XA1.lib Show annotated file Show diff for this revision Revisions of this file
main.cpp Show annotated file Show diff for this revision Revisions of this file
mbed.bld Show annotated file Show diff for this revision Revisions of this file
diff -r 000000000000 -r 6e330c197193 Adafruit_GFX/Adafruit_GFX.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Adafruit_GFX/Adafruit_GFX.cpp	Mon Jan 27 12:04:30 2020 +0000
@@ -0,0 +1,454 @@
+/***********************************
+This is a our graphics core library, for all our displays. 
+We'll be adapting all the
+existing libaries to use this core to make updating, support 
+and upgrading easier!
+
+Adafruit invests time and resources providing this open source code, 
+please support Adafruit and open-source hardware by purchasing 
+products from Adafruit!
+
+Written by Limor Fried/Ladyada  for Adafruit Industries.  
+BSD license, check license.txt for more information
+All text above must be included in any redistribution
+****************************************/
+
+/*
+ *  Modified by Neal Horman 7/14/2012 for use in mbed
+ */
+
+#include "mbed.h"
+
+#include "Adafruit_GFX.h"
+#include "glcdfont.h"
+
+#if defined(GFX_WANT_ABSTRACTS)
+// draw a circle outline
+void Adafruit_GFX::drawCircle(int16_t x0, int16_t y0, int16_t r, uint16_t color)
+{
+    int16_t f = 1 - r;
+    int16_t ddF_x = 1;
+    int16_t ddF_y = -2 * r;
+    int16_t x = 0;
+    int16_t y = r;
+    
+    drawPixel(x0, y0+r, color);
+    drawPixel(x0, y0-r, color);
+    drawPixel(x0+r, y0, color);
+    drawPixel(x0-r, y0, color);
+    
+    while (x<y)
+    {
+        if (f >= 0)
+        {
+            y--;
+            ddF_y += 2;
+            f += ddF_y;
+        }
+        x++;
+        ddF_x += 2;
+        f += ddF_x;
+        
+        drawPixel(x0 + x, y0 + y, color);
+        drawPixel(x0 - x, y0 + y, color);
+        drawPixel(x0 + x, y0 - y, color);
+        drawPixel(x0 - x, y0 - y, color);
+        drawPixel(x0 + y, y0 + x, color);
+        drawPixel(x0 - y, y0 + x, color);
+        drawPixel(x0 + y, y0 - x, color);
+        drawPixel(x0 - y, y0 - x, color);
+    }
+}
+
+void Adafruit_GFX::drawCircleHelper( int16_t x0, int16_t y0, int16_t r, uint8_t cornername, uint16_t color)
+{
+    int16_t f     = 1 - r;
+    int16_t ddF_x = 1;
+    int16_t ddF_y = -2 * r;
+    int16_t x     = 0;
+    int16_t y     = r;
+    
+    while (x<y)
+    {
+        if (f >= 0)
+        {
+            y--;
+            ddF_y += 2;
+            f += ddF_y;
+        }
+        x++;
+        ddF_x += 2;
+        f += ddF_x;
+        
+        if (cornername & 0x4)
+        {
+            drawPixel(x0 + x, y0 + y, color);
+            drawPixel(x0 + y, y0 + x, color);
+        } 
+
+        if (cornername & 0x2)
+        {
+            drawPixel(x0 + x, y0 - y, color);
+            drawPixel(x0 + y, y0 - x, color);
+        }
+
+        if (cornername & 0x8)
+        {
+            drawPixel(x0 - y, y0 + x, color);
+            drawPixel(x0 - x, y0 + y, color);
+        }
+        
+        if (cornername & 0x1)
+        {
+            drawPixel(x0 - y, y0 - x, color);
+            drawPixel(x0 - x, y0 - y, color);
+        }
+    }
+}
+
+void Adafruit_GFX::fillCircle(int16_t x0, int16_t y0, int16_t r, uint16_t color)
+{
+    drawFastVLine(x0, y0-r, 2*r+1, color);
+    fillCircleHelper(x0, y0, r, 3, 0, color);
+}
+
+// used to do circles and roundrects!
+void Adafruit_GFX::fillCircleHelper(int16_t x0, int16_t y0, int16_t r, uint8_t cornername, int16_t delta, uint16_t color)
+{
+    int16_t f     = 1 - r;
+    int16_t ddF_x = 1;
+    int16_t ddF_y = -2 * r;
+    int16_t x     = 0;
+    int16_t y     = r;
+    
+    while (x<y)
+    {
+        if (f >= 0)
+        {
+            y--;
+            ddF_y += 2;
+            f += ddF_y;
+        }
+        x++;
+        ddF_x += 2;
+        f += ddF_x;
+        
+        if (cornername & 0x1)
+        {
+            drawFastVLine(x0+x, y0-y, 2*y+1+delta, color);
+            drawFastVLine(x0+y, y0-x, 2*x+1+delta, color);
+        }
+
+        if (cornername & 0x2)
+        {
+            drawFastVLine(x0-x, y0-y, 2*y+1+delta, color);
+            drawFastVLine(x0-y, y0-x, 2*x+1+delta, color);
+        }
+    }
+}
+#endif
+
+#if defined(GFX_WANT_ABSTRACTS) || defined(GFX_SIZEABLE_TEXT)
+// bresenham's algorithm - thx wikpedia
+void Adafruit_GFX::drawLine(int16_t x0, int16_t y0,  int16_t x1, int16_t y1, uint16_t color)
+{
+    int16_t steep = abs(y1 - y0) > abs(x1 - x0);
+    
+    if (steep)
+    {
+        swap(x0, y0);
+        swap(x1, y1);
+    }
+    
+    if (x0 > x1)
+    {
+        swap(x0, x1);
+        swap(y0, y1);
+    }
+    
+    int16_t dx, dy;
+    dx = x1 - x0;
+    dy = abs(y1 - y0);
+    
+    int16_t err = dx / 2;
+    int16_t ystep;
+    
+    if (y0 < y1)
+        ystep = 1;
+    else
+        ystep = -1;
+    
+    for (; x0<=x1; x0++)
+    {
+        if (steep)
+            drawPixel(y0, x0, color);
+        else
+            drawPixel(x0, y0, color);
+
+        err -= dy;
+        if (err < 0)
+        {
+            y0 += ystep;
+            err += dx;
+        }
+    }
+}
+
+void Adafruit_GFX::drawFastVLine(int16_t x, int16_t y, int16_t h, uint16_t color)
+{
+    // stupidest version - update in subclasses if desired!
+    drawLine(x, y, x, y+h-1, color);
+}
+
+void Adafruit_GFX::fillRect(int16_t x, int16_t y, int16_t w, int16_t h, uint16_t color)
+{
+    // stupidest version - update in subclasses if desired!
+    for (int16_t i=x; i<x+w; i++)
+        drawFastVLine(i, y, h, color); 
+}
+#endif
+
+#if defined(GFX_WANT_ABSTRACTS)
+// draw a rectangle
+void Adafruit_GFX::drawRect(int16_t x, int16_t y, int16_t w, int16_t h, uint16_t color)
+{
+    drawFastHLine(x, y, w, color);
+    drawFastHLine(x, y+h-1, w, color);
+    drawFastVLine(x, y, h, color);
+    drawFastVLine(x+w-1, y, h, color);
+}
+
+void Adafruit_GFX::drawFastHLine(int16_t x, int16_t y, int16_t w, uint16_t color)
+{
+    // stupidest version - update in subclasses if desired!
+    drawLine(x, y, x+w-1, y, color);
+}
+
+void Adafruit_GFX::fillScreen(uint16_t color)
+{
+    fillRect(0, 0, _width, _height, color);
+}
+
+// draw a rounded rectangle!
+void Adafruit_GFX::drawRoundRect(int16_t x, int16_t y, int16_t w, int16_t h, int16_t r, uint16_t color)
+{
+    // smarter version
+    drawFastHLine(x+r  , y    , w-2*r, color); // Top
+    drawFastHLine(x+r  , y+h-1, w-2*r, color); // Bottom
+    drawFastVLine(  x    , y+r  , h-2*r, color); // Left
+    drawFastVLine(  x+w-1, y+r  , h-2*r, color); // Right
+    // draw four corners
+    drawCircleHelper(x+r    , y+r    , r, 1, color);
+    drawCircleHelper(x+w-r-1, y+r    , r, 2, color);
+    drawCircleHelper(x+w-r-1, y+h-r-1, r, 4, color);
+    drawCircleHelper(x+r    , y+h-r-1, r, 8, color);
+}
+
+// fill a rounded rectangle!
+void Adafruit_GFX::fillRoundRect(int16_t x, int16_t y, int16_t w, int16_t h, int16_t r, uint16_t color)
+{
+    // smarter version
+    fillRect(x+r, y, w-2*r, h, color);
+    
+    // draw four corners
+    fillCircleHelper(x+w-r-1, y+r, r, 1, h-2*r-1, color);
+    fillCircleHelper(x+r    , y+r, r, 2, h-2*r-1, color);
+}
+
+// draw a triangle!
+void Adafruit_GFX::drawTriangle(int16_t x0, int16_t y0, int16_t x1, int16_t y1, int16_t x2, int16_t y2, uint16_t color)
+{
+    drawLine(x0, y0, x1, y1, color);
+    drawLine(x1, y1, x2, y2, color);
+    drawLine(x2, y2, x0, y0, color);
+}
+
+// fill a triangle!
+void Adafruit_GFX::fillTriangle ( int16_t x0, int16_t y0, int16_t x1, int16_t y1, int16_t x2, int16_t y2, uint16_t color)
+{
+    int16_t a, b, y, last;
+    
+    // Sort coordinates by Y order (y2 >= y1 >= y0)
+    if (y0 > y1)
+        swap(y0, y1); swap(x0, x1);
+
+    if (y1 > y2)
+        swap(y2, y1); swap(x2, x1);
+
+    if (y0 > y1)
+        swap(y0, y1); swap(x0, x1);
+
+    
+    if(y0 == y2)
+    { // Handle awkward all-on-same-line case as its own thing
+        a = b = x0;
+        if(x1 < a)
+            a = x1;
+        else if(x1 > b)
+            b = x1;
+            
+        if(x2 < a)
+            a = x2;
+        else if(x2 > b) b = x2;
+            drawFastHLine(a, y0, b-a+1, color);
+        return;
+    }
+
+    int16_t
+        dx01 = x1 - x0,
+        dy01 = y1 - y0,
+        dx02 = x2 - x0,
+        dy02 = y2 - y0,
+        dx12 = x2 - x1,
+        dy12 = y2 - y1,
+        sa   = 0,
+        sb   = 0;
+
+    // For upper part of triangle, find scanline crossings for segments
+    // 0-1 and 0-2.  If y1=y2 (flat-bottomed triangle), the scanline y1
+    // is included here (and second loop will be skipped, avoiding a /0
+    // error there), otherwise scanline y1 is skipped here and handled
+    // in the second loop...which also avoids a /0 error here if y0=y1
+    // (flat-topped triangle).
+    if(y1 == y2)
+        last = y1;   // Include y1 scanline
+    else
+        last = y1-1; // Skip it
+
+    for(y=y0; y<=last; y++)
+    {
+        a   = x0 + sa / dy01;
+        b   = x0 + sb / dy02;
+        sa += dx01;
+        sb += dx02;
+        /* longhand:
+        a = x0 + (x1 - x0) * (y - y0) / (y1 - y0);
+        b = x0 + (x2 - x0) * (y - y0) / (y2 - y0);
+        */
+        if(a > b)
+            swap(a,b);
+        drawFastHLine(a, y, b-a+1, color);
+    }
+
+    // For lower part of triangle, find scanline crossings for segments
+    // 0-2 and 1-2.  This loop is skipped if y1=y2.
+    sa = dx12 * (y - y1);
+    sb = dx02 * (y - y0);
+    for(; y<=y2; y++)
+    {
+        a   = x1 + sa / dy12;
+        b   = x0 + sb / dy02;
+        sa += dx12;
+        sb += dx02;
+        /* longhand:
+        a = x1 + (x2 - x1) * (y - y1) / (y2 - y1);
+        b = x0 + (x2 - x0) * (y - y0) / (y2 - y0);
+        */
+        if(a > b)
+            swap(a,b);
+        drawFastHLine(a, y, b-a+1, color);
+    }
+}
+
+void Adafruit_GFX::drawBitmap(int16_t x, int16_t y, const uint8_t *bitmap, int16_t w, int16_t h, uint16_t color)
+{
+    for (int16_t j=0; j<h; j++)
+    {
+        for (int16_t i=0; i<w; i++ )
+        {
+            if (bitmap[i + (j/8)*w] & _BV(j%8))
+                drawPixel(x+i, y+j, color);
+        }
+    }
+}
+#endif
+
+size_t Adafruit_GFX::writeChar(uint8_t c)
+{
+    if (c == '\n')
+    {
+        cursor_y += textsize*8;
+        cursor_x = 0;
+    }
+    else if (c == '\r')
+        cursor_x = 0;
+    else
+    {
+        drawChar(cursor_x, cursor_y, c, textcolor, textbgcolor, textsize);
+        cursor_x += textsize*6;
+        if (wrap && (cursor_x > (_width - textsize*6)))
+        {
+            cursor_y += textsize*8;
+            cursor_x = 0;
+        }
+    }
+    return 1;
+}
+
+// draw a character
+void Adafruit_GFX::drawChar(int16_t x, int16_t y, unsigned char c, uint16_t color, uint16_t bg, uint8_t size)
+{
+    if(
+        (x >= _width) || // Clip right
+        (y >= _height) || // Clip bottom
+        ((x + 5 * size - 1) < 0) || // Clip left
+        ((y + 8 * size - 1) < 0) // Clip top
+        )
+    return;
+    
+    for (int8_t i=0; i<6; i++ )
+    {
+        uint8_t line = 0;
+
+        if (i == 5) 
+            line = 0x0;
+        else 
+            line = font[(c*5)+i];
+            
+        for (int8_t j = 0; j<8; j++)
+        {
+            if (line & 0x1)
+            {
+#if defined(GFX_WANT_ABSTRACTS) || defined(GFX_SIZEABLE_TEXT)
+                if (size == 1) // default size
+                    drawPixel(x+i, y+j, color);
+                else // big size
+                    fillRect(x+(i*size), y+(j*size), size, size, color);
+#else
+                drawPixel(x+i, y+j, color);
+#endif
+            }
+            else if (bg != color)
+            {
+#if defined(GFX_WANT_ABSTRACTS) || defined(GFX_SIZEABLE_TEXT)
+                if (size == 1) // default size
+                    drawPixel(x+i, y+j, bg);
+                else // big size
+                    fillRect(x+i*size, y+j*size, size, size, bg);
+#else
+                drawPixel(x+i, y+j, bg);
+#endif
+            }
+            line >>= 1;
+        }
+    }
+}
+
+void Adafruit_GFX::setRotation(uint8_t x)
+{
+    x %= 4;  // cant be higher than 3
+    rotation = x;
+    switch (x)
+    {
+        case 0:
+        case 2:
+            _width = _rawWidth;
+            _height = _rawHeight;
+            break;
+        case 1:
+        case 3:
+            _width = _rawHeight;
+            _height = _rawWidth;
+            break;
+    }
+}
diff -r 000000000000 -r 6e330c197193 Adafruit_GFX/Adafruit_GFX.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Adafruit_GFX/Adafruit_GFX.h	Mon Jan 27 12:04:30 2020 +0000
@@ -0,0 +1,183 @@
+/***********************************
+This is a our graphics core library, for all our displays. 
+We'll be adapting all the
+existing libaries to use this core to make updating, support 
+and upgrading easier!
+
+Adafruit invests time and resources providing this open source code, 
+please support Adafruit and open-source hardware by purchasing 
+products from Adafruit!
+
+Written by Limor Fried/Ladyada  for Adafruit Industries.  
+BSD license, check license.txt for more information
+All text above must be included in any redistribution
+****************************************/
+
+/*
+ *  Modified by Neal Horman 7/14/2012 for use in mbed
+ */
+
+#ifndef _ADAFRUIT_GFX_H_
+#define _ADAFRUIT_GFX_H_
+
+#include "Adafruit_GFX_Config.h"
+
+static inline void swap(int16_t &a, int16_t &b)
+{
+    int16_t t = a;
+    
+    a = b;
+    b = t;
+}
+
+#ifndef _BV
+#define _BV(bit) (1<<(bit))
+#endif
+
+#define BLACK 0
+#define WHITE 1
+
+/**
+ * This is a Text and Graphics element drawing class.
+ * These functions draw to the display buffer.
+ *
+ * Display drivers should be derived from here.
+ * The Display drivers push the display buffer to the
+ * hardware based on application control.
+ *
+ */
+class Adafruit_GFX : public Stream
+{
+ public:
+    Adafruit_GFX(int16_t w, int16_t h)
+        : _rawWidth(w)
+        , _rawHeight(h)
+        , _width(w)
+        , _height(h)
+        , cursor_x(0)
+        , cursor_y(0)
+        , textcolor(WHITE)
+        , textbgcolor(BLACK)
+        , textsize(1)
+        , rotation(0)
+        , wrap(true)
+        {};
+
+    /// Paint one BLACK or WHITE pixel in the display buffer
+    // this must be defined by the subclass
+    virtual void drawPixel(int16_t x, int16_t y, uint16_t color) = 0;
+    // this is optional
+    virtual void invertDisplay(bool i) {};
+    
+    // Stream implementation - provides printf() interface
+    // You would otherwise be forced to use writeChar()
+    virtual int _putc(int value) { return writeChar(value); };
+    virtual int _getc() { return -1; };
+
+#ifdef GFX_WANT_ABSTRACTS
+    // these are 'generic' drawing functions, so we can share them!
+    
+    /** Draw a Horizontal Line
+     * @note GFX_WANT_ABSTRACTS must be defined in Adafruit_GFX_config.h
+     */
+    virtual void drawFastHLine(int16_t x, int16_t y, int16_t w, uint16_t color);
+    /** Draw a rectangle
+     * @note GFX_WANT_ABSTRACTS must be defined in Adafruit_GFX_config.h
+     */
+    virtual void drawRect(int16_t x, int16_t y, int16_t w, int16_t h, uint16_t color);
+    /** Fill the entire display
+     * @note GFX_WANT_ABSTRACTS must be defined in Adafruit_GFX_config.h
+     */
+    virtual void fillScreen(uint16_t color);
+
+    /** Draw a circle
+     * @note GFX_WANT_ABSTRACTS must be defined in Adafruit_GFX_config.h
+     */
+    void drawCircle(int16_t x0, int16_t y0, int16_t r, uint16_t color);
+    void drawCircleHelper(int16_t x0, int16_t y0, int16_t r, uint8_t cornername, uint16_t color);
+    
+    /** Draw and fill a circle
+     * @note GFX_WANT_ABSTRACTS must be defined in Adafruit_GFX_config.h
+     */
+    void fillCircle(int16_t x0, int16_t y0, int16_t r, uint16_t color);
+    void fillCircleHelper(int16_t x0, int16_t y0, int16_t r, uint8_t cornername, int16_t delta, uint16_t color);
+
+    /** Draw a triangle
+     * @note GFX_WANT_ABSTRACTS must be defined in Adafruit_GFX_config.h
+     */
+    void drawTriangle(int16_t x0, int16_t y0, int16_t x1, int16_t y1, int16_t x2, int16_t y2, uint16_t color);
+    /** Draw and fill a triangle
+     * @note GFX_WANT_ABSTRACTS must be defined in Adafruit_GFX_config.h
+     */
+    void fillTriangle(int16_t x0, int16_t y0, int16_t x1, int16_t y1, int16_t x2, int16_t y2, uint16_t color);
+    
+    /** Draw a rounded rectangle
+     * @note GFX_WANT_ABSTRACTS must be defined in Adafruit_GFX_config.h
+     */
+    void drawRoundRect(int16_t x0, int16_t y0, int16_t w, int16_t h, int16_t radius, uint16_t color);
+    /** Draw and fill a rounded rectangle
+     * @note GFX_WANT_ABSTRACTS must be defined in Adafruit_GFX_config.h
+     */
+    void fillRoundRect(int16_t x0, int16_t y0, int16_t w, int16_t h, int16_t radius, uint16_t color);
+    /** Draw a bitmap
+     * @note GFX_WANT_ABSTRACTS must be defined in Adafruit_GFX_config.h
+     */
+    void drawBitmap(int16_t x, int16_t y, const uint8_t *bitmap, int16_t w, int16_t h, uint16_t color);
+#endif
+
+#if defined(GFX_WANT_ABSTRACTS) || defined(GFX_SIZEABLE_TEXT)
+    /** Draw a line
+     * @note GFX_WANT_ABSTRACTS or GFX_SIZEABLE_TEXT must be defined in Adafruit_GFX_config.h
+     */
+    virtual void drawLine(int16_t x0, int16_t y0, int16_t x1, int16_t y1, uint16_t color);
+    /** Draw a vertical line
+     * @note GFX_WANT_ABSTRACTS or GFX_SIZEABLE_TEXT must be defined in Adafruit_GFX_config.h
+     */
+    virtual void drawFastVLine(int16_t x, int16_t y, int16_t h, uint16_t color);
+    /** Draw and fill a rectangle
+     * @note GFX_WANT_ABSTRACTS or GFX_SIZEABLE_TEXT must be defined in Adafruit_GFX_config.h
+     */
+    virtual void fillRect(int16_t x, int16_t y, int16_t w, int16_t h, uint16_t color);
+#endif
+
+    /// Draw a text character at a specified pixel location
+    void drawChar(int16_t x, int16_t y, unsigned char c, uint16_t color, uint16_t bg, uint8_t size);
+    /// Draw a text character at the text cursor location
+    size_t writeChar(uint8_t);
+
+    /// Get the width of the display in pixels
+    inline int16_t width(void) { return _width; };
+    /// Get the height of the display in pixels
+    inline int16_t height(void) { return _height; };
+
+    /// Set the text cursor location, based on the size of the text
+    inline void setTextCursor(int16_t x, int16_t y) { cursor_x = x; cursor_y = y; };
+#if defined(GFX_WANT_ABSTRACTS) || defined(GFX_SIZEABLE_TEXT)
+    /** Set the size of the text to be drawn
+     * @note Make sure to enable either GFX_SIZEABLE_TEXT or GFX_WANT_ABSTRACTS
+     */
+    inline void setTextSize(uint8_t s) { textsize = (s > 0) ? s : 1; };
+#endif
+    /// Set the text foreground and background colors to be the same
+    inline void setTextColor(uint16_t c) { textcolor = c; textbgcolor = c; }
+    /// Set the text foreground and background colors independantly
+    inline void setTextColor(uint16_t c, uint16_t b) { textcolor = c; textbgcolor = b; };
+    /// Set text wraping mode true or false
+    inline void setTextWrap(bool w) { wrap = w; };
+
+    /// Set the display rotation, 1, 2, 3, or 4
+    void setRotation(uint8_t r);
+    /// Get the current rotation
+    inline uint8_t getRotation(void) { rotation %= 4; return rotation; };
+
+protected:
+    int16_t  _rawWidth, _rawHeight;   // this is the 'raw' display w/h - never changes
+    int16_t  _width, _height; // dependent on rotation
+    int16_t  cursor_x, cursor_y;
+    uint16_t textcolor, textbgcolor;
+    uint8_t  textsize;
+    uint8_t  rotation;
+    bool  wrap; // If set, 'wrap' text at right edge of display
+};
+
+#endif
diff -r 000000000000 -r 6e330c197193 Adafruit_GFX/Adafruit_GFX_Config.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Adafruit_GFX/Adafruit_GFX_Config.h	Mon Jan 27 12:04:30 2020 +0000
@@ -0,0 +1,14 @@
+#ifndef _ADAFRUIT_GFX_CONFIG_H_
+#define _ADAFRUIT_GFX_CONFIG_H_
+
+// Uncomment this to turn off the builtin splash
+//#define NO_SPLASH_ADAFRUIT
+
+// Uncomment this to enable all functionality
+#define GFX_WANT_ABSTRACTS
+
+// Uncomment this to enable only runtime font scaling, without all the rest of the Abstracts
+//#define GFX_SIZEABLE_TEXT
+
+
+#endif
\ No newline at end of file
diff -r 000000000000 -r 6e330c197193 Adafruit_GFX/Adafruit_SSD1306.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Adafruit_GFX/Adafruit_SSD1306.cpp	Mon Jan 27 12:04:30 2020 +0000
@@ -0,0 +1,253 @@
+/*********************************************************************
+This is a library for our Monochrome OLEDs based on SSD1306 drivers
+
+  Pick one up today in the adafruit shop!
+  ------> http://www.adafruit.com/category/63_98
+
+These displays use SPI to communicate, 4 or 5 pins are required to  
+interface
+
+Adafruit invests time and resources providing this open source code, 
+please support Adafruit and open-source hardware by purchasing 
+products from Adafruit!
+
+Written by Limor Fried/Ladyada  for Adafruit Industries.  
+BSD license, check license.txt for more information
+All text above, and the splash screen below must be included in any redistribution
+*********************************************************************/
+
+/*
+ *  Modified by Neal Horman 7/14/2012 for use in mbed
+ */
+
+#include "mbed.h"
+#include "Adafruit_SSD1306.h"
+
+#define SSD1306_SETCONTRAST 0x81
+#define SSD1306_DISPLAYALLON_RESUME 0xA4
+#define SSD1306_DISPLAYALLON 0xA5
+#define SSD1306_NORMALDISPLAY 0xA6
+#define SSD1306_INVERTDISPLAY 0xA7
+#define SSD1306_DISPLAYOFF 0xAE
+#define SSD1306_DISPLAYON 0xAF
+#define SSD1306_SETDISPLAYOFFSET 0xD3
+#define SSD1306_SETCOMPINS 0xDA
+#define SSD1306_SETVCOMDETECT 0xDB
+#define SSD1306_SETDISPLAYCLOCKDIV 0xD5
+#define SSD1306_SETPRECHARGE 0xD9
+#define SSD1306_SETMULTIPLEX 0xA8
+#define SSD1306_SETLOWCOLUMN 0x00
+#define SSD1306_SETHIGHCOLUMN 0x10
+#define SSD1306_SETSTARTLINE 0x40
+#define SSD1306_MEMORYMODE 0x20
+#define SSD1306_COMSCANINC 0xC0
+#define SSD1306_COMSCANDEC 0xC8
+#define SSD1306_SEGREMAP 0xA0
+#define SSD1306_CHARGEPUMP 0x8D
+
+void Adafruit_SSD1306::begin(uint8_t vccstate)
+{
+    rst = 1;
+    // VDD (3.3V) goes high at start, lets just chill for a ms
+    wait_ms(1);
+    // bring reset low
+    rst = 0;
+    // wait 10ms
+    wait_ms(10);
+    // bring out of reset
+    rst = 1;
+    // turn on VCC (9V?)
+
+    command(SSD1306_DISPLAYOFF);
+    command(SSD1306_SETDISPLAYCLOCKDIV);
+    command(0x80);                                  // the suggested ratio 0x80
+
+    command(SSD1306_SETMULTIPLEX);
+    command(_rawHeight-1);
+
+    command(SSD1306_SETDISPLAYOFFSET);
+    command(0x0);                                   // no offset
+
+    command(SSD1306_SETSTARTLINE | 0x0);            // line #0
+
+    command(SSD1306_CHARGEPUMP);
+    command((vccstate == SSD1306_EXTERNALVCC) ? 0x10 : 0x14);
+
+    command(SSD1306_MEMORYMODE);
+    command(0x00);                                  // 0x0 act like ks0108
+
+    command(SSD1306_SEGREMAP | 0x1);
+
+    command(SSD1306_COMSCANDEC);
+
+    command(SSD1306_SETCOMPINS);
+    command(_rawHeight == 32 ? 0x02 : 0x12);        // TODO - calculate based on _rawHieght ?
+
+    command(SSD1306_SETCONTRAST);
+    command(_rawHeight == 32 ? 0x8F : ((vccstate == SSD1306_EXTERNALVCC) ? 0x9F : 0xCF) );
+
+    command(SSD1306_SETPRECHARGE);
+    command((vccstate == SSD1306_EXTERNALVCC) ? 0x22 : 0xF1);
+
+    command(SSD1306_SETVCOMDETECT);
+    command(0x40);
+
+    command(SSD1306_DISPLAYALLON_RESUME);
+
+    command(SSD1306_NORMALDISPLAY);
+    
+    command(SSD1306_DISPLAYON);
+}
+
+// Set a single pixel
+void Adafruit_SSD1306::drawPixel(int16_t x, int16_t y, uint16_t color)
+{
+    if ((x < 0) || (x >= width()) || (y < 0) || (y >= height()))
+        return;
+    
+    // check rotation, move pixel around if necessary
+    switch (getRotation())
+    {
+        case 1:
+            swap(x, y);
+            x = _rawWidth - x - 1;
+            break;
+        case 2:
+            x = _rawWidth - x - 1;
+            y = _rawHeight - y - 1;
+            break;
+        case 3:
+            swap(x, y);
+            y = _rawHeight - y - 1;
+            break;
+    }  
+    
+    // x is which column
+    if (color == WHITE) 
+        buffer[x+ (y/8)*_rawWidth] |= _BV((y%8));  
+    else // else black
+        buffer[x+ (y/8)*_rawWidth] &= ~_BV((y%8)); 
+}
+
+void Adafruit_SSD1306::invertDisplay(bool i)
+{
+	command(i ? SSD1306_INVERTDISPLAY : SSD1306_NORMALDISPLAY);
+}
+
+// Send the display buffer out to the display
+void Adafruit_SSD1306::display(void)
+{
+	command(SSD1306_SETLOWCOLUMN | 0x0);  // low col = 0
+	command(SSD1306_SETHIGHCOLUMN | 0x0);  // hi col = 0
+	command(SSD1306_SETSTARTLINE | 0x0); // line #0
+	sendDisplayBuffer();
+}
+
+// Clear the display buffer. Requires a display() call at some point afterwards
+void Adafruit_SSD1306::clearDisplay(void)
+{
+	std::fill(buffer.begin(),buffer.end(),0);
+}
+
+void Adafruit_SSD1306::splash(void)
+{
+#ifndef NO_SPLASH_ADAFRUIT
+	uint8_t adaFruitLogo[64 * 128 / 8] =
+	{ 
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80,
+		0x80, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0x80, 0x80, 0xC0, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x00, 0x80, 0xC0, 0xE0, 0xF0, 0xF8, 0xFC, 0xF8, 0xE0, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x80, 0x80,
+		0x80, 0x80, 0x00, 0x80, 0x80, 0x00, 0x00, 0x00, 0x00, 0x80, 0x80, 0x80, 0x80, 0x80, 0x00, 0xFF,
+		0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x80, 0x80, 0x80, 0x80, 0x00, 0x00, 0x80, 0x80, 0x00, 0x00,
+		0x80, 0xFF, 0xFF, 0x80, 0x80, 0x00, 0x80, 0x80, 0x00, 0x80, 0x80, 0x80, 0x80, 0x00, 0x80, 0x80,
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x80, 0x00, 0x00, 0x8C, 0x8E, 0x84, 0x00, 0x00, 0x80, 0xF8,
+		0xF8, 0xF8, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xE0, 0xE0, 0xC0, 0x80,
+		0x00, 0xE0, 0xFC, 0xFE, 0xFF, 0xFF, 0xFF, 0x7F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFE, 0xFF, 0xC7, 0x01, 0x01,
+		0x01, 0x01, 0x83, 0xFF, 0xFF, 0x00, 0x00, 0x7C, 0xFE, 0xC7, 0x01, 0x01, 0x01, 0x01, 0x83, 0xFF,
+		0xFF, 0xFF, 0x00, 0x38, 0xFE, 0xC7, 0x83, 0x01, 0x01, 0x01, 0x83, 0xC7, 0xFF, 0xFF, 0x00, 0x00,
+		0x01, 0xFF, 0xFF, 0x01, 0x01, 0x00, 0xFF, 0xFF, 0x07, 0x01, 0x01, 0x01, 0x00, 0x00, 0x7F, 0xFF,
+		0x80, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0x7F, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x01, 0xFF,
+		0xFF, 0xFF, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x03, 0x0F, 0x3F, 0x7F, 0x7F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xE7, 0xC7, 0xC7, 0x8F,
+		0x8F, 0x9F, 0xBF, 0xFF, 0xFF, 0xC3, 0xC0, 0xF0, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFC, 0xFC, 0xFC,
+		0xFC, 0xFC, 0xFC, 0xFC, 0xFC, 0xF8, 0xF8, 0xF0, 0xF0, 0xE0, 0xC0, 0x00, 0x01, 0x03, 0x03, 0x03,
+		0x03, 0x03, 0x01, 0x03, 0x03, 0x00, 0x00, 0x00, 0x00, 0x01, 0x03, 0x03, 0x03, 0x03, 0x01, 0x01,
+		0x03, 0x01, 0x00, 0x00, 0x00, 0x01, 0x03, 0x03, 0x03, 0x03, 0x01, 0x01, 0x03, 0x03, 0x00, 0x00,
+		0x00, 0x03, 0x03, 0x00, 0x00, 0x00, 0x03, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+		0x03, 0x03, 0x03, 0x03, 0x03, 0x01, 0x00, 0x00, 0x00, 0x01, 0x03, 0x01, 0x00, 0x00, 0x00, 0x03,
+		0x03, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		// 128x32^^^  128x64vvv
+		0x00, 0x00, 0x00, 0x80, 0xC0, 0xE0, 0xF0, 0xF9, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x3F, 0x1F, 0x0F,
+		0x87, 0xC7, 0xF7, 0xFF, 0xFF, 0x1F, 0x1F, 0x3D, 0xFC, 0xF8, 0xF8, 0xF8, 0xF8, 0x7C, 0x7D, 0xFF,
+		0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F, 0x3F, 0x0F, 0x07, 0x00, 0x30, 0x30, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x00, 0xFE, 0xFE, 0xFC, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0xC0, 0x00,
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x30, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0xC0, 0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F, 0x7F, 0x3F, 0x1F,
+		0x0F, 0x07, 0x1F, 0x7F, 0xFF, 0xFF, 0xF8, 0xF8, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFE, 0xF8, 0xE0,
+		0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFE, 0xFE, 0x00, 0x00,
+		0x00, 0xFC, 0xFE, 0xFC, 0x0C, 0x06, 0x06, 0x0E, 0xFC, 0xF8, 0x00, 0x00, 0xF0, 0xF8, 0x1C, 0x0E,
+		0x06, 0x06, 0x06, 0x0C, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0xFE, 0xFE, 0x00, 0x00, 0x00, 0x00, 0xFC,
+		0xFE, 0xFC, 0x00, 0x18, 0x3C, 0x7E, 0x66, 0xE6, 0xCE, 0x84, 0x00, 0x00, 0x06, 0xFF, 0xFF, 0x06,
+		0x06, 0xFC, 0xFE, 0xFC, 0x0C, 0x06, 0x06, 0x06, 0x00, 0x00, 0xFE, 0xFE, 0x00, 0x00, 0xC0, 0xF8,
+		0xFC, 0x4E, 0x46, 0x46, 0x46, 0x4E, 0x7C, 0x78, 0x40, 0x18, 0x3C, 0x76, 0xE6, 0xCE, 0xCC, 0x80,
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x00, 0x01, 0x07, 0x0F, 0x1F, 0x1F, 0x3F, 0x3F, 0x3F, 0x3F, 0x1F, 0x0F, 0x03,
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0F, 0x0F, 0x00, 0x00,
+		0x00, 0x0F, 0x0F, 0x0F, 0x00, 0x00, 0x00, 0x00, 0x0F, 0x0F, 0x00, 0x00, 0x03, 0x07, 0x0E, 0x0C,
+		0x18, 0x18, 0x0C, 0x06, 0x0F, 0x0F, 0x0F, 0x00, 0x00, 0x01, 0x0F, 0x0E, 0x0C, 0x18, 0x0C, 0x0F,
+		0x07, 0x01, 0x00, 0x04, 0x0E, 0x0C, 0x18, 0x0C, 0x0F, 0x07, 0x00, 0x00, 0x00, 0x0F, 0x0F, 0x00,
+		0x00, 0x0F, 0x0F, 0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0F, 0x0F, 0x00, 0x00, 0x00, 0x07,
+		0x07, 0x0C, 0x0C, 0x18, 0x1C, 0x0C, 0x06, 0x06, 0x00, 0x04, 0x0E, 0x0C, 0x18, 0x0C, 0x0F, 0x07,
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
+	};
+	
+	uint8_t heart_rate_symbol [] = {
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80,
+		0x40, 0x00, 0x00, 0x80, 0x48, 0x20, 0x10, 0x88, 0x44, 0x20, 0x12, 0x88, 0x44, 0x20, 0x10, 0x88,
+		0x44, 0x20, 0x12, 0x88, 0x46, 0x20, 0x90, 0xC8, 0x60, 0x30, 0x90, 0xC0, 0x60, 0x30, 0x90, 0x80,
+		0x40, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x88, 0x44, 0x22,
+		0x11, 0x88, 0x44, 0x22, 0x11, 0x88, 0x44, 0x22, 0x11, 0x88, 0x44, 0x22, 0x11, 0x88, 0x44, 0x22,
+		0x91, 0xC8, 0x64, 0x32, 0x99, 0xCC, 0x66, 0x33, 0x99, 0xCC, 0x66, 0x33, 0x99, 0xCC, 0x66, 0x33,
+		0x99, 0xCC, 0x66, 0x33, 0x98, 0xCC, 0x00, 0x00, 0x00, 0x00, 0x20, 0x88, 0x44, 0x22, 0x11, 0x88,
+		0x44, 0x22, 0x11, 0x88, 0x44, 0x22, 0x11, 0x88, 0x44, 0x22, 0x91, 0xC8, 0x64, 0x32, 0x99, 0xCC,
+		0x66, 0x33, 0x99, 0xCC, 0x66, 0x33, 0x99, 0xCC, 0x66, 0x33, 0x99, 0xCC, 0x66, 0x33, 0x99, 0xCC,
+		0x66, 0x33, 0x99, 0x4C, 0x26, 0x13, 0x889, 0x44, 0x00, 0x00, 0x00, 0x00, 0x91, 0x88, 0x44, 0x22,
+		0x11, 0x88, 0x44, 0x22, 0x91, 0xC8, 0x64, 0x32, 0x99, 0xCC, 0x66, 0x33, 0x99, 0xCC, 0x66, 0x33,
+		0x99, 0xCC, 0x66, 0x33, 0x99, 0xCC, 0x66, 0x33, 0x19, 0x4C, 0x26, 0x33, 0x99, 0x4C, 0x26, 0x13,
+		0x89, 0x44, 0x22, 0x11, 0x88, 0x44, 0x22, 0x31, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04,
+		0x04, 0x22, 0x99, 0x8C, 0x66, 0x33, 0x99, 0x8C, 0x66, 0x33, 0x99, 0x8C, 0x26, 0x33, 0x99, 0xCC,
+		0x26, 0x33, 0x19, 0xCC, 0x26, 0x33, 0x19, 0xCC, 0x22, 0x01, 0x81, 0x00, 0x00, 0x01, 0x08, 0x44,
+		0x22, 0x11, 0x88, 0x44, 0x22, 0x11, 0x48, 0x00, 0x11, 0x90, 0x88, 0x44, 0x30, 0x30, 0x2C, 0x20,
+		0x30, 0x78, 0x30, 0x30, 0x2C, 0x20, 0x30, 0x79,
+};
+	
+	std::copy(
+		&heart_rate_symbol[0]
+		, &heart_rate_symbol[0] + (_rawHeight == 32 ? sizeof(heart_rate_symbol)/2 : sizeof(heart_rate_symbol))
+		, buffer.begin()
+		);
+#endif
+}
diff -r 000000000000 -r 6e330c197193 Adafruit_GFX/Adafruit_SSD1306.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Adafruit_GFX/Adafruit_SSD1306.h	Mon Jan 27 12:04:30 2020 +0000
@@ -0,0 +1,220 @@
+/*********************************************************************
+This is a library for our Monochrome OLEDs based on SSD1306 drivers
+
+  Pick one up today in the adafruit shop!
+  ------> http://www.adafruit.com/category/63_98
+
+These displays use SPI to communicate, 4 or 5 pins are required to  
+interface
+
+Adafruit invests time and resources providing this open source code, 
+please support Adafruit and open-source hardware by purchasing 
+products from Adafruit!
+
+Written by Limor Fried/Ladyada  for Adafruit Industries.  
+BSD license, check license.txt for more information
+All text above, and the splash screen must be included in any redistribution
+*********************************************************************/
+
+/*
+ *  Modified by Neal Horman 7/14/2012 for use in mbed
+ */
+
+#ifndef _ADAFRUIT_SSD1306_H_
+#define _ADAFRUIT_SSD1306_H_
+
+#include "mbed.h"
+#include "Adafruit_GFX.h"
+
+#include <vector>
+#include <algorithm>
+
+// A DigitalOut sub-class that provides a constructed default state
+class DigitalOut2 : public DigitalOut
+{
+public:
+	DigitalOut2(PinName pin, bool active = false) : DigitalOut(pin) { write(active); };
+	DigitalOut2& operator= (int value) { write(value); return *this; };
+	DigitalOut2& operator= (DigitalOut2& rhs) { write(rhs.read()); return *this; };
+	operator int() { return read(); };
+};
+
+#define SSD1306_EXTERNALVCC 0x1
+#define SSD1306_SWITCHCAPVCC 0x2
+
+/** The pure base class for the SSD1306 display driver.
+ *
+ * You should derive from this for a new transport interface type,
+ * such as the SPI and I2C drivers.
+ */
+class Adafruit_SSD1306 : public Adafruit_GFX
+{
+public:
+	Adafruit_SSD1306(PinName RST, uint8_t rawHeight = 32, uint8_t rawWidth = 128)
+		: Adafruit_GFX(rawWidth,rawHeight)
+		, rst(RST,false)
+	{
+		buffer.resize(rawHeight * rawWidth / 8);
+	};
+
+	void begin(uint8_t switchvcc = SSD1306_SWITCHCAPVCC);
+	
+	// These must be implemented in the derived transport driver
+	virtual void command(uint8_t c) = 0;
+	virtual void data(uint8_t c) = 0;
+	virtual void drawPixel(int16_t x, int16_t y, uint16_t color);
+
+	/// Clear the display buffer    
+	void clearDisplay(void);
+	virtual void invertDisplay(bool i);
+
+	/// Cause the display to be updated with the buffer content.
+	void display();
+	/// Fill the buffer with the AdaFruit splash screen.
+	virtual void splash();
+    
+protected:
+	virtual void sendDisplayBuffer() = 0;
+	DigitalOut2 rst;
+
+	// the memory buffer for the LCD
+	std::vector<uint8_t> buffer;
+};
+
+
+/** This is the SPI SSD1306 display driver transport class
+ *
+ */
+class Adafruit_SSD1306_Spi : public Adafruit_SSD1306
+{
+public:
+	/** Create a SSD1306 SPI transport display driver instance with the specified DC, RST, and CS pins, as well as the display dimentions
+	 *
+	 * Required parameters
+	 * @param spi - a reference to an initialized SPI object
+	 * @param DC (Data/Command) pin name
+	 * @param RST (Reset) pin name
+	 * @param CS (Chip Select) pin name
+	 *
+	 * Optional parameters
+	 * @param rawHeight - the vertical number of pixels for the display, defaults to 32
+	 * @param rawWidth - the horizonal number of pixels for the display, defaults to 128
+	 */
+	Adafruit_SSD1306_Spi(SPI &spi, PinName DC, PinName RST, PinName CS, uint8_t rawHieght = 32, uint8_t rawWidth = 128)
+	    : Adafruit_SSD1306(RST, rawHieght, rawWidth)
+	    , cs(CS,true)
+	    , dc(DC,false)
+	    , mspi(spi)
+	    {
+		    begin();
+		    splash();
+		    display();
+	    };
+
+	virtual void command(uint8_t c)
+	{
+	    cs = 1;
+	    dc = 0;
+	    cs = 0;
+	    mspi.write(c);
+	    cs = 1;
+	};
+
+	virtual void data(uint8_t c)
+	{
+	    cs = 1;
+	    dc = 1;
+	    cs = 0;
+	    mspi.write(c);
+	    cs = 1;
+	};
+
+protected:
+	virtual void sendDisplayBuffer()
+	{
+		cs = 1;
+		dc = 1;
+		cs = 0;
+
+		for(uint16_t i=0, q=buffer.size(); i<q; i++)
+			mspi.write(buffer[i]);
+
+		if(height() == 32)
+		{
+			for(uint16_t i=0, q=buffer.size(); i<q; i++)
+				mspi.write(0);
+		}
+
+		cs = 1;
+	};
+
+	DigitalOut2 cs, dc;
+	SPI &mspi;
+};
+
+/** This is the I2C SSD1306 display driver transport class
+ *
+ */
+class Adafruit_SSD1306_I2c : public Adafruit_SSD1306
+{
+public:
+	#define SSD_I2C_ADDRESS     0x78
+	/** Create a SSD1306 I2C transport display driver instance with the specified RST pin name, the I2C address, as well as the display dimensions
+	 *
+	 * Required parameters
+	 * @param i2c - A reference to an initialized I2C object
+	 * @param RST - The Reset pin name
+	 *
+	 * Optional parameters
+	 * @param i2cAddress - The i2c address of the display
+	 * @param rawHeight - The vertical number of pixels for the display, defaults to 32
+	 * @param rawWidth - The horizonal number of pixels for the display, defaults to 128
+	 */
+	Adafruit_SSD1306_I2c(I2C &i2c, PinName RST, uint8_t i2cAddress = SSD_I2C_ADDRESS, uint8_t rawHeight = 32, uint8_t rawWidth = 128)
+	    : Adafruit_SSD1306(RST, rawHeight, rawWidth)
+	    , mi2c(i2c)
+	    , mi2cAddress(i2cAddress)
+	    {
+		    begin();
+		    splash();
+		    display();
+	    };
+
+	virtual void command(uint8_t c)
+	{
+		char buff[2];
+		buff[0] = 0; // Command Mode
+		buff[1] = c;
+		mi2c.write(mi2cAddress, buff, sizeof(buff));
+	}
+
+	virtual void data(uint8_t c)
+	{
+		char buff[2];
+		buff[0] = 0x40; // Data Mode
+		buff[1] = c;
+		mi2c.write(mi2cAddress, buff, sizeof(buff));
+	};
+
+protected:
+	virtual void sendDisplayBuffer()
+	{
+		char buff[17];
+		buff[0] = 0x40; // Data Mode
+
+		// send display buffer in 16 byte chunks
+		for(uint16_t i=0, q=buffer.size(); i<q; i+=16 ) 
+		{	uint8_t x ;
+
+			// TODO - this will segfault if buffer.size() % 16 != 0
+			for(x=1; x<sizeof(buff); x++) 
+				buff[x] = buffer[i+x-1];
+			mi2c.write(mi2cAddress, buff, sizeof(buff));
+		}
+	};
+
+	I2C &mi2c;
+	uint8_t mi2cAddress;
+};
+
+#endif
\ No newline at end of file
diff -r 000000000000 -r 6e330c197193 Adafruit_GFX/glcdfont.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Adafruit_GFX/glcdfont.h	Mon Jan 27 12:04:30 2020 +0000
@@ -0,0 +1,285 @@
+/*********************************************************************
+This is a library for our Monochrome OLEDs based on SSD1306 drivers
+
+  Pick one up today in the adafruit shop!
+  ------> http://www.adafruit.com/category/63_98
+
+These displays use SPI to communicate, 4 or 5 pins are required to  
+interface
+
+Adafruit invests time and resources providing this open source code, 
+please support Adafruit and open-source hardware by purchasing 
+products from Adafruit!
+
+Written by Limor Fried/Ladyada  for Adafruit Industries.  
+BSD license, check license.txt for more information
+All text above, and the splash screen must be included in any redistribution
+*********************************************************************/
+
+/*
+ *  Modified by Neal Horman 7/14/2012 for use in LPC1768
+ */
+ 
+#ifndef FONT5X7_H
+#define FONT5X7_H
+
+// standard ascii 5x7 font
+
+static unsigned char  font[] = {
+    0x00, 0x00, 0x00, 0x00, 0x00,   
+    0x3E, 0x5B, 0x4F, 0x5B, 0x3E,     
+    0x3E, 0x6B, 0x4F, 0x6B, 0x3E,     
+    0x1C, 0x3E, 0x7C, 0x3E, 0x1C, 
+    0x18, 0x3C, 0x7E, 0x3C, 0x18, 
+    0x1C, 0x57, 0x7D, 0x57, 0x1C, 
+    0x1C, 0x5E, 0x7F, 0x5E, 0x1C, 
+    0x00, 0x18, 0x3C, 0x18, 0x00, 
+    0xFF, 0xE7, 0xC3, 0xE7, 0xFF, 
+    0x00, 0x18, 0x24, 0x18, 0x00, 
+    0xFF, 0xE7, 0xDB, 0xE7, 0xFF, 
+    0x30, 0x48, 0x3A, 0x06, 0x0E, 
+    0x26, 0x29, 0x79, 0x29, 0x26, 
+    0x40, 0x7F, 0x05, 0x05, 0x07, 
+    0x40, 0x7F, 0x05, 0x25, 0x3F, 
+    0x5A, 0x3C, 0xE7, 0x3C, 0x5A, 
+    0x7F, 0x3E, 0x1C, 0x1C, 0x08, 
+    0x08, 0x1C, 0x1C, 0x3E, 0x7F, 
+    0x14, 0x22, 0x7F, 0x22, 0x14, 
+    0x5F, 0x5F, 0x00, 0x5F, 0x5F, 
+    0x06, 0x09, 0x7F, 0x01, 0x7F, 
+    0x00, 0x66, 0x89, 0x95, 0x6A, 
+    0x60, 0x60, 0x60, 0x60, 0x60, 
+    0x94, 0xA2, 0xFF, 0xA2, 0x94, 
+    0x08, 0x04, 0x7E, 0x04, 0x08, 
+    0x10, 0x20, 0x7E, 0x20, 0x10, 
+    0x08, 0x08, 0x2A, 0x1C, 0x08, 
+    0x08, 0x1C, 0x2A, 0x08, 0x08, 
+    0x1E, 0x10, 0x10, 0x10, 0x10, 
+    0x0C, 0x1E, 0x0C, 0x1E, 0x0C, 
+    0x30, 0x38, 0x3E, 0x38, 0x30, 
+    0x06, 0x0E, 0x3E, 0x0E, 0x06, 
+    0x00, 0x00, 0x00, 0x00, 0x00, 
+    0x00, 0x00, 0x5F, 0x00, 0x00, 
+    0x00, 0x07, 0x00, 0x07, 0x00, 
+    0x14, 0x7F, 0x14, 0x7F, 0x14, 
+    0x24, 0x2A, 0x7F, 0x2A, 0x12, 
+    0x23, 0x13, 0x08, 0x64, 0x62, 
+    0x36, 0x49, 0x56, 0x20, 0x50, 
+    0x00, 0x08, 0x07, 0x03, 0x00, 
+    0x00, 0x1C, 0x22, 0x41, 0x00, 
+    0x00, 0x41, 0x22, 0x1C, 0x00, 
+    0x2A, 0x1C, 0x7F, 0x1C, 0x2A, 
+    0x08, 0x08, 0x3E, 0x08, 0x08, 
+    0x00, 0x80, 0x70, 0x30, 0x00, 
+    0x08, 0x08, 0x08, 0x08, 0x08, 
+    0x00, 0x00, 0x60, 0x60, 0x00, 
+    0x20, 0x10, 0x08, 0x04, 0x02, 
+    0x3E, 0x51, 0x49, 0x45, 0x3E, 
+    0x00, 0x42, 0x7F, 0x40, 0x00, 
+    0x72, 0x49, 0x49, 0x49, 0x46, 
+    0x21, 0x41, 0x49, 0x4D, 0x33, 
+    0x18, 0x14, 0x12, 0x7F, 0x10, 
+    0x27, 0x45, 0x45, 0x45, 0x39, 
+    0x3C, 0x4A, 0x49, 0x49, 0x31, 
+    0x41, 0x21, 0x11, 0x09, 0x07, 
+    0x36, 0x49, 0x49, 0x49, 0x36, 
+    0x46, 0x49, 0x49, 0x29, 0x1E, 
+    0x00, 0x00, 0x14, 0x00, 0x00, 
+    0x00, 0x40, 0x34, 0x00, 0x00, 
+    0x00, 0x08, 0x14, 0x22, 0x41, 
+    0x14, 0x14, 0x14, 0x14, 0x14, 
+    0x00, 0x41, 0x22, 0x14, 0x08, 
+    0x02, 0x01, 0x59, 0x09, 0x06, 
+    0x3E, 0x41, 0x5D, 0x59, 0x4E, 
+    0x7C, 0x12, 0x11, 0x12, 0x7C, 
+    0x7F, 0x49, 0x49, 0x49, 0x36, 
+    0x3E, 0x41, 0x41, 0x41, 0x22, 
+    0x7F, 0x41, 0x41, 0x41, 0x3E, 
+    0x7F, 0x49, 0x49, 0x49, 0x41, 
+    0x7F, 0x09, 0x09, 0x09, 0x01, 
+    0x3E, 0x41, 0x41, 0x51, 0x73, 
+    0x7F, 0x08, 0x08, 0x08, 0x7F, 
+    0x00, 0x41, 0x7F, 0x41, 0x00, 
+    0x20, 0x40, 0x41, 0x3F, 0x01, 
+    0x7F, 0x08, 0x14, 0x22, 0x41, 
+    0x7F, 0x40, 0x40, 0x40, 0x40, 
+    0x7F, 0x02, 0x1C, 0x02, 0x7F, 
+    0x7F, 0x04, 0x08, 0x10, 0x7F, 
+    0x3E, 0x41, 0x41, 0x41, 0x3E, 
+    0x7F, 0x09, 0x09, 0x09, 0x06, 
+    0x3E, 0x41, 0x51, 0x21, 0x5E, 
+    0x7F, 0x09, 0x19, 0x29, 0x46, 
+    0x26, 0x49, 0x49, 0x49, 0x32, 
+    0x03, 0x01, 0x7F, 0x01, 0x03, 
+    0x3F, 0x40, 0x40, 0x40, 0x3F, 
+    0x1F, 0x20, 0x40, 0x20, 0x1F, 
+    0x3F, 0x40, 0x38, 0x40, 0x3F, 
+    0x63, 0x14, 0x08, 0x14, 0x63, 
+    0x03, 0x04, 0x78, 0x04, 0x03, 
+    0x61, 0x59, 0x49, 0x4D, 0x43, 
+    0x00, 0x7F, 0x41, 0x41, 0x41, 
+    0x02, 0x04, 0x08, 0x10, 0x20, 
+    0x00, 0x41, 0x41, 0x41, 0x7F, 
+    0x04, 0x02, 0x01, 0x02, 0x04, 
+    0x40, 0x40, 0x40, 0x40, 0x40, 
+    0x00, 0x03, 0x07, 0x08, 0x00, 
+    0x20, 0x54, 0x54, 0x78, 0x40, 
+    0x7F, 0x28, 0x44, 0x44, 0x38, 
+    0x38, 0x44, 0x44, 0x44, 0x28, 
+    0x38, 0x44, 0x44, 0x28, 0x7F, 
+    0x38, 0x54, 0x54, 0x54, 0x18, 
+    0x00, 0x08, 0x7E, 0x09, 0x02, 
+    0x18, 0xA4, 0xA4, 0x9C, 0x78, 
+    0x7F, 0x08, 0x04, 0x04, 0x78, 
+    0x00, 0x44, 0x7D, 0x40, 0x00, 
+    0x20, 0x40, 0x40, 0x3D, 0x00, 
+    0x7F, 0x10, 0x28, 0x44, 0x00, 
+    0x00, 0x41, 0x7F, 0x40, 0x00, 
+    0x7C, 0x04, 0x78, 0x04, 0x78, 
+    0x7C, 0x08, 0x04, 0x04, 0x78, 
+    0x38, 0x44, 0x44, 0x44, 0x38, 
+    0xFC, 0x18, 0x24, 0x24, 0x18, 
+    0x18, 0x24, 0x24, 0x18, 0xFC, 
+    0x7C, 0x08, 0x04, 0x04, 0x08, 
+    0x48, 0x54, 0x54, 0x54, 0x24, 
+    0x04, 0x04, 0x3F, 0x44, 0x24, 
+    0x3C, 0x40, 0x40, 0x20, 0x7C, 
+    0x1C, 0x20, 0x40, 0x20, 0x1C, 
+    0x3C, 0x40, 0x30, 0x40, 0x3C, 
+    0x44, 0x28, 0x10, 0x28, 0x44, 
+    0x4C, 0x90, 0x90, 0x90, 0x7C, 
+    0x44, 0x64, 0x54, 0x4C, 0x44, 
+    0x00, 0x08, 0x36, 0x41, 0x00, 
+    0x00, 0x00, 0x77, 0x00, 0x00, 
+    0x00, 0x41, 0x36, 0x08, 0x00, 
+    0x02, 0x01, 0x02, 0x04, 0x02, 
+    0x3C, 0x26, 0x23, 0x26, 0x3C, 
+    0x1E, 0xA1, 0xA1, 0x61, 0x12, 
+    0x3A, 0x40, 0x40, 0x20, 0x7A, 
+    0x38, 0x54, 0x54, 0x55, 0x59, 
+    0x21, 0x55, 0x55, 0x79, 0x41, 
+    0x21, 0x54, 0x54, 0x78, 0x41, 
+    0x21, 0x55, 0x54, 0x78, 0x40, 
+    0x20, 0x54, 0x55, 0x79, 0x40, 
+    0x0C, 0x1E, 0x52, 0x72, 0x12, 
+    0x39, 0x55, 0x55, 0x55, 0x59, 
+    0x39, 0x54, 0x54, 0x54, 0x59, 
+    0x39, 0x55, 0x54, 0x54, 0x58, 
+    0x00, 0x00, 0x45, 0x7C, 0x41, 
+    0x00, 0x02, 0x45, 0x7D, 0x42, 
+    0x00, 0x01, 0x45, 0x7C, 0x40, 
+    0xF0, 0x29, 0x24, 0x29, 0xF0, 
+    0xF0, 0x28, 0x25, 0x28, 0xF0, 
+    0x7C, 0x54, 0x55, 0x45, 0x00, 
+    0x20, 0x54, 0x54, 0x7C, 0x54, 
+    0x7C, 0x0A, 0x09, 0x7F, 0x49, 
+    0x32, 0x49, 0x49, 0x49, 0x32, 
+    0x32, 0x48, 0x48, 0x48, 0x32, 
+    0x32, 0x4A, 0x48, 0x48, 0x30, 
+    0x3A, 0x41, 0x41, 0x21, 0x7A, 
+    0x3A, 0x42, 0x40, 0x20, 0x78, 
+    0x00, 0x9D, 0xA0, 0xA0, 0x7D, 
+    0x39, 0x44, 0x44, 0x44, 0x39, 
+    0x3D, 0x40, 0x40, 0x40, 0x3D, 
+    0x3C, 0x24, 0xFF, 0x24, 0x24, 
+    0x48, 0x7E, 0x49, 0x43, 0x66, 
+    0x2B, 0x2F, 0xFC, 0x2F, 0x2B, 
+    0xFF, 0x09, 0x29, 0xF6, 0x20, 
+    0xC0, 0x88, 0x7E, 0x09, 0x03, 
+    0x20, 0x54, 0x54, 0x79, 0x41, 
+    0x00, 0x00, 0x44, 0x7D, 0x41, 
+    0x30, 0x48, 0x48, 0x4A, 0x32, 
+    0x38, 0x40, 0x40, 0x22, 0x7A, 
+    0x00, 0x7A, 0x0A, 0x0A, 0x72, 
+    0x7D, 0x0D, 0x19, 0x31, 0x7D, 
+    0x26, 0x29, 0x29, 0x2F, 0x28, 
+    0x26, 0x29, 0x29, 0x29, 0x26, 
+    0x30, 0x48, 0x4D, 0x40, 0x20, 
+    0x38, 0x08, 0x08, 0x08, 0x08, 
+    0x08, 0x08, 0x08, 0x08, 0x38, 
+    0x2F, 0x10, 0xC8, 0xAC, 0xBA, 
+    0x2F, 0x10, 0x28, 0x34, 0xFA, 
+    0x00, 0x00, 0x7B, 0x00, 0x00, 
+    0x08, 0x14, 0x2A, 0x14, 0x22, 
+    0x22, 0x14, 0x2A, 0x14, 0x08, 
+    0xAA, 0x00, 0x55, 0x00, 0xAA, 
+    0xAA, 0x55, 0xAA, 0x55, 0xAA, 
+    0x00, 0x00, 0x00, 0xFF, 0x00, 
+    0x10, 0x10, 0x10, 0xFF, 0x00, 
+    0x14, 0x14, 0x14, 0xFF, 0x00, 
+    0x10, 0x10, 0xFF, 0x00, 0xFF, 
+    0x10, 0x10, 0xF0, 0x10, 0xF0, 
+    0x14, 0x14, 0x14, 0xFC, 0x00, 
+    0x14, 0x14, 0xF7, 0x00, 0xFF, 
+    0x00, 0x00, 0xFF, 0x00, 0xFF, 
+    0x14, 0x14, 0xF4, 0x04, 0xFC, 
+    0x14, 0x14, 0x17, 0x10, 0x1F, 
+    0x10, 0x10, 0x1F, 0x10, 0x1F, 
+    0x14, 0x14, 0x14, 0x1F, 0x00, 
+    0x10, 0x10, 0x10, 0xF0, 0x00, 
+    0x00, 0x00, 0x00, 0x1F, 0x10, 
+    0x10, 0x10, 0x10, 0x1F, 0x10, 
+    0x10, 0x10, 0x10, 0xF0, 0x10, 
+    0x00, 0x00, 0x00, 0xFF, 0x10, 
+    0x10, 0x10, 0x10, 0x10, 0x10, 
+    0x10, 0x10, 0x10, 0xFF, 0x10, 
+    0x00, 0x00, 0x00, 0xFF, 0x14, 
+    0x00, 0x00, 0xFF, 0x00, 0xFF, 
+    0x00, 0x00, 0x1F, 0x10, 0x17, 
+    0x00, 0x00, 0xFC, 0x04, 0xF4, 
+    0x14, 0x14, 0x17, 0x10, 0x17, 
+    0x14, 0x14, 0xF4, 0x04, 0xF4, 
+    0x00, 0x00, 0xFF, 0x00, 0xF7, 
+    0x14, 0x14, 0x14, 0x14, 0x14, 
+    0x14, 0x14, 0xF7, 0x00, 0xF7, 
+    0x14, 0x14, 0x14, 0x17, 0x14, 
+    0x10, 0x10, 0x1F, 0x10, 0x1F, 
+    0x14, 0x14, 0x14, 0xF4, 0x14, 
+    0x10, 0x10, 0xF0, 0x10, 0xF0, 
+    0x00, 0x00, 0x1F, 0x10, 0x1F, 
+    0x00, 0x00, 0x00, 0x1F, 0x14, 
+    0x00, 0x00, 0x00, 0xFC, 0x14, 
+    0x00, 0x00, 0xF0, 0x10, 0xF0, 
+    0x10, 0x10, 0xFF, 0x10, 0xFF, 
+    0x14, 0x14, 0x14, 0xFF, 0x14, 
+    0x10, 0x10, 0x10, 0x1F, 0x00, 
+    0x00, 0x00, 0x00, 0xF0, 0x10, 
+    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 
+    0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 
+    0xFF, 0xFF, 0xFF, 0x00, 0x00, 
+    0x00, 0x00, 0x00, 0xFF, 0xFF, 
+    0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 
+    0x38, 0x44, 0x44, 0x38, 0x44, 
+    0x7C, 0x2A, 0x2A, 0x3E, 0x14, 
+    0x7E, 0x02, 0x02, 0x06, 0x06, 
+    0x02, 0x7E, 0x02, 0x7E, 0x02, 
+    0x63, 0x55, 0x49, 0x41, 0x63, 
+    0x38, 0x44, 0x44, 0x3C, 0x04, 
+    0x40, 0x7E, 0x20, 0x1E, 0x20, 
+    0x06, 0x02, 0x7E, 0x02, 0x02, 
+    0x99, 0xA5, 0xE7, 0xA5, 0x99, 
+    0x1C, 0x2A, 0x49, 0x2A, 0x1C, 
+    0x4C, 0x72, 0x01, 0x72, 0x4C, 
+    0x30, 0x4A, 0x4D, 0x4D, 0x30, 
+    0x30, 0x48, 0x78, 0x48, 0x30, 
+    0xBC, 0x62, 0x5A, 0x46, 0x3D, 
+    0x3E, 0x49, 0x49, 0x49, 0x00, 
+    0x7E, 0x01, 0x01, 0x01, 0x7E, 
+    0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 
+    0x44, 0x44, 0x5F, 0x44, 0x44, 
+    0x40, 0x51, 0x4A, 0x44, 0x40, 
+    0x40, 0x44, 0x4A, 0x51, 0x40, 
+    0x00, 0x00, 0xFF, 0x01, 0x03, 
+    0xE0, 0x80, 0xFF, 0x00, 0x00, 
+    0x08, 0x08, 0x6B, 0x6B, 0x08,
+    0x36, 0x12, 0x36, 0x24, 0x36, 
+    0x06, 0x0F, 0x09, 0x0F, 0x06, 
+    0x00, 0x00, 0x18, 0x18, 0x00, 
+    0x00, 0x00, 0x10, 0x10, 0x00, 
+    0x30, 0x40, 0xFF, 0x01, 0x01, 
+    0x00, 0x1F, 0x01, 0x01, 0x1E, 
+    0x00, 0x19, 0x1D, 0x17, 0x12, 
+    0x00, 0x3C, 0x3C, 0x3C, 0x3C, 
+    0x00, 0x00, 0x00, 0x00, 0x00, 
+};
+#endif
diff -r 000000000000 -r 6e330c197193 Arduino.lib
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Arduino.lib	Mon Jan 27 12:04:30 2020 +0000
@@ -0,0 +1,1 @@
+https://os.mbed.com/users/eduardoG26/code/Arduino/#abbc3308dfa1
diff -r 000000000000 -r 6e330c197193 LSM9DS1_registre.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/LSM9DS1_registre.h	Mon Jan 27 12:04:30 2020 +0000
@@ -0,0 +1,164 @@
+// Accelerometer and Gyroscope registers
+#define LSM9DS1XG_ACT_THS           0x04
+#define LSM9DS1XG_ACT_DUR           0x05
+#define LSM9DS1XG_INT_GEN_CFG_XL    0x06
+#define LSM9DS1XG_INT_GEN_THS_X_XL  0x07
+#define LSM9DS1XG_INT_GEN_THS_Y_XL  0x08
+#define LSM9DS1XG_INT_GEN_THS_Z_XL  0x09
+#define LSM9DS1XG_INT_GEN_DUR_XL    0x0A
+#define LSM9DS1XG_REFERENCE_G       0x0B
+#define LSM9DS1XG_INT1_CTRL         0x0C
+#define LSM9DS1XG_INT2_CTRL         0x0D
+#define LSM9DS1XG_WHO_AM_I          0x0F  // should return 0x68
+#define LSM9DS1XG_CTRL_REG1_G       0x10
+#define LSM9DS1XG_CTRL_REG2_G       0x11
+#define LSM9DS1XG_CTRL_REG3_G       0x12
+#define LSM9DS1XG_ORIENT_CFG_G      0x13
+#define LSM9DS1XG_INT_GEN_SRC_G     0x14
+#define LSM9DS1XG_OUT_TEMP_L        0x15
+#define LSM9DS1XG_OUT_TEMP_H        0x16
+#define LSM9DS1XG_STATUS_REG        0x17
+#define LSM9DS1XG_OUT_X_L_G         0x18
+#define LSM9DS1XG_OUT_X_H_G         0x19
+#define LSM9DS1XG_OUT_Y_L_G         0x1A
+#define LSM9DS1XG_OUT_Y_H_G         0x1B
+#define LSM9DS1XG_OUT_Z_L_G         0x1C
+#define LSM9DS1XG_OUT_Z_H_G         0x1D
+#define LSM9DS1XG_CTRL_REG4         0x1E
+#define LSM9DS1XG_CTRL_REG5_XL      0x1F
+#define LSM9DS1XG_CTRL_REG6_XL      0x20
+#define LSM9DS1XG_CTRL_REG7_XL      0x21
+#define LSM9DS1XG_CTRL_REG8         0x22
+#define LSM9DS1XG_CTRL_REG9         0x23
+#define LSM9DS1XG_CTRL_REG10        0x24
+#define LSM9DS1XG_INT_GEN_SRC_XL    0x26
+//#define LSM9DS1XG_STATUS_REG        0x27 // duplicate of 0x17!
+#define LSM9DS1XG_OUT_X_L_XL        0x28
+#define LSM9DS1XG_OUT_X_H_XL        0x29
+#define LSM9DS1XG_OUT_Y_L_XL        0x2A
+#define LSM9DS1XG_OUT_Y_H_XL        0x2B
+#define LSM9DS1XG_OUT_Z_L_XL        0x2C
+#define LSM9DS1XG_OUT_Z_H_XL        0x2D
+#define LSM9DS1XG_FIFO_CTRL         0x2E
+#define LSM9DS1XG_FIFO_SRC          0x2F
+#define LSM9DS1XG_INT_GEN_CFG_G     0x30
+#define LSM9DS1XG_INT_GEN_THS_XH_G  0x31
+#define LSM9DS1XG_INT_GEN_THS_XL_G  0x32
+#define LSM9DS1XG_INT_GEN_THS_YH_G  0x33
+#define LSM9DS1XG_INT_GEN_THS_YL_G  0x34
+#define LSM9DS1XG_INT_GEN_THS_ZH_G  0x35
+#define LSM9DS1XG_INT_GEN_THS_ZL_G  0x36
+#define LSM9DS1XG_INT_GEN_DUR_G     0x37
+//
+// Magnetometer registers
+#define LSM9DS1M_OFFSET_X_REG_L_M   0x05
+#define LSM9DS1M_OFFSET_X_REG_H_M   0x06
+#define LSM9DS1M_OFFSET_Y_REG_L_M   0x07
+#define LSM9DS1M_OFFSET_Y_REG_H_M   0x08
+#define LSM9DS1M_OFFSET_Z_REG_L_M   0x09
+#define LSM9DS1M_OFFSET_Z_REG_H_M   0x0A
+#define LSM9DS1M_WHO_AM_I           0x0F
+#define LSM9DS1M_CTRL_REG1_M        0x20
+#define LSM9DS1M_CTRL_REG2_M        0x21
+#define LSM9DS1M_CTRL_REG3_M        0x22
+#define LSM9DS1M_CTRL_REG4_M        0x23
+#define LSM9DS1M_CTRL_REG5_M        0x24
+#define LSM9DS1M_STATUS_REG_M       0x27
+#define LSM9DS1M_OUT_X_L_M          0x28
+#define LSM9DS1M_OUT_X_H_M          0x29
+#define LSM9DS1M_OUT_Y_L_M          0x2A
+#define LSM9DS1M_OUT_Y_H_M          0x2B
+#define LSM9DS1M_OUT_Z_L_M          0x2C
+#define LSM9DS1M_OUT_Z_H_M          0x2D
+#define LSM9DS1M_INT_CFG_M          0x30
+#define LSM9DS1M_INT_SRC_M          0x31
+#define LSM9DS1M_INT_THS_L_M        0x32
+#define LSM9DS1M_INT_THS_H_M        0x33
+
+// Using the LSM9DS1+MS5611 Teensy 3.1 Add-On shield, ADO is set to 1
+// Seven-bit device address of accel/gyro is 110101 for ADO = 0 and 110101 for ADO = 1
+
+#define LSM9DS1XG_ADDRESS 0xD4  //  Device address when ADO = 1
+#define LSM9DS1M_ADDRESS  0x38  //  Address of magnetometer
+#define SerialDebug true  // set to true to get Serial output for debugging
+
+
+
+
+
+
+// Set initial input parameters
+enum Ascale {
+    // set of allowable accel full scale settings
+    AFS_2G = 0,
+    AFS_16G,
+    AFS_4G,
+    AFS_8G
+};
+
+enum Aodr {  // set of allowable gyro sample rates
+    AODR_PowerDown = 0,
+    AODR_10Hz,
+    AODR_50Hz,
+    AODR_119Hz,
+    AODR_238Hz,
+    AODR_476Hz,
+    AODR_952Hz
+};
+
+enum Abw {  // set of allowable accewl bandwidths
+    ABW_408Hz = 0,
+    ABW_211Hz,
+    ABW_105Hz,
+    ABW_50Hz
+};
+
+enum Gscale {  // set of allowable gyro full scale settings
+    GFS_245DPS = 0,
+    GFS_500DPS,
+    GFS_NoOp,
+    GFS_2000DPS
+};
+
+enum Godr {  // set of allowable gyro sample rates
+    GODR_PowerDown = 0,
+    GODR_14_9Hz,
+    GODR_59_5Hz,
+    GODR_119Hz,
+    GODR_238Hz,
+    GODR_476Hz,
+    GODR_952Hz
+};
+
+enum Gbw {   // set of allowable gyro data bandwidths
+    GBW_low = 0,  // 14 Hz at Godr = 238 Hz,  33 Hz at Godr = 952 Hz
+    GBW_med,      // 29 Hz at Godr = 238 Hz,  40 Hz at Godr = 952 Hz
+    GBW_high,     // 63 Hz at Godr = 238 Hz,  58 Hz at Godr = 952 Hz
+    GBW_highest   // 78 Hz at Godr = 238 Hz, 100 Hz at Godr = 952 Hz
+};
+
+enum Mscale {  // set of allowable mag full scale settings
+    MFS_4G = 0,
+    MFS_8G,
+    MFS_12G,
+    MFS_16G
+};
+
+enum Mmode {
+    MMode_LowPower = 0,
+    MMode_MedPerformance,
+    MMode_HighPerformance,
+    MMode_UltraHighPerformance
+};
+
+enum Modr {  // set of allowable mag sample rates
+    MODR_0_625Hz = 0,
+    MODR_1_25Hz,
+    MODR_2_5Hz,
+    MODR_5Hz,
+    MODR_10Hz,
+    MODR_20Hz,
+    MODR_80Hz
+};
+
+#define PI  3.141592653589793238463
\ No newline at end of file
diff -r 000000000000 -r 6e330c197193 MBed_Adafruit-GPS-Library.lib
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/MBed_Adafruit-GPS-Library.lib	Mon Jan 27 12:04:30 2020 +0000
@@ -0,0 +1,1 @@
+https://os.mbed.com/teams/Projet_BMC/code/MBed_Adafruit-GPS-Library/#90f2232bbdfd
diff -r 000000000000 -r 6e330c197193 SDFileSystem.lib
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/SDFileSystem.lib	Mon Jan 27 12:04:30 2020 +0000
@@ -0,0 +1,1 @@
+https://os.mbed.com/teams/Projet_BMC/code/SDFileSystem/#e8ca65f9b149
diff -r 000000000000 -r 6e330c197193 SimpleBLE.lib
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/SimpleBLE.lib	Mon Jan 27 12:04:30 2020 +0000
@@ -0,0 +1,1 @@
+https://os.mbed.com/teams/ENSMM/code/SimpleBLE/#e26d79727dfa
diff -r 000000000000 -r 6e330c197193 USBDevice.lib
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/USBDevice.lib	Mon Jan 27 12:04:30 2020 +0000
@@ -0,0 +1,1 @@
+http://mbed.org/users/mbed_official/code/USBDevice/#53949e6131f6
diff -r 000000000000 -r 6e330c197193 X_NUCLEO_IDB0XA1.lib
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/X_NUCLEO_IDB0XA1.lib	Mon Jan 27 12:04:30 2020 +0000
@@ -0,0 +1,1 @@
+https://os.mbed.com/teams/Projet_BMC/code/X_NUCLEO_IDB0XA1/#d4451967ffad
diff -r 000000000000 -r 6e330c197193 main.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/main.cpp	Mon Jan 27 12:04:30 2020 +0000
@@ -0,0 +1,831 @@
+//Includes
+
+//#include "mbed.h"//déja défini dans une bibliotheque
+#include "SimpleBLE.h"
+#include "USBSerial.h"
+#include "SDFileSystem.h"
+#include "Adafruit_SSD1306.h"
+#include "Arduino.h"
+#include "MBed_Adafruit_GPS.h"
+#include "LSM9DS1_registre.h"
+
+
+
+
+Timer dt ;
+int t_avant = 0 ;
+int t_m = 0  ;
+int t_d = 0;
+int t_apres = 0;
+
+
+
+
+I2C i2c_m(PB_9, PB_8);
+unsigned char nCRC;       // calculated check sum to ensure PROM integrity
+double dT, OFFSET, SENS, T2, OFFSET2, SENS2;  // First order and second order corrections for raw S5637 temperature and pressure data
+int16_t accelCount[3], gyroCount[3], magCount[3];  // Stores the 16-bit signed accelerometer, gyro, and mag sensor output
+float gyroBias1[3] = {0, 0, 0}, accelBias[3] = {0, 0, 0},  magBias[3] = {0, 0, 0}; // Bias corrections for gyro, accelerometer, and magnetometer
+int16_t tempCount;            // temperature raw count output
+float   temperature;          // Stores the LSM9DS1gyro internal chip temperature in degrees Celsius
+double Temperature, Pressure; // stores MS5611 pressures sensor pressure and temperature
+// global constants for 9 DoF fusion and AHRS (Attitude and Heading Reference System)
+float GyroMeasError = PI * (40.0f / 180.0f);   // gyroscope measurement error in rads/s (start at 40 deg/s)
+float GyroMeasDrift = PI * (0.0f  / 180.0f);   // gyroscope measurement drift in rad/s/s (start at 0.0 deg/s/s)
+// There is a tradeoff in the beta parameter between accuracy and response speed.
+// In the original Madgwick study, beta of 0.041 (corresponding to GyroMeasError of 2.7 degrees/s) was found to give optimal accuracy.
+// However, with this value, the LSM9SD0 response time is about 10 seconds to a stable initial quaternion.
+// Subsequent changes also require a longish lag time to a stable output, not fast enough for a quadcopter or robot car!
+// By increasing beta (GyroMeasError) by about a factor of fifteen, the response time constant is reduced to ~2 sec
+// I haven't noticed any reduction in solution accuracy. This is essentially the I coefficient in a PID control sense;
+// the bigger the feedback coefficient, the faster the solution converges, usually at the expense of accuracy.
+// In any case, this is the free parameter in the Madgwick filtering and fusion scheme.
+float beta = sqrt(3.0f / 4.0f) * GyroMeasError;   // compute beta
+float zeta = sqrt(3.0f / 4.0f) * GyroMeasDrift;   // compute zeta, the other free parameter in the Madgwick scheme usually set to a small or zero value
+#define Kp 2.0f * 5.0f // these are the free parameters in the Mahony filter and fusion scheme, Kp for proportional feedback, Ki for integral
+#define Ki 0.0f
+
+uint32_t delt_t = 0, count = 0, sumCount = 0;  // used to control display output rate
+float pitch, yaw, roll;
+float deltat = 0.0f, sum = 0.0f;          // integration interval for both filter schemes
+uint32_t Now = 0;                         // used to calculate integration interval
+
+float ax, ay, az, gx, gy, gz, mx, my, mz; // variables to hold latest sensor data values
+float q[4] = {1.0f, 0.0f, 0.0f, 0.0f};    // vector to hold quaternion
+float eInt[3] = {0.0f, 0.0f, 0.0f};       // vector to hold integral error for Mahony meth
+
+// Specify sensor full scale
+uint8_t Gscale = GFS_245DPS; // gyro full scale
+uint8_t Godr = GODR_238Hz;   // gyro data sample rate
+uint8_t Gbw = GBW_med;       // gyro data bandwidth
+uint8_t Ascale = AFS_2G;     // accel full scale
+uint8_t Aodr = AODR_238Hz;   // accel data sample rate
+uint8_t Abw = ABW_50Hz;      // accel data bandwidth
+uint8_t Mscale = MFS_4G;     // mag full scale
+uint8_t Modr = MODR_10Hz;    // mag data sample rate
+uint8_t Mmode = MMode_HighPerformance;  // magnetometer operation mode
+float aRes, gRes, mRes;      // scale resolutions per LSB for the sensors
+
+
+void getMres();
+void getGres();
+void getAres();
+void writeByte(uint8_t address, uint8_t subAddress, uint8_t data);
+uint8_t readByte(uint8_t address, uint8_t subAddress);
+void readBytes(uint8_t address, uint8_t subAddress, uint8_t count, uint8_t * dest);
+void accelgyrocalLSM9DS1(float * dest1, float * dest2);
+void magcalLSM9DS1(float * dest1);
+void readAccelData(int16_t * destination);
+void readGyroData(int16_t * destination);
+void readMagData(int16_t * destination);
+void initLSM9DS1();
+void selftestLSM9DS1();
+
+
+Serial * gps_Serial;
+SDFileSystem sd(PA_7, PA_6, PA_5, PB_6, "sd");
+SimpleBLE ble("ObCP_Baton ");
+FILE *fp_ble= fopen("/sd/valeur_ble.txt", "w");
+FILE *fp= fopen("/sd/valeur_force.txt", "w");
+I2C i2c(PB_9, PB_8);
+Adafruit_SSD1306_I2c oled(i2c,PC_13);
+USBSerial pc(0x1f00, 0x2012, 0x0001, false);
+
+AnalogIn tension_A502(A0);
+DigitalOut myledr(PB_5);
+DigitalOut myledg(PB_3);
+DigitalOut myledb(PA_10);
+InterruptIn button1(PB_4);
+InterruptIn button2(PB_10);
+
+
+float lat_dd, lon_dd, lat_1, lon_1, lat_2, lon_2, distance = 0;
+float sum_distance = 0;
+float steps = 0;
+double avg_speed = 0;
+float cal = 0;
+int i_gps ;
+float t =0;
+float lastUpdate = 0;
+
+int  height=0;
+bool   interruption1= false;
+char name[20];
+int i=0 ;
+int weight;
+int age ;
+char gender[1];
+int max_heart_rate;
+bool message_envoyee= false;
+
+
+const int size_data = 50;
+float force_measure[size_data];
+float pression_measure[size_data];
+float volts_measure[size_data];
+int size_data_i= 0;
+bool  interruption2;
+bool force_mesure = false;
+
+void fct_name_text(uint8_t newState);
+void fct_height_int(uint8_t newState);
+void fct_weight_int(uint8_t newState);
+void fct_age_int(uint8_t newState);
+void fct_gender_text(uint8_t newState);
+void fct_max_heart_rate_int(uint8_t newState);
+void fct_fini(uint8_t newState);
+
+void fct_interruption_ble();
+
+
+int intToStr(int x, char str[], int d);
+void ftoa(float n, char* res, int afterpoint);
+float pow_nc(float n, int k);
+void reverse(char* str, int len) ;
+
+void fct_interruption_force(void);
+
+void OLED_writeString(string str, int x, int y);
+void OLED_drawSmile();
+
+
+
+SimpleChar<uint8_t> name_text =        ble.writeOnly_u8(0x8600, 0x8601, &fct_name_text);
+SimpleChar<uint8_t> height_int =       ble.writeOnly_u8(0x8600, 0x8602, &fct_height_int);
+SimpleChar<uint8_t> weight_int=        ble.writeOnly_u8(0x8600, 0x8603, &fct_weight_int);
+SimpleChar<uint8_t> age_int=           ble.writeOnly_u8(0x8600, 0x8604, &fct_age_int);
+SimpleChar<uint8_t> gender_text=       ble.writeOnly_u8(0x8600, 0x8605, &fct_gender_text);
+SimpleChar<uint8_t> max_heart_rate_u8= ble.writeOnly_u8(0x8600, 0x8606, &fct_max_heart_rate_int);
+SimpleChar<uint8_t> fini =             ble.writeOnly_u8(0x8600, 0x8607, &fct_fini);
+
+int main(int, char**)
+{
+    bool erreur_imu = false;
+    ble.start();
+    gps_Serial = new Serial(PA_2,PA_3); //serial object for use w/ GPS
+    Adafruit_GPS myGPS(gps_Serial); //object of Adafruit's GPS class
+    char c; //when read via Adafruit_GPS::read(), the class returns single character stored here
+    Timer refresh_Timer; //sets up a timer for use in loop; how often do we print GPS info?
+    const int refresh_Time = 2000; //refresh time in ms
+    button1.rise(&fct_interruption_ble);
+    button2.rise(&fct_interruption_force);
+    uint8_t c_who_I_m = readByte(LSM9DS1XG_ADDRESS, LSM9DS1XG_WHO_AM_I);
+    uint8_t d_who_I_m = readByte(LSM9DS1M_ADDRESS, LSM9DS1M_WHO_AM_I);                         // Read WHO_AM_I register for LSM9DS1 magnetometer//pc.printf("LSM9DS1 magnetometer % d"); ////////pc.printf("I AM %x",d);  ////////pc.printf(" I should be 0x3D\n");
+    if (c_who_I_m == 0x68 && d_who_I_m == 0x3D) {
+        // WHO_AM_I should always be 0x0E for the accel/gyro and 0x3C for the mag
+        getAres();////////pc.printf("accel sensitivity is %f   .",1./(1000.*aRes)); //////////////pc.printf(" LSB/mg");
+        getGres();////////pc.printf("gyro sensitivity is %f       ." ,1./(1000.*gRes)); //////////////pc.printf(" LSB/mdps");
+        getMres();////////pc.printf("mag sensitivity is %f    .", 1./(1000.*mRes)); //////////////pc.printf(" LSB/mGauss");
+        selftestLSM9DS1(); ////////pc.printf("Perform gyro and accel self test"); // check function of gyro and accelerometer via self test
+        accelgyrocalLSM9DS1( gyroBias1, accelBias);  // Calibrate gyro and accelerometers, load biases in bias registers////////pc.printf("accel biases (mg) %f    %f    %f \n",1000.*accelBias[0],1000.*accelBias[1],1000.*accelBias[2]);////////pc.printf("gyro biases (dps) %f    %f    %f \n",gyroBias[0],gyroBias[1],gyroBias[2]);
+        magcalLSM9DS1(magBias);////////pc.printf("mag biases (mG) %f    %f    %f \n",1000.*magBias[0],1000.*magBias[1],1000.*magBias[2]);
+        wait(2); // add delay to see results before serial spew of data
+        initLSM9DS1(); ////////pc.printf("LSM9DS1 initialized for active data mode...."); // Initialize device for active mode read of acclerometer, gyroscope, and temperature
+        erreur_imu = true;
+    }
+    myGPS.begin(9600);
+    myGPS.sendCommand(PMTK_SET_NMEA_OUTPUT_RMCGGA); //these commands are defined in MBed_Adafruit_GPS.h; a link is provided there for command creation
+    myGPS.sendCommand(PMTK_SET_NMEA_UPDATE_1HZ);
+    myGPS.sendCommand(PGCMD_ANTENNA);
+    oled.clearDisplay();
+    OLED_writeString("Hello! ", 32, 16);
+    pc.printf("\n********************************Bonjour**************************************\n");
+    refresh_Timer.start();
+    while (1) {
+        while ( interruption1 == true) {
+            myledr =1 ;
+            if ( message_envoyee== true ) {
+                wait(1);
+                fprintf(fp,"\n********************************BLE**************************************\n");
+                fprintf(fp,"name: %s ; ",name);
+                fprintf(fp,"height: %d  ;",height);
+                fprintf(fp,"weight: %d  ;",weight);
+                fprintf(fp,"age: %d  ;",age);
+                fprintf(fp,"gender: %s  ;",gender);
+                fprintf(fp,"max_heart_rate: %d  ;",max_heart_rate);
+                fprintf(fp,"\n********************************BLE-fin**************************************\n");
+                message_envoyee= false;
+                myledr =0 ;
+                interruption1= false;
+                oled.clearDisplay();
+                OLED_writeString(" welcome  ", 32, 16);
+                oled.clearDisplay();
+                OLED_writeString(name, 32, 16);
+            } else {
+                ble.waitForEvent();
+            }
+        }
+
+        while ( (interruption2 == true) and (force_mesure ==false )) {
+            myledg =1;
+            if (size_data_i==0 ) {
+                fprintf(fp,"\n volts_measure  pression_measure force_measure \n");
+            }
+            volts_measure[size_data_i] = tension_A502.read()*3.3 ;
+            pression_measure[size_data_i]  = 9146.3*(pow_nc(volts_measure[size_data_i],3))-47648*(pow_nc(volts_measure[size_data_i],2))+103084*volts_measure[size_data_i]-47228;
+            force_measure[size_data_i] = pression_measure[size_data_i] *0.00193/9.81;
+            if( not (pression_measure[size_data_i]< 0 or force_measure[size_data_i]< 0) ) {
+                fprintf(fp,"%f  %f   %f  \n",volts_measure[size_data_i],pression_measure[size_data_i],force_measure[size_data_i] );
+                pc.printf("%f  %f   %f  \n",volts_measure[size_data_i],pression_measure[size_data_i],force_measure[size_data_i] );
+                oled.clearDisplay();
+                oled.setTextSize(2);
+                char res[20];
+                ftoa(force_measure[size_data_i], res, 3);
+                OLED_writeString(res, 1, 1);
+                size_data_i =size_data_i+1;
+                wait(0.5);
+                if (size_data_i ==size_data-1 ) {
+                    interruption2 = false;
+                    force_mesure = true ;
+                    size_data_i =0;
+                    myledg =0;
+                }
+
+            }
+
+        }
+        if ( force_mesure ==true ) {
+            oled.clearDisplay();
+            while (1) {
+                dt.start();
+                if (erreur_imu == true) {
+                    int l = 0;
+                    fprintf(fp,"\n********************************Gait  **************************************\n");
+                    fprintf(fp,"ax, ay, az, gx, gy,gz,mx, my,mz\n");
+                    while (l<5000) {
+
+                        if (readByte(LSM9DS1XG_ADDRESS, LSM9DS1XG_STATUS_REG) & 0x01) {
+                            //Accelerometer new data available.  // check if new accel data is ready
+                            readAccelData(accelCount);  // Read the x/y/z adc values  // Now we'll calculate the accleration value into actual g's
+                            ax = (float)accelCount[0]*aRes - accelBias[0];  // get actual g value, this depends on scale being set
+                            ay = (float)accelCount[1]*aRes - accelBias[1];
+                            az = (float)accelCount[2]*aRes - accelBias[2];
+                        }
+                        if (readByte(LSM9DS1XG_ADDRESS, LSM9DS1XG_STATUS_REG) & 0x02) {  // check if new gyro data is ready
+                            readGyroData(gyroCount);  // Read the x/y/z adc values  // Calculate the gyro value into actual degrees per second
+                            gx = (float)gyroCount[0]*gRes - gyroBias1[0];  // get actual gyro value, this depends on scale being set
+                            gy = (float)gyroCount[1]*gRes - gyroBias1[1];
+                            gz = (float)gyroCount[2]*gRes - gyroBias1[2];
+                        }
+
+                        if (readByte(LSM9DS1M_ADDRESS, LSM9DS1M_STATUS_REG_M) & 0x08) {  // check if new mag data is ready
+                            readMagData(magCount);  // Read the x/y/z adc values
+                            mx = (float)magCount[0]*mRes; // - magBias[0];  // get actual magnetometer value, this depends on scale being set
+                            my = (float)magCount[1]*mRes; // - magBias[1];
+                            mz = (float)magCount[2]*mRes; // - magBias[2];}
+                        }
+                        l= l+1;
+                        fprintf(fp,"\n %f  %f %f ;%f  %f %f ;%f  %f %f ", ax, ay, az, gx, gy,gz,mx, my,mz);
+                        wait_us(1);
+                    }
+                } else
+                    pc.printf("Erreur LSM9DS1");
+            }
+            fprintf(fp,"\n********************************GPS **************************************\n");
+            c = myGPS.read();   //queries the GPS
+            myledb = 0;
+            if (c) { }
+            if ( myGPS.newNMEAreceived() ) {
+                if ( !myGPS.parse(myGPS.lastNMEA())) {
+                    continue;
+                }
+            }
+            if (refresh_Timer.read_ms() >= refresh_Time) {
+                refresh_Timer.reset();
+
+                if (myGPS.fix) {
+                    myledb = 0.5;
+                    fprintf(fp,"Time: %d:%d:%d.%u\n", myGPS.hour+1, myGPS.minute, myGPS.seconds, myGPS.milliseconds);
+                    Now = millis()*0.001 ;
+                    t = Now - t;
+                    fprintf(fp,"Date: %d/%d/20%d\n", myGPS.day, myGPS.month, myGPS.year);
+                    fprintf(fp,"Fix:. %d\n", (int) myGPS.fix);
+                    fprintf(fp,"Quality: %d\n\n", (int) myGPS.fixquality);
+
+                    pc.printf("Time: %d:%d:%d.%u\n", myGPS.hour+1, myGPS.minute, myGPS.seconds, myGPS.milliseconds);
+                    pc.printf("Date: %d/%d/20%d\n", myGPS.day, myGPS.month, myGPS.year);
+                    pc.printf("Fix: %d\n", (int) myGPS.fix);
+                    pc.printf("Quality: %d\n\n", (int) myGPS.fixquality);
+                    lat_dd = myGPS.coordToDegDec(myGPS.latitude);
+                    lon_dd = myGPS.coordToDegDec(myGPS.longitude);
+                    if (i_gps == 0) {
+                        lat_1 = lat_dd;
+                        lon_1 = lon_dd;
+                        lat_2 = lat_1;
+                        lon_2 = lon_1;
+                        t_m = dt.read_ms() ;
+                        t_m = dt.read();
+                    }   else    {
+                        lat_1 = lat_2;
+                        lon_1 = lon_2;
+                        lat_2 = lat_dd;
+                        lon_2 = lon_dd;
+                        t_apres = t_m ;
+                        t_m = dt.read();
+                        t_d = t_apres - t_m ;
+                        ::distance =  myGPS.getDistance(lat_1, lon_1, lat_2, lon_2);
+                        ::sum_distance += ::distance;
+                        ::steps = myGPS.getSteps(::sum_distance, height);
+                        ::avg_speed = myGPS.getAvgSpeed(::sum_distance, t);
+                        char res[20];
+                        ftoa(steps, res, 1);
+                        OLED_writeString(res, 1, 1);
+                    }
+                    fprintf(fp,"Satellites : %d\n", myGPS.satellites);
+                    fprintf(fp,"Location (deg) : %5.5f%c, %5.5f%c\n", lat_dd, myGPS.lat, lon_dd, myGPS.lon);
+                    fprintf(fp,"Altitude (m) : %5.2f\n", myGPS.altitude);
+                    fprintf(fp,"Distance (m) : %5.2f\n", ::sum_distance);
+                    fprintf(fp,"Steps taken : %5.0f\n", ::steps);
+                    fprintf(fp,"Average speed (km/h) : %5.2f\n\n\n", ::avg_speed);
+                    pc.printf("Satellites : %d\n", myGPS.satellites);
+                    pc.printf("Location (deg) : %5.5f%c, %5.5f%c\n", lat_dd, myGPS.lat, lon_dd, myGPS.lon);
+                    pc.printf("Altitude (m) : %5.2f\n", myGPS.altitude);
+                    pc.printf("Distance (m) : %5.2f\n", ::sum_distance);
+                    pc.printf("Steps taken : %5.0f\n", ::steps);
+                    pc.printf("Average speed (km/h) : %5.5f\n\n\n", ::avg_speed);
+                    myledb = 0;
+                    i_gps++;
+                }
+            }
+        }                                                   // Closing the file
+    }
+}
+
+
+
+
+
+void fct_name_text(uint8_t newState)
+{
+    name[i] = (char) newState;
+    i= i+1 ;
+    pc.printf("name %s  ",name);
+}
+void fct_height_int(uint8_t newState)
+{
+    height = (int) newState;
+    pc.printf("height %d  ",height);
+}
+void fct_weight_int(uint8_t newState)
+{
+    weight = (int) newState;
+    pc.printf("weight %d  ",weight);
+}
+void fct_age_int(uint8_t newState)
+{
+    age = (int) newState;
+    pc.printf("age %d  ",age);
+}
+void fct_gender_text(uint8_t newState)
+{
+    gender[0] = (char) newState;
+    pc.printf("gender %s  ",gender);
+}
+void fct_max_heart_rate_int(uint8_t newState)
+{
+    max_heart_rate = (int) newState;
+    pc.printf("max_heart_rate %d  ",max_heart_rate);
+}
+void fct_fini(uint8_t newState)
+{
+    message_envoyee= true;
+    pc.printf("message_envoyee ");
+}
+
+void fct_interruption_ble()
+{
+    interruption1= true ;
+    height = 0;
+    i=0;
+    for (int j=1; j<sizeof(name); j++) {
+        name[j] = ' ';
+    }
+    weight=0;
+    age =0;
+    char gender[1] = {'_'} ;
+    max_heart_rate=0;
+    message_envoyee= false;
+}
+
+void fct_interruption_force()
+{
+    interruption2 = true ;
+    force_mesure = false;
+}
+
+
+void OLED_writeString(string str, int x, int y)
+{
+    oled.setTextCursor(x, y);
+    oled.fillRect(x, y, 128, 8, 0);
+
+    for (int k = 0; k < str.length(); k++) {
+        oled.writeChar(str[k]);
+    }
+
+    oled.display();
+}
+
+void ftoa(float n, char* res, int afterpoint)   //https://www.geeksforgeeks.org/convert-floating-point-number-string/
+{
+
+    int ipart = (int)n; // Extract integer part
+    float fpart = n - (float)ipart; // Extract floating part
+    int k = intToStr(ipart, res, 0); // convert integer part to string
+    if (afterpoint != 0) { // check for display option after point
+        res[k] = '.'; // a
+        fpart = fpart * pow_nc(10, afterpoint);
+        intToStr((int)fpart, res + k + 1, afterpoint);
+    }
+}
+
+int intToStr(int x, char str[], int d)
+{
+    int k = 0;
+    while (x) {
+        str[k++] = (x % 10) + '0';
+        x = x / 10;
+    }
+
+    // If number of digits required is more, then
+    // add 0s at the beginning
+    while (k < d)
+        str[k++] = '0';
+
+    reverse(str, k);
+    str[k] = '\0';
+    return k;
+}
+
+
+void reverse(char* str, int len)
+{
+    int k = 0, j = len - 1, temp;
+    while (k < j) {
+        temp = str[k];
+        str[k] = str[j];
+        str[j] = temp;
+        k++;
+        j--;
+    }
+}
+
+
+float pow_nc(float n, int l)
+{
+    for (int k=1; k<l; k++) {
+        n= n*n ;
+    }
+    return(n);
+}
+
+
+// Mostra no display uma mensagem de receptividade
+void OLED_drawSmile()
+{
+    oled.clearDisplay();
+    oled.drawCircle(12, 20, 9, 1);
+    oled.fillRect(0, 5, 22, 15, 0);
+    oled.fillTriangle(2, 15, 10, 15, 6, 7, 1);
+    oled.fillTriangle(3, 15, 9, 15, 6, 8, 0);
+    oled.fillTriangle(14, 15, 22, 15, 18, 7, 1);
+    oled.fillTriangle(15, 15, 21, 15, 18, 8, 0);
+    oled.clearDisplay();
+
+}
+void selftestLSM9DS1()
+{
+    float accel_noST[3] = {0., 0., 0.}, accel_ST[3] = {0., 0., 0.};
+    float gyro_noST[3] = {0., 0., 0.}, gyro_ST[3] = {0., 0., 0.};
+    writeByte(LSM9DS1XG_ADDRESS, LSM9DS1XG_CTRL_REG10,   0x00); // disable self test
+    accelgyrocalLSM9DS1(gyro_noST, accel_noST);
+    ////pc.printf("disable self test ");
+    writeByte(LSM9DS1XG_ADDRESS, LSM9DS1XG_CTRL_REG10,   0x05); // enable gyro/accel self test
+    accelgyrocalLSM9DS1(gyro_ST, accel_ST);
+    ////pc.printf("enable gyro/accel self test");
+
+    float gyrodx = (gyro_ST[0] - gyro_noST[0]);
+    float gyrody = (gyro_ST[1] - gyro_noST[1]);
+    float gyrodz = (gyro_ST[2] - gyro_noST[2]);
+
+    ////pc.printf("Gyro self-test results: ");
+    ////pc.printf("x-axis = %f , dps" ,gyrodx); //////////pc.printf(" should be between 20 and 250 dps  \n");
+    ////pc.printf("y-axis = %f ",gyrody); //////////pc.printf(" dps"); //////pc.printf(" should be between 20 and 250 dps \n");
+    ////pc.printf("z-axis = %f ",gyrodz); //////////pc.printf(" dps"); //////pc.printf(" should be between 20 and 250 dps \n");
+
+    float accdx = 1000.*(accel_ST[0] - accel_noST[0]);
+    float accdy = 1000.*(accel_ST[1] - accel_noST[1]);
+    float accdz = 1000.*(accel_ST[2] - accel_noST[2]);
+    //pc.printf( "%f,%f,%f,%f,%f,%f\n", gyrodx,gyrody,gyrodz,accdx,accdy,accdz);
+    ////pc.printf("Accelerometer self-test results: ");
+    ////pc.printf("x-axis = %f" , accdx); //////////pc.printf(" mg"); //////pc.printf(" should be between 60 and 1700 mg \n");
+    ////pc.printf("y-axis = %f" , accdy); //////////pc.printf(" mg"); //////pc.printf(" should be between 60 and 1700 mg \n");
+    ////pc.printf("z-axis = %f", accdz); ////////pc.printf(" mg"); //////pc.printf(" should be between 60 and 1700 mg \n");
+
+    writeByte(LSM9DS1XG_ADDRESS, LSM9DS1XG_CTRL_REG10,   0x00); // disable self test
+
+    wait(0.2);
+
+}
+
+
+
+void initLSM9DS1()
+{
+    // enable the 3-axes of the gyroscope
+    writeByte(LSM9DS1XG_ADDRESS, LSM9DS1XG_CTRL_REG4, 0x38);
+    ////pc.printf( "enable the 3-axes of the gyroscope\n");
+    // configure the gyroscope
+    writeByte(LSM9DS1XG_ADDRESS, LSM9DS1XG_CTRL_REG1_G, Godr << 5 | Gscale << 3 | Gbw);
+    ////pc.printf("// configure the gyroscope\n");
+    wait(0.2);
+    // enable the three axes of the accelerometer
+    writeByte(LSM9DS1XG_ADDRESS, LSM9DS1XG_CTRL_REG5_XL, 0x38);
+    ////pc.printf("// enable the three axes of the accelerometer\n ") ;
+    // configure the accelerometer-specify bandwidth selection with Abw
+    writeByte(LSM9DS1XG_ADDRESS, LSM9DS1XG_CTRL_REG6_XL, Aodr << 5 | Ascale << 3 | 0x04 |Abw);
+    ////pc.printf("configure the accelerometer-specify bandwidth selection with Abw\n");
+    wait(0.2);
+    // enable block data update, allow auto-increment during multiple byte read
+    writeByte(LSM9DS1XG_ADDRESS, LSM9DS1XG_CTRL_REG8, 0x44);
+    ////pc.printf("enable block data update, allow auto-increment during multiple byte read\n");
+    // configure the magnetometer-enable temperature compensation of mag data
+    writeByte(LSM9DS1M_ADDRESS, LSM9DS1M_CTRL_REG1_M, 0x80 | Mmode << 5 | Modr << 2); // select x,y-axis mode
+    ////pc.printf("configure the magnetometer-enable temperature compensation of mag data\n");
+    writeByte(LSM9DS1M_ADDRESS, LSM9DS1M_CTRL_REG2_M, Mscale << 5 ); // select mag full scale
+    writeByte(LSM9DS1M_ADDRESS, LSM9DS1M_CTRL_REG3_M, 0x00 ); // continuous conversion mode
+    writeByte(LSM9DS1M_ADDRESS, LSM9DS1M_CTRL_REG4_M, Mmode << 2 ); // select z-axis mode
+    writeByte(LSM9DS1M_ADDRESS, LSM9DS1M_CTRL_REG5_M, 0x40 ); // select block update mode
+}
+void getMres()
+
+{
+    switch (Mscale) {
+        // Possible magnetometer scales (and their register bit settings) are:
+        // 4 Gauss (00), 8 Gauss (01), 12 Gauss (10) and 16 Gauss (11)
+        case MFS_4G:
+            mRes = 4.0/32768.0;
+            break;
+        case MFS_8G:
+            mRes = 8.0/32768.0;
+            break;
+        case MFS_12G:
+            mRes = 12.0/32768.0;
+            break;
+        case MFS_16G:
+            mRes = 16.0/32768.0;
+            break;
+    }
+}
+
+
+void getGres()
+
+{
+    switch (Gscale) {
+        // Possible gyro scales (and their register bit settings) are:
+        // 245 DPS (00), 500 DPS (01), and 2000 DPS  (11).
+        case GFS_245DPS:
+            gRes = 245.0/32768.0;//2^15
+            break;
+        case GFS_500DPS:
+            gRes = 500.0/32768.0;
+            break;
+        case GFS_2000DPS:
+            gRes = 2000.0/32768.0;
+            break;
+    }
+}
+
+
+void getAres()
+
+{
+    switch (Ascale) {
+        // Possible accelerometer scales (and their register bit settings) are:
+        // 2 Gs (00), 16 Gs (01), 4 Gs (10), and 8 Gs  (11).
+        case AFS_2G:
+            aRes = 2.0/32768.0;
+            break;
+        case AFS_16G:
+            aRes = 16.0/32768.0;
+            break;
+        case AFS_4G:
+            aRes = 4.0/32768.0;
+            break;
+        case AFS_8G:
+            aRes = 8.0/32768.0;
+            break;
+    }
+}
+
+void writeByte(uint8_t address, uint8_t subAddress, uint8_t data)
+
+{
+    char temp_data[2] = {subAddress, data};
+    i2c_m.write(address, temp_data, 2);
+}
+uint8_t readByte(uint8_t address, uint8_t subAddress)
+
+{
+    char data;
+    char temp[1] = {subAddress};
+    i2c_m.write(address, temp, 1);
+    temp[1] = 0x00;
+    i2c_m.write(address, temp, 1);
+    int a = i2c_m.read(address, &data, 1);
+    return data;
+
+}
+void readBytes(uint8_t address, uint8_t subAddress, uint8_t count, uint8_t * dest)
+
+{
+
+    int i;
+    char temp_dest[count];
+    char temp[1] = {subAddress};
+    i2c_m.write(address, temp, 1);
+    i2c_m.read(address, temp_dest, count);
+    for (i=0; i < count; i++) {
+        dest[i] = temp_dest[i];
+    }
+}
+
+
+void accelgyrocalLSM9DS1(float * dest1, float * dest2)
+
+{
+    uint8_t data[6] = {0};
+    int32_t gyro_bias[3] = {0, 0, 0}, accel_bias[3] = {0, 0, 0};
+    uint16_t samples, ii;
+    writeByte(LSM9DS1XG_ADDRESS, LSM9DS1XG_CTRL_REG4, 0x38);        // enable the 3-axes of the gyroscope
+    writeByte(LSM9DS1XG_ADDRESS, LSM9DS1XG_CTRL_REG1_G, Godr << 5 | Gscale << 3 | Gbw);    // configure the gyroscope
+    wait(0.2);
+    writeByte(LSM9DS1XG_ADDRESS, LSM9DS1XG_CTRL_REG5_XL, 0x38);     // enable the three axes of the accelerometer
+    writeByte(LSM9DS1XG_ADDRESS, LSM9DS1XG_CTRL_REG6_XL, Aodr << 5 | Ascale << 3 | 0x04 |Abw);  // configure the accelerometer-specify bandwidth selection with Abw
+    wait(0.2);
+    writeByte(LSM9DS1XG_ADDRESS, LSM9DS1XG_CTRL_REG8, 0x44);// enable block data update, allow auto-increment during multiple byte read
+    uint8_t c = readByte(LSM9DS1XG_ADDRESS, LSM9DS1XG_CTRL_REG9);// First get gyro bias
+    writeByte(LSM9DS1XG_ADDRESS, LSM9DS1XG_CTRL_REG9, (c & 0xFD)| 0x02);     // Enable gyro FIFO
+    wait(0.050);                                                       // Wait for change to take effect
+    writeByte(LSM9DS1XG_ADDRESS, LSM9DS1XG_FIFO_CTRL, 0x20 | 0x1F);  // Enable gyro FIFO stream mode and set watermark at 32 samples
+    wait(1);  // delay 1000 milliseconds to collect FIFO samples
+    samples = (readByte(LSM9DS1XG_ADDRESS, LSM9DS1XG_FIFO_SRC) & 0x2F); // Read number of stored samples
+    for(ii = 0; ii < samples ; ii++) {
+        // Read the gyro data stored in the FIFO
+        int16_t gyro_temp[3] = {0, 0, 0};
+        readBytes(LSM9DS1XG_ADDRESS, LSM9DS1XG_OUT_X_L_G, 6, &data[0]);
+        gyro_temp[0] = (int16_t) (((int16_t)data[1] << 8) | data[0]); // Form signed 16-bit integer for each sample in FIFO
+        gyro_temp[1] = (int16_t) (((int16_t)data[3] << 8) | data[2]);
+        gyro_temp[2] = (int16_t) (((int16_t)data[5] << 8) | data[4]);
+
+        gyro_bias[0] += (int32_t) gyro_temp[0]; // Sum individual signed 16-bit biases to get accumulated signed 32-bit biases
+        gyro_bias[1] += (int32_t) gyro_temp[1];
+        gyro_bias[2] += (int32_t) gyro_temp[2];
+    }
+
+    gyro_bias[0] /= samples; // average the data
+    gyro_bias[1] /= samples;
+    gyro_bias[2] /= samples;
+
+    dest1[0] = (float)gyro_bias[0]*gRes;  // Properly scale the data to get deg/s
+    dest1[1] = (float)gyro_bias[1]*gRes;
+    dest1[2] = (float)gyro_bias[2]*gRes;
+
+    c = readByte(LSM9DS1XG_ADDRESS, LSM9DS1XG_CTRL_REG9);
+    writeByte(LSM9DS1XG_ADDRESS, LSM9DS1XG_CTRL_REG9, c & ~0x02);   //Disable gyro FIFO
+    wait(0.050);
+    writeByte(LSM9DS1XG_ADDRESS, LSM9DS1XG_FIFO_CTRL, 0x00);  // Enable gyro bypass mode
+
+    // now get the accelerometer bias
+    c = readByte(LSM9DS1XG_ADDRESS, LSM9DS1XG_CTRL_REG9);
+    writeByte(LSM9DS1XG_ADDRESS, LSM9DS1XG_CTRL_REG9, (c & 0xFD)| 0x02);     // Enable accel FIFO
+    wait(0.050);                                                       // Wait for change to take effect
+    writeByte(LSM9DS1XG_ADDRESS, LSM9DS1XG_FIFO_CTRL, 0x20 | 0x1F);  // Enable accel FIFO stream mode and set watermark at 32 samples
+    wait(1);  // delay 1000 milliseconds to collect FIFO samples
+
+    samples = (readByte(LSM9DS1XG_ADDRESS, LSM9DS1XG_FIFO_SRC) & 0x2F); // Read number of stored samples
+
+    for(ii = 0; ii < samples ; ii++) {            // Read the accel data stored in the FIFO
+        int16_t accel_temp[3] = {0, 0, 0};
+        readBytes(LSM9DS1XG_ADDRESS, LSM9DS1XG_OUT_X_L_XL, 6, &data[0]);
+        accel_temp[0] = (int16_t) (((int16_t)data[1] << 8) | data[0]); // Form signed 16-bit integer for each sample in FIFO
+        accel_temp[1] = (int16_t) (((int16_t)data[3] << 8) | data[2]);
+        accel_temp[2] = (int16_t) (((int16_t)data[5] << 8) | data[4]);
+
+        accel_bias[0] += (int32_t) accel_temp[0]; // Sum individual signed 16-bit biases to get accumulated signed 32-bit biases
+        accel_bias[1] += (int32_t) accel_temp[1];
+        accel_bias[2] += (int32_t) accel_temp[2];
+    }
+
+    accel_bias[0] /= samples; // average the data
+    accel_bias[1] /= samples;
+    accel_bias[2] /= samples;
+
+    if(accel_bias[2] > 0L) {
+        accel_bias[2] -= (int32_t) (1.0/aRes);   // Remove gravity from the z-axis accelerometer bias calculation
+    } else {
+        accel_bias[2] += (int32_t) (1.0/aRes);
+    }
+
+    dest2[0] = (float)accel_bias[0]*aRes;  // Properly scale the data to get g
+    dest2[1] = (float)accel_bias[1]*aRes;
+    dest2[2] = (float)accel_bias[2]*aRes;
+
+    c = readByte(LSM9DS1XG_ADDRESS, LSM9DS1XG_CTRL_REG9);
+    writeByte(LSM9DS1XG_ADDRESS, LSM9DS1XG_CTRL_REG9, c & ~0x02);   //Disable accel FIFO
+    wait(0.050);
+    writeByte(LSM9DS1XG_ADDRESS, LSM9DS1XG_FIFO_CTRL, 0x00);  // Enable accel bypass mode*/
+}
+void magcalLSM9DS1(float * dest1)
+
+{
+    uint8_t data[6]; // data array to hold mag x, y, z, data
+    uint16_t ii = 0, sample_count = 0;
+    int32_t mag_bias[3] = {0, 0, 0};
+    int16_t mag_max[3] = {0, 0, 0}, mag_min[3] = {0, 0, 0};
+
+    // configure the magnetometer-enable temperature compensation of mag data
+    writeByte(LSM9DS1M_ADDRESS, LSM9DS1M_CTRL_REG1_M, 0x80 | Mmode << 5 | Modr << 2); // select x,y-axis mode
+    writeByte(LSM9DS1M_ADDRESS, LSM9DS1M_CTRL_REG2_M, Mscale << 5 ); // select mag full scale
+    writeByte(LSM9DS1M_ADDRESS, LSM9DS1M_CTRL_REG3_M, 0x00 ); // continuous conversion mode
+    writeByte(LSM9DS1M_ADDRESS, LSM9DS1M_CTRL_REG4_M, Mmode << 2 ); // select z-axis mode
+    writeByte(LSM9DS1M_ADDRESS, LSM9DS1M_CTRL_REG5_M, 0x40 ); // select block update mode
+    ////pc.printf("Mag Calibration: Wave device in a figure eight until done!\n");
+    wait(0.004);
+
+    sample_count = 128;
+    for(ii = 0; ii < sample_count; ii++) {
+        int16_t mag_temp[3] = {0, 0, 0};
+        readBytes(LSM9DS1M_ADDRESS, LSM9DS1M_OUT_X_L_M, 6, &data[0]);  // Read the six raw data registers into data array
+        mag_temp[0] = (int16_t) (((int16_t)data[1] << 8) | data[0]) ;   // Form signed 16-bit integer for each sample in FIFO
+        mag_temp[1] = (int16_t) (((int16_t)data[3] << 8) | data[2]) ;
+        mag_temp[2] = (int16_t) (((int16_t)data[5] << 8) | data[4]) ;
+        for (int jj = 0; jj < 3; jj++) {
+            if(mag_temp[jj] > mag_max[jj]) mag_max[jj] = mag_temp[jj];
+            if(mag_temp[jj] < mag_min[jj]) mag_min[jj] = mag_temp[jj];
+        }
+        wait(0.105);  // at 10 Hz ODR, new mag data is available every 100 ms
+    }
+
+//    ////pc.printf("mag x min/max:"); //pc.printfmag_max[0]); //pc.printfmag_min[0]);
+//    ////pc.printf("mag y min/max:"); //pc.printfmag_max[1]); //pc.printfmag_min[1]);
+//    ////pc.printf("mag z min/max:"); //pc.printfmag_max[2]); //pc.printfmag_min[2]);
+
+    mag_bias[0]  = (mag_max[0] + mag_min[0])/2;  // get average x mag bias in counts
+    mag_bias[1]  = (mag_max[1] + mag_min[1])/2;  // get average y mag bias in counts
+    mag_bias[2]  = (mag_max[2] + mag_min[2])/2;  // get average z mag bias in counts
+
+    dest1[0] = (float) mag_bias[0]*mRes;  // save mag biases in G for main program
+    dest1[1] = (float) mag_bias[1]*mRes;
+    dest1[2] = (float) mag_bias[2]*mRes;
+
+    //write biases to accelerometermagnetometer offset registers as counts);
+    writeByte(LSM9DS1M_ADDRESS, LSM9DS1M_OFFSET_X_REG_L_M, (int16_t) mag_bias[0]  & 0xFF);
+    writeByte(LSM9DS1M_ADDRESS, LSM9DS1M_OFFSET_X_REG_H_M, ((int16_t)mag_bias[0] >> 8) & 0xFF);
+    writeByte(LSM9DS1M_ADDRESS, LSM9DS1M_OFFSET_Y_REG_L_M, (int16_t) mag_bias[1] & 0xFF);
+    writeByte(LSM9DS1M_ADDRESS, LSM9DS1M_OFFSET_Y_REG_H_M, ((int16_t)mag_bias[1] >> 8) & 0xFF);
+    writeByte(LSM9DS1M_ADDRESS, LSM9DS1M_OFFSET_Z_REG_L_M, (int16_t) mag_bias[2] & 0xFF);
+    writeByte(LSM9DS1M_ADDRESS, LSM9DS1M_OFFSET_Z_REG_H_M, ((int16_t)mag_bias[2] >> 8) & 0xFF);
+
+    ////pc.printf("Mag Calibration done!\n");
+}
+
+void readAccelData(int16_t * destination)
+
+{
+    uint8_t rawData[6];  // x/y/z accel register data stored here
+    readBytes(LSM9DS1XG_ADDRESS, LSM9DS1XG_OUT_X_L_XL, 6, &rawData[0]);  // Read the six raw data registers into data array
+    destination[0] = ((int16_t)rawData[1] << 8) | rawData[0] ;  // Turn the MSB and LSB into a signed 16-bit value
+    destination[1] = ((int16_t)rawData[3] << 8) | rawData[2] ;
+    destination[2] = ((int16_t)rawData[5] << 8) | rawData[4] ;
+}
+
+void readGyroData(int16_t * destination)
+
+{
+    uint8_t rawData[6];  // x/y/z gyro register data stored here
+    readBytes(LSM9DS1XG_ADDRESS, LSM9DS1XG_OUT_X_L_G, 6, &rawData[0]);  // Read the six raw data registers sequentially into data array
+    destination[0] = ((int16_t)rawData[1] << 8) | rawData[0] ;  // Turn the MSB and LSB into a signed 16-bit value
+    destination[1] = ((int16_t)rawData[3] << 8) | rawData[2] ;
+    destination[2] = ((int16_t)rawData[5] << 8) | rawData[4] ;
+}
+
+void readMagData(int16_t * destination)
+{
+    uint8_t rawData[6];  // x/y/z gyro register data stored here
+    readBytes(LSM9DS1M_ADDRESS, LSM9DS1M_OUT_X_L_M, 6, &rawData[0]);  // Read the six raw data registers sequentially into data array
+    destination[0] = ((int16_t)rawData[1] << 8) | rawData[0] ;  // Turn the MSB and LSB into a signed 16-bit value
+    destination[1] = ((int16_t)rawData[3] << 8) | rawData[2] ;  // Data stored as little Endian
+    destination[2] = ((int16_t)rawData[5] << 8) | rawData[4] ;
+}
+
+
+
+
+
+
+
+
+
+
diff -r 000000000000 -r 6e330c197193 mbed.bld
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/mbed.bld	Mon Jan 27 12:04:30 2020 +0000
@@ -0,0 +1,1 @@
+https://os.mbed.com/users/mbed_official/code/mbed/builds/65be27845400
\ No newline at end of file