ENSMM
Programme complet de bâton de marche sauf capteur cardiaque
Dependencies: mbed SimpleBLE X_NUCLEO_IDB0XA1 SDFileSystem MBed_Adafruit-GPS-Library Arduino USBDevice
Revision 0:6e330c197193, committed 2020-01-27
- Comitter:
- zmoutaou
- Date:
- Mon Jan 27 12:04:30 2020 +0000
- Commit message:
- BMC
Changed in this revision
--- /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;
+ }
+}
--- /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
--- /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
--- /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
+}
--- /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
--- /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
--- /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
--- /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
--- /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
--- /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
--- /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
--- /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
--- /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
--- /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] ;
+}
+
+
+
+
+
+
+
+
+
+
--- /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