From a26ce94b708adb887fc5c83e319ec7c748aa6bac Mon Sep 17 00:00:00 2001 From: MartMazik Date: Thu, 25 May 2023 19:12:01 +0300 Subject: [PATCH] =?UTF-8?q?=D0=A1=D0=BE=D0=B1=D1=80=D0=B0=D0=BD=D1=8B=20?= =?UTF-8?q?=D0=B2=D1=81=D0=B5=20=D1=87=D0=B0=D1=81=D1=82=D0=B8=20=D0=B2?= =?UTF-8?q?=D0=BC=D0=B5=D1=81=D1=82=D0=B5?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- slave/SPISlave.c | 59 ++++++++ slave/SPISlave.h | 25 ++++ slave/head_oled_i2c.h | 84 ++++++++++++ slave/oled_i2c.c | 312 ++++++++++++++++++++++++++++++++++++++++++ slave/slave.ino | 248 +++++++++++++++++++++++++++++++++ 5 files changed, 728 insertions(+) create mode 100644 slave/SPISlave.c create mode 100644 slave/SPISlave.h create mode 100644 slave/head_oled_i2c.h create mode 100644 slave/oled_i2c.c create mode 100644 slave/slave.ino diff --git a/slave/SPISlave.c b/slave/SPISlave.c new file mode 100644 index 0000000..a117bc5 --- /dev/null +++ b/slave/SPISlave.c @@ -0,0 +1,59 @@ +#include +#include "SPISlave.h" +#include "head_oled_i2c.h" + +static int index = 0; +static int arIndex = 0; +static char data[255]; + +void SPI_SlaveInit(void) +{ + DDR_SPI = (1 << DD_MISO); + SPCR = (1 << SPE) | (1 << SPIE); +} + +// Функция для вычисления контрольной суммы XOR +char CRC8(char *data, int length) { + char crc = 0x00; + char poly = 0x07; // полином для CRC8 + + for (int i = 0; i < length; i++) { + crc ^= data[i]; // XOR текущего байта с crc + + for (int j = 0; j < length; j++) { + if (crc & 0x80) { // если старший бит crc равен 1 + crc = (crc << 1) ^ poly; // сдвигаем crc на 1 бит влево и XOR с полиномом + } else { + crc <<= 1; // иначе просто сдвигаем на 1 бит влево + } + } + } + + return crc; +} + +char crc8(char *data, int len) { + char crc = 0x00; + while (len--) { + crc ^= *data++; + for (int i = 0; i < 8; i++) { + if (crc & 0x80) { + crc = (crc << 1) ^ 0x07; + } else { + crc <<= 1; + } + } + } + return crc; +} + + +// Проверка массива на ноль +char checkArray(char *arr, int size) { + for (int i = 0; i < size; i++) { + if (arr[i] != 0) { + return 1; + } + } + return 0; +} diff --git a/slave/SPISlave.h b/slave/SPISlave.h new file mode 100644 index 0000000..fa185f0 --- /dev/null +++ b/slave/SPISlave.h @@ -0,0 +1,25 @@ +#ifndef SPISlave_H +#define SPISlave_H + +#define DDR_SPI DDRB +#define DD_MOSI PB3 +#define DD_MISO PB4 +#define DD_SCK PB5 +#define DD_SS PB2 + + +#ifdef __cplusplus +extern "C" { +#endif + +void SPI_SlaveInit(void); +char CRC8(char *data, int length); +char checkArray(char *arr, int size); + +char crc8(char *data, int len); + +#ifdef __cplusplus +} +#endif + +#endif \ No newline at end of file diff --git a/slave/head_oled_i2c.h b/slave/head_oled_i2c.h new file mode 100644 index 0000000..5d6237e --- /dev/null +++ b/slave/head_oled_i2c.h @@ -0,0 +1,84 @@ +#ifndef head_oled_i2c +#define head_oled_i2c + +#define OLED_HEIGHT_64 0x12 +#define OLED_64 0x3F + +#define OLED_DISPLAY_OFF 0xAE +#define OLED_DISPLAY_ON 0xAF + +#define OLED_COMMAND_MODE 0x00 +#define OLED_ONE_COMMAND_MODE 0x80 +#define OLED_DATA_MODE 0x40 + +#define OLED_ADDRESSING_MODE 0x20 +#define OLED_VERTICAL 0x01 + +#define OLED_NORMAL_V 0xC8 +#define OLED_NORMAL_H 0xA1 + +#define OLED_CONTRAST 0x81 +#define OLED_SETCOMPINS 0xDA +#define OLED_SETVCOMDETECT 0xDB +#define OLED_CLOCKDIV 0xD5 +#define OLED_SETMULTIPLEX 0xA8 +#define OLED_COLUMNADDR 0x21 +#define OLED_PAGEADDR 0x22 +#define OLED_CHARGEPUMP 0x8D + +#define OLED_NORMALDISPLAY 0xA6 + +#define OLED_BUFSIZE (128*64/8) + +#define OLED_MAX_X 127 +#define OLED_MAX_Y 63 +#define OLED_MAX_ROW 7 + +#define OLED_ADDR 0x3C +#define OLED_I2C_FREQ 100000UL + +#ifdef __cplusplus +extern "C" { +#endif + +void i2c_begin(uint8_t address); +void i2c_endTransaction(); +void i2c_beginTransmission(uint8_t address); +void i2c_write(uint8_t data); + +void endTransm(); +void sendByteRaw(uint8_t data); +void startTransm(); +void beginData(); +void sendByte(uint8_t data); + +void sendCommand(uint8_t cmd1); +void sendCommandData(uint8_t cmd1, uint8_t cmd2); +uint8_t constrainValue(uint8_t value, uint8_t min, uint8_t max); +void setWindow(int x0, int y0, int x1, int y1); + +void beginCommand(); +void beginOneCommand(); + +void initialization(); + +void setBit(uint8_t *value, uint8_t bitIndex, uint8_t bitValue); +void DrawPixel(uint8_t x, uint8_t y, uint8_t fill); +void DrawLine(uint8_t x1, uint8_t y1, uint8_t x2, uint8_t y2, uint8_t color); +void DrawRect(uint8_t x, uint8_t y, uint8_t width, uint8_t height, uint8_t color, uint8_t fill); +void DrawCircle(uint8_t x0, uint8_t y0, uint8_t radius, uint8_t color, uint8_t fill); +void Fill(uint8_t fill); +void update(); + +void DrawChar(uint8_t x, uint8_t y, uint8_t charIndex, uint8_t fill); +void AddSymbol(uint8_t symbol); +void DelSymbol(); +void SetPage(uint8_t p); + + + +#ifdef __cplusplus +} +#endif + +#endif \ No newline at end of file diff --git a/slave/oled_i2c.c b/slave/oled_i2c.c new file mode 100644 index 0000000..00d82ab --- /dev/null +++ b/slave/oled_i2c.c @@ -0,0 +1,312 @@ +#include "stdint.h" +#include +#include "head_oled_i2c.h" + +uint8_t _oled_buffer[OLED_BUFSIZE]; +uint8_t _writes = 0; + +void i2c_begin(uint8_t address) { + TWBR = ((F_CPU / OLED_I2C_FREQ) - 16) / 2; + TWAR = (address << 1); +} + +void i2c_endTransaction() { + TWCR = (1 << TWINT) | (1 << TWEN) | (1 << TWSTO); +} + +void i2c_beginTransmission(uint8_t address) { + TWCR = (1 << TWINT) | (1 << TWSTA) | (1 << TWEN); + while (!(TWCR & (1 << TWINT))); + + TWDR = (address << 1); + TWCR = (1 << TWINT) | (1 << TWEN); + while (!(TWCR & (1 << TWINT))); +} + +void i2c_write(uint8_t data) { + TWDR = data; // Запись данных + TWCR = (1 << TWINT) | (1 << TWEN); + while (!(TWCR & (1 << TWINT))); +} + + + +void endTransm() { + i2c_endTransaction(); + _writes = 0; +} + +void sendByteRaw(uint8_t data) { + i2c_write(data); +} + +void startTransm() { + i2c_beginTransmission(OLED_ADDR); +} + +void beginCommand() { + startTransm(); + sendByteRaw(OLED_COMMAND_MODE); +} + +void beginData() { + startTransm(); + sendByteRaw(OLED_DATA_MODE); +} + +void sendByte(uint8_t data) { + sendByteRaw(data); + _writes++; + if (_writes >= 16) { + endTransm(); + beginData(); + } +} + +void beginOneCommand() { + startTransm(); + sendByteRaw(OLED_ONE_COMMAND_MODE); +} + +void sendCommand(uint8_t cmd1) { + beginOneCommand(); + sendByteRaw(cmd1); + endTransm(); +} + +void sendCommandData(uint8_t cmd1, uint8_t cmd2) { + beginCommand(); + sendByteRaw(cmd1); + sendByteRaw(cmd2); + endTransm(); +} + +uint8_t constrainValue(uint8_t value, uint8_t min, uint8_t max) { + if (value < min) { + return min; + } else if (value > max) { + return max; + } + return value; +} + + +void setWindow(int x0, int y0, int x1, int y1) { + beginCommand(); + sendByteRaw(OLED_COLUMNADDR); + sendByteRaw(constrainValue(x0, 0, OLED_MAX_X)); + sendByteRaw(constrainValue(x1, 0, OLED_MAX_X)); + sendByteRaw(OLED_PAGEADDR); + sendByteRaw(constrainValue(y0, 0, OLED_MAX_ROW)); + sendByteRaw(constrainValue(y1, 0, OLED_MAX_ROW)); + endTransm(); +} + +void initialization() { + i2c_begin(OLED_ADDR); + + beginCommand(); + sendByte(OLED_DISPLAY_OFF); + sendByte(OLED_CLOCKDIV); + sendByte(0x80); + sendByte(OLED_CHARGEPUMP); + sendByte(0x14); + sendByte(OLED_ADDRESSING_MODE); + sendByte(OLED_VERTICAL); + sendByte(OLED_NORMAL_H); + sendByte(OLED_NORMAL_V); + sendByte(OLED_CONTRAST); + sendByte(0x7F); + sendByte(OLED_SETVCOMDETECT); + sendByte(0x40); + sendByte(OLED_NORMALDISPLAY); + sendByte(OLED_DISPLAY_ON); + endTransm(); + + beginCommand(); + sendByte(OLED_SETCOMPINS); + sendByte(OLED_HEIGHT_64); + sendByte(OLED_SETMULTIPLEX); + sendByte(OLED_64); + endTransm(); + + setWindow(0, 0, OLED_MAX_X, OLED_MAX_ROW); +} + +void setBit(uint8_t *value, uint8_t bitIndex, uint8_t bitValue) { + if (bitValue != 0) { + *value |= (1 << bitIndex); + } else { + *value &= ~(1 << bitIndex); + } +} + +void DrawPixel(uint8_t x, uint8_t y, uint8_t fill) { + if (x < 0 || x > OLED_MAX_X || y < 0 || y > OLED_MAX_Y) return; + uint16_t _bufIndex = ((y) >> 3) + ((x) << (3)); + setBit(&_oled_buffer[_bufIndex], y & 0b111, fill); +} + +void DrawLine(uint8_t x1, uint8_t y1, uint8_t x2, uint8_t y2, uint8_t color) { + uint8_t dx = abs(x2 - x1); + uint8_t dy = abs(y2 - y1); + uint8_t sx = x1 < x2 ? 1 : -1; + uint8_t sy = y1 < y2 ? 1 : -1; + uint8_t err = dx - dy; + + while (1) { + DrawPixel(x1, y1, color); + + if (x1 == x2 && y1 == y2) break; + + uint8_t e2 = 2 * err; + + if (e2 > -dy) { + err -= dy; + x1 += sx; + } + + if (e2 < dx) { + err += dx; + y1 += sy; + } + } +} + +void DrawRect(uint8_t x, uint8_t y, uint8_t width, uint8_t height, uint8_t color, uint8_t fill) { + if (fill) { + for (uint8_t i = y; i < y + height; i++) { + DrawLine(x, i, x + width - 1, i, color); + } + } else { + for (uint8_t i = x; i < x + width; i++) { + DrawPixel(i, y, color); + DrawPixel(i, y + height - 1, color); + } + for (uint8_t i = y; i < y + height; i++) { + DrawPixel(x, i, color); + DrawPixel(x + width - 1, i, color); + } + } +} + +// +void DrawCircle(uint8_t x0, uint8_t y0, uint8_t radius, uint8_t color, uint8_t fill) { + int8_t x = radius; + int8_t y = 0; + int8_t err = 0; + + while (x >= y) { + if (fill) { + for (int8_t i = x0 - x; i <= x0 + x; i++) { + DrawPixel(i, y0 + y, color); + DrawPixel(i, y0 - y, color); + } + for (int8_t i = x0 - y; i <= x0 + y; i++) { + DrawPixel(i, y0 + x, color); + DrawPixel(i, y0 - x, color); + } + } else { + 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); + } + + y++; + err += 1 + 2 * y; + if (2 * (err - x) + 1 > 0) { + x--; + err += 1 - 2 * x; + } + } +} + +// Заполнить дисплей +void Fill(uint8_t fill) { + memset(_oled_buffer, fill, OLED_BUFSIZE); +} + +// Обновить дисплей +void update() { + setWindow(0, 0, OLED_MAX_X, OLED_MAX_ROW); + beginData(); + for (int i = 0; i < OLED_BUFSIZE; i++) sendByte(_oled_buffer[i]); + endTransm(); +} + +const uint8_t _charMap[][5] = { + {0x00, 0x00, 0x00, 0x00, 0x00}, // 0x20 32 + {0x00, 0x1c, 0x22, 0x41, 0x00}, // ( 0x21 33 + {0x00, 0x41, 0x22, 0x1c, 0x00}, // ) 0x22 34 + {0x14, 0x08, 0x3e, 0x08, 0x14}, // * 0x23 35 + {0x08, 0x08, 0x3e, 0x08, 0x08}, // + 0x24 36 + {0x00, 0x50, 0x30, 0x00, 0x00}, // , 0x25 37 + {0x08, 0x08, 0x08, 0x08, 0x08}, // - 0x26 38 + {0x00, 0x60, 0x60, 0x00, 0x00}, // . 0x27 39 + {0x20, 0x10, 0x08, 0x04, 0x02}, // / 0x28 40 + {0x3e, 0x51, 0x49, 0x45, 0x3e}, // 0 0x29 41 + {0x00, 0x42, 0x7f, 0x40, 0x00}, // 1 0x2a 42 + {0x42, 0x61, 0x51, 0x49, 0x46}, // 2 0x2b 43 + {0x21, 0x41, 0x45, 0x4b, 0x31}, // 3 0x2c 44 + {0x18, 0x14, 0x12, 0x7f, 0x10}, // 4 0x2d 45 + {0x27, 0x45, 0x45, 0x45, 0x39}, // 5 0x2e 46 + {0x3c, 0x4a, 0x49, 0x49, 0x30}, // 6 0x2f 47 + {0x01, 0x71, 0x09, 0x05, 0x03}, // 7 0x30 48 + {0x36, 0x49, 0x49, 0x49, 0x36}, // 8 0x31 49 + {0x06, 0x49, 0x49, 0x29, 0x1e}, // 9 0x32 50 + {0x00, 0x36, 0x36, 0x00, 0x00}, // : 0x33 51 + {0x08, 0x14, 0x22, 0x41, 0x00}, // < 0x34 52 + {0x14, 0x14, 0x14, 0x14, 0x14}, // = 0x35 53 + {0x00, 0x41, 0x22, 0x14, 0x08}, // > 0x36 54 +}; + +void DrawChar(uint8_t x, uint8_t y, uint8_t charIndex, uint8_t fill) { + // Проверяем, что индекс символа находится в допустимых пределах + if (charIndex >= sizeof(_charMap) / sizeof(_charMap[0])) { + return; // Символ не найден + } + + // Рисуем символ пиксель за пикселем + for (uint8_t col = 0; col < 5; col++) { + uint8_t columnData = _charMap[charIndex][col]; + + for (uint8_t row = 0; row < 8; row++) { + if (columnData & (1 << row)) { + DrawPixel(x + col, y + row, fill); + } + } + } +} + +uint8_t page = 0; +uint8_t amountByteInPage[8] = {0, 0, 0, 0, 0, 0, 0, 0}; + +void SetPage(uint8_t p){ + page = p; + if (p < 0) page = 0; + if (p > 8) page = 8; +} + +void AddSymbol(uint8_t symbol){ + if (amountByteInPage[page] + 5 < 128){ + DrawChar(amountByteInPage[page],page*8,symbol,1); + amountByteInPage[page] += 6; + } +} + +// Delete the last symbol from the display buffer +void DelSymbol(){ + if (amountByteInPage[page] - 6 <= 0){ + amountByteInPage[page] = 0; + DrawRect(amountByteInPage[page],page*8,127,8,0,1); + }else{ + amountByteInPage[page] -= 6; + DrawRect(amountByteInPage[page],page*8,6,8,0,1); + } +} + diff --git a/slave/slave.ino b/slave/slave.ino new file mode 100644 index 0000000..92b8753 --- /dev/null +++ b/slave/slave.ino @@ -0,0 +1,248 @@ + +#include "SPISlave.h" +#include "head_oled_i2c.h" +// #include +// #include +// GyverOLED oled; + + +// GyverOLED oled; + +static int index = 0; +static int arIndex = 0; +static char data[64]; + +// void SPI_SlaveInit(void) +// { +// DDR_SPI = (1 << DD_MISO); +// SPCR = (1 << SPE) | (1 << SPIE); +// } + +// biblary + + + +ISR(SPI_STC_vect) +{ + char received = SPDR; + data[index] = received; + index++; +} + +void setup() +{ + Serial.begin(9600); + SPI_SlaveInit(); + initialization(); + + // oled_init(); + Fill(0); + SetPage(2); + update(); + + + // oled.setScale(3); + // oled.home(); + + Serial.println(); + Serial.println("Initialization "); +} + +void SetCommand(char *data2, int length){ + char command = data2[0]; + // Отрезать 1 элемент от оставшихся + + Serial.print("\nReceived command: "); + Serial.println(command, HEX); + switch (command){ + case 1: + AllClearCommand(&data2[1], length-1); + break; + case 2: + SetPageCommand(&data2[1], length-1); + break; + + // case 6: + // PrintMassive(&data2[1], length-1); + // break; + case 3: + AddSymbolCommand(&data2[1], length-1); + break; + case 4: + DelSymbolCommand(&data2[1], length-1); + break; + case 5: + DrawPixelCommand(&data2[1], length-1); + PrintMassive(&data2[1], length-1); + break; + case 6: + DrawLineCommand(&data2[1], length-1); + break; + case 7: + DrawCircleCommand(&data2[1], length-1); + break; + case 8: + DrawRectangleCommand(&data2[1], length-1); + break; + + } +} + + +void PrintMassive(uint8_t *symbols, int lenght){ + Serial.print("Received Add: "); + + // oled.setScale(3); // масштаб текста (1..4) + // oled.home(); // курсор в 0,0 + // oled.print("Привет!"); + for(int i = 0; i < lenght - 1; i++) { + char str[3]; + sprintf(str, "%01X", symbols[i]); + Serial.print(str); + Serial.print(" "); + } +} + +// Another +// command 1 +void AllClearCommand(char *symbols, int lenght){ + int param = symbols[0]; + if (param == 0){ + Fill(0); + update(); + // oled.fill(0); + } + else{ + Fill(255); + update(); + // oled.fill(255); + } + } + +// command 2 +void SetPageCommand(char *symbols, int lenght){ + // int x = symbols[0]; + // int y = symbols[1]; + // oled.setCursor(x,y); + SetPage(symbols[0]); + update(); + } + +// command 3 +void AddSymbolCommand(char *symbols, int lenght) { + // SetPage(2); + for (int i = 0; i < lenght - 1; i++) { + // oled.print(symbols[i]); + AddSymbol(symbols[i]); + } + update(); +} + +// command 4 +void DelSymbolCommand(char *symbols, int lenght) { + for (int i = 0; i < symbols[0]; i++) { + DelSymbol(); + } + + update(); +} + +// command 5 +void DrawPixelCommand(char *symbols, int lenght){ + int x = symbols[0]; + int y = symbols[1]; + int color = symbols[2]; + + DrawPixel(x, y, color); + update(); + // oled.dot(x,y,color); +} + +// command 6 +void DrawLineCommand(char *symbols, int lenght){ + int x = symbols[0]; + int y = symbols[1]; + int x1 = symbols[2]; + int y1 = symbols[3]; + int color = symbols[4]; + + DrawLine(x, y, x1, y1, color); + update(); + // oled.line(x,y,x1,y1,color); +} + +// command 7 +void DrawCircleCommand(char *symbols, int lenght){ + int x = symbols[0]; + int y = symbols[1]; + int r = symbols[2]; + // white on black color=1, fill=0 + int color = symbols[3]; + int fill = symbols[4]; + + DrawCircle(x, y, r, color, fill); + update(); + // oled.circle(x,y,r,color); +} + +// command 8 +void DrawRectangleCommand(char *symbols, int lenght){ + int x = symbols[0]; + int y = symbols[1]; + int width = symbols[2]; + int height = symbols[3]; + // white on black color=1, fill=0 + int color = symbols[4]; + int fill = symbols[5]; + DrawRect(x, y, width, height, color, fill); + update(); + // oled.rect(x,y,x1,y1,color); +} + + +// Вывод массива +void arrayOut(uint8_t *arr, int size){ + Serial.print("Array: "); + for(int i = 0; i < size;i++){ + char str[3]; + sprintf(str, "%02X", arr[i]); + Serial.print(str); + Serial.print(" "); + } + Serial.println("."); +} + + +void loop() { + if(PINB & (1 << 2)){ + if(index > 0){ + + arrayOut(data, index); + + char sum = 0; + sum = crc8(data, index-1); + + char checkNull = 0; + char last_1 = data[index - 1]; + + Serial.println(sum, HEX); + + if (last_1 == sum){ + Serial.println(); + Serial.println("Старт вывода массивов"); + Serial.println(sum, HEX); + + SetCommand(data, index); + // oled.print(data[0]); + Serial.println("Стоп вывода массивов"); + index = 0; + return; + }else{ + Serial.println("Nothing ..."); + + index = 0; + } + + } + } +}