
Hauptprogramm
Dependencies: ILI9340_Driver_Lib PM2_Libary Lib_DFPlayerMini
Revision 16:f0480e9c5039, committed 2021-04-21
- Comitter:
- ackerden
- Date:
- Wed Apr 21 13:48:47 2021 +0000
- Parent:
- 15:babdd038715a
- Child:
- 17:621c4212fd4e
- Commit message:
Changed in this revision
--- 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