Hauptprogramm

Dependencies:   ILI9340_Driver_Lib PM2_Libary Lib_DFPlayerMini

Files at this revision

API Documentation at this revision

Comitter:
ackerden
Date:
Wed Apr 21 13:48:47 2021 +0000
Parent:
15:babdd038715a
Child:
17:621c4212fd4e
Commit message:

Changed in this revision

Adafruit_LEDBackpack.lib Show diff for this revision Revisions of this file
PM2_Libary.lib Show annotated file Show diff for this revision Revisions of this file
Servo/servo.cpp Show diff for this revision Revisions of this file
Servo/servo.h Show diff for this revision Revisions of this file
Servo/servo_bewegung.cpp Show annotated file Show diff for this revision Revisions of this file
Servo/servo_bewegung.h Show annotated file Show diff for this revision Revisions of this file
Time/Adafruit_Display/Adafruit_GFX.cpp Show annotated file Show diff for this revision Revisions of this file
Time/Adafruit_Display/Adafruit_GFX.h Show annotated file Show diff for this revision Revisions of this file
Time/Adafruit_Display/Adafruit_LED_Backpack.cpp Show annotated file Show diff for this revision Revisions of this file
Time/Adafruit_Display/Adafruit_LED_Backpack.h Show annotated file Show diff for this revision Revisions of this file
Time/Adafruit_Display/Wire.h Show annotated file Show diff for this revision Revisions of this file
Time/Adafruit_Display/glcfont.h 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
--- a/Adafruit_LEDBackpack.lib	Mon Apr 19 14:10:40 2021 +0000
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,1 +0,0 @@
-https://os.mbed.com/teams/PM-2/code/Adafruit_LEDBackpack/#cf319ebfe4a7
--- a/PM2_Libary.lib	Mon Apr 19 14:10:40 2021 +0000
+++ b/PM2_Libary.lib	Wed Apr 21 13:48:47 2021 +0000
@@ -1,1 +1,1 @@
-https://os.mbed.com/users/pmic/code/PM2_Libary/#9cc27f98645a
+https://os.mbed.com/users/pmic/code/PM2_Libary/#6b747ad59ff5
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Servo/servo_bewegung.cpp	Wed Apr 21 13:48:47 2021 +0000
@@ -0,0 +1,28 @@
+#include "mbed.h"
+#include "Servo.h"
+
+#include "servo_bewegung.h"
+
+#define MID         1500
+#define MIN         1000
+#define MAX         2000
+#define STEP          50
+//Time delay between steps in milliseconds
+#define TIME         100
+
+
+void bewegung(int zeit){ 
+
+Servo Servo1(PA_0);
+Servo1.Enable(1500,20000);
+    for(int j=0; j<zeit; j++){
+       for (int pos = 1000; pos < 2000; pos += 25) {
+          Servo1.SetPosition(pos);
+          wait_ms(STEP);
+      }
+      for (int pos = 2000; pos > 1000; pos -= 25) {
+          Servo1.SetPosition(pos);
+          wait_ms(STEP);
+      }
+      }
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Servo/servo_bewegung.h	Wed Apr 21 13:48:47 2021 +0000
@@ -0,0 +1,6 @@
+#ifndef _SERVO_BEWEGUNG_H_
+#define _SERVO_BEWEGUNG_H_
+
+void bewegung(int zeit);
+
+#endif
\ No newline at end of file
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Time/Adafruit_Display/Adafruit_GFX.cpp	Wed Apr 21 13:48:47 2021 +0000
@@ -0,0 +1,431 @@
+
+#include "mbed.h"
+
+#include "Adafruit_GFX.h"
+#include "glcfont.h"
+
+#ifdef 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);
+        }
+    }
+}
+
+// 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;
+        }
+    }
+}
+
+
+// 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::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::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::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); 
+}
+
+
+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);
+    }
+}
+#endif
+
+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);
+        }
+    }
+}
+
+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 (size == 1) // default size
+                    drawPixel(x+i, y+j, color);
+#ifdef WANT_ABSTRACTS
+                else // big size
+                    fillRect(x+(i*size), y+(j*size), size, size, color);
+#endif
+            }
+            else if (bg != color)
+            {
+                if (size == 1) // default size
+                    drawPixel(x+i, y+j, bg);
+#ifdef WANT_ABSTRACTS
+                else // big size
+                    fillRect(x+i*size, y+j*size, size, size, 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/Time/Adafruit_Display/Adafruit_GFX.h	Wed Apr 21 13:48:47 2021 +0000
@@ -0,0 +1,95 @@
+
+#ifndef _ADAFRUIT_GFX_H_
+#define _ADAFRUIT_GFX_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
+
+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)
+        {};
+
+    // 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 WANT_ABSTRACTS
+    // these are 'generic' drawing functions, so we can share them!
+    virtual void drawLine(int16_t x0, int16_t y0, int16_t x1, int16_t y1, uint16_t color);
+    virtual void drawFastVLine(int16_t x, int16_t y, int16_t h, uint16_t color);
+    virtual void drawFastHLine(int16_t x, int16_t y, int16_t w, uint16_t color);
+    virtual void drawRect(int16_t x, int16_t y, int16_t w, int16_t h, uint16_t color);
+    virtual void fillRect(int16_t x, int16_t y, int16_t w, int16_t h, uint16_t color);
+    virtual void fillScreen(uint16_t color);
+
+    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);
+    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);
+
+    void drawTriangle(int16_t x0, int16_t y0, int16_t x1, int16_t y1, int16_t x2, int16_t y2, uint16_t color);
+    void fillTriangle(int16_t x0, int16_t y0, int16_t x1, int16_t y1, int16_t x2, int16_t y2, uint16_t color);
+    void drawRoundRect(int16_t x0, int16_t y0, int16_t w, int16_t h, int16_t radius, uint16_t color);
+    void fillRoundRect(int16_t x0, int16_t y0, int16_t w, int16_t h, int16_t radius, uint16_t color);
+#endif
+
+    void drawBitmap(int16_t x, int16_t y, const uint8_t *bitmap, int16_t w, int16_t h, uint16_t color);
+    //virtual void drawChar(int16_t x, int16_t y, unsigned char c, uint16_t color, uint16_t bg, uint8_t size);
+    //virtual size_t writeChar(uint8_t);
+    void drawChar(int16_t x, int16_t y, unsigned char c, uint16_t color, uint16_t bg, uint8_t size);
+    size_t writeChar(uint8_t);
+    
+    int16_t width(void) { return _width; };
+    int16_t height(void) { return _height; };
+
+    void setCursor(int16_t x, int16_t y) { cursor_x = x; cursor_y = y; };
+    void setTextSize(uint8_t s) { textsize = (s > 0) ? s : 1; };
+    void setTextColor(uint16_t c) { textcolor = c; textbgcolor = c; }
+    void setTextColor(uint16_t c, uint16_t b) { textcolor = c; textbgcolor = b; };
+    void setTextWrap(bool w) { wrap = w; };
+
+    void setRotation(uint8_t r);
+    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/Time/Adafruit_Display/Adafruit_LED_Backpack.cpp	Wed Apr 21 13:48:47 2021 +0000
@@ -0,0 +1,394 @@
+#include "mbed.h"
+#include "Adafruit_LED_Backpack.h"
+#include "Adafruit_GFX.h"
+#include "glcfont.h"
+
+#include "I2C.h"
+
+#ifndef _BV
+#define _BV(bit) (1 << (bit)) ///< Bit-value if not defined by Arduino
+#endif
+
+#ifndef _swap_int16_t
+#define _swap_int16_t(a, b)                                                    \
+  {                                                                            \
+    int16_t t = a;                                                             \
+    a = b;                                                                     \
+    b = t;                                                                     \
+  } ///< 16-bit var swap
+#endif
+
+static const uint8_t numbertable[] = {
+    0x3F, /* 0 */
+    0x06, /* 1 */
+    0x5B, /* 2 */
+    0x4F, /* 3 */
+    0x66, /* 4 */
+    0x6D, /* 5 */
+    0x7D, /* 6 */
+    0x07, /* 7 */
+    0x7F, /* 8 */
+    0x6F, /* 9 */
+    0x77, /* a */
+    0x7C, /* b */
+    0x39, /* C */
+    0x5E, /* d */
+    0x79, /* E */
+    0x71, /* F */
+};
+
+/*static const uint16_t alphafonttable[] PROGMEM = {
+
+    0b0000000000000001, 0b0000000000000010, 0b0000000000000100,
+    0b0000000000001000, 0b0000000000010000, 0b0000000000100000,
+    0b0000000001000000, 0b0000000010000000, 0b0000000100000000,
+    0b0000001000000000, 0b0000010000000000, 0b0000100000000000,
+    0b0001000000000000, 0b0010000000000000, 0b0100000000000000,
+    0b1000000000000000, 0b0000000000000000, 0b0000000000000000,
+    0b0000000000000000, 0b0000000000000000, 0b0000000000000000,
+    0b0000000000000000, 0b0000000000000000, 0b0000000000000000,
+    0b0001001011001001, 0b0001010111000000, 0b0001001011111001,
+    0b0000000011100011, 0b0000010100110000, 0b0001001011001000,
+    0b0011101000000000, 0b0001011100000000,
+    0b0000000000000000, //
+    0b0000000000000110, // !
+    0b0000001000100000, // "
+    0b0001001011001110, // #
+    0b0001001011101101, // $
+    0b0000110000100100, // %
+    0b0010001101011101, // &
+    0b0000010000000000, // '
+    0b0010010000000000, // (
+    0b0000100100000000, // )
+    0b0011111111000000, // *
+    0b0001001011000000, // +
+    0b0000100000000000, // ,
+    0b0000000011000000, // -
+    0b0000000000000000, // .
+    0b0000110000000000, // /
+    0b0000110000111111, // 0
+    0b0000000000000110, // 1
+    0b0000000011011011, // 2
+    0b0000000010001111, // 3
+    0b0000000011100110, // 4
+    0b0010000001101001, // 5
+    0b0000000011111101, // 6
+    0b0000000000000111, // 7
+    0b0000000011111111, // 8
+    0b0000000011101111, // 9
+    0b0001001000000000, // :
+    0b0000101000000000, // ;
+    0b0010010000000000, // <
+    0b0000000011001000, // =
+    0b0000100100000000, // >
+    0b0001000010000011, // ?
+    0b0000001010111011, // @
+    0b0000000011110111, // A
+    0b0001001010001111, // B
+    0b0000000000111001, // C
+    0b0001001000001111, // D
+    0b0000000011111001, // E
+    0b0000000001110001, // F
+    0b0000000010111101, // G
+    0b0000000011110110, // H
+    0b0001001000000000, // I
+    0b0000000000011110, // J
+    0b0010010001110000, // K
+    0b0000000000111000, // L
+    0b0000010100110110, // M
+    0b0010000100110110, // N
+    0b0000000000111111, // O
+    0b0000000011110011, // P
+    0b0010000000111111, // Q
+    0b0010000011110011, // R
+    0b0000000011101101, // S
+    0b0001001000000001, // T
+    0b0000000000111110, // U
+    0b0000110000110000, // V
+    0b0010100000110110, // W
+    0b0010110100000000, // X
+    0b0001010100000000, // Y
+    0b0000110000001001, // Z
+    0b0000000000111001, // [
+    0b0010000100000000, //
+    0b0000000000001111, // ]
+    0b0000110000000011, // ^
+    0b0000000000001000, // _
+    0b0000000100000000, // `
+    0b0001000001011000, // a
+    0b0010000001111000, // b
+    0b0000000011011000, // c
+    0b0000100010001110, // d
+    0b0000100001011000, // e
+    0b0000000001110001, // f
+    0b0000010010001110, // g
+    0b0001000001110000, // h
+    0b0001000000000000, // i
+    0b0000000000001110, // j
+    0b0011011000000000, // k
+    0b0000000000110000, // l
+    0b0001000011010100, // m
+    0b0001000001010000, // n
+    0b0000000011011100, // o
+    0b0000000101110000, // p
+    0b0000010010000110, // q
+    0b0000000001010000, // r
+    0b0010000010001000, // s
+    0b0000000001111000, // t
+    0b0000000000011100, // u
+    0b0010000000000100, // v
+    0b0010100000010100, // w
+    0b0010100011000000, // x
+    0b0010000000001100, // y
+    0b0000100001001000, // z
+    0b0000100101001001, // {
+    0b0001001000000000, // |
+    0b0010010010001001, // }
+    0b0000010100100000, // ~
+    0b0011111111111111,
+
+};*/
+/*
+//mpl - something with stdio screwing things up.  need to define serial port to use for debug
+extern BufferedSerial pc;
+
+void Adafruit_LED_Backpack::setBrightness(uint8_t b) {
+  if (b > 15) b = 15;
+  uint8_t c = 0xE0 | b;
+  char foo[1];
+  foo[0] = c;
+  _i2c->write(i2c_addr, foo, 1); 
+}
+
+void Adafruit_LED_Backpack::blinkRate(uint8_t b) {
+  if (b > 3) b = 0; // turn off if not sure
+  uint8_t c = HT16K33_BLINK_CMD | HT16K33_BLINK_DISPLAYON | (b << 1);
+  char foo[1];
+  foo[0] = c;
+  _i2c->write(i2c_addr, foo, 1);
+}
+
+Adafruit_LED_Backpack::Adafruit_LED_Backpack(I2C *i2c): _i2c(i2c) {
+}
+
+void Adafruit_LED_Backpack::begin(uint8_t _addr = 0x70) {
+  i2c_addr = _addr << 1;
+
+  char foo[1];
+  foo[0] = 0x21;
+
+  _i2c->write(i2c_addr, foo, 1);  // turn on oscillator
+
+  blinkRate(HT16K33_BLINK_OFF);
+  
+  setBrightness(15); // max brightness
+}
+
+void Adafruit_LED_Backpack::writeDisplay(void) {
+  char foo[17];
+  foo[0] = 0x00;
+  int j = 0;
+  for (uint8_t i=1; i<=16; i+=2) {
+    int x = displaybuffer[j] & 0xFF;
+    foo[i] = x;
+    int x2 = displaybuffer[j] >> 8;
+    foo[i+1] = x2;
+    j++;
+  }
+  _i2c->write(i2c_addr, foo, 17);
+}
+
+void Adafruit_LED_Backpack::clear(void) {
+  for (uint8_t i=0; i<16; i++) {
+    displaybuffer[i] = 0;
+  }
+}
+
+/******************************* 7 SEGMENT OBJECT */
+/*
+Adafruit_7segment::Adafruit_7segment(void): Adafruit_LED_Backpack(_i2c), Adafruit_GFX(8, 8) { }//position = 0; }
+
+void Adafruit_7segment::print(unsigned long n, int base) {
+  if (base == 0)
+    write(n);
+  else
+    printNumber(n, base);
+}
+
+void Adafruit_7segment::print(char c, int base) { print((long)c, base); }
+
+void Adafruit_7segment::print(unsigned char b, int base) {
+  print((unsigned long)b, base);
+}
+
+void Adafruit_7segment::print(int n, int base) { print((long)n, base); }
+
+void Adafruit_7segment::print(unsigned int n, int base) {
+  print((unsigned long)n, base);
+}
+
+void Adafruit_7segment::println(void) { position = 0; }
+
+void Adafruit_7segment::println(char c, int base) {
+  print(c, base);
+  println();
+}
+
+void Adafruit_7segment::println(unsigned char b, int base) {
+  print(b, base);
+  println();
+}
+
+void Adafruit_7segment::println(int n, int base) {
+  print(n, base);
+  println();
+}
+
+void Adafruit_7segment::println(unsigned int n, int base) {
+  print(n, base);
+  println();
+}
+
+void Adafruit_7segment::println(long n, int base) {
+  print(n, base);
+  println();
+}
+
+void Adafruit_7segment::println(unsigned long n, int base) {
+  print(n, base);
+  println();
+}
+
+void Adafruit_7segment::println(double n, int digits) {
+  print(n, digits);
+  println();
+}
+
+void Adafruit_7segment::print(double n, int digits) { printFloat(n, digits); }
+
+size_t Adafruit_7segment::write(uint8_t c) {
+
+  uint8_t r = 0;
+
+  if (c == '\n')
+    position = 0;
+  if (c == '\r')
+    position = 0;
+
+  if ((c >= '0') && (c <= '9')) {
+    writeDigitNum(position, c - '0');
+    r = 1;
+  }
+
+  position++;
+  if (position == 2)
+    position++;
+
+  return r;
+}
+
+void Adafruit_7segment::writeDigitRaw(uint8_t d, uint8_t bitmask) {
+  if (d > 4)
+    return;
+  displaybuffer[d] = bitmask;
+}
+
+void Adafruit_7segment::drawColon(bool state) {
+  if (state)
+    displaybuffer[2] = 0x2;
+  else
+    displaybuffer[2] = 0;
+}
+
+void Adafruit_7segment::writeColon(void) {
+  _i2c.beginTransmission(i2c_addr);
+  Wire.write((uint8_t)0x04); // start at address $02
+
+  Wire.write(displaybuffer[2] & 0xFF);
+  Wire.write(displaybuffer[2] >> 8);
+
+  Wire.endTransmission();
+}
+
+void Adafruit_7segment::writeDigitNum(uint8_t d, uint8_t num, bool dot) {
+  if (d > 4)
+    return;
+
+  writeDigitRaw(d, numbertable[num] | (dot << 7));
+}
+
+void Adafruit_7segment::print(long n, int base) { printNumber(n, base); }
+
+void Adafruit_7segment::printNumber(long n, uint8_t base) {
+  printFloat(n, 0, base);
+}
+
+void Adafruit_7segment::printFloat(double n, uint8_t fracDigits, uint8_t base) {
+  uint8_t numericDigits = 4; // available digits on display
+  bool isNegative = false;   // true if the number is negative
+
+  // is the number negative?
+  if (n < 0) {
+    isNegative = true; // need to draw sign later
+    --numericDigits;   // the sign will take up one digit
+    n *= -1;           // pretend the number is positive
+  }
+
+  // calculate the factor required to shift all fractional digits
+  // into the integer part of the number
+  double toIntFactor = 1.0;
+  for (int i = 0; i < fracDigits; ++i)
+    toIntFactor *= base;
+
+  // create integer containing digits to display by applying
+  // shifting factor and rounding adjustment
+  uint32_t displayNumber = n * toIntFactor + 0.5;
+
+  // calculate upper bound on displayNumber given
+  // available digits on display
+  uint32_t tooBig = 1;
+  for (int i = 0; i < numericDigits; ++i)
+    tooBig *= base;
+
+  // if displayNumber is too large, try fewer fractional digits
+  while (displayNumber >= tooBig) {
+    --fracDigits;
+    toIntFactor /= base;
+    displayNumber = n * toIntFactor + 0.5;
+  }
+
+  // did toIntFactor shift the decimal off the display?
+  if (toIntFactor < 1) {
+    printError();
+  } else {
+    // otherwise, display the number
+    int8_t displayPos = 4;
+
+    if (displayNumber) // if displayNumber is not 0
+    {
+      for (uint8_t i = 0; displayNumber || i <= fracDigits; ++i) {
+        bool displayDecimal = (fracDigits != 0 && i == fracDigits);
+        writeDigitNum(displayPos--, displayNumber % base, displayDecimal);
+        if (displayPos == 2)
+          writeDigitRaw(displayPos--, 0x00);
+        displayNumber /= base;
+      }
+    } else {
+      writeDigitNum(displayPos--, 0, false);
+    }
+
+    // display negative sign if negative
+    if (isNegative)
+      writeDigitRaw(displayPos--, 0x40);
+
+    // clear remaining display positions
+    while (displayPos >= 0)
+      writeDigitRaw(displayPos--, 0x00);
+  }
+}
+
+void Adafruit_7segment::printError(void) {
+  for (uint8_t i = 0; i < SEVENSEG_DIGITS; ++i) {
+    writeDigitRaw(i, (i == 2 ? 0x00 : 0x40));
+  }
+}*/
\ No newline at end of file
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Time/Adafruit_Display/Adafruit_LED_Backpack.h	Wed Apr 21 13:48:47 2021 +0000
@@ -0,0 +1,264 @@
+#include "mbed.h"
+#include "Adafruit_GFX.h"
+
+#define LED_ON 1
+#define LED_OFF 0
+
+#define LED_RED 1
+#define LED_YELLOW 2
+#define LED_GREEN 3
+ 
+
+
+#define HT16K33_BLINK_CMD 0x80
+#define HT16K33_BLINK_DISPLAYON 0x01
+#define HT16K33_BLINK_OFF 0
+#define HT16K33_BLINK_2HZ  1
+#define HT16K33_BLINK_1HZ  2
+#define HT16K33_BLINK_HALFHZ  3
+
+
+#define DEC 10 ///< Print value in decimal format (base 10)
+#define HEX 16 ///< Print value in hexadecimal format (base 16)
+#define OCT 8  ///< Print value in octal format (base 8)
+#define BIN 2  ///< Print value in binary format (base 2)
+#define BYTE 0 ///< Issue 7-segment data as raw bits
+
+#define HT16K33_CMD_BRIGHTNESS 0x0E
+
+#define SEVENSEG_DIGITS 5 ///< # Digits in 7-seg displays, plus NUL end
+
+class Adafruit_LED_Backpack {
+ public:
+  Adafruit_LED_Backpack(I2C *i2c);
+  void begin(uint8_t _addr);
+  void setBrightness(uint8_t b);
+  void blinkRate(uint8_t b);
+  void writeDisplay(void);
+  void clear(void);
+
+  uint16_t displaybuffer[16]; 
+
+  void init(uint8_t a);
+
+  protected:
+    I2C *_i2c;
+  
+ private:
+  uint8_t i2c_addr;
+};
+
+class Adafruit_8x8matrix : public Adafruit_LED_Backpack, public Adafruit_GFX {
+ public:
+  Adafruit_8x8matrix(I2C *i2c);
+
+  void drawPixel(int16_t x, int16_t y, uint16_t color);
+
+ private:
+};
+
+class Adafruit_16x8matrix : public Adafruit_LED_Backpack, public Adafruit_GFX {
+ public:
+  Adafruit_16x8matrix(I2C *i2c);
+
+  void drawPixel(int16_t x, int16_t y, uint16_t color);
+    virtual void drawChar(int16_t x, int16_t y, unsigned char c, uint16_t color, uint16_t bg, uint8_t size);
+    virtual size_t writeChar(uint8_t);
+  void scrollChar(uint8_t c);
+
+ private:
+};
+
+class Adafruit_7segment : public Adafruit_LED_Backpack, public Adafruit_GFX {
+public:
+    Adafruit_7segment(void);
+    
+    /*!
+    @brief   Issue single digit to display.
+    @param   c  Digit to write (ASCII character, not numeric).
+    @return  1 if character written, else 0 (non-digit characters).
+  */
+  size_t write(uint8_t c);
+
+  /*!
+    @brief  Print byte-size numeric value to 7-segment display.
+    @param  c     Numeric value.
+    @param  base  Number base (default = BYTE = raw bits)
+  */
+  void print(char c, int base = BYTE);
+
+  /*!
+    @brief  Print unsigned byte-size numeric value to 7-segment display.
+    @param  b     Numeric value.
+    @param  base  Number base (default = BYTE = raw bits)
+  */
+  void print(unsigned char b, int base = BYTE);
+
+  /*!
+    @brief  Print integer value to 7-segment display.
+    @param  n     Numeric value.
+    @param  base  Number base (default = DEC = base 10)
+  */
+  void print(int n, int base = DEC);
+
+  /*!
+    @brief  Print unsigned integer value to 7-segment display.
+    @param  n     Numeric value.
+    @param  base  Number base (default = DEC = base 10)
+  */
+  void print(unsigned int n, int base = DEC);
+
+  /*!
+    @brief  Print long integer value to 7-segment display.
+    @param  n     Numeric value.
+    @param  base  Number base (default = DEC = base 10)
+  */
+  void print(long n, int base = DEC);
+
+  /*!
+    @brief  Print unsigned long integer value to 7-segment display.
+    @param  n     Numeric value.
+    @param  base  Number base (default = DEC = base 10)
+  */
+  void print(unsigned long n, int base = DEC);
+
+  /*!
+    @brief  Print double-precision float value to 7-segment display.
+    @param  n       Numeric value.
+    @param  digits  Fractional-part digits.
+  */
+  void print(double n, int digits = 2);
+
+  /*!
+    @brief  Print byte-size numeric value w/newline to 7-segment display.
+    @param  c     Numeric value.
+    @param  base  Number base (default = BYTE = raw bits)
+  */
+  void println(char c, int base = BYTE);
+
+  /*!
+    @brief  Print unsigned byte-size numeric value w/newline to 7-segment
+            display.
+    @param  b     Numeric value.
+    @param  base  Number base (default = BYTE = raw bits)
+  */
+  void println(unsigned char b, int base = BYTE);
+
+  /*!
+    @brief  Print integer value with newline to 7-segment display.
+    @param  n     Numeric value.
+    @param  base  Number base (default = DEC = base 10)
+  */
+  void println(int n, int base = DEC);
+
+  /*!
+    @brief  Print unsigned integer value with newline to 7-segment display.
+    @param  n     Numeric value.
+    @param  base  Number base (default = DEC = base 10)
+  */
+  void println(unsigned int n, int base = DEC);
+
+  /*!
+    @brief  Print long integer value with newline to 7-segment display.
+    @param  n     Numeric value.
+    @param  base  Number base (default = DEC = base 10)
+  */
+  void println(long n, int base = DEC);
+
+  /*!
+    @brief  Print unsigned long integer value w/newline to 7-segment display.
+    @param  n     Numeric value.
+    @param  base  Number base (default = DEC = base 10)
+  */
+  void println(unsigned long n, int base = DEC);
+
+  /*!
+    @brief  Print double-precision float value to 7-segment display.
+    @param  n       Numeric value.
+    @param  digits  Fractional-part digits.
+  */
+  void println(double n, int digits = 2);
+
+  /*!
+    @brief  Print newline to 7-segment display (rewind position to start).
+  */
+  void println(void);
+
+  /*!
+    @brief  Write raw segment bits into display buffer.
+    @param  x        Character position (0-3).
+    @param  bitmask  Segment bits.
+  */
+  void writeDigitRaw(uint8_t x, uint8_t bitmask);
+
+  /*!
+    @brief  Set specific digit # to a numeric value.
+    @param  x    Character position.
+    @param  num  Numeric (not ASCII) value.
+    @param  dot  If true, light corresponding decimal.
+  */
+  void writeDigitNum(uint8_t x, uint8_t num, bool dot = false);
+
+  /*!
+    @brief  Set or unset colon segment.
+    @param  state  'true' to enable colon, 'false' for off.
+  */
+  void drawColon(bool state);
+
+  /*!
+    @brief  General integer-printing function used by some of the print()
+            variants.
+    @param  n     Numeric value.
+    @param  base  Base (2 = binary).
+  */
+  void printNumber(long n, uint8_t base = 2);
+
+  /*!
+    @brief  General float-printing function used by some of the print()
+            variants.
+    @param  n           Numeric value.
+    @param  fracDigits  Fractional-part digits.
+    @param  base        Base (default DEC = base 10).
+  */
+  void printFloat(double n, uint8_t fracDigits = 2, uint8_t base = DEC);
+
+  /*!
+    @brief  Light display segments in an error-indicating configuration.
+  */
+  void printError(void);
+
+  /*!
+    @brief  Issue colon-on directly to display (bypass buffer).
+  */
+  void writeColon(void);
+
+private:
+  uint8_t position; ///< Current print position, 0-3
+};
+
+/*!
+    @brief  Class for four-digit alphanumeric displays.
+*/
+class Adafruit_AlphaNum4 : public Adafruit_LED_Backpack {
+public:
+  /*!
+    @brief  Constructor for four-digit alphanumeric displays.
+  */
+  Adafruit_AlphaNum4(void);
+
+  /*!
+    @brief  Write single character of alphanumeric display as raw bits
+            (not a general print function).
+    @param  n        Character index (0-3).
+    @param  bitmask  Segment bitmask.
+  */
+  void writeDigitRaw(uint8_t n, uint16_t bitmask);
+
+  /*!
+    @brief  Write single ASCII character to alphanumeric display.
+    @param  n      Character index (0-3).
+    @param  ascii  ASCII character.
+    @param  dot    If true, also light corresponding dot segment.
+  */
+  void writeDigitAscii(uint8_t n, uint8_t ascii, bool dot = false);
+};
\ No newline at end of file
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Time/Adafruit_Display/glcfont.h	Wed Apr 21 13:48:47 2021 +0000
@@ -0,0 +1,264 @@
+#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
+ 
\ No newline at end of file
--- a/main.cpp	Mon Apr 19 14:10:40 2021 +0000
+++ b/main.cpp	Wed Apr 21 13:48:47 2021 +0000
@@ -1,14 +1,26 @@
 #include "mbed.h"
+#include "Servo.h"
+//Eigene Header einbinden
 
-//Eigene Header einbinden
+//include Zeitfunktion
 #include "realtimer.h"
 
+//include Servosteuerung
+#include "servo_bewegung.h"
+
 
 //LED Anzeige
-#include "Adafruit_LEDBackpack.h"
-#include "Adafruit_GFX.h"
-#include "glcdfont.h"
+//#include "Adafruit_LED_Backpack.h"
+
+
+
 
+#define MID         1500
+#define MIN         1000
+#define MAX         2000
+#define STEP          50
+//Time delay between steps in milliseconds
+#define TIME         100
 
 using namespace std::chrono;
 
@@ -16,6 +28,10 @@
 DigitalOut  led(LED1);
 
 
+
+//I2C i2c(I2C_SDA , I2C_SCL);
+
+
 bool  executeMainTask = false;
 Timer user_button_timer, loop_timer;
 
@@ -24,17 +40,27 @@
 void button_fall();
 void button_rise();
 
-
-I2C i2c(D14, D6);
-Adafruit_8x8matrix matrix = Adafruit_8x8matrix(&i2c);
+/*void setup() {
+#ifndef __AVR_ATtiny85__
+  Serial.begin(9600);
+  Serial.println("7 Segment Backpack Test");
+#endif
+  matrix.begin(0x70);
+}*/
+//Adafruit_7segment matrix = Adafruit_7segment();
 
 int main()
 {
-    matrix.begin(0x70);
+    //myservo.period_ms(20);
+    //myservo.pulsewidth_us(MID); //NB in microseconds
     
     set_time(1618332129);  //Zeit setzen
+    
+    //Laufvariablen
     int i = 0;
-    
+    int zeit = 30;
+    Servo Servo1(PA_0);
+    Servo1.Enable(1500,20000);
     
     user_button.fall(&button_fall);
     user_button.rise(&button_rise);
@@ -44,18 +70,40 @@
 
         loop_timer.reset();
         
-        matrix.clear();
-        for (int i = 0; i < 8; i++) {
-          for (int j = 0; j < 8; j++) {
-              matrix.drawPixel(i, j, LED_ON);  
-          }
-        }
-        matrix.writeDisplay();  // write the changes we just made to the display
-        wait(60);
+  /*matrix.print(10000, DEC);
+  matrix.writeDisplay();
+  delay(500);
+
+  // print a hex number
+  matrix.print(0xBEEF, HEX);
+  matrix.writeDisplay();
+  delay(500);
+
+  // print a floating point 
+  matrix.print(12.34);
+  matrix.writeDisplay();
+  delay(500);
+  
+  // print with print/println
+  for (uint16_t counter = 0; counter < 9999; counter++) {
+    matrix.println(counter);
+    matrix.writeDisplay();
+    delay(10);*/
 
  
 
         if (executeMainTask) {
+            
+        for (int pos = 1000; pos < 2000; pos += 25) {
+          Servo1.SetPosition(pos);
+          wait_ns(50);
+      }
+      for (int pos = 2000; pos > 1000; pos -= 25) {
+          Servo1.SetPosition(pos);
+          wait_ns(50);
+      }
+        bewegung(zeit);
+        
         
         //Zeitfunktion
         uhrzeit(time(NULL));
@@ -96,4 +144,25 @@
     if (t_button_ms > 200) {
         executeMainTask = !executeMainTask;
     }
-}
\ No newline at end of file
+}
+
+/*uint16_t blinkcounter = 0;
+  boolean drawDots = false;
+  for (uint16_t counter = 0; counter < 9999; counter ++) {
+    matrix.writeDigitNum(0, (counter / 1000), drawDots);
+    matrix.writeDigitNum(1, (counter / 100) % 10, drawDots);
+    matrix.drawColon(drawDots);
+    matrix.writeDigitNum(3, (counter / 10) % 10, drawDots);
+    matrix.writeDigitNum(4, counter % 10, drawDots);
+   
+    blinkcounter+=50;
+    if (blinkcounter < 500) {
+      drawDots = false;
+    } else if (blinkcounter < 1000) {
+      drawDots = true;
+    } else {
+      blinkcounter = 0;
+    }
+    matrix.writeDisplay();
+    delay(10);
+  }*/
\ No newline at end of file