Pipboy3Kmark4/pipboyIO/extDisplay.cpp

#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>
#include "extDisplay.h"
#include "radDisplaySettings.h"

#define EXT_DISPLAY_I2C_ADDRESS 0x3C
#define EXT_SCREEN_WIDTH 128
#define EXT_SCREEN_HEIGHT 64


Adafruit_SSD1306 extDisplay(EXT_SCREEN_WIDTH, EXT_SCREEN_HEIGHT, &Wire, -1);

void initExtDisplay() {
    Wire.begin(EXT_I2C_SDA, EXT_I2C_SCL);
    if(!extDisplay.begin(SSD1306_SWITCHCAPVCC, EXT_DISPLAY_I2C_ADDRESS)) {
        //Serial.println("SSD1306 #1 allocation failed");
        for(;;);
    }

    changeExt(50);
}

void changeExt(float value) {
    extDisplay.clearDisplay();
    overlayOnExtDisplay();
    drawLineExtDisplay(valueOnExtDisplay(value));
    extDisplay.display();
}

void pixelOnExtDisplay(int16_t x, int16_t y) {
    extDisplay.clearDisplay();
    extDisplay.drawPixel(x, y, WHITE);
    extDisplay.display();
}

float valueOnExtDisplay(float value) {
    return mapFloat(value, 0, 100, 150, 210);
}

void drawLineExtDisplay(float value) {
    int r1 = 122;
    int r2 = 112;
    float rad = value * PI / 180.0;
    float radSin = sin(rad);
    float radCos = cos(rad);

    for (int x = extCenterX - 1; x < extCenterX + 1; x++) {
        for (int y = extCenterY - 1; y < extCenterY + 1; y++) {
            extDisplay.drawLine(
                x + (r1 * radSin), 
                y - (r1 * radCos), 
                x + (r2 * radSin), 
                y - (r2 * radCos), 
                WHITE);
        }
    }
}

void overlayOnExtDisplay() {
    int duga[2] = {85, 125};
    for (int d = 0; d < 2; d++) {
        for (int angleCalc = 150; angleCalc <= 210.0; angleCalc+= 1) {
            float rad = angleCalc * PI / 180.0;
            int angle = map(angleCalc, 210, 150, 0, 100);
            float radSin = sin(rad);
            float radCos = cos(rad);

            int endX = 64 + (duga[d] * radSin);
            int endY = -70 - (duga[d] * radCos);
            extDisplay.drawPixel(endX, endY, WHITE);

            if (d == 0 && angle % 10 == 0) {
                int duga0ext = 95;
                int startX = 64 + (duga0ext * radSin);
                int startY = -70 - (duga0ext * radCos);
                extDisplay.drawLine(endX, endY, startX, startY, WHITE);
            } 

            if (d == 0 && angle % 5 == 0) {
                int duga0ext = 90;
                int startX = 64 + (duga0ext * radSin);
                int startY = -70 - (duga0ext * radCos);
                extDisplay.drawLine(endX, endY, startX, startY, WHITE);
            }

            if (d == 1 && angle % 5 == 0) {
                int duga1ext = 128;
                int startX = 64 + (duga1ext * radSin);
                int startY = -70 - (duga1ext * radCos);
                extDisplay.drawLine(endX, endY, startX, startY, WHITE);
            }

            if (d == 0 && angle % 10 == 0) {
                int neededLetter = abs(100 - angle);
                int duga1ext = duga[d] + 15;
                int startX = 64 + (duga1ext * radSin);
                int startY = -70 - (duga1ext * radCos);
                int moveLetters = 5;

                for (int i = 0; i < sizeof(ZeroLetterPoint) / sizeof(ZeroLetterPoint[0]); i++) {
                    extDisplay.drawPixel(startX + ZeroLetterPoint[i][0], startY + ZeroLetterPoint[i][1], WHITE);
                }

                switch (neededLetter) {
                    case 10:
                        for (int i = 0; i < sizeof(OneLetterPoint) / sizeof(OneLetterPoint[0]); i++) {
                            extDisplay.drawPixel(startX + OneLetterPoint[i][0], startY + OneLetterPoint[i][1] + moveLetters, WHITE);
                        }
                        break;

                    case 20:
                        for (int i = 0; i < sizeof(TwoLetterPoint) / sizeof(TwoLetterPoint[0]); i++) {
                            extDisplay.drawPixel(startX + TwoLetterPoint[i][0], startY + TwoLetterPoint[i][1] + moveLetters, WHITE);
                        }
                        break;

                    case 30:
                        for (int i = 0; i < sizeof(ThreeLetterPoint) / sizeof(ThreeLetterPoint[0]); i++) {
                            extDisplay.drawPixel(startX + ThreeLetterPoint[i][0], startY + ThreeLetterPoint[i][1] + moveLetters, WHITE);
                        }
                        break;

                    case 40:
                        for (int i = 0; i < sizeof(FourLetterPoint) / sizeof(FourLetterPoint[0]); i++) {
                            extDisplay.drawPixel(startX + FourLetterPoint[i][0], startY + FourLetterPoint[i][1] + moveLetters, WHITE);
                        }
                        break;

                    case 50:
                        for (int i = 0; i < sizeof(FiveLetterPoint) / sizeof(FiveLetterPoint[0]); i++) {
                            extDisplay.drawPixel(startX + FiveLetterPoint[i][0], startY + FiveLetterPoint[i][1] + moveLetters, WHITE);
                        }
                        break;

                    case 60:
                        for (int i = 0; i < sizeof(SixLetterPoint) / sizeof(SixLetterPoint[0]); i++) {
                            extDisplay.drawPixel(startX + SixLetterPoint[i][0], startY + SixLetterPoint[i][1] + moveLetters, WHITE);
                        }
                        break;

                    case 70:
                        for (int i = 0; i < sizeof(SevenLetterPoint) / sizeof(SevenLetterPoint[0]); i++) {
                            extDisplay.drawPixel(startX + SevenLetterPoint[i][0], startY + SevenLetterPoint[i][1] + moveLetters, WHITE);
                        }
                        break;

                    case 80:
                        for (int i = 0; i < sizeof(EightLetterPoint) / sizeof(EightLetterPoint[0]); i++) {
                            extDisplay.drawPixel(startX + EightLetterPoint[i][0], startY + EightLetterPoint[i][1] + moveLetters, WHITE);
                        }
                        break;

                    case 90:
                        for (int i = 0; i < sizeof(NineLetterPoint) / sizeof(NineLetterPoint[0]); i++) {
                            extDisplay.drawPixel(startX + NineLetterPoint[i][0], startY + NineLetterPoint[i][1] + moveLetters, WHITE);
                        }
                        break;

                    case 100:
                        for (int i = 0; i < sizeof(ZeroLetterPoint) / sizeof(ZeroLetterPoint[0]); i++) {
                            extDisplay.drawPixel(startX + ZeroLetterPoint[i][0], startY + ZeroLetterPoint[i][1] + moveLetters, WHITE);
                        }

                        for (int i = 0; i < sizeof(OneLetterPoint) / sizeof(OneLetterPoint[0]); i++) {
                            extDisplay.drawPixel(startX + OneLetterPoint[i][0], startY + OneLetterPoint[i][1] + moveLetters * 2, WHITE);
                        }
                        break;
                    
                    default:
                        break;
                }
            }
        }
    }
}

//display calc
// center 64 / -70
// break high radius 132
// break low raduis 80

// 80 min 150
// 80 max 210

void lineCalcOnExtDisplay(int16_t x, int16_t y, int radius) {
    extDisplay.clearDisplay();
    overlayOnExtDisplay();

    float rad = x * PI / 180.0;
    int endX = 64 + (radius * sin(rad));
    int endY = -70 - (radius * cos(rad));

    if (endX <= 128 && endX >= 0 && endY <= 64 && endY >= 0) {
        extDisplay.drawPixel(endX, endY, WHITE);
    }
    

    extDisplay.display();
}