DEV Community: jay jordan

how to build portable television with hologram function

jay jordan — Tue, 02 Jan 2024 13:00:03 +0000

1. High-resolution liquid crystal display (LCD) that displays video content and holograms. 2. A graphics processor (GPU) for processing graphics and creating a holographic effect. 3. Central processing unit (CPU) for data processing, control of TV functions and holography. 4. Memory for storing the operating system, applications and video content. 5. Built-in wireless technology, such as Wi-Fi or Bluetooth, to connect to the Internet and control the TV using a smartphone or tablet.
6. Audio system for providing audio accompaniment of videos and holograms. 7. Battery to power the TV in portability mode. 8. Camera and depth sensors for capturing images and creating a real-time holographic effect. 9. Software for controlling the TV, displaying holograms and playing content. 10. Connectors such as HDMI or USB for connecting external devices such as game consoles or flash drives.

vape heater

jay jordan — Mon, 25 Dec 2023 16:11:07 +0000

include

include “i2c.h”

include “i2c_BMP280.h”

BMP280 bmp280;
LiquidCrystal_I2C lcd(0x3f,20,4);

SimpleDHT22 dht22;

//Define the pins
const int ButtonPin = 2;
const int pinDHT22 = 3;
const int DownPowerPin = 4;
const int UpPowerPin = 5;

const int FiringPin = 10;
const int BuzzerPin = 8;
const int PowerBoost = 11;
const int LedPin = 13;

// Discrete Variable Declarations
int ButtonState = 0;
int PowerBoostState = 0;
int BuzzerShutoffOK = 1;
int PowerLevelRaw = 50;
int PowerLevelScaled = 0;
int PowerSetting = 10;
int UpPowerValue = 1;
int DownPowerValue = 1;

// BMP280 Vars
float BMPtemperature;
float BMPpascal;
static float BMPmeters, BMPmetersold;

// Timers
unsigned long ButtonMillisStart = 0;
unsigned long ButtonMillisTimeout = 6000;

unsigned long FlashMillisStart = 0;
unsigned long FlashMillisTimeout = 100;

unsigned long SleepMillisStart = 0;
unsigned long SleepMillisTimeout = 300000;

int ButtonTimeout = 0;
int VapeTime = 0;
int VapeTimeLast = 0;

// Counters
int MyCounter = 0;
int LightCounter = 0;

// One Shots
int ButtonRising = 0;
int ButtonFalling = 0;
int UpPowerONS = 0;
int DownPowerONS = 0;
char LastSecond;

// This is for the Real Time Clock

define DS3231_I2C_ADDRESS 0x68

// Convert normal decimal numbers to binary coded decimal
byte decToBcd(byte val){
return( (val/10*16) + (val%10) );
}
// Convert binary coded decimal to normal decimal numbers
byte bcdToDec(byte val){
return( (val/16*10) + (val%16) );
}

//—————————————-
void wakeUp()
{
// Just a handler for the pin interrupt.
}
//—————————————-

void setup() {
Wire.begin();
Serial.begin(9600);

//Serial.print(“Probe BMP280: “);
if (bmp280.initialize()){ //Serial.println(“BMP Sensor found”);
}
else
{
//Serial.println(“BMP Sensor missing”);
while (1) {}
}

// onetime-measure:
bmp280.setEnabled(0);
bmp280.triggerMeasurement();

//LCD Setup
lcd.init(); //initialize the lcd

// RTC
// set the initial time here:
// DS3231 seconds, minutes, hours, day, date, month, year
//setDS3231time(30,16,18,7,1,9,2017);

// Setup Pin Modes
pinMode(DownPowerPin, INPUT_PULLUP);
pinMode(UpPowerPin, INPUT_PULLUP);
pinMode(ButtonPin, INPUT_PULLUP);
pinMode(BuzzerPin, OUTPUT);
pinMode(PowerBoost, INPUT_PULLUP);
pinMode(LedPin, OUTPUT);
lcd.noBacklight();

//Configure Wireless
lcd.backlight();
lcd.setCursor(0,1);
lcd.print(“Setting Mode”);
Serial.println(“AT+CWMODE=1”);
delay(1000);

lcd.setCursor(0,1);
lcd.print(“Connecting Network”);
Serial.println(“AT+CWJAP=\”yourSSID\”,\”yourPASSWORD\””);
delay(3000);

}

// —————————————
// RTC Logic for Setting clock
// —————————————
void setDS3231time(byte second, byte minute, byte hour, byte dayOfWeek, byte
dayOfMonth, byte month, byte year){
// sets time and date data to DS3231
Wire.beginTransmission(DS3231_I2C_ADDRESS);
Wire.write(0); // set next input to start at the seconds register
Wire.write(decToBcd(second)); // set seconds
Wire.write(decToBcd(minute)); // set minutes
Wire.write(decToBcd(hour)); // set hours
Wire.write(decToBcd(dayOfWeek)); // set day of week (1=Sunday, 7=Saturday)
Wire.write(decToBcd(dayOfMonth)); // set date (1 to 31)
Wire.write(decToBcd(month)); // set month
Wire.write(decToBcd(year)); // set year (0 to 99)
Wire.endTransmission();
}

void readDS3231time(byte *second,
byte *minute,
byte *hour,
byte *dayOfWeek,
byte *dayOfMonth,
byte *month,
byte *year)
{
Wire.beginTransmission(DS3231_I2C_ADDRESS);
Wire.write(0); // set DS3231 register pointer to 00h
Wire.endTransmission();
Wire.requestFrom(DS3231_I2C_ADDRESS, 7);
// request seven bytes of data from DS3231 starting from register 00h
*second = bcdToDec(Wire.read() & 0x7f);
*minute = bcdToDec(Wire.read());
*hour = bcdToDec(Wire.read() & 0x3f);
*dayOfWeek = bcdToDec(Wire.read());
*dayOfMonth = bcdToDec(Wire.read());
*month = bcdToDec(Wire.read());
*year = bcdToDec(Wire.read());
}

// —————————————
// End of RTC Code
// —————————————

//—————————————-
void loop() {
// read the state of the pushbuttons:
ButtonState = digitalRead(ButtonPin);
PowerBoostState = digitalRead(PowerBoost);
DownPowerValue = digitalRead(DownPowerPin);
UpPowerValue = digitalRead(UpPowerPin);

// Get the BMP280 Data
bmp280.awaitMeasurement();
bmp280.getTemperature(BMPtemperature);
bmp280.getPressure(BMPpascal);
bmp280.getAltitude(BMPmeters);
BMPmetersold = (BMPmetersold * 10 + BMPmeters)/11;

bmp280.triggerMeasurement();

// get the milliseconds for the timers.
unsigned long CurrentMillis = millis();

//Low Power Setup
//attachInterrupt(0, wakeUp, LOW);
if ((CurrentMillis-SleepMillisStart) > SleepMillisTimeout){
LowPower.powerDown(SLEEP_1S, ADC_OFF, BOD_OFF);
}

// Power Level Control
if (!DownPowerValue){
if (DownPowerONS==0){
PowerLevelRaw=PowerLevelRaw-5;
}
DownPowerONS = 1;
if (PowerLevelRaw < 0){
PowerLevelRaw = 0;
}
}else{
DownPowerONS=0;
}

if (!UpPowerValue){
if (UpPowerONS==0){
PowerLevelRaw=PowerLevelRaw+5;
}
UpPowerONS = 1;
if (PowerLevelRaw > 255){
PowerLevelRaw = 255;
}
}else{
UpPowerONS=0;
}

PowerLevelScaled = PowerLevelRaw/1;
if (!PowerBoostState){
PowerLevelScaled=PowerLevelScaled*1.3;
}

// ************************* Button is PRESSED *************************
if (ButtonState == LOW) {
SleepMillisStart=CurrentMillis;
ButtonFalling = 0;

// turn on the backlight on lcd

if ((CurrentMillis -FlashMillisStart) < FlashMillisTimeout){
lcd.backlight();
}else if ((CurrentMillis -FlashMillisStart) < (FlashMillisTimeout *2)){
lcd.noBacklight();
} else {
FlashMillisStart = CurrentMillis;
}

VapeTime = ((CurrentMillis-ButtonMillisStart) / 1000);
if (VapeTime!=VapeTimeLast){
lcd.clear();
lcd.setCursor(0,0);
lcd.print(“*** Running ***”);
lcd.setCursor(0,1);
if (PowerBoostState==1){
lcd.print (“High Power: “);
}else{
lcd.print (“Low Power: “);
}
lcd.print(VapeTime);
VapeTimeLast=VapeTime;
}

if ((CurrentMillis – ButtonMillisStart) < ButtonMillisTimeout){
digitalWrite(LedPin,HIGH);
analogWrite(FiringPin, PowerLevelScaled);
}else{
ButtonTimeout = 1;
digitalWrite(LedPin,LOW);
digitalWrite(BuzzerPin,HIGH);
analogWrite(FiringPin, 0);

// Clear One Shot

}
ButtonRising = 1;
}else{
// ************************* Button is RELEASED ************************
ButtonRising = 0;
if (LightCounter > 10000){LightCounter = 0;}
if (ButtonFalling == 0){LightCounter = 0;}
byte second, minute, hour, dayOfWeek, dayOfMonth, month, year;
readDS3231time(&second, &minute, &hour, &dayOfWeek, &dayOfMonth, &month,
&year);
if (second!=LastSecond){
LightCounter++;
float temperature = 0;
float humidity = 0;
int err = SimpleDHTErrSuccess;
if ((err = dht22.read2(pinDHT22, &temperature, &humidity, NULL)) != SimpleDHTErrSuccess) {
//Serial.print(“Read DHT22 failed, err=”); Serial.println(err);delay(200);
return;
}

//lcd.backlight();
if (LightCounter > 300){
lcd.noBacklight();
}else{
lcd.backlight();
}
//lcd.clear();
lcd.setCursor(0,0);
lcd.print(hour);
lcd.print(“:”);
if (minute < 10){lcd.print(“0”);}
lcd.print(minute);
lcd.print(“:”);
if (second < 10){lcd.print(“0″);}
lcd.print(second);
lcd.print (” “);
temperature=temperature*1.8+32;
lcd.print(temperature);
lcd.print((char)223);
lcd.print (“F “);
LastSecond = second;

lcd.setCursor(0,1);
lcd.print(“Humidity: “);
lcd.print(humidity);
lcd.print(“% “);

lcd.setCursor(0,2);
lcd.print(“PSR: “);
lcd.print(BMPpascal/3386.38867);
lcd.print(” In Hg “);

lcd.setCursor(0,3);
lcd.print(“Raw Power: “);
lcd.print(PowerLevelScaled);
lcd.print(” “);
}
ButtonTimeout = 0;
ButtonMillisStart = CurrentMillis;
if (BuzzerShutoffOK == 1) {
digitalWrite(BuzzerPin,LOW);
}
digitalWrite(LedPin,LOW);
analogWrite(FiringPin, 0);

ButtonFalling = 1;
}

// Alarm Logic
byte second, minute, hour, dayOfWeek, dayOfMonth, month, year;
readDS3231time(&second, &minute, &hour, &dayOfWeek, &dayOfMonth, &month,
&year);

if ((hour==5) and (minute==0)){
//Serial.println(“Alarm”);
BuzzerShutoffOK=0;
digitalWrite(BuzzerPin,HIGH);
}else{
BuzzerShutoffOK=1;
}

if (!UpPowerValue and !DownPowerValue and !PowerBoostState){
analogWrite(FiringPin, 0);

lcd.clear();
lcd.setCursor(0,0);
lcd.print(“Opening Garage Door”);
lcd.setCursor(0,1);

lcd.setCursor(0,1);
lcd.print(“Connecting Door… “);
Serial.println(“AT+CIPSTART=\”TCP\”,\”192.168.1.178\”,80″);
delay(2000);

lcd.setCursor(0,1);
lcd.print(“Setting Length… “);
Serial.println(“AT+CIPSEND=20”);
delay(1000);

lcd.setCursor(0,1);
lcd.print(“Sending Command… “);
Serial.println(“GET /?DoorCMD=DC”);
Serial.println(“”);
delay(3000);

lcd.setCursor(0,1);
lcd.print(“Closing Connection “);
Serial.println(“AT+CIPCLOSE”);
delay(1000);

lcd.clear();

}
/*

Created by ArduinoGetStarted.com *
This example code is in the public domain *
Tutorial page: https://arduinogetstarted.com/tutorials/arduino-heating-system */

include

define SENSOR_PIN 2 // Arduino pin connected to DS18B20 sensor's DQ pin

define RELAY_PIN A5 // Arduino pin connected to relay which connected to heating element

const int TEMP_THRESHOLD_UPPER = 20; // upper threshold of temperature, change to your desire value
const int TEMP_THRESHOLD_LOWER = 15; // lower threshold of temperature, change to your desire value

OneWire oneWire(SENSOR_PIN); // setup a oneWire instance
DallasTemperature sensors(&oneWire); // pass oneWire to DallasTemperature library

float temperature; // temperature in Celsius

void setup() {
Serial.begin(9600); // initialize serial
sensors.begin(); // initialize the sensor
pinMode(RELAY_PIN, OUTPUT); // initialize digital pin as an output
}

void loop() {
sensors.requestTemperatures(); // send the command to get temperatures
temperature = sensors.getTempCByIndex(0); // read temperature in Celsius

if(temperature > TEMP_THRESHOLD_UPPER) {
Serial.println("The heating element is turned off");
digitalWrite(RELAY_PIN, LOW); // turn off
} else if(temperature < TEMP_THRESHOLD_LOWER){
Serial.println("The heating element is turned on");
digitalWrite(RELAY_PIN, HIGH); // turn on
}

delay(500);
}

gaming portable console heater

jay jordan — Mon, 25 Dec 2023 16:09:48 +0000

include

int uinput;

extern "C"
JNIEXPORT void JNICALL
Java_com_monobogdan_inputservicebridge_InputNative_init(JNIEnv *env, jclass clazz) {
uinput = open("/dev/input/event2", O_WRONLY);

__android_log_print(ANDROID_LOG_DEBUG  , "Test", uinput >= 0 ? "Open event OK" : "Failed to open event");

}

void emit(int fd, int type, int code, int val)
{
struct input_event ie;
ie.type = type;
ie.code = code;
ie.value = val;
/* timestamp values below are ignored */
ie.time.tv_sec = 0;
ie.time.tv_usec = 0;
write(fd, &ie, sizeof(ie));
}

extern "C"
JNIEXPORT void JNICALL
Java_com_monobogdan_inputservicebridge_InputNative_sendKeyEvent(JNIEnv *env, jclass clazz,
jint key_code, jboolean pressed) {
__android_log_print(ANDROID_LOG_DEBUG , "Test", "Send");
emit(uinput, EV_KEY, key_code, (bool)pressed ? 1 : 0);
emit(uinput, EV_SYN, SYN_REPORT, 0);
}
package com.monobogdan.inputservicebridge;

public class InputListener extends Service {

private static final int tty = 3;

private InputManager iManager;
private Map<Character, Integer> keyMap;
private Method injectMethod;

private Process runAsRoot(String cmd)
{
    try {
        return Runtime.getRuntime().exec(new String[] { "su", "-c", cmd });
    }
    catch (IOException e)
    {
        e.printStackTrace();

        return null;
    }
}

@Override
public void onCreate() {
    super.onCreate();

    // According to linux key map (input-event-codes.h)
    keyMap = new HashMap<>();
    keyMap.put('U', 103);
    keyMap.put('D', 108);
    keyMap.put('L', 105);
    keyMap.put('R', 106);
    keyMap.put('E', 115);
    keyMap.put('B', 158);
    keyMap.put('A', 232);
    keyMap.put('C', 212);

    InputNative.init();

    try {
        runAsRoot("chmod 777 /dev/input/event2").waitFor();
    } catch (InterruptedException e) {
        throw new RuntimeException(e);
    }

    Executors.newSingleThreadExecutor().execute(new Runnable() {
        @Override
        public void run() {
            Process proc = runAsRoot("cat /dev/ttyMT" + tty);
            BufferedReader reader = new BufferedReader(new InputStreamReader(proc.getInputStream()));

            while(true)
            {
                try {
                    String line = reader.readLine();

                    if(line != null && line.length() > 0) {
                        Log.i("Hi", "run: " + line);

                        boolean pressing = line.charAt(0) == 'D';
                        int keyCode = keyMap.get(line.charAt(2));

                        Log.i("TAG", "run: " + keyCode);
                        InputNative.sendKeyEvent(keyCode, pressing);
                    }
                }
                catch(IOException e)
                {
                    e.printStackTrace();
                }

                /*try {
                    Thread.sleep(1000 / 30);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }*/
            }
        }
    });
}

@Override
public IBinder onBind(Intent intent) {
    return null;
}

}#include

include

include "pico/stdlib.h"

include "pico/time.h"

include "hardware/uart.h"

struct keyMap
{
int gpio;
char key;
bool pressed;
int lastTick;
};

keyMap keys[] = {
{
15,
'L',
false,
0
},
{
14,
'U',
false,
0
},
{
13,
'D',
false,
0
},
{
12,
'R',
false,
0
},
{
11,
'E',
false,
0
},
{
10,
'B',
false,
0
},

{
    20,
    'A',
    false,
    0
},
{
    21,
    'C',
    false,
    0
}

};

define KEY_NUM 8

int main() {
stdio_init_all();

uart_init(uart0, 921600);
gpio_set_function(PICO_DEFAULT_UART_TX_PIN, GPIO_FUNC_UART);
gpio_set_function(PICO_DEFAULT_UART_RX_PIN, GPIO_FUNC_UART);
sleep_ms(1000); // Allow serial monitor to settle

for(int i = 0; i <  KEY_NUM; i++)
{
    gpio_init(keys[i].gpio);
    gpio_set_dir(keys[i].gpio, false);
    gpio_pull_up(keys[i].gpio);
}

while(true)
{
    int now = time_us_32();

    for(int i = 0; i < KEY_NUM; i++)
    {
        char buf[5];
        buf[1] = ' ';
        buf[3] = '\n';
        buf[4] = 0;

        if(!gpio_get(keys[i].gpio) && !keys[i].pressed && now - keys[i].lastTick > 15500)
        {
            buf[0] = 'D';
            buf[2] = keys[i].key;
            puts(buf);

            keys[i].lastTick = now;
            keys[i].pressed = true;
            continue;
        }

        if(gpio_get(keys[i].gpio) && keys[i].pressed && now - keys[i].lastTick > 15500)
        {
            buf[0] = 'U';
            buf[2] = keys[i].key;
            puts(buf);

            keys[i].pressed = false;
            keys[i].lastTick = now;
        }
    }
}

}

include "DHT.h"

include "LiquidCrystal.h"

LiquidCrystal lcd(7, 8, 9, 10, 11 ,12);

define DHTPIN 6

define DHTTYPE DHT22

DHT sensor(DHTPIN, DHTTYPE);
int relay_pin = 9;

void setup() {
lcd.begin(16,2);
sensor.begin();
pinMode(relay_pin, OUTPUT);
digitalWrite(relay_pin, HIGH);
}
void loop() {
lcd.clear();
float t = sensor.readTemperature(); //считывание температуры с датчика
// Проверка, посылает ли датчик значения или нет
if (isnan(t)) {
lcd.print("Failed");
delay(1000);
return;
}
lcd.setCursor(0,0);
lcd.print("Temp: ");
lcd.print(t);
lcd.print(" C");
if (t > 35){
digitalWrite(relay_pin, LOW);
lcd.setCursor(0,1);
lcd.print("Fan is ON ");
delay(10);
}
else{
digitalWrite(relay_pin, HIGH);
lcd.setCursor(0,1);
lcd.print("Fan is OFF ");
}
delay(2000);
}

portable television 3d printer

jay jordan — Mon, 25 Dec 2023 16:08:27 +0000

define X_STEP_PIN 54

define X_DIR_PIN 55

define X_ENABLE_PIN 38

define X_MIN_PIN 3

define X_MAX_PIN 2

define Y_STEP_PIN 60

define Y_DIR_PIN 61

define Y_ENABLE_PIN 56

define Y_MIN_PIN 14

define Y_MAX_PIN 15

define Z_STEP_PIN 46

define Z_DIR_PIN 48

define Z_ENABLE_PIN 62

define Z_MIN_PIN 18

define Z_MAX_PIN 19

define E_STEP_PIN 26

define E_DIR_PIN 28

define E_ENABLE_PIN 24

define Q_STEP_PIN 36

define Q_DIR_PIN 34

define Q_ENABLE_PIN 30

define SDPOWER -1

define SDSS 53

define LED_PIN 13

define FAN_PIN 9

define PS_ON_PIN 12

define KILL_PIN -1

define HEATER_0_PIN 10

define HEATER_1_PIN 8

define TEMP_0_PIN 13 // ANALOG NUMBERING

define TEMP_1_PIN 14 // ANALOG NUMBERING

void setup() {

pinMode(FAN_PIN , OUTPUT);

pinMode(HEATER_0_PIN , OUTPUT);

pinMode(HEATER_1_PIN , OUTPUT);

pinMode(LED_PIN , OUTPUT);

pinMode(X_STEP_PIN , OUTPUT);

pinMode(X_DIR_PIN , OUTPUT);

pinMode(X_ENABLE_PIN , OUTPUT);

pinMode(Y_STEP_PIN , OUTPUT);

pinMode(Y_DIR_PIN , OUTPUT);

pinMode(Y_ENABLE_PIN , OUTPUT);

pinMode(Z_STEP_PIN , OUTPUT);

pinMode(Z_DIR_PIN , OUTPUT);

pinMode(Z_ENABLE_PIN , OUTPUT);

pinMode(E_STEP_PIN , OUTPUT);

pinMode(E_DIR_PIN , OUTPUT);

pinMode(E_ENABLE_PIN , OUTPUT);

pinMode(Q_STEP_PIN , OUTPUT);

pinMode(Q_DIR_PIN , OUTPUT);

pinMode(Q_ENABLE_PIN , OUTPUT);

digitalWrite(X_ENABLE_PIN , LOW);

digitalWrite(Y_ENABLE_PIN , LOW);

digitalWrite(Z_ENABLE_PIN , LOW);

digitalWrite(E_ENABLE_PIN , LOW);

digitalWrite(Q_ENABLE_PIN , LOW);

}

void loop () {

if (millis() %1000 <500)

digitalWrite(LED_PIN, HIGH);

else

digitalWrite(LED_PIN, LOW);

if (millis() %1000 <300) {

digitalWrite(HEATER_0_PIN, HIGH);

digitalWrite(HEATER_1_PIN, LOW);

digitalWrite(FAN_PIN, LOW);

} else if (millis() %1000 <600) {

digitalWrite(HEATER_0_PIN, LOW);

digitalWrite(HEATER_1_PIN, HIGH);

digitalWrite(FAN_PIN, LOW);

} else {

digitalWrite(HEATER_0_PIN, LOW);

digitalWrite(HEATER_1_PIN, LOW);

digitalWrite(FAN_PIN, HIGH);

}

if (millis() %10000 <5000) {

digitalWrite(X_DIR_PIN , HIGH);

digitalWrite(Y_DIR_PIN , HIGH);

digitalWrite(Z_DIR_PIN , HIGH);

digitalWrite(E_DIR_PIN , HIGH);

digitalWrite(Q_DIR_PIN , HIGH);

}

else {

digitalWrite(X_DIR_PIN , LOW);

digitalWrite(Y_DIR_PIN , LOW);

digitalWrite(Z_DIR_PIN , LOW);

digitalWrite(E_DIR_PIN , LOW);

digitalWrite(Q_DIR_PIN , LOW);

}

digitalWrite(X_STEP_PIN , HIGH);

digitalWrite(Y_STEP_PIN , HIGH);

digitalWrite(Z_STEP_PIN , HIGH);

digitalWrite(E_STEP_PIN , HIGH);

digitalWrite(Q_STEP_PIN , HIGH);

delay(1);

digitalWrite(X_STEP_PIN , LOW);

digitalWrite(Y_STEP_PIN , LOW);

digitalWrite(Z_STEP_PIN , LOW);

digitalWrite(E_STEP_PIN , LOW);

digitalWrite(Q_STEP_PIN , LOW);

}

This code should activate all the steppers, fans, and heaters. The only problem with this code is that it does not activate both z-axis steppers; it only activates one. If you encounter any problems with any of the components, try isolating them and only running them in the code. If you would like to test the z-axis and thermistor, download the following codes:

ifndef THERMISTORTABLES_H_

define THERMISTORTABLES_H_

define OVERSAMPLENR 16

if (THERMISTORHEATER_0 == 1) || (THERMISTORHEATER_1 == 1) || (THERMISTORHEATER_2 == 1) || (THERMISTORBED == 1) //100k bed thermistor

const short temptable_1[][2] PROGMEM = {
{ 23*OVERSAMPLENR , 300 },
{ 25*OVERSAMPLENR , 295 },
{ 27*OVERSAMPLENR , 290 },
{ 28*OVERSAMPLENR , 285 },
{ 31*OVERSAMPLENR , 280 },
{ 33*OVERSAMPLENR , 275 },
{ 35*OVERSAMPLENR , 270 },
{ 38*OVERSAMPLENR , 265 },
{ 41*OVERSAMPLENR , 260 },
{ 44*OVERSAMPLENR , 255 },
{ 48*OVERSAMPLENR , 250 },
{ 52*OVERSAMPLENR , 245 },
{ 56*OVERSAMPLENR , 240 },
{ 61*OVERSAMPLENR , 235 },
{ 66*OVERSAMPLENR , 230 },
{ 71*OVERSAMPLENR , 225 },
{ 78*OVERSAMPLENR , 220 },
{ 84*OVERSAMPLENR , 215 },
{ 92*OVERSAMPLENR , 210 },
{ 100*OVERSAMPLENR , 205 },
{ 109*OVERSAMPLENR , 200 },
{ 120*OVERSAMPLENR , 195 },
{ 131*OVERSAMPLENR , 190 },
{ 143*OVERSAMPLENR , 185 },
{ 156*OVERSAMPLENR , 180 },
{ 171*OVERSAMPLENR , 175 },
{ 187*OVERSAMPLENR , 170 },
{ 205*OVERSAMPLENR , 165 },
{ 224*OVERSAMPLENR , 160 },
{ 245*OVERSAMPLENR , 155 },
{ 268*OVERSAMPLENR , 150 },
{ 293*OVERSAMPLENR , 145 },
{ 320*OVERSAMPLENR , 140 },
{ 348*OVERSAMPLENR , 135 },
{ 379*OVERSAMPLENR , 130 },
{ 411*OVERSAMPLENR , 125 },
{ 445*OVERSAMPLENR , 120 },
{ 480*OVERSAMPLENR , 115 },
{ 516*OVERSAMPLENR , 110 },
{ 553*OVERSAMPLENR , 105 },
{ 591*OVERSAMPLENR , 100 },
{ 628*OVERSAMPLENR , 95 },
{ 665*OVERSAMPLENR , 90 },
{ 702*OVERSAMPLENR , 85 },
{ 737*OVERSAMPLENR , 80 },
{ 770*OVERSAMPLENR , 75 },
{ 801*OVERSAMPLENR , 70 },
{ 830*OVERSAMPLENR , 65 },
{ 857*OVERSAMPLENR , 60 },
{ 881*OVERSAMPLENR , 55 },
{ 903*OVERSAMPLENR , 50 },
{ 922*OVERSAMPLENR , 45 },
{ 939*OVERSAMPLENR , 40 },
{ 954*OVERSAMPLENR , 35 },
{ 966*OVERSAMPLENR , 30 },
{ 977*OVERSAMPLENR , 25 },
{ 985*OVERSAMPLENR , 20 },
{ 993*OVERSAMPLENR , 15 },
{ 999*OVERSAMPLENR , 10 },
{ 1004*OVERSAMPLENR , 5 },
{ 1008*OVERSAMPLENR , 0 } //safety
};

endif

if (THERMISTORHEATER_0 == 2) || (THERMISTORHEATER_1 == 2) || (THERMISTORHEATER_2 == 2) || (THERMISTORBED == 2) //200k bed thermistor

const short temptable_2[][2] PROGMEM = {
{1*OVERSAMPLENR, 848},
{54*OVERSAMPLENR, 275},
{107*OVERSAMPLENR, 228},
{160*OVERSAMPLENR, 202},
{213*OVERSAMPLENR, 185},
{266*OVERSAMPLENR, 171},
{319*OVERSAMPLENR, 160},
{372*OVERSAMPLENR, 150},
{425*OVERSAMPLENR, 141},
{478*OVERSAMPLENR, 133},
{531*OVERSAMPLENR, 125},
{584*OVERSAMPLENR, 118},
{637*OVERSAMPLENR, 110},
{690*OVERSAMPLENR, 103},
{743*OVERSAMPLENR, 95},
{796*OVERSAMPLENR, 86},
{849*OVERSAMPLENR, 77},
{902*OVERSAMPLENR, 65},
{955*OVERSAMPLENR, 49},
{1008*OVERSAMPLENR, 17},
{1020*OVERSAMPLENR, 0} //safety
};

endif

if (THERMISTORHEATER_0 == 3) || (THERMISTORHEATER_1 == 3) || (THERMISTORHEATER_2 == 3) || (THERMISTORBED == 3) //mendel-parts

const short temptable_3[][2] PROGMEM = {
{1*OVERSAMPLENR,864},
{21*OVERSAMPLENR,300},
{25*OVERSAMPLENR,290},
{29*OVERSAMPLENR,280},
{33*OVERSAMPLENR,270},
{39*OVERSAMPLENR,260},
{46*OVERSAMPLENR,250},
{54*OVERSAMPLENR,240},
{64*OVERSAMPLENR,230},
{75*OVERSAMPLENR,220},
{90*OVERSAMPLENR,210},
{107*OVERSAMPLENR,200},
{128*OVERSAMPLENR,190},
{154*OVERSAMPLENR,180},
{184*OVERSAMPLENR,170},
{221*OVERSAMPLENR,160},
{265*OVERSAMPLENR,150},
{316*OVERSAMPLENR,140},
{375*OVERSAMPLENR,130},
{441*OVERSAMPLENR,120},
{513*OVERSAMPLENR,110},
{588*OVERSAMPLENR,100},
{734*OVERSAMPLENR,80},
{856*OVERSAMPLENR,60},
{938*OVERSAMPLENR,40},
{986*OVERSAMPLENR,20},
{1008*OVERSAMPLENR,0},
{1018*OVERSAMPLENR,-20}
};

endif

if (THERMISTORHEATER_0 == 4) || (THERMISTORHEATER_1 == 4) || (THERMISTORHEATER_2 == 4) || (THERMISTORBED == 4) //10k thermistor

const short temptable_4[][2] PROGMEM = {
{1*OVERSAMPLENR, 430},
{54*OVERSAMPLENR, 137},
{107*OVERSAMPLENR, 107},
{160*OVERSAMPLENR, 91},
{213*OVERSAMPLENR, 80},
{266*OVERSAMPLENR, 71},
{319*OVERSAMPLENR, 64},
{372*OVERSAMPLENR, 57},
{425*OVERSAMPLENR, 51},
{478*OVERSAMPLENR, 46},
{531*OVERSAMPLENR, 41},
{584*OVERSAMPLENR, 35},
{637*OVERSAMPLENR, 30},
{690*OVERSAMPLENR, 25},
{743*OVERSAMPLENR, 20},
{796*OVERSAMPLENR, 14},
{849*OVERSAMPLENR, 7},
{902*OVERSAMPLENR, 0},
{955*OVERSAMPLENR, -11},
{1008*OVERSAMPLENR, -35}
};

endif

if (THERMISTORHEATER_0 == 5) || (THERMISTORHEATER_1 == 5) || (THERMISTORHEATER_2 == 5) || (THERMISTORBED == 5) //100k ParCan thermistor (104GT-2)

const short temptable_5[][2] PROGMEM = {
{1*OVERSAMPLENR, 713},
{18*OVERSAMPLENR, 316},
{35*OVERSAMPLENR, 266},
{52*OVERSAMPLENR, 239},
{69*OVERSAMPLENR, 221},
{86*OVERSAMPLENR, 208},
{103*OVERSAMPLENR, 197},
{120*OVERSAMPLENR, 188},
{137*OVERSAMPLENR, 181},
{154*OVERSAMPLENR, 174},
{171*OVERSAMPLENR, 169},
{188*OVERSAMPLENR, 163},
{205*OVERSAMPLENR, 159},
{222*OVERSAMPLENR, 154},
{239*OVERSAMPLENR, 150},
{256*OVERSAMPLENR, 147},
{273*OVERSAMPLENR, 143},
{290*OVERSAMPLENR, 140},
{307*OVERSAMPLENR, 136},
{324*OVERSAMPLENR, 133},
{341*OVERSAMPLENR, 130},
{358*OVERSAMPLENR, 128},
{375*OVERSAMPLENR, 125},
{392*OVERSAMPLENR, 122},
{409*OVERSAMPLENR, 120},
{426*OVERSAMPLENR, 117},
{443*OVERSAMPLENR, 115},
{460*OVERSAMPLENR, 112},
{477*OVERSAMPLENR, 110},
{494*OVERSAMPLENR, 108},
{511*OVERSAMPLENR, 106},
{528*OVERSAMPLENR, 103},
{545*OVERSAMPLENR, 101},
{562*OVERSAMPLENR, 99},
{579*OVERSAMPLENR, 97},
{596*OVERSAMPLENR, 95},
{613*OVERSAMPLENR, 92},
{630*OVERSAMPLENR, 90},
{647*OVERSAMPLENR, 88},
{664*OVERSAMPLENR, 86},
{681*OVERSAMPLENR, 84},
{698*OVERSAMPLENR, 81},
{715*OVERSAMPLENR, 79},
{732*OVERSAMPLENR, 77},
{749*OVERSAMPLENR, 75},
{766*OVERSAMPLENR, 72},
{783*OVERSAMPLENR, 70},
{800*OVERSAMPLENR, 67},
{817*OVERSAMPLENR, 64},
{834*OVERSAMPLENR, 61},
{851*OVERSAMPLENR, 58},
{868*OVERSAMPLENR, 55},
{885*OVERSAMPLENR, 52},
{902*OVERSAMPLENR, 48},
{919*OVERSAMPLENR, 44},
{936*OVERSAMPLENR, 40},
{953*OVERSAMPLENR, 34},
{970*OVERSAMPLENR, 28},
{987*OVERSAMPLENR, 20},
{1004*OVERSAMPLENR, 8},
{1021*OVERSAMPLENR, 0}
};

endif

if (THERMISTORHEATER_0 == 6) || (THERMISTORHEATER_1 == 6) || (THERMISTORHEATER_2 == 6) || (THERMISTORBED == 6) // 100k Epcos thermistor

const short temptable_6[][2] PROGMEM = {
{28*OVERSAMPLENR, 250},
{31*OVERSAMPLENR, 245},
{35*OVERSAMPLENR, 240},
{39*OVERSAMPLENR, 235},
{42*OVERSAMPLENR, 230},
{44*OVERSAMPLENR, 225},
{49*OVERSAMPLENR, 220},
{53*OVERSAMPLENR, 215},
{62*OVERSAMPLENR, 210},
{73*OVERSAMPLENR, 205},
{72*OVERSAMPLENR, 200},
{94*OVERSAMPLENR, 190},
{102*OVERSAMPLENR, 185},
{116*OVERSAMPLENR, 170},
{143*OVERSAMPLENR, 160},
{183*OVERSAMPLENR, 150},
{223*OVERSAMPLENR, 140},
{270*OVERSAMPLENR, 130},
{318*OVERSAMPLENR, 120},
{383*OVERSAMPLENR, 110},
{413*OVERSAMPLENR, 105},
{439*OVERSAMPLENR, 100},
{484*OVERSAMPLENR, 95},
{513*OVERSAMPLENR, 90},
{607*OVERSAMPLENR, 80},
{664*OVERSAMPLENR, 70},
{781*OVERSAMPLENR, 60},
{810*OVERSAMPLENR, 55},
{849*OVERSAMPLENR, 50},
{914*OVERSAMPLENR, 45},
{914*OVERSAMPLENR, 40},
{935*OVERSAMPLENR, 35},
{954*OVERSAMPLENR, 30},
{970*OVERSAMPLENR, 25},
{978*OVERSAMPLENR, 22},
{1008*OVERSAMPLENR, 3}
};

endif

if (THERMISTORHEATER_0 == 7) || (THERMISTORHEATER_1 == 7) || (THERMISTORHEATER_2 == 7) || (THERMISTORBED == 7) // 100k Honeywell 135-104LAG-J01

const short temptable_7[][2] PROGMEM = {
{46*OVERSAMPLENR, 270},
{50*OVERSAMPLENR, 265},
{54*OVERSAMPLENR, 260},
{58*OVERSAMPLENR, 255},
{62*OVERSAMPLENR, 250},
{67*OVERSAMPLENR, 245},
{72*OVERSAMPLENR, 240},
{79*OVERSAMPLENR, 235},
{85*OVERSAMPLENR, 230},
{91*OVERSAMPLENR, 225},
{99*OVERSAMPLENR, 220},
{107*OVERSAMPLENR, 215},
{116*OVERSAMPLENR, 210},
{126*OVERSAMPLENR, 205},
{136*OVERSAMPLENR, 200},
{149*OVERSAMPLENR, 195},
{160*OVERSAMPLENR, 190},
{175*OVERSAMPLENR, 185},
{191*OVERSAMPLENR, 180},
{209*OVERSAMPLENR, 175},
{224*OVERSAMPLENR, 170},
{246*OVERSAMPLENR, 165},
{267*OVERSAMPLENR, 160},
{293*OVERSAMPLENR, 155},
{316*OVERSAMPLENR, 150},
{340*OVERSAMPLENR, 145},
{364*OVERSAMPLENR, 140},
{396*OVERSAMPLENR, 135},
{425*OVERSAMPLENR, 130},
{460*OVERSAMPLENR, 125},
{489*OVERSAMPLENR, 120},
{526*OVERSAMPLENR, 115},
{558*OVERSAMPLENR, 110},
{591*OVERSAMPLENR, 105},
{628*OVERSAMPLENR, 100},
{660*OVERSAMPLENR, 95},
{696*OVERSAMPLENR, 90},
{733*OVERSAMPLENR, 85},
{761*OVERSAMPLENR, 80},
{794*OVERSAMPLENR, 75},
{819*OVERSAMPLENR, 70},
{847*OVERSAMPLENR, 65},
{870*OVERSAMPLENR, 60},
{892*OVERSAMPLENR, 55},
{911*OVERSAMPLENR, 50},
{929*OVERSAMPLENR, 45},
{944*OVERSAMPLENR, 40},
{959*OVERSAMPLENR, 35},
{971*OVERSAMPLENR, 30},
{981*OVERSAMPLENR, 25},
{989*OVERSAMPLENR, 20},
{994*OVERSAMPLENR, 15},
{1001*OVERSAMPLENR, 10},
{1005*OVERSAMPLENR, 5}
};

endif

define TT_NAME(_N) temptable ## _N

define TT_NAME(_N) _TT_NAME(_N)

ifdef THERMISTORHEATER_0

#define heater_0_temptable TT_NAME(THERMISTORHEATER_0)
#define heater_0_temptable_len (sizeof(heater_0_temptable)/sizeof(*heater_0_temptable))

else

ifdef HEATER_0_USES_THERMISTOR

#error No heater 0 thermistor table specified

else // HEATER_0_USES_THERMISTOR

#define heater_0_temptable 0
#define heater_0_temptable_len 0

endif // HEATER_0_USES_THERMISTOR

endif

ifdef THERMISTORHEATER_1

#define heater_1_temptable TT_NAME(THERMISTORHEATER_1)
#define heater_1_temptable_len (sizeof(heater_1_temptable)/sizeof(*heater_1_temptable))

else

ifdef HEATER_1_USES_THERMISTOR

#error No heater 1 thermistor table specified

else // HEATER_1_USES_THERMISTOR

#define heater_1_temptable 0
#define heater_1_temptable_len 0

endif // HEATER_1_USES_THERMISTOR

endif

ifdef THERMISTORHEATER_2

#define heater_2_temptable TT_NAME(THERMISTORHEATER_2)
#define heater_2_temptable_len (sizeof(heater_2_temptable)/sizeof(*heater_2_temptable))

else

ifdef HEATER_2_USES_THERMISTOR

#error No heater 2 thermistor table specified

else // HEATER_2_USES_THERMISTOR

#define heater_2_temptable 0
#define heater_2_temptable_len 0

endif // HEATER_2_USES_THERMISTOR

endif

ifdef THERMISTORBED

#define bedtemptable TT_NAME(THERMISTORBED)
#define bedtemptable_len (sizeof(bedtemptable)/sizeof(*bedtemptable))

else

ifdef BED_USES_THERMISTOR

#error No bed thermistor table specified

endif // BED_USES_THERMISTOR

endif

endif //THERMISTORTABLES_H_

include "thermistortables.h"

define X_STEP_PIN 54

define X_DIR_PIN 55

define X_ENABLE_PIN 38

define X_MIN_PIN 3

define X_MAX_PIN 2

define Y_STEP_PIN 60

define Y_DIR_PIN 61

define Y_ENABLE_PIN 56

define Y_MIN_PIN 14

define Y_MAX_PIN 15

define Z_STEP_PIN 46

define Z_DIR_PIN 48

define Z_ENABLE_PIN 62

define Z_MIN_PIN 18

define Z_MAX_PIN 19

define E_STEP_PIN 26

define E_DIR_PIN 28

define E_ENABLE_PIN 24

define Q_STEP_PIN 36

define Q_DIR_PIN 34

define Q_ENABLE_PIN 30

define SDPOWER -1

define EXTRUDERS 3

define TEMP_SENSOR_AD595_OFFSET 0.0

define TEMP_SENSOR_AD595_GAIN 1.0

define THERMISTORHEATER_0 1

define THERMISTORHEATER_1 1

define THERMISTORHEATER_2 1

define HEATER_0_USES_THERMISTOR 1

define HEATER_1_USES_THERMISTOR 1

define HEATER_2_USES_THERMISTOR 1

static void *heater_ttbl_map[EXTRUDERS] = { (void *)heater_0_temptable

if EXTRUDERS > 1

                                       , (void *)heater_1_temptable

endif

if EXTRUDERS > 2

                                       , (void *)heater_2_temptable

endif

if EXTRUDERS > 3

#error Unsupported number of extruders

endif

};

static int heater_ttbllen_map[EXTRUDERS] = { heater_0_temptable_len

if EXTRUDERS > 1

                                        , heater_1_temptable_len

endif

if EXTRUDERS > 2

                                        , heater_2_temptable_len

endif

if EXTRUDERS > 3

#error Unsupported number of extruders

endif

};

#define PGM_RD_W(x) (short)pgm_read_word(&x)

define SDSS 53

define LED_PIN 13

define FAN_PIN 9

define PS_ON_PIN 12

define KILL_PIN -1

define HEATER_0_PIN 10

define HEATER_1_PIN 8

define TEMP_0_PIN 15 // ANALOG NUMBERING

define TEMP_1_PIN 14 // ANALOG NUMBERING

define TEMP_2_PIN 13 // ANALOG NUMBERING

void setup() {

pinMode(TEMP_0_PIN , INPUT);

pinMode(TEMP_1_PIN , INPUT);

pinMode(TEMP_2_PIN , INPUT);

pinMode(FAN_PIN , OUTPUT);

pinMode(HEATER_0_PIN , OUTPUT);

pinMode(HEATER_1_PIN , OUTPUT);

pinMode(LED_PIN , OUTPUT);

pinMode(X_STEP_PIN , OUTPUT);

pinMode(X_DIR_PIN , OUTPUT);

pinMode(X_ENABLE_PIN , OUTPUT);

pinMode(Y_STEP_PIN , OUTPUT);

pinMode(Y_DIR_PIN , OUTPUT);

pinMode(Y_ENABLE_PIN , OUTPUT);

pinMode(Z_STEP_PIN , OUTPUT);

pinMode(Z_DIR_PIN , OUTPUT);

pinMode(Z_ENABLE_PIN , OUTPUT);

pinMode(E_STEP_PIN , OUTPUT);

pinMode(E_DIR_PIN , OUTPUT);

pinMode(E_ENABLE_PIN , OUTPUT);

pinMode(Q_STEP_PIN , OUTPUT);

pinMode(Q_DIR_PIN , OUTPUT);

pinMode(Q_ENABLE_PIN , OUTPUT);

digitalWrite(X_ENABLE_PIN , LOW);

digitalWrite(Y_ENABLE_PIN , LOW);

digitalWrite(Z_ENABLE_PIN , LOW);

digitalWrite(E_ENABLE_PIN , LOW);

digitalWrite(Q_ENABLE_PIN , LOW);

Serial.begin(115200);

}

float analog2temp(int raw, uint8_t e) {

#ifdef HEATER_0_USES_MAX6675

if (e == 0)

{

 return 0.25 * raw;

}

#endif

if(heater_ttbl_map[e] != 0)

{

float celsius = 0;

byte i;

short (tt)[][2] = (short ()[][2])(heater_ttbl_map[e]);

raw = (1023 * OVERSAMPLENR) - raw;

for (i=1; i<heater_ttbllen_map[e]; i++)

{

 if ((PGM_RD_W((*tt)[i][0]) > raw) && ((float)(PGM_RD_W((*tt)[i][0]) - PGM_RD_W((*tt)[i-1][0])) >0))

 {

   celsius = PGM_RD_W((*tt)[i-1][1]) +

     (raw - PGM_RD_W((*tt)[i-1][0])) *

     (float)(PGM_RD_W((*tt)[i][1]) - PGM_RD_W((*tt)[i-1][1])) /

     (float)(PGM_RD_W((*tt)[i][0]) - PGM_RD_W((*tt)[i-1][0]));

   break;

 }

}

// Overflow: Set to last value in the table

if (i == heater_ttbllen_map[e]) celsius = PGM_RD_W((*tt)[i-1][1]);

return celsius;

}

return ((raw * ((5.0 * 100.0) / 1024.0) / OVERSAMPLENR) * TEMP_SENSOR_AD595_GAIN) + TEMP_SENSOR_AD595_OFFSET;

}

unsigned long prevMillis;

void loop () {

if (millis() %1000 <500)

digitalWrite(LED_PIN, HIGH);

else

digitalWrite(LED_PIN, LOW);

if (millis() %1000 <300) {

digitalWrite(HEATER_0_PIN, HIGH);

digitalWrite(HEATER_1_PIN, LOW);

digitalWrite(FAN_PIN, LOW);

} else if (millis() %1000 <600) {

digitalWrite(HEATER_0_PIN, LOW);

digitalWrite(HEATER_1_PIN, HIGH);

digitalWrite(FAN_PIN, LOW);

} else {

digitalWrite(HEATER_0_PIN, LOW);

digitalWrite(HEATER_1_PIN, LOW);

digitalWrite(FAN_PIN, HIGH);

}

if (millis() %2000 <1000) {

digitalWrite(X_DIR_PIN , HIGH);

digitalWrite(Y_DIR_PIN , HIGH);

digitalWrite(Z_DIR_PIN , HIGH);

digitalWrite(E_DIR_PIN , HIGH);

digitalWrite(Q_DIR_PIN , HIGH);

}

else {

digitalWrite(X_DIR_PIN , LOW);

digitalWrite(Y_DIR_PIN , LOW);

digitalWrite(Z_DIR_PIN , LOW);

digitalWrite(E_DIR_PIN , LOW);

digitalWrite(Q_DIR_PIN , LOW);

}

digitalWrite(X_STEP_PIN , HIGH);

digitalWrite(Y_STEP_PIN , HIGH);

digitalWrite(Z_STEP_PIN , HIGH);

digitalWrite(E_STEP_PIN , HIGH);

digitalWrite(Q_STEP_PIN , HIGH);

delay(1);

digitalWrite(X_STEP_PIN , LOW);

digitalWrite(Y_STEP_PIN , LOW);

digitalWrite(Z_STEP_PIN , LOW);

digitalWrite(E_STEP_PIN , LOW);

digitalWrite(Q_STEP_PIN , LOW);

if (millis() -prevMillis >500){

prevMillis=millis();

int t = analogRead( TEMP_0_PIN);

Serial.print("T0 ");

Serial.print(t);

Serial.print("/");

Serial.print(analog2temp(1024 - t,0),0);

Serial.print(" T1 ");

t = analogRead( TEMP_1_PIN);

Serial.print(t);

Serial.print("/");

Serial.print(analog2temp(1024 - t,1),0);

Serial.print(" T2 ");

t = analogRead( TEMP_2_PIN);

Serial.print(t);

Serial.print("/");

Serial.println(analog2temp(1024 - t,2),0);

}

}
/***

Required libraries:
Arduino_GFX: https://github.com/moononournation/Arduino_GFX.git
libhelix: https://github.com/pschatzmann/arduino-libhelix.git
JPEGDEC: https://github.com/bitbank2/JPEGDEC.git */

// auto fall back to MP3 if AAC file not available

define AAC_FILENAME "/44100.aac"

define MP3_FILENAME "/44100.mp3"

// #define MJPEG_FILENAME "/288_30fps.mjpeg"
// #define MJPEG_FILENAME "/320_30fps.mjpeg"

define MJPEG_FILENAME "/480_15fps.mjpeg"

// #define MJPEG_FILENAME "/480_30fps.mjpeg"

define FPS 15

// #define FPS 30
// #define MJPEG_BUFFER_SIZE (288 * 240 * 2 / 8)
// #define MJPEG_BUFFER_SIZE (320 * 240 * 2 / 8)

define MJPEG_BUFFER_SIZE (480 * 270 * 2 / 8)

define AUDIOASSIGNCORE 1

define DECODEASSIGNCORE 0

define DRAWASSIGNCORE 1

define SDMMC_D3 10 // SDMMC Data3 / SPI CS

define SDMMC_CMD 11 // SDMMC CMD / SPI MOSI

define SDMMC_CLK 12 // SDMMC CLK / SPI SCK

define SDMMC_D0 13 // SDMMC Data0 / SPI MISO

include

/*******************************************************************************

Start of Arduino_GFX setting ***************************************************************************/ #include #define GFX_BL 2 Arduino_DataBus *bus = new Arduino_ESP32LCD16( 48 / DC /, 45 / CS /, 47 / WR /, 21 / RD /, 5 / D0 /, 6 / D1 /, 7 / D2 /, 15 / D3 /, 16 / D4 /, 4 / D5 /, 8 / D6 /, 3 / D7 /, 46 / D8 /, 9 / D9 /, 1 / D10 /, 42 / D11 /, 39 / D12 /, 41 / D13 /, 40 / D14 /, 14 / D15 /); Arduino_GFX *gfx = new Arduino_NV3041A(bus, 17 / RST /, 0 / rotation /, true / IPS */); /*****************************************************************************
End of Arduino_GFX setting ******************************************************************************/

/* variables */
static int next_frame = 0;
static int skipped_frames = 0;
static unsigned long start_ms, curr_ms, next_frame_ms;

/* audio */

include "esp32_audio_task.h"

/* MJPEG Video */

include "mjpeg_decode_draw_task.h"

// pixel drawing callback
static int drawMCU(JPEGDRAW pDraw)
{
// Serial.printf("Draw pos = (%d, %d), size = %d x %d\n", pDraw->x, pDraw->y, pDraw->iWidth, pDraw->iHeight);
unsigned long s = millis();
gfx->draw16bitRGBBitmap(pDraw->x, pDraw->y, pDraw->pPixels, pDraw->iWidth, pDraw->iHeight);
total_show_video_ms += millis() - s;
return 1;
} / drawMCU() */

void setup()
{
WiFi.mode(WIFI_OFF);

Serial.begin(115200);
// Serial.setDebugOutput(true);
// while(!Serial);
Serial.println("ESP32_4827A043");

ifdef GFX_EXTRA_PRE_INIT

GFX_EXTRA_PRE_INIT();

endif

Serial.println("Init display");
if (!gfx->begin())
{
Serial.println("Init display failed!");
}
gfx->fillScreen(BLACK);

ifdef GFX_BL

pinMode(GFX_BL, OUTPUT);
digitalWrite(GFX_BL, HIGH);

endif

Serial.println("Init I2S");
gfx->println("Init I2S");
esp_err_t ret_val = i2s_init(I2S_NUM_0, 44100, -1 /* MCLK /, 19 / SCLK /, 18 / LRCK /, 17 / DOUT /, -1 / DIN */);
if (ret_val != ESP_OK)
{
Serial.printf("i2s_init failed: %d\n", ret_val);
}
i2s_zero_dma_buffer(I2S_NUM_0);

Serial.println("Init FS");
gfx->println("Init FS");
// if (!LittleFS.begin(false, "/root"))
// if (!SPIFFS.begin(false, "/root"))
if (!FFat.begin(false, "/root"))

// SPIClass spi = SPIClass(HSPI);
// spi.begin(SDMMC_CLK, SDMMC_D0 /* MISO /, SDMMC_CMD / MOSI /, SDMMC_D3 / SS /);
// if (!SD.begin(SDMMC_D3 / SS */, spi, 80000000))

// pinMode(SDMMC_D3 /* CS /, OUTPUT);
// digitalWrite(SDMMC_D3 / CS /, HIGH);
// SD_MMC.setPins(SDMMC_CLK, SDMMC_CMD, SDMMC_D0);
// if (!SD_MMC.begin("/root", true)) / 1-bit SD bus mode */
{
Serial.println("ERROR: File system mount failed!");
gfx->println("ERROR: File system mount failed!");
}
else
{
bool aac_file_available = false;
Serial.println("Open AAC file: " AAC_FILENAME);
gfx->println("Open AAC file: " AAC_FILENAME);
// File aFile = LittleFS.open(AAC_FILENAME);
// File aFile = SPIFFS.open(AAC_FILENAME);
File aFile = FFat.open(AAC_FILENAME);
// File aFile = SD.open(AAC_FILENAME);
// File aFile = SD_MMC.open(AAC_FILENAME);
if (aFile)
{
aac_file_available = true;
}
else
{
Serial.println("Open MP3 file: " MP3_FILENAME);
gfx->println("Open MP3 file: " MP3_FILENAME);
// aFile = LittleFS.open(MP3_FILENAME);
// aFile = SPIFFS.open(MP3_FILENAME);
aFile = FFat.open(MP3_FILENAME);
// aFile = SD.open(MP3_FILENAME);
// aFile = SD_MMC.open(MP3_FILENAME);
}

if (!aFile || aFile.isDirectory())
{
  Serial.println("ERROR: Failed to open " AAC_FILENAME " or " MP3_FILENAME " file for reading");
  gfx->println("ERROR: Failed to open " AAC_FILENAME " or " MP3_FILENAME " file for reading");
}
else
{
  Serial.println("Open MJPEG file: " MJPEG_FILENAME);
  gfx->println("Open MJPEG file: " MJPEG_FILENAME);
  // File vFile = LittleFS.open(MJPEG_FILENAME);
  // File vFile = SPIFFS.open(MJPEG_FILENAME);
  File vFile = FFat.open(MJPEG_FILENAME);
  // File vFile = SD.open(MJPEG_FILENAME);
  // File vFile = SD_MMC.open(MJPEG_FILENAME);
  if (!vFile || vFile.isDirectory())
  {
    Serial.println("ERROR: Failed to open " MJPEG_FILENAME " file for reading");
    gfx->println("ERROR: Failed to open " MJPEG_FILENAME " file for reading");
  }
  else
  {
    Serial.println("Init video");
    gfx->println("Init video");
    mjpeg_setup(&vFile, MJPEG_BUFFER_SIZE, drawMCU,
                false /* useBigEndian */, DECODEASSIGNCORE, DRAWASSIGNCORE);

    Serial.println("Start play audio task");
    gfx->println("Start play audio task");
    BaseType_t ret_val;
    if (aac_file_available)
    {
      ret_val = aac_player_task_start(&aFile, AUDIOASSIGNCORE);
    }
    else
    {
      ret_val = mp3_player_task_start(&aFile, AUDIOASSIGNCORE);
    }
    if (ret_val != pdPASS)
    {
      Serial.printf("Audio player task start failed: %d\n", ret_val);
      gfx->printf("Audio player task start failed: %d\n", ret_val);
    }

    Serial.println("Start play video");
    gfx->println("Start play video");
    start_ms = millis();
    curr_ms = millis();
    next_frame_ms = start_ms + (++next_frame * 1000 / FPS / 2);
    while (vFile.available() && mjpeg_read_frame()) // Read video
    {
      total_read_video_ms += millis() - curr_ms;
      curr_ms = millis();

      if (millis() < next_frame_ms) // check show frame or skip frame
      {
        // Play video
        mjpeg_draw_frame();
        total_decode_video_ms += millis() - curr_ms;
        curr_ms = millis();
      }
      else
      {
        ++skipped_frames;
        Serial.println("Skip frame");
      }

      while (millis() < next_frame_ms)
      {
        vTaskDelay(pdMS_TO_TICKS(1));
      }

      curr_ms = millis();
      next_frame_ms = start_ms + (++next_frame * 1000 / FPS);
    }
    int time_used = millis() - start_ms;
    int total_frames = next_frame - 1;
    Serial.println("AV end");
    vFile.close();
    aFile.close();

    delay(200);

    int played_frames = total_frames - skipped_frames;
    float fps = 1000.0 * played_frames / time_used;
    total_decode_audio_ms -= total_play_audio_ms;
    // total_decode_video_ms -= total_show_video_ms;
    Serial.printf("Played frames: %d\n", played_frames);
    Serial.printf("Skipped frames: %d (%0.1f %%)\n", skipped_frames, 100.0 * skipped_frames / total_frames);
    Serial.printf("Time used: %d ms\n", time_used);
    Serial.printf("Expected FPS: %d\n", FPS);
    Serial.printf("Actual FPS: %0.1f\n", fps);
    Serial.printf("Read audio: %lu ms (%0.1f %%)\n", total_read_audio_ms, 100.0 * total_read_audio_ms / time_used);
    Serial.printf("Decode audio: %lu ms (%0.1f %%)\n", total_decode_audio_ms, 100.0 * total_decode_audio_ms / time_used);
    Serial.printf("Play audio: %lu ms (%0.1f %%)\n", total_play_audio_ms, 100.0 * total_play_audio_ms / time_used);
    Serial.printf("Read video: %lu ms (%0.1f %%)\n", total_read_video_ms, 100.0 * total_read_video_ms / time_used);
    Serial.printf("Decode video: %lu ms (%0.1f %%)\n", total_decode_video_ms, 100.0 * total_decode_video_ms / time_used);
    Serial.printf("Show video: %lu ms (%0.1f %%)\n", total_show_video_ms, 100.0 * total_show_video_ms / time_used);

define CHART_MARGIN 64

define LEGEND_A_COLOR 0x1BB6

define LEGEND_B_COLOR 0xFBE1

define LEGEND_C_COLOR 0x2D05

define LEGEND_D_COLOR 0xD125

define LEGEND_E_COLOR 0x9337

define LEGEND_F_COLOR 0x8AA9

define LEGEND_G_COLOR 0xE3B8

define LEGEND_H_COLOR 0x7BEF

define LEGEND_I_COLOR 0xBDE4

define LEGEND_J_COLOR 0x15F9

    // gfx->setCursor(0, 0);
    gfx->setTextColor(WHITE);
    gfx->printf("Played frames: %d\n", played_frames);
    gfx->printf("Skipped frames: %d (%0.1f %%)\n", skipped_frames, 100.0 * skipped_frames / total_frames);
    gfx->printf("Time used: %d ms\n", time_used);
    gfx->printf("Expected FPS: %d\n", FPS);
    gfx->printf("Actual FPS: %0.1f\n\n", fps);

    int16_t r1 = ((gfx->height() - CHART_MARGIN - CHART_MARGIN) / 2);
    int16_t r2 = r1 / 2;
    int16_t cx = gfx->width() - r1 - 10;
    int16_t cy = r1 + CHART_MARGIN;

    float arc_start1 = 0;
    float arc_end1 = arc_start1 + max(2.0, 360.0 * total_read_audio_ms / time_used);
    for (int i = arc_start1 + 1; i < arc_end1; i += 2)
    {
      gfx->fillArc(cx, cy, r1, r2, arc_start1 - 90.0, i - 90.0, LEGEND_A_COLOR);
    }
    gfx->fillArc(cx, cy, r1, r2, arc_start1 - 90.0, arc_end1 - 90.0, LEGEND_A_COLOR);
    gfx->setTextColor(LEGEND_A_COLOR);
    gfx->printf("Read audio: %lu ms (%0.1f %%)\n", total_read_audio_ms, 100.0 * total_read_audio_ms / time_used);

    float arc_start2 = arc_end1;
    float arc_end2 = arc_start2 + max(2.0, 360.0 * total_decode_audio_ms / time_used);
    for (int i = arc_start2 + 1; i < arc_end2; i += 2)
    {
      gfx->fillArc(cx, cy, r1, r2, arc_start2 - 90.0, i - 90.0, LEGEND_B_COLOR);
    }
    gfx->fillArc(cx, cy, r1, r2, arc_start2 - 90.0, arc_end2 - 90.0, LEGEND_B_COLOR);
    gfx->setTextColor(LEGEND_B_COLOR);
    gfx->printf("Decode audio: %lu ms (%0.1f %%)\n", total_decode_audio_ms, 100.0 * total_decode_audio_ms / time_used);
    gfx->setTextColor(LEGEND_J_COLOR);
    gfx->printf("Play audio: %lu ms (%0.1f %%)\n", total_play_audio_ms, 100.0 * total_play_audio_ms / time_used);

    float arc_start3 = arc_end2;
    float arc_end3 = arc_start3 + max(2.0, 360.0 * total_read_video_ms / time_used);
    for (int i = arc_start3 + 1; i < arc_end3; i += 2)
    {
      gfx->fillArc(cx, cy, r1, r2, arc_start3 - 90.0, i - 90.0, LEGEND_C_COLOR);
    }
    gfx->fillArc(cx, cy, r1, r2, arc_start3 - 90.0, arc_end3 - 90.0, LEGEND_C_COLOR);
    gfx->setTextColor(LEGEND_C_COLOR);
    gfx->printf("Read video: %lu ms (%0.1f %%)\n", total_read_video_ms, 100.0 * total_read_video_ms / time_used);

    float arc_start4 = arc_end3;
    float arc_end4 = arc_start4 + max(2.0, 360.0 * total_show_video_ms / time_used);
    for (int i = arc_start4 + 1; i < arc_end4; i += 2)
    {
      gfx->fillArc(cx, cy, r1, r2, arc_start4 - 90.0, i - 90.0, LEGEND_D_COLOR);
    }
    gfx->fillArc(cx, cy, r1, r2, arc_start4 - 90.0, arc_end4 - 90.0, LEGEND_D_COLOR);
    gfx->setTextColor(LEGEND_D_COLOR);
    gfx->printf("Show video: %lu ms (%0.1f %%)\n", total_show_video_ms, 100.0 * total_show_video_ms / time_used);

    float arc_start5 = 0;
    float arc_end5 = arc_start5 + max(2.0, 360.0 * total_decode_video_ms / time_used);
    for (int i = arc_start5 + 1; i < arc_end5; i += 2)
    {
      gfx->fillArc(cx, cy, r2, 0, arc_start5 - 90.0, i - 90.0, LEGEND_E_COLOR);
    }
    gfx->fillArc(cx, cy, r2, 0, arc_start5 - 90.0, arc_end5 - 90.0, LEGEND_E_COLOR);
    gfx->setTextColor(LEGEND_E_COLOR);
    gfx->printf("Decode video: %lu ms (%0.1f %%)\n", total_decode_video_ms, 100.0 * total_decode_video_ms / time_used);
  }

  // delay(60000);

ifdef GFX_BL

  // digitalWrite(GFX_BL, LOW);

endif

  // gfx->displayOff();
  // esp_deep_sleep_start();
}

}
}

void loop()
{
}

include "driver/i2s.h"

include "AACDecoderHelix.h"

include "MP3DecoderHelix.h"

define GAIN_LEVEL 0.8

static unsigned long total_read_audio_ms = 0;
static unsigned long total_decode_audio_ms = 0;
static unsigned long total_play_audio_ms = 0;

static i2s_port_t _i2s_num;
static esp_err_t i2s_init(i2s_port_t i2s_num, uint32_t sample_rate,
int mck_io_num, /!< MCK in out pin. Note that ESP32 supports setting MCK on GPIO0/GPIO1/GPIO3 only/
int bck_io_num, /!< BCK in out pin/
int ws_io_num, /!< WS in out pin/
int data_out_num, /!< DATA out pin/
int data_in_num /!< DATA in pin/
)
{
_i2s_num = i2s_num;

esp_err_t ret_val = ESP_OK;

i2s_config_t i2s_config;
i2s_config.mode = (i2s_mode_t)(I2S_MODE_MASTER | I2S_MODE_TX);
i2s_config.sample_rate = sample_rate;
i2s_config.bits_per_sample = I2S_BITS_PER_SAMPLE_16BIT;
i2s_config.channel_format = I2S_CHANNEL_FMT_RIGHT_LEFT;
i2s_config.communication_format = I2S_COMM_FORMAT_STAND_I2S;
i2s_config.intr_alloc_flags = ESP_INTR_FLAG_LEVEL1;
i2s_config.dma_buf_count = 8;
i2s_config.dma_buf_len = 160;
i2s_config.use_apll = false;
i2s_config.tx_desc_auto_clear = true;
i2s_config.fixed_mclk = 0;
i2s_config.mclk_multiple = I2S_MCLK_MULTIPLE_DEFAULT;
i2s_config.bits_per_chan = I2S_BITS_PER_CHAN_16BIT;

i2s_pin_config_t pin_config;
pin_config.mck_io_num = mck_io_num;
pin_config.bck_io_num = bck_io_num;
pin_config.ws_io_num = ws_io_num;
pin_config.data_out_num = data_out_num;
pin_config.data_in_num = data_in_num;

ret_val |= i2s_driver_install(i2s_num, &i2s_config, 0, NULL);
ret_val |= i2s_set_pin(i2s_num, &pin_config);

return ret_val;
}

static int _samprate = 0;
static void aacAudioDataCallback(AACFrameInfo &info, int16_t pwm_buffer, size_t len, void)
{
unsigned long s = millis();
if (_samprate != info.sampRateOut)
{
// log_i("bitRate: %d, nChans: %d, sampRateCore: %d, sampRateOut: %d, bitsPerSample: %d, outputSamps: %d, profile: %d, tnsUsed: %d, pnsUsed: %d",
// info.bitRate, info.nChans, info.sampRateCore, info.sampRateOut, info.bitsPerSample, info.outputSamps, info.profile, info.tnsUsed, info.pnsUsed);
i2s_set_clk(_i2s_num, info.sampRateOut /* sample_rate /, info.bitsPerSample / bits_cfg /, (info.nChans == 2) ? I2S_CHANNEL_STEREO : I2S_CHANNEL_MONO / channel /);
_samprate = info.sampRateOut;
}
size_t i2s_bytes_written = 0;
for (int i = 0; i < len; i++)
{
pwm_buffer[i] = pwm_buffer[i] * GAIN_LEVEL;
}
i2s_write(_i2s_num, pwm_buffer, len * 2, &i2s_bytes_written, portMAX_DELAY);
// log_i("len: %d, i2s_bytes_written: %d", len, i2s_bytes_written);
total_play_audio_ms += millis() - s;
}
static void mp3AudioDataCallback(MP3FrameInfo &info, int16_t *pwm_buffer, size_t len, void)
{
unsigned long s = millis();
if (_samprate != info.samprate)
{
log_i("bitrate: %d, nChans: %d, samprate: %d, bitsPerSample: %d, outputSamps: %d, layer: %d, version: %d",
info.bitrate, info.nChans, info.samprate, info.bitsPerSample, info.outputSamps, info.layer, info.version);
i2s_set_clk(_i2s_num, info.samprate /* sample_rate /, info.bitsPerSample / bits_cfg /, (info.nChans == 2) ? I2S_CHANNEL_STEREO : I2S_CHANNEL_MONO / channel */);
_samprate = info.samprate;
}
size_t i2s_bytes_written = 0;
for (int i = 0; i < len; i++)
{
pwm_buffer[i] = pwm_buffer[i] * GAIN_LEVEL;
}
i2s_write(_i2s_num, pwm_buffer, len * 2, &i2s_bytes_written, portMAX_DELAY);
// log_i("len: %d, i2s_bytes_written: %d", len, i2s_bytes_written);
total_play_audio_ms += millis() - s;
}

static uint8_t _frame[MP3_MAX_FRAME_SIZE]; // MP3_MAX_FRAME_SIZE is smaller, so always use MP3_MAX_FRAME_SIZE

static libhelix::AACDecoderHelix _aac(aacAudioDataCallback);
static void aac_player_task(void *pvParam)
{
Stream *input = (Stream *)pvParam;

int r, w;
unsigned long ms = millis();
while (r = input->readBytes(_frame, MP3_MAX_FRAME_SIZE))
{
total_read_audio_ms += millis() - ms;
ms = millis();

while (r > 0)
{
  w = _aac.write(_frame, r);
  // log_i("r: %d, w: %d\n", r, w);
  r -= w;
}
total_decode_audio_ms += millis() - ms;
ms = millis();

}
log_i("AAC stop.");

vTaskDelete(NULL);
}

static libhelix::MP3DecoderHelix _mp3(mp3AudioDataCallback);
static void mp3_player_task(void *pvParam)
{
Stream *input = (Stream *)pvParam;

int r, w;
unsigned long ms = millis();
while (r = input->readBytes(_frame, MP3_MAX_FRAME_SIZE))
{
total_read_audio_ms += millis() - ms;
ms = millis();

while (r > 0)
{
  w = _mp3.write(_frame, r);
  // log_i("r: %d, w: %d\n", r, w);
  r -= w;
}
total_decode_audio_ms += millis() - ms;
ms = millis();

}
log_i("MP3 stop.");

vTaskDelete(NULL);
}

static BaseType_t aac_player_task_start(Stream *input, BaseType_t audioAssignCore)
{
_aac.begin();

return xTaskCreatePinnedToCore(
(TaskFunction_t)aac_player_task,
(const char *const)"AAC Player Task",
(const uint32_t)2000,
(void *const)input,
(UBaseType_t)configMAX_PRIORITIES - 1,
(TaskHandle_t *const)NULL,
(const BaseType_t)audioAssignCore);
}

static BaseType_t mp3_player_task_start(Stream *input, BaseType_t audioAssignCore)
{
_mp3.begin();

return xTaskCreatePinnedToCore(
(TaskFunction_t)mp3_player_task,
(const char *const)"MP3 Player Task",
(const uint32_t)2000,
(void *const)input,
(UBaseType_t)configMAX_PRIORITIES - 1,
(TaskHandle_t *const)NULL,
(const BaseType_t)audioAssignCore);
}

define READ_BUFFER_SIZE 1024

define MAXOUTPUTSIZE (MAX_BUFFERED_PIXELS / 16 / 16)

// #define MAXOUTPUTSIZE (480 / 4 / 16)

define NUMBER_OF_DECODE_BUFFER 3

define NUMBER_OF_DRAW_BUFFER 9

include

typedef struct
{
int32_t size;
uint8_t *buf;
} mjpegBuf;

typedef struct
{
xQueueHandle xqh;
JPEG_DRAW_CALLBACK *drawFunc;
} paramDrawTask;

typedef struct
{
xQueueHandle xqh;
mjpegBuf *mBuf;
JPEG_DRAW_CALLBACK *drawFunc;
} paramDecodeTask;

static JPEGDRAW jpegdraws[NUMBER_OF_DRAW_BUFFER];
static int _draw_queue_cnt = 0;
static JPEGDEC _jpegDec;
static xQueueHandle _xqh;
static bool _useBigEndian;

static unsigned long total_read_video_ms = 0;
static unsigned long total_decode_video_ms = 0;
static unsigned long total_show_video_ms = 0;

Stream *_input;

int32_t _mjpegBufSize;

uint8_t *_read_buf;
int32_t _mjpeg_buf_offset = 0;

TaskHandle_t _decodeTask;
TaskHandle_t _draw_task;
paramDecodeTask _pDecodeTask;
paramDrawTask _pDrawTask;
uint8_t *_mjpeg_buf;
uint8_t _mBufIdx = 0;

int32_t _inputindex = 0;
int32_t _buf_read;
int32_t _remain = 0;
mjpegBuf _mjpegBufs[NUMBER_OF_DECODE_BUFFER];

static int queueDrawMCU(JPEGDRAW *pDraw)
{
int len = pDraw->iWidth * pDraw->iHeight * 2;
JPEGDRAW *j = &jpegdraws[_draw_queue_cnt % NUMBER_OF_DRAW_BUFFER];
j->x = pDraw->x;
j->y = pDraw->y;
j->iWidth = pDraw->iWidth;
j->iHeight = pDraw->iHeight;
memcpy(j->pPixels, pDraw->pPixels, len);

// log_i("queueDrawMCU start.");
++_draw_queue_cnt;
xQueueSend(_xqh, &j, portMAX_DELAY);
// log_i("queueDrawMCU end.");

return 1;
}

static void decode_task(void *arg)
{
paramDecodeTask *p = (paramDecodeTask *)arg;
mjpegBuf *mBuf;
log_i("decode_task start.");
while (xQueueReceive(p->xqh, &mBuf, portMAX_DELAY))
{
// log_i("mBuf->size: %d", mBuf->size);
// log_i("mBuf->buf start: %X %X, end: %X, %X.", mBuf->buf[0], mBuf->buf[1], mBuf->buf[mBuf->size - 2], mBuf->buf[mBuf->size - 1]);
unsigned long s = millis();

_jpegDec.openRAM(mBuf->buf, mBuf->size, p->drawFunc);

// _jpegDec.setMaxOutputSize(MAXOUTPUTSIZE);
if (_useBigEndian)
{
  _jpegDec.setPixelType(RGB565_BIG_ENDIAN);
}
_jpegDec.setMaxOutputSize(MAXOUTPUTSIZE);
_jpegDec.decode(0, 0, 0);
_jpegDec.close();

total_decode_video_ms += millis() - s;

}
vQueueDelete(p->xqh);
log_i("decode_task end.");
vTaskDelete(NULL);
}

static void draw_task(void *arg)
{
paramDrawTask *p = (paramDrawTask *)arg;
JPEGDRAW *pDraw;
log_i("draw_task start.");
while (xQueueReceive(p->xqh, &pDraw, portMAX_DELAY))
{
// log_i("draw_task work start: x: %d, y: %d, iWidth: %d, iHeight: %d.", pDraw->x, pDraw->y, pDraw->iWidth, pDraw->iHeight);
p->drawFunc(pDraw);
// log_i("draw_task work end.");
}
vQueueDelete(p->xqh);
log_i("draw_task end.");
vTaskDelete(NULL);
}

bool mjpeg_setup(Stream *input, int32_t mjpegBufSize, JPEG_DRAW_CALLBACK *pfnDraw,
bool useBigEndian, BaseType_t decodeAssignCore, BaseType_t drawAssignCore)
{
_input = input;
_mjpegBufSize = mjpegBufSize;
_useBigEndian = useBigEndian;

for (int i = 0; i < NUMBER_OF_DECODE_BUFFER; ++i)
{
_mjpegBufs[i].buf = (uint8_t *)malloc(mjpegBufSize);
if (_mjpegBufs[i].buf)
{
log_i("#%d decode buffer allocated.", i);
}
else
{
log_e("#%d decode buffer allocat failed.", i);
}
}
_mjpeg_buf = _mjpegBufs[_mBufIdx].buf;

if (!_read_buf)
{
_read_buf = (uint8_t *)malloc(READ_BUFFER_SIZE);
}
if (_read_buf)
{
log_i("Read buffer allocated.");
}

_xqh = xQueueCreate(NUMBER_OF_DRAW_BUFFER, sizeof(JPEGDRAW));
_pDrawTask.xqh = _xqh;
_pDrawTask.drawFunc = pfnDraw;
_pDecodeTask.xqh = xQueueCreate(NUMBER_OF_DECODE_BUFFER, sizeof(mjpegBuf));
_pDecodeTask.drawFunc = queueDrawMCU;

xTaskCreatePinnedToCore(
(TaskFunction_t)decode_task,
(const char *const)"MJPEG decode Task",
(const uint32_t)2000,
(void *const)&_pDecodeTask,
(UBaseType_t)configMAX_PRIORITIES - 1,
(TaskHandle_t *const)&_decodeTask,
(const BaseType_t)decodeAssignCore);
xTaskCreatePinnedToCore(
(TaskFunction_t)draw_task,
(const char *const)"MJPEG Draw Task",
(const uint32_t)2000,
(void *const)&_pDrawTask,
(UBaseType_t)configMAX_PRIORITIES - 1,
(TaskHandle_t *const)&_draw_task,
(const BaseType_t)drawAssignCore);

for (int i = 0; i < NUMBER_OF_DRAW_BUFFER; i++)
{
if (!jpegdraws[i].pPixels)
{
jpegdraws[i].pPixels = (uint16_t *)heap_caps_malloc(MAXOUTPUTSIZE * 16 * 16 * 2, MALLOC_CAP_DMA);
}
if (jpegdraws[i].pPixels)
{
log_i("#%d draw buffer allocated.", i);
}
else
{
log_e("#%d draw buffer allocat failed.", i);
}
}

return true;
}

bool mjpeg_read_frame()
{
if (_inputindex == 0)
{
_buf_read = _input->readBytes(_read_buf, READ_BUFFER_SIZE);
_inputindex += _buf_read;
}
_mjpeg_buf_offset = 0;
int i = 0;
bool found_FFD8 = false;
while ((_buf_read > 0) && (!found_FFD8))
{
i = 0;
while ((i < _buf_read) && (!found_FFD8))
{
if ((_read_buf[i] == 0xFF) && (_read_buf[i + 1] == 0xD8)) // JPEG header
{
// log_i("Found FFD8 at: %d.", i);
found_FFD8 = true;
}
++i;
}
if (found_FFD8)
{
--i;
}
else
{
_buf_read = _input->readBytes(_read_buf, READ_BUFFER_SIZE);
}
}
uint8_t *_p = _read_buf + i;
_buf_read -= i;
bool found_FFD9 = false;
if (_buf_read > 0)
{
i = 3;
while ((_buf_read > 0) && (!found_FFD9))
{
if ((_mjpeg_buf_offset > 0) && (_mjpeg_buf[_mjpeg_buf_offset - 1] == 0xFF) && (_p[0] == 0xD9)) // JPEG trailer
{
found_FFD9 = true;
}
else
{
while ((i < _buf_read) && (!found_FFD9))
{
if ((_p[i] == 0xFF) && (_p[i + 1] == 0xD9)) // JPEG trailer
{
found_FFD9 = true;
++i;
}
++i;
}
}

  // log_i("i: %d", i);
  memcpy(_mjpeg_buf + _mjpeg_buf_offset, _p, i);
  _mjpeg_buf_offset += i;
  int32_t o = _buf_read - i;
  if (o > 0)
  {
    // log_i("o: %d", o);
    memcpy(_read_buf, _p + i, o);
    _buf_read = _input->readBytes(_read_buf + o, READ_BUFFER_SIZE - o);
    _p = _read_buf;
    _inputindex += _buf_read;
    _buf_read += o;
    // log_i("_buf_read: %d", _buf_read);
  }
  else
  {
    _buf_read = _input->readBytes(_read_buf, READ_BUFFER_SIZE);
    _p = _read_buf;
    _inputindex += _buf_read;
  }
  i = 0;
}
if (found_FFD9)
{
  // log_i("Found FFD9 at: %d.", _mjpeg_buf_offset);
  if (_mjpeg_buf_offset > _mjpegBufSize)
  {
    log_e("_mjpeg_buf_offset(%d) > _mjpegBufSize (%d)", _mjpeg_buf_offset, _mjpegBufSize);
  }
  return true;
}

}

return false;
}

bool mjpeg_draw_frame()
{
mjpegBuf *mBuf = &_mjpegBufs[_mBufIdx];
mBuf->size = _mjpeg_buf_offset;
// log_i("_mjpegBufs[%d].size: %d.", _mBufIdx, _mjpegBufs[_mBufIdx].size);
// log_i("_mjpegBufs[%d].buf start: %X %X, end: %X, %X.", _mjpegBufs, _mjpegBufs[_mBufId].buf[0], _mjpegBufs[_mBufIdx].buf[1], _mjpegBufs[_mBufIdx].buf[_mjpeg_buf_offset - 2], _mjpegBufs[_mBufIdx].buf[_mjpeg_buf_offset - 1]);
xQueueSend(_pDecodeTask.xqh, &mBuf, portMAX_DELAY);
++_mBufIdx;
if (_mBufIdx >= NUMBER_OF_DECODE_BUFFER)
{
_mBufIdx = 0;
}
_mjpeg_buf = _mjpegBufs[_mBufIdx].buf;
// log_i("queue decode_task end");

return true;
}

portable console 3d printer

jay jordan — Mon, 25 Dec 2023 16:06:06 +0000

define X_STEP_PIN 54

define X_DIR_PIN 55

define X_ENABLE_PIN 38

define X_MIN_PIN 3

define X_MAX_PIN 2

define Y_STEP_PIN 60

define Y_DIR_PIN 61

define Y_ENABLE_PIN 56

define Y_MIN_PIN 14

define Y_MAX_PIN 15

define Z_STEP_PIN 46

define Z_DIR_PIN 48

define Z_ENABLE_PIN 62

define Z_MIN_PIN 18

define Z_MAX_PIN 19

define E_STEP_PIN 26

define E_DIR_PIN 28

define E_ENABLE_PIN 24

define Q_STEP_PIN 36

define Q_DIR_PIN 34

define Q_ENABLE_PIN 30

define SDPOWER -1

define SDSS 53

define LED_PIN 13

define FAN_PIN 9

define PS_ON_PIN 12

define KILL_PIN -1

define HEATER_0_PIN 10

define HEATER_1_PIN 8

define TEMP_0_PIN 13 // ANALOG NUMBERING

define TEMP_1_PIN 14 // ANALOG NUMBERING

void setup() {

pinMode(FAN_PIN , OUTPUT);

pinMode(HEATER_0_PIN , OUTPUT);

pinMode(HEATER_1_PIN , OUTPUT);

pinMode(LED_PIN , OUTPUT);

pinMode(X_STEP_PIN , OUTPUT);

pinMode(X_DIR_PIN , OUTPUT);

pinMode(X_ENABLE_PIN , OUTPUT);

pinMode(Y_STEP_PIN , OUTPUT);

pinMode(Y_DIR_PIN , OUTPUT);

pinMode(Y_ENABLE_PIN , OUTPUT);

pinMode(Z_STEP_PIN , OUTPUT);

pinMode(Z_DIR_PIN , OUTPUT);

pinMode(Z_ENABLE_PIN , OUTPUT);

pinMode(E_STEP_PIN , OUTPUT);

pinMode(E_DIR_PIN , OUTPUT);

pinMode(E_ENABLE_PIN , OUTPUT);

pinMode(Q_STEP_PIN , OUTPUT);

pinMode(Q_DIR_PIN , OUTPUT);

pinMode(Q_ENABLE_PIN , OUTPUT);

digitalWrite(X_ENABLE_PIN , LOW);

digitalWrite(Y_ENABLE_PIN , LOW);

digitalWrite(Z_ENABLE_PIN , LOW);

digitalWrite(E_ENABLE_PIN , LOW);

digitalWrite(Q_ENABLE_PIN , LOW);

}

void loop () {

if (millis() %1000 <500)

digitalWrite(LED_PIN, HIGH);

else

digitalWrite(LED_PIN, LOW);

if (millis() %1000 <300) {

digitalWrite(HEATER_0_PIN, HIGH);

digitalWrite(HEATER_1_PIN, LOW);

digitalWrite(FAN_PIN, LOW);

} else if (millis() %1000 <600) {

digitalWrite(HEATER_0_PIN, LOW);

digitalWrite(HEATER_1_PIN, HIGH);

digitalWrite(FAN_PIN, LOW);

} else {

digitalWrite(HEATER_0_PIN, LOW);

digitalWrite(HEATER_1_PIN, LOW);

digitalWrite(FAN_PIN, HIGH);

}

if (millis() %10000 <5000) {

digitalWrite(X_DIR_PIN , HIGH);

digitalWrite(Y_DIR_PIN , HIGH);

digitalWrite(Z_DIR_PIN , HIGH);

digitalWrite(E_DIR_PIN , HIGH);

digitalWrite(Q_DIR_PIN , HIGH);

}

else {

digitalWrite(X_DIR_PIN , LOW);

digitalWrite(Y_DIR_PIN , LOW);

digitalWrite(Z_DIR_PIN , LOW);

digitalWrite(E_DIR_PIN , LOW);

digitalWrite(Q_DIR_PIN , LOW);

}

digitalWrite(X_STEP_PIN , HIGH);

digitalWrite(Y_STEP_PIN , HIGH);

digitalWrite(Z_STEP_PIN , HIGH);

digitalWrite(E_STEP_PIN , HIGH);

digitalWrite(Q_STEP_PIN , HIGH);

delay(1);

digitalWrite(X_STEP_PIN , LOW);

digitalWrite(Y_STEP_PIN , LOW);

digitalWrite(Z_STEP_PIN , LOW);

digitalWrite(E_STEP_PIN , LOW);

digitalWrite(Q_STEP_PIN , LOW);

}

ifndef THERMISTORTABLES_H_

define THERMISTORTABLES_H_

define OVERSAMPLENR 16

if (THERMISTORHEATER_0 == 1) || (THERMISTORHEATER_1 == 1) || (THERMISTORHEATER_2 == 1) || (THERMISTORBED == 1) //100k bed thermistor

endif

if (THERMISTORHEATER_0 == 2) || (THERMISTORHEATER_1 == 2) || (THERMISTORHEATER_2 == 2) || (THERMISTORBED == 2) //200k bed thermistor

endif

if (THERMISTORHEATER_0 == 3) || (THERMISTORHEATER_1 == 3) || (THERMISTORHEATER_2 == 3) || (THERMISTORBED == 3) //mendel-parts

endif

if (THERMISTORHEATER_0 == 4) || (THERMISTORHEATER_1 == 4) || (THERMISTORHEATER_2 == 4) || (THERMISTORBED == 4) //10k thermistor

endif

if (THERMISTORHEATER_0 == 5) || (THERMISTORHEATER_1 == 5) || (THERMISTORHEATER_2 == 5) || (THERMISTORBED == 5) //100k ParCan thermistor (104GT-2)

endif

if (THERMISTORHEATER_0 == 6) || (THERMISTORHEATER_1 == 6) || (THERMISTORHEATER_2 == 6) || (THERMISTORBED == 6) // 100k Epcos thermistor

endif

if (THERMISTORHEATER_0 == 7) || (THERMISTORHEATER_1 == 7) || (THERMISTORHEATER_2 == 7) || (THERMISTORBED == 7) // 100k Honeywell 135-104LAG-J01

endif

define TT_NAME(_N) temptable ## _N

define TT_NAME(_N) _TT_NAME(_N)

ifdef THERMISTORHEATER_0

#define heater_0_temptable TT_NAME(THERMISTORHEATER_0)
#define heater_0_temptable_len (sizeof(heater_0_temptable)/sizeof(*heater_0_temptable))

else

ifdef HEATER_0_USES_THERMISTOR

#error No heater 0 thermistor table specified

else // HEATER_0_USES_THERMISTOR

#define heater_0_temptable 0
#define heater_0_temptable_len 0

endif // HEATER_0_USES_THERMISTOR

endif

ifdef THERMISTORHEATER_1

#define heater_1_temptable TT_NAME(THERMISTORHEATER_1)
#define heater_1_temptable_len (sizeof(heater_1_temptable)/sizeof(*heater_1_temptable))

else

ifdef HEATER_1_USES_THERMISTOR

#error No heater 1 thermistor table specified

else // HEATER_1_USES_THERMISTOR

#define heater_1_temptable 0
#define heater_1_temptable_len 0

endif // HEATER_1_USES_THERMISTOR

endif

ifdef THERMISTORHEATER_2

#define heater_2_temptable TT_NAME(THERMISTORHEATER_2)
#define heater_2_temptable_len (sizeof(heater_2_temptable)/sizeof(*heater_2_temptable))

else

ifdef HEATER_2_USES_THERMISTOR

#error No heater 2 thermistor table specified

else // HEATER_2_USES_THERMISTOR

#define heater_2_temptable 0
#define heater_2_temptable_len 0

endif // HEATER_2_USES_THERMISTOR

endif

ifdef THERMISTORBED

#define bedtemptable TT_NAME(THERMISTORBED)
#define bedtemptable_len (sizeof(bedtemptable)/sizeof(*bedtemptable))

else

ifdef BED_USES_THERMISTOR

#error No bed thermistor table specified

endif // BED_USES_THERMISTOR

endif

endif //THERMISTORTABLES_H_

include "thermistortables.h"

define X_STEP_PIN 54

define X_DIR_PIN 55

define X_ENABLE_PIN 38

define X_MIN_PIN 3

define X_MAX_PIN 2

define Y_STEP_PIN 60

define Y_DIR_PIN 61

define Y_ENABLE_PIN 56

define Y_MIN_PIN 14

define Y_MAX_PIN 15

define Z_STEP_PIN 46

define Z_DIR_PIN 48

define Z_ENABLE_PIN 62

define Z_MIN_PIN 18

define Z_MAX_PIN 19

define E_STEP_PIN 26

define E_DIR_PIN 28

define E_ENABLE_PIN 24

define Q_STEP_PIN 36

define Q_DIR_PIN 34

define Q_ENABLE_PIN 30

define SDPOWER -1

define EXTRUDERS 3

define TEMP_SENSOR_AD595_OFFSET 0.0

define TEMP_SENSOR_AD595_GAIN 1.0

define THERMISTORHEATER_0 1

define THERMISTORHEATER_1 1

define THERMISTORHEATER_2 1

define HEATER_0_USES_THERMISTOR 1

define HEATER_1_USES_THERMISTOR 1

define HEATER_2_USES_THERMISTOR 1

static void *heater_ttbl_map[EXTRUDERS] = { (void *)heater_0_temptable

if EXTRUDERS > 1

                                       , (void *)heater_1_temptable

endif

if EXTRUDERS > 2

                                       , (void *)heater_2_temptable

endif

if EXTRUDERS > 3

#error Unsupported number of extruders

endif

};

static int heater_ttbllen_map[EXTRUDERS] = { heater_0_temptable_len

if EXTRUDERS > 1

                                        , heater_1_temptable_len

endif

if EXTRUDERS > 2

                                        , heater_2_temptable_len

endif

if EXTRUDERS > 3

#error Unsupported number of extruders

endif

};

#define PGM_RD_W(x) (short)pgm_read_word(&x)

define SDSS 53

define LED_PIN 13

define FAN_PIN 9

define PS_ON_PIN 12

define KILL_PIN -1

define HEATER_0_PIN 10

define HEATER_1_PIN 8

define TEMP_0_PIN 15 // ANALOG NUMBERING

define TEMP_1_PIN 14 // ANALOG NUMBERING

define TEMP_2_PIN 13 // ANALOG NUMBERING

void setup() {

pinMode(TEMP_0_PIN , INPUT);

pinMode(TEMP_1_PIN , INPUT);

pinMode(TEMP_2_PIN , INPUT);

pinMode(FAN_PIN , OUTPUT);

pinMode(HEATER_0_PIN , OUTPUT);

pinMode(HEATER_1_PIN , OUTPUT);

pinMode(LED_PIN , OUTPUT);

pinMode(X_STEP_PIN , OUTPUT);

pinMode(X_DIR_PIN , OUTPUT);

pinMode(X_ENABLE_PIN , OUTPUT);

pinMode(Y_STEP_PIN , OUTPUT);

pinMode(Y_DIR_PIN , OUTPUT);

pinMode(Y_ENABLE_PIN , OUTPUT);

pinMode(Z_STEP_PIN , OUTPUT);

pinMode(Z_DIR_PIN , OUTPUT);

pinMode(Z_ENABLE_PIN , OUTPUT);

pinMode(E_STEP_PIN , OUTPUT);

pinMode(E_DIR_PIN , OUTPUT);

pinMode(E_ENABLE_PIN , OUTPUT);

pinMode(Q_STEP_PIN , OUTPUT);

pinMode(Q_DIR_PIN , OUTPUT);

pinMode(Q_ENABLE_PIN , OUTPUT);

digitalWrite(X_ENABLE_PIN , LOW);

digitalWrite(Y_ENABLE_PIN , LOW);

digitalWrite(Z_ENABLE_PIN , LOW);

digitalWrite(E_ENABLE_PIN , LOW);

digitalWrite(Q_ENABLE_PIN , LOW);

Serial.begin(115200);

}

float analog2temp(int raw, uint8_t e) {

#ifdef HEATER_0_USES_MAX6675

if (e == 0)

{

 return 0.25 * raw;

}

#endif

if(heater_ttbl_map[e] != 0)

{

float celsius = 0;

byte i;

short (tt)[][2] = (short ()[][2])(heater_ttbl_map[e]);

raw = (1023 * OVERSAMPLENR) - raw;

for (i=1; i<heater_ttbllen_map[e]; i++)

{

 if ((PGM_RD_W((*tt)[i][0]) > raw) && ((float)(PGM_RD_W((*tt)[i][0]) - PGM_RD_W((*tt)[i-1][0])) >0))

 {

   celsius = PGM_RD_W((*tt)[i-1][1]) +

     (raw - PGM_RD_W((*tt)[i-1][0])) *

     (float)(PGM_RD_W((*tt)[i][1]) - PGM_RD_W((*tt)[i-1][1])) /

     (float)(PGM_RD_W((*tt)[i][0]) - PGM_RD_W((*tt)[i-1][0]));

   break;

 }

}

// Overflow: Set to last value in the table

if (i == heater_ttbllen_map[e]) celsius = PGM_RD_W((*tt)[i-1][1]);

return celsius;

}

return ((raw * ((5.0 * 100.0) / 1024.0) / OVERSAMPLENR) * TEMP_SENSOR_AD595_GAIN) + TEMP_SENSOR_AD595_OFFSET;

}

unsigned long prevMillis;

void loop () {

if (millis() %1000 <500)

digitalWrite(LED_PIN, HIGH);

else

digitalWrite(LED_PIN, LOW);

if (millis() %1000 <300) {

digitalWrite(HEATER_0_PIN, HIGH);

digitalWrite(HEATER_1_PIN, LOW);

digitalWrite(FAN_PIN, LOW);

} else if (millis() %1000 <600) {

digitalWrite(HEATER_0_PIN, LOW);

digitalWrite(HEATER_1_PIN, HIGH);

digitalWrite(FAN_PIN, LOW);

} else {

digitalWrite(HEATER_0_PIN, LOW);

digitalWrite(HEATER_1_PIN, LOW);

digitalWrite(FAN_PIN, HIGH);

}

if (millis() %2000 <1000) {

digitalWrite(X_DIR_PIN , HIGH);

digitalWrite(Y_DIR_PIN , HIGH);

digitalWrite(Z_DIR_PIN , HIGH);

digitalWrite(E_DIR_PIN , HIGH);

digitalWrite(Q_DIR_PIN , HIGH);

}

else {

digitalWrite(X_DIR_PIN , LOW);

digitalWrite(Y_DIR_PIN , LOW);

digitalWrite(Z_DIR_PIN , LOW);

digitalWrite(E_DIR_PIN , LOW);

digitalWrite(Q_DIR_PIN , LOW);

}

digitalWrite(X_STEP_PIN , HIGH);

digitalWrite(Y_STEP_PIN , HIGH);

digitalWrite(Z_STEP_PIN , HIGH);

digitalWrite(E_STEP_PIN , HIGH);

digitalWrite(Q_STEP_PIN , HIGH);

delay(1);

digitalWrite(X_STEP_PIN , LOW);

digitalWrite(Y_STEP_PIN , LOW);

digitalWrite(Z_STEP_PIN , LOW);

digitalWrite(E_STEP_PIN , LOW);

digitalWrite(Q_STEP_PIN , LOW);

if (millis() -prevMillis >500){

prevMillis=millis();

int t = analogRead( TEMP_0_PIN);

Serial.print("T0 ");

Serial.print(t);

Serial.print("/");

Serial.print(analog2temp(1024 - t,0),0);

Serial.print(" T1 ");

t = analogRead( TEMP_1_PIN);

Serial.print(t);

Serial.print("/");

Serial.print(analog2temp(1024 - t,1),0);

Serial.print(" T2 ");

t = analogRead( TEMP_2_PIN);

Serial.print(t);

Serial.print("/");

Serial.println(analog2temp(1024 - t,2),0);

}

include

int uinput;

extern "C"
JNIEXPORT void JNICALL
Java_com_monobogdan_inputservicebridge_InputNative_init(JNIEnv *env, jclass clazz) {
uinput = open("/dev/input/event2", O_WRONLY);

__android_log_print(ANDROID_LOG_DEBUG  , "Test", uinput >= 0 ? "Open event OK" : "Failed to open event");

}

public class InputListener extends Service {

private static final int tty = 3;

private InputManager iManager;
private Map<Character, Integer> keyMap;
private Method injectMethod;

private Process runAsRoot(String cmd)
{
    try {
        return Runtime.getRuntime().exec(new String[] { "su", "-c", cmd });
    }
    catch (IOException e)
    {
        e.printStackTrace();

        return null;
    }
}

@Override
public void onCreate() {
    super.onCreate();

    // According to linux key map (input-event-codes.h)
    keyMap = new HashMap<>();
    keyMap.put('U', 103);
    keyMap.put('D', 108);
    keyMap.put('L', 105);
    keyMap.put('R', 106);
    keyMap.put('E', 115);
    keyMap.put('B', 158);
    keyMap.put('A', 232);
    keyMap.put('C', 212);

    InputNative.init();

    try {
        runAsRoot("chmod 777 /dev/input/event2").waitFor();
    } catch (InterruptedException e) {
        throw new RuntimeException(e);
    }

    Executors.newSingleThreadExecutor().execute(new Runnable() {
        @Override
        public void run() {
            Process proc = runAsRoot("cat /dev/ttyMT" + tty);
            BufferedReader reader = new BufferedReader(new InputStreamReader(proc.getInputStream()));

            while(true)
            {
                try {
                    String line = reader.readLine();

                    if(line != null && line.length() > 0) {
                        Log.i("Hi", "run: " + line);

                        boolean pressing = line.charAt(0) == 'D';
                        int keyCode = keyMap.get(line.charAt(2));

                        Log.i("TAG", "run: " + keyCode);
                        InputNative.sendKeyEvent(keyCode, pressing);
                    }
                }
                catch(IOException e)
                {
                    e.printStackTrace();
                }

                /*try {
                    Thread.sleep(1000 / 30);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }*/
            }
        }
    });
}

@Override
public IBinder onBind(Intent intent) {
    return null;
}
#include <stdio.h>

include

include "pico/stdlib.h"

include "pico/time.h"

include "hardware/uart.h"

struct keyMap
{
int gpio;
char key;
bool pressed;
int lastTick;
};

keyMap keys[] = {
{
15,
'L',
false,
0
},
{
14,
'U',
false,
0
},
{
13,
'D',
false,
0
},
{
12,
'R',
false,
0
},
{
11,
'E',
false,
0
},
{
10,
'B',
false,
0
},

{
    20,
    'A',
    false,
    0
},
{
    21,
    'C',
    false,
    0
}

};

define KEY_NUM 8

int main() {
stdio_init_all();

uart_init(uart0, 921600);
gpio_set_function(PICO_DEFAULT_UART_TX_PIN, GPIO_FUNC_UART);
gpio_set_function(PICO_DEFAULT_UART_RX_PIN, GPIO_FUNC_UART);
sleep_ms(1000); // Allow serial monitor to settle

for(int i = 0; i <  KEY_NUM; i++)
{
    gpio_init(keys[i].gpio);
    gpio_set_dir(keys[i].gpio, false);
    gpio_pull_up(keys[i].gpio);
}

while(true)
{
    int now = time_us_32();

    for(int i = 0; i < KEY_NUM; i++)
    {
        char buf[5];
        buf[1] = ' ';
        buf[3] = '\n';
        buf[4] = 0;

        if(!gpio_get(keys[i].gpio) && !keys[i].pressed && now - keys[i].lastTick > 15500)
        {
            buf[0] = 'D';
            buf[2] = keys[i].key;
            puts(buf);

            keys[i].lastTick = now;
            keys[i].pressed = true;
            continue;
        }

        if(gpio_get(keys[i].gpio) && keys[i].pressed && now - keys[i].lastTick > 15500)
        {
            buf[0] = 'U';
            buf[2] = keys[i].key;
            puts(buf);

            keys[i].pressed = false;
            keys[i].lastTick = now;
        }

portable computer smart watch

jay jordan — Mon, 25 Dec 2023 16:04:14 +0000

ifndef ARDUINO_STM32_FEATHER

#include "pins_arduino.h"
#include "wiring_private.h"

endif

include

// If the SPI library has transaction support, these functions
// establish settings and protect from interference from other
// libraries. Otherwise, they simply do nothing.

ifdef SPI_HAS_TRANSACTION

static inline void spi_begin(void) attribute((always_inline));
static inline void spi_begin(void) {

if defined (ARDUINO_ARCH_ARC32)

// max speed!
SPI.beginTransaction(SPISettings(16000000, MSBFIRST, SPI_MODE0));

else

// max speed!

SPI.beginTransaction(SPISettings(24000000, MSBFIRST, SPI_MODE0));

endif

}
static inline void spi_end(void) attribute((always_inline));
static inline void spi_end(void) {
SPI.endTransaction();
}

else

define spi_begin()

define spi_end()

endif

// Constructor when using software SPI. All output pins are configurable.
ILI9488::ILI9488(int8_t cs, int8_t dc, int8_t mosi,
int8_t sclk, int8_t rst, int8_t miso) : Adafruit_GFX(ILI9488_TFTWIDTH, ILI9488_TFTHEIGHT) {
_cs = cs;
_dc = dc;
_mosi = mosi;
_miso = miso;
_sclk = sclk;
_rst = rst;
hwSPI = false;
}

// Constructor when using hardware SPI. Faster, but must use SPI pins
// specific to each board type (e.g. 11,13 for Uno, 51,52 for Mega, etc.)
ILI9488::ILI9488(int8_t cs, int8_t dc, int8_t rst) : Adafruit_GFX(ILI9488_TFTWIDTH, ILI9488_TFTHEIGHT) {
_cs = cs;
_dc = dc;
_rst = rst;
hwSPI = true;
_mosi = _sclk = 0;
}

void ILI9488::spiwrite(uint8_t c) {

//Serial.print("0x"); Serial.print(c, HEX); Serial.print(", ");

if (hwSPI) {

if defined (AVR)

#ifndef SPI_HAS_TRANSACTION
uint8_t backupSPCR = SPCR;
SPCR = mySPCR;
#endif
SPDR = c;
while(!(SPSR & _BV(SPIF)));
#ifndef SPI_HAS_TRANSACTION
SPCR = backupSPCR;
#endif

else

SPI.transfer(c);

endif

} else {

if defined(ESP8266) || defined (ARDUINO_ARCH_ARC32) || defined(ARDUINO_ARCH_RP2040) || defined(ARDUINO_ARCH_ESP32)

for(uint8_t bit = 0x80; bit; bit >>= 1) {
  if(c & bit) {
digitalWrite(_mosi, HIGH);
  } else {
digitalWrite(_mosi, LOW);
  }
  digitalWrite(_sclk, HIGH);
  digitalWrite(_sclk, LOW);
}

else

// Fast SPI bitbang swiped from LPD8806 library
for(uint8_t bit = 0x80; bit; bit >>= 1) {
  if(c & bit) {
//digitalWrite(_mosi, HIGH);
*mosiport |=  mosipinmask;
  } else {
//digitalWrite(_mosi, LOW);
*mosiport &= ~mosipinmask;
  }
  //digitalWrite(_sclk, HIGH);
  *clkport |=  clkpinmask;
  //digitalWrite(_sclk, LOW);
  *clkport &= ~clkpinmask;
}

endif

}
}

void ILI9488::writecommand(uint8_t c) {

if defined(USE_FAST_PINIO) && !defined (VARIANT_ARDUINO_STM32)

*dcport &= ~dcpinmask;
*csport &= ~cspinmask;

else

digitalWrite(_dc, LOW);
digitalWrite(_sclk, LOW);
digitalWrite(_cs, LOW);

endif

spiwrite(c);

if defined(USE_FAST_PINIO) && !defined (VARIANT_ARDUINO_STM32)

*csport |= cspinmask;

else

digitalWrite(_cs, HIGH);

endif

}

void ILI9488::writedata(uint8_t c) {

if defined(USE_FAST_PINIO) && !defined (VARIANT_ARDUINO_STM32)

*dcport |= dcpinmask;
*csport &= ~cspinmask;

else

digitalWrite(_dc, HIGH);
digitalWrite(_cs, LOW);

endif

spiwrite(c);

if defined(USE_FAST_PINIO) && !defined (VARIANT_ARDUINO_STM32)

*csport |= cspinmask;

else

digitalWrite(_cs, HIGH);

endif

}

// Rather than a bazillion writecommand() and writedata() calls, screen
// initialization commands and arguments are organized in these tables
// stored in PROGMEM. The table may look bulky, but that's mostly the
// formatting -- storage-wise this is hundreds of bytes more compact
// than the equivalent code. Companion function follows.

define DELAY 0x80

// Companion code to the above tables. Reads and issues
// a series of LCD commands stored in PROGMEM byte array.
void ILI9488::commandList(uint8_t *addr) {

uint8_t numCommands, numArgs;
uint16_t ms;

numCommands = pgm_read_byte(addr++); // Number of commands to follow
while(numCommands--) { // For each command...
writecommand(pgm_read_byte(addr++)); // Read, issue command
numArgs = pgm_read_byte(addr++); // Number of args to follow
ms = numArgs & DELAY; // If hibit set, delay follows args
numArgs &= ~DELAY; // Mask out delay bit
while(numArgs--) { // For each argument...
writedata(pgm_read_byte(addr++)); // Read, issue argument
}

if(ms) {
  ms = pgm_read_byte(addr++); // Read post-command delay time (ms)
  if(ms == 255) ms = 500;     // If 255, delay for 500 ms
  delay(ms);
}

}
}

void ILI9488::begin(void) {
if (_rst > 0) {
pinMode(_rst, OUTPUT);
digitalWrite(_rst, LOW);
}

pinMode(_dc, OUTPUT);
pinMode(_cs, OUTPUT);

if defined(USE_FAST_PINIO) && !defined (VARIANT_ARDUINO_STM32)

csport = portOutputRegister(digitalPinToPort(_cs));
cspinmask = digitalPinToBitMask(_cs);
dcport = portOutputRegister(digitalPinToPort(_dc));
dcpinmask = digitalPinToBitMask(_dc);

endif

if(hwSPI) { // Using hardware SPI
SPI.begin();

ifndef SPI_HAS_TRANSACTION

SPI.setBitOrder(MSBFIRST);
SPI.setDataMode(SPI_MODE0);

#if defined (AVR)
SPI.setClockDivider(SPI_CLOCK_DIV2); // 8 MHz (full! speed!)
mySPCR = SPCR;
#elif defined(TEENSYDUINO) || defined (STM32F1)
SPI.setClockDivider(SPI_CLOCK_DIV2); // 8 MHz (full! speed!)
#elif defined (arm_)
SPI.setClockDivider(11); // 8-ish MHz (full! speed!)
#endif

endif

} else {
pinMode(_sclk, OUTPUT);
pinMode(_mosi, OUTPUT);
pinMode(_miso, INPUT);

if defined(USE_FAST_PINIO) && !defined (VARIANT_ARDUINO_STM32)

clkport     = portOutputRegister(digitalPinToPort(_sclk));
clkpinmask  = digitalPinToBitMask(_sclk);
mosiport    = portOutputRegister(digitalPinToPort(_mosi));
mosipinmask = digitalPinToBitMask(_mosi);
*clkport   &= ~clkpinmask;
*mosiport  &= ~mosipinmask;

endif

}

// toggle RST low to reset
if (_rst > 0) {
digitalWrite(_rst, HIGH);
delay(5);
digitalWrite(_rst, LOW);
delay(20);
digitalWrite(_rst, HIGH);
delay(150);
}

/*
uint8_t x = readcommand8(ILI9488_RDMODE);
Serial.print("\nDisplay Power Mode: 0x"); Serial.println(x, HEX);
x = readcommand8(ILI9488_RDMADCTL);
Serial.print("\nMADCTL Mode: 0x"); Serial.println(x, HEX);
x = readcommand8(ILI9488_RDPIXFMT);
Serial.print("\nPixel Format: 0x"); Serial.println(x, HEX);
x = readcommand8(ILI9488_RDIMGFMT);
Serial.print("\nImage Format: 0x"); Serial.println(x, HEX);
x = readcommand8(ILI9488_RDSELFDIAG);
Serial.print("\nSelf Diagnostic: 0x"); Serial.println(x, HEX);
*/
//if(cmdList) commandList(cmdList);

if (hwSPI) spi_begin();
// writecommand(0xEF);
// writedata(0x03);
// writedata(0x80);
// writedata(0x02);
//
// writecommand(0xCF);
// writedata(0x00);
// writedata(0XC1);
// writedata(0X30);
//
// writecommand(0xED);
// writedata(0x64);
// writedata(0x03);
// writedata(0X12);
// writedata(0X81);
//
// writecommand(0xE8);
// writedata(0x85);
// writedata(0x00);
// writedata(0x78);
//
// writecommand(0xCB);
// writedata(0x39);
// writedata(0x2C);
// writedata(0x00);
// writedata(0x34);
// writedata(0x02);
//
// writecommand(0xF7);
// writedata(0x20);
//
// writecommand(0xEA);
// writedata(0x00);
// writedata(0x00);
//
// writecommand(ILI9488_PWCTR1); //Power control
// writedata(0x23); //VRH[5:0]
//
// writecommand(ILI9488_PWCTR2); //Power control
// writedata(0x10); //SAP[2:0];BT[3:0]
//
// writecommand(ILI9488_VMCTR1); //VCM control
// writedata(0x3e); //¶Ô±È¶Èµ÷½Ú
// writedata(0x28);
//
// writecommand(ILI9488_VMCTR2); //VCM control2
// writedata(0x86); //--
//
// writecommand(ILI9488_MADCTL); // Memory Access Control
// writedata(0x48);
//
// writecommand(ILI9488_PIXFMT);
// writedata(0x55);
//
// writecommand(ILI9488_FRMCTR1);
// writedata(0x00);
// writedata(0x18);
//
// writecommand(ILI9488_DFUNCTR); // Display Function Control
// writedata(0x08);
// writedata(0x82);
// writedata(0x27);
//
// writecommand(0xF2); // 3Gamma Function Disable
// writedata(0x00);
//
// writecommand(ILI9488_GAMMASET); //Gamma curve selected
// writedata(0x01);
//
// writecommand(ILI9488_GMCTRP1); //Set Gamma
// writedata(0x0F);
// writedata(0x31);
// writedata(0x2B);
// writedata(0x0C);
// writedata(0x0E);
// writedata(0x08);
// writedata(0x4E);
// writedata(0xF1);
// writedata(0x37);
// writedata(0x07);
// writedata(0x10);
// writedata(0x03);
// writedata(0x0E);
// writedata(0x09);
// writedata(0x00);
//
// writecommand(ILI9488_GMCTRN1); //Set Gamma
// writedata(0x00);
// writedata(0x0E);
// writedata(0x14);
// writedata(0x03);
// writedata(0x11);
// writedata(0x07);
// writedata(0x31);
// writedata(0xC1);
// writedata(0x48);
// writedata(0x08);
// writedata(0x0F);
// writedata(0x0C);
// writedata(0x31);
// writedata(0x36);
// writedata(0x0F);

writecommand(0xE0);
writedata(0x00);
writedata(0x03);
writedata(0x09);
writedata(0x08);
writedata(0x16);
writedata(0x0A);
writedata(0x3F);
writedata(0x78);
writedata(0x4C);
writedata(0x09);
writedata(0x0A);
writedata(0x08);
writedata(0x16);
writedata(0x1A);
writedata(0x0F);

writecommand(0XE1);
writedata(0x00);
writedata(0x16);
writedata(0x19);
writedata(0x03);
writedata(0x0F);
writedata(0x05);
writedata(0x32);
writedata(0x45);
writedata(0x46);
writedata(0x04);
writedata(0x0E);
writedata(0x0D);
writedata(0x35);
writedata(0x37);
writedata(0x0F);



writecommand(0XC0);      //Power Control 1
writedata(0x17);    //Vreg1out
writedata(0x15);    //Verg2out

writecommand(0xC1);      //Power Control 2
writedata(0x41);    //VGH,VGL

writecommand(0xC5);      //Power Control 3
writedata(0x00);
writedata(0x12);    //Vcom
writedata(0x80);

writecommand(0x36);      //Memory Access
writedata(0x48);

writecommand(0x3A);      // Interface Pixel Format
writedata(0x66);      //18 bit

writecommand(0XB0);      // Interface Mode Control
writedata(0x80);                 //SDO NOT USE

writecommand(0xB1);      //Frame rate
writedata(0xA0);    //60Hz

writecommand(0xB4);      //Display Inversion Control
writedata(0x02);    //2-dot

writecommand(0XB6);      //Display Function Control  RGB/MCU Interface Control

writedata(0x02);    //MCU
writedata(0x02);    //Source,Gate scan dieection

writecommand(0XE9);      // Set Image Functio
writedata(0x00);    // Disable 24 bit data

writecommand(0xF7);      // Adjust Control
writedata(0xA9);
writedata(0x51);
writedata(0x2C);
writedata(0x82);    // D7 stream, loose

writecommand(ILI9488_SLPOUT); //Exit Sleep
if (hwSPI) spi_end();
delay(120);
if (hwSPI) spi_begin();
writecommand(ILI9488_DISPON); //Display on
if (hwSPI) spi_end();

}

void ILI9488::setScrollArea(uint16_t topFixedArea, uint16_t bottomFixedArea){
if (hwSPI) spi_begin();
writecommand(0x33); // Vertical scroll definition
writedata(topFixedArea >> 8);
writedata(topFixedArea);
writedata((_height - topFixedArea - bottomFixedArea) >> 8);
writedata(_height - topFixedArea - bottomFixedArea);
writedata(bottomFixedArea >> 8);
writedata(bottomFixedArea);
if (hwSPI) spi_end();
}
void ILI9488::scroll(uint16_t pixels){
if (hwSPI) spi_begin();
writecommand(0x37); // Vertical scrolling start address
writedata(pixels >> 8);
writedata(pixels);
if (hwSPI) spi_end();
}

void ILI9488::setAddrWindow(uint16_t x0, uint16_t y0, uint16_t x1,
uint16_t y1) {

writecommand(ILI9488_CASET); // Column addr set
writedata(x0 >> 8);
writedata(x0 & 0xFF); // XSTART
writedata(x1 >> 8);
writedata(x1 & 0xFF); // XEND

writecommand(ILI9488_PASET); // Row addr set
writedata(y0>>8);
writedata(y0 &0xff); // YSTART
writedata(y1>>8);
writedata(y1 &0xff); // YEND

writecommand(ILI9488_RAMWR); // write to RAM

}

void ILI9488::drawImage(const uint8_t* img, uint16_t x, uint16_t y, uint16_t w, uint16_t h){

// rudimentary clipping (drawChar w/big text requires this)
if((x >= _width) || (y >= _height)) return;
if((x + w - 1) >= _width)  w = _width  - x;
if((y + h - 1) >= _height) h = _height - y;

if (hwSPI) spi_begin();
setAddrWindow(x, y, x+w-1, y+h-1);

// uint8_t hi = color >> 8, lo = color;

#if defined(USE_FAST_PINIO) && !defined (VARIANT_ARDUINO_STM32)
dcport |= dcpinmask;
*csport &= ~cspinmask;
#else
digitalWrite(_dc, HIGH);
digitalWrite(_cs, LOW);
#endif
uint8_t linebuff[w*3+1];
uint16_t pixels = w*h;
// uint16_t count = 0;
uint32_t count = 0;
for (uint16_t i = 0; i < h; i++) {
uint16_t pixcount = 0;
for (uint16_t o = 0; o < w; o++) {
uint8_t b1 = img[count];
count++;
uint8_t b2 = img[count];
count++;
uint16_t color = b1 << 8 | b2;
linebuff[pixcount] = (((color & 0xF800) >> 11) 255) / 31;
pixcount++;
linebuff[pixcount] = (((color & 0x07E0) >> 5) * 255) / 63;
pixcount++;
linebuff[pixcount] = ((color & 0x001F)* 255) / 31;
pixcount++;
} // for row
#if defined (STM32F1)
SPI.dmaSend(linebuff, w*3);
#else
for(uint16_t b = 0; b < w*3; b++){
spiwrite(linebuff[b]);
}
#endif

}// for col
#if defined(USE_FAST_PINIO) && !defined (VARIANT_ARDUINO_STM32)
*csport |= cspinmask;
#else
digitalWrite(_cs, HIGH);
#endif

if (hwSPI) spi_end();

}

void ILI9488::pushColor(uint16_t color) {
if (hwSPI) spi_begin();

if defined(USE_FAST_PINIO) && !defined (VARIANT_ARDUINO_STM32)

*dcport |= dcpinmask;
*csport &= ~cspinmask;

else

digitalWrite(_dc, HIGH);
digitalWrite(_cs, LOW);

endif

// spiwrite(color >> 8);
// spiwrite(color);
// spiwrite(0); // added for 24 bit
write16BitColor(color);

if defined(USE_FAST_PINIO) && !defined (VARIANT_ARDUINO_STM32)

*csport |= cspinmask;

else

digitalWrite(_cs, HIGH);

endif

if (hwSPI) spi_end();
}

void ILI9488::pushColors(uint16_t data, uint8_t len, boolean first) {
uint16_t color;
uint8_t buff[len*3+1];
uint16_t count = 0;
uint8_t lencount = len;
if (hwSPI) spi_begin();
#if defined(USE_FAST_PINIO) && !defined (VARIANT_ARDUINO_STM32)
*csport &= ~cspinmask;
#else
digitalWrite(cs, LOW);
#endif
if(first == true) { // Issue GRAM write command only on first call
#if defined(USE_FAST_PINIO) && !defined (_VARIANT_ARDUINO_STM32)
*dcport |= dcpinmask;
#else
digitalWrite(_dc, HIGH);
#endif
}
while(lencount--) {
color = *data++;
buff[count] = (((color & 0xF800) >> 11) 255) / 31;
count++;
buff[count] = (((color & 0x07E0) >> 5) * 255) / 63;
count++;
buff[count] = ((color & 0x001F)* 255) / 31;
count++;
}
#if defined (STM32F1)
SPI.dmaSend(buff, len*3);
#else
for(uint16_t b = 0; b < len*3; b++){
spiwrite(buff[b]);
}
#endif
#if defined(USE_FAST_PINIO) && !defined (VARIANT_ARDUINO_STM32)
*csport |= cspinmask;
#else
digitalWrite(_cs, HIGH);
#endif

if (hwSPI) spi_end();

}

void ILI9488::write16BitColor(uint16_t color){
// #if (STM32F1)
// uint8_t buff[4] = {
// (((color & 0xF800) >> 11)* 255) / 31,
// (((color & 0x07E0) >> 5) * 255) / 63,
// ((color & 0x001F)* 255) / 31
// };
// SPI.dmaSend(buff, 3);
// #else
uint8_t r = (color & 0xF800) >> 11;
uint8_t g = (color & 0x07E0) >> 5;
uint8_t b = color & 0x001F;

r = (r * 255) / 31;
g = (g * 255) / 63;
b = (b * 255) / 31;

spiwrite(r);
spiwrite(g);
spiwrite(b);
yield();
// #endif
}

void ILI9488::drawPixel(int16_t x, int16_t y, uint16_t color) {

if((x < 0) ||(x >= _width) || (y < 0) || (y >= _height)) return;

if (hwSPI) spi_begin();
setAddrWindow(x,y,x+1,y+1);

if defined(USE_FAST_PINIO) && !defined (VARIANT_ARDUINO_STM32)

*dcport |= dcpinmask;
*csport &= ~cspinmask;

else

digitalWrite(_dc, HIGH);
digitalWrite(_cs, LOW);

endif

// spiwrite(color >> 8);
// spiwrite(color);
// spiwrite(0); // added for 24 bit
write16BitColor(color);

if defined(USE_FAST_PINIO) && !defined (VARIANT_ARDUINO_STM32)

*csport |= cspinmask;

else

digitalWrite(_cs, HIGH);

endif

if (hwSPI) spi_end();
}

void ILI9488::drawFastVLine(int16_t x, int16_t y, int16_t h,
uint16_t color) {

// Rudimentary clipping
if((x >= _width) || (y >= _height)) return;

if((y+h-1) >= _height)
h = _height-y;

if (hwSPI) spi_begin();
setAddrWindow(x, y, x, y+h-1);

// uint8_t hi = color >> 8, lo = color;

if defined(USE_FAST_PINIO) && !defined (VARIANT_ARDUINO_STM32)

*dcport |= dcpinmask;
*csport &= ~cspinmask;

else

digitalWrite(_dc, HIGH);
digitalWrite(_cs, LOW);

endif

while (h--) {
// spiwrite(hi);
// spiwrite(lo);
// spiwrite(0); // added for 24 bit
write16BitColor(color);

}

if defined(USE_FAST_PINIO) && !defined (VARIANT_ARDUINO_STM32)

*csport |= cspinmask;

else

digitalWrite(_cs, HIGH);

endif

if (hwSPI) spi_end();
}

void ILI9488::drawFastHLine(int16_t x, int16_t y, int16_t w,
uint16_t color) {

// Rudimentary clipping
if((x >= _width) || (y >= _height)) return;
if((x+w-1) >= _width) w = _width-x;
if (hwSPI) spi_begin();
setAddrWindow(x, y, x+w-1, y);

// uint8_t hi = color >> 8, lo = color;

if defined(USE_FAST_PINIO) && !defined (VARIANT_ARDUINO_STM32)

*dcport |= dcpinmask;
*csport &= ~cspinmask;

else

digitalWrite(_dc, HIGH);
digitalWrite(_cs, LOW);

endif

while (w--) {
// spiwrite(hi);
// spiwrite(lo);
// spiwrite(0); // added for 24 bit
write16BitColor(color);
}

if defined(USE_FAST_PINIO) && !defined (VARIANT_ARDUINO_STM32)

*csport |= cspinmask;

else

digitalWrite(_cs, HIGH);

endif

if (hwSPI) spi_end();
}

void ILI9488::fillScreen(uint16_t color) {
fillRect(0, 0, _width, _height, color);
}

// fill a rectangle
void ILI9488::fillRect(int16_t x, int16_t y, int16_t w, int16_t h,
uint16_t color) {

// rudimentary clipping (drawChar w/big text requires this)
if((x >= _width) || (y >= _height)) return;
if((x + w - 1) >= _width) w = _width - x;
if((y + h - 1) >= _height) h = _height - y;

if (hwSPI) spi_begin();
setAddrWindow(x, y, x+w-1, y+h-1);

// uint8_t hi = color >> 8, lo = color;

if defined(USE_FAST_PINIO) && !defined (VARIANT_ARDUINO_STM32)

*dcport |= dcpinmask;
*csport &= ~cspinmask;

else

digitalWrite(_dc, HIGH);
digitalWrite(_cs, LOW);

endif

if (STM32F1)

//use dma fast fills
uint8_t buff[4] = {
(((color & 0xF800) >> 11)* 255) / 31,
(((color & 0x07E0) >> 5) * 255) / 63,
((color & 0x001F)* 255) / 31
};
uint8_t linebuff[w*3+1];
int cnt = 0;
for(int i = 0; i < w; i++){
linebuff[cnt]= buff[0];
cnt++;
linebuff[cnt]= buff[1];
cnt++;
linebuff[cnt]= buff[2];
cnt++;
}
for(y=h; y>0; y--) {
SPI.dmaSend(linebuff, w*3);
}

else

for(y=h; y>0; y--) {
for(x=w; x>0; x--) {
// spiwrite(hi);
// spiwrite(lo);
// spiwrite(0); // added for 24 bit
write16BitColor(color);
}
}

endif

if defined(USE_FAST_PINIO) && !defined (VARIANT_ARDUINO_STM32)

*csport |= cspinmask;

else

digitalWrite(_cs, HIGH);

endif

if (hwSPI) spi_end();
}

// Pass 8-bit (each) R,G,B, get back 16-bit packed color
uint16_t ILI9488::color565(uint8_t r, uint8_t g, uint8_t b) {
return ((r & 0xF8) << 8) | ((g & 0xFC) << 3) | (b >> 3);
}

define MADCTL_MY 0x80

define MADCTL_MX 0x40

define MADCTL_MV 0x20

define MADCTL_ML 0x10

define MADCTL_RGB 0x00

define MADCTL_BGR 0x08

define MADCTL_MH 0x04

void ILI9488::setRotation(uint8_t m) {

if (hwSPI) spi_begin();
writecommand(ILI9488_MADCTL);
rotation = m % 4; // can't be higher than 3
switch (rotation) {
case 0:
writedata(MADCTL_MX | MADCTL_BGR);
_width = ILI9488_TFTWIDTH;
_height = ILI9488_TFTHEIGHT;
break;
case 1:
writedata(MADCTL_MV | MADCTL_BGR);
_width = ILI9488_TFTHEIGHT;
_height = ILI9488_TFTWIDTH;
break;
case 2:
writedata(MADCTL_MY | MADCTL_BGR);
_width = ILI9488_TFTWIDTH;
_height = ILI9488_TFTHEIGHT;
break;
case 3:
writedata(MADCTL_MX | MADCTL_MY | MADCTL_MV | MADCTL_BGR);
_width = ILI9488_TFTHEIGHT;
_height = ILI9488_TFTWIDTH;
break;
}
if (hwSPI) spi_end();
}

void ILI9488::invertDisplay(boolean i) {
if (hwSPI) spi_begin();
writecommand(i ? ILI9488_INVON : ILI9488_INVOFF);
if (hwSPI) spi_end();
}

////////// stuff not actively being used, but kept for posterity

uint8_t ILI9488::spiread(void) {
uint8_t r = 0;

if (hwSPI) {

if defined (AVR)

#ifndef SPI_HAS_TRANSACTION
uint8_t backupSPCR = SPCR;
SPCR = mySPCR;
#endif
SPDR = 0x00;
while(!(SPSR & _BV(SPIF)));
r = SPDR;

#ifndef SPI_HAS_TRANSACTION
SPCR = backupSPCR;
#endif

else

r = SPI.transfer(0x00);

endif

} else {

for (uint8_t i=0; i<8; i++) {
  digitalWrite(_sclk, LOW);
  digitalWrite(_sclk, HIGH);
  r <<= 1;
  if (digitalRead(_miso))
r |= 0x1;
}

}
//Serial.print("read: 0x"); Serial.print(r, HEX);

return r;
}

uint8_t ILI9488::readdata(void) {
digitalWrite(_dc, HIGH);
digitalWrite(_cs, LOW);
uint8_t r = spiread();
digitalWrite(_cs, HIGH);

return r;
}

uint8_t ILI9488::readcommand8(uint8_t c, uint8_t index) {
if (hwSPI) spi_begin();
digitalWrite(_dc, LOW); // command
digitalWrite(_cs, LOW);
spiwrite(0xD9); // woo sekret command?
digitalWrite(_dc, HIGH); // data
spiwrite(0x10 + index);
digitalWrite(_cs, HIGH);

digitalWrite(_dc, LOW);
digitalWrite(_sclk, LOW);
digitalWrite(_cs, LOW);
spiwrite(c);

digitalWrite(_dc, HIGH);
uint8_t r = spiread();
digitalWrite(_cs, HIGH);
if (hwSPI) spi_end();
return r;
}

uint16_t ILI9488::readcommand16(uint8_t c) {
digitalWrite(_dc, LOW);
if (_cs)
digitalWrite(_cs, LOW);

spiwrite(c);
pinMode(_sid, INPUT); // input!
uint16_t r = spiread();
r <<= 8;
r |= spiread();
if (_cs)
digitalWrite(_cs, HIGH);

pinMode(_sid, OUTPUT); // back to output
return r;
}

uint32_t ILI9488::readcommand32(uint8_t c) {
digitalWrite(_dc, LOW);
if (_cs)
digitalWrite(_cs, LOW);
spiwrite(c);
pinMode(_sid, INPUT); // input!

dummyclock();
dummyclock();

uint32_t r = spiread();
r <<= 8;
r |= spiread();
r <<= 8;
r |= spiread();
r <<= 8;
r |= spiread();
if (_cs)
digitalWrite(_cs, HIGH);

pinMode(_sid, OUTPUT); // back to output
return r;
}

/
/**************************************************
This is our GFX example for the Adafruit ILI9488 Breakout and Shield
----> http://www.adafruit.com/products/1651

Check out the links above for our tutorials and wiring diagrams
These displays use SPI to communicate, 4 or 5 pins are required to
interface (RST is optional)
Adafruit invests time and resources providing this open source code,
please support Adafruit and open-source hardware by purchasing
products from Adafruit!

Written by Limor Fried/Ladyada for Adafruit Industries.
MIT license, all text above must be included in any redistribution
****************************************************/

include "SPI.h"

include

define TFT_CS PA1

define TFT_DC PB3

define TFT_LED PB0

define TFT_RST PB4

// Use hardware SPI (on Uno, #13, #12, #11) and the above for CS/DC
ILI9488 tft = ILI9488(TFT_CS, TFT_DC, TFT_RST);
// If using the breakout, change pins as desired
//Adafruit_ILI9488 tft = Adafruit_ILI9488(TFT_CS, TFT_DC, TFT_MOSI, TFT_CLK, TFT_RST, TFT_MISO);

void setup() {
Serial.begin(9600);
Serial.println("ILI9488 Test!");

tft.begin();

// read diagnostics (optional but can help debug problems)
uint8_t x = tft.readcommand8(ILI9488_RDMODE);
Serial.print("Display Power Mode: 0x"); Serial.println(x, HEX);
x = tft.readcommand8(ILI9488_RDMADCTL);
Serial.print("MADCTL Mode: 0x"); Serial.println(x, HEX);
x = tft.readcommand8(ILI9488_RDPIXFMT);
Serial.print("Pixel Format: 0x"); Serial.println(x, HEX);
x = tft.readcommand8(ILI9488_RDIMGFMT);
Serial.print("Image Format: 0x"); Serial.println(x, HEX);
x = tft.readcommand8(ILI9488_RDSELFDIAG);
Serial.print("Self Diagnostic: 0x"); Serial.println(x, HEX);

Serial.println(F("Benchmark Time (microseconds)"));

Serial.print(F("Screen fill "));
Serial.println(testFillScreen());
delay(500);

Serial.print(F("Text "));
Serial.println(testText());
delay(3000);

Serial.print(F("Lines "));
Serial.println(testLines(ILI9488_CYAN));
delay(500);

Serial.print(F("Horiz/Vert Lines "));
Serial.println(testFastLines(ILI9488_RED, ILI9488_BLUE));
delay(500);

Serial.print(F("Rectangles (outline) "));
Serial.println(testRects(ILI9488_GREEN));
delay(500);

Serial.print(F("Rectangles (filled) "));
Serial.println(testFilledRects(ILI9488_YELLOW, ILI9488_MAGENTA));
delay(500);

Serial.print(F("Circles (filled) "));
Serial.println(testFilledCircles(10, ILI9488_MAGENTA));

Serial.print(F("Circles (outline) "));
Serial.println(testCircles(10, ILI9488_WHITE));
delay(500);

Serial.print(F("Triangles (outline) "));
Serial.println(testTriangles());
delay(500);

Serial.print(F("Triangles (filled) "));
Serial.println(testFilledTriangles());
delay(500);

Serial.print(F("Rounded rects (outline) "));
Serial.println(testRoundRects());
delay(500);

Serial.print(F("Rounded rects (filled) "));
Serial.println(testFilledRoundRects());
delay(500);

Serial.println(F("Done!"));

}

void loop(void) {
for(uint8_t rotation=0; rotation<4; rotation++) {
tft.setRotation(rotation);
testText();
delay(1000);
}
}

unsigned long testFillScreen() {
unsigned long start = micros();
tft.fillScreen(ILI9488_BLACK);
tft.fillScreen(ILI9488_RED);
tft.fillScreen(ILI9488_GREEN);
tft.fillScreen(ILI9488_BLUE);
tft.fillScreen(ILI9488_BLACK);
return micros() - start;
}

unsigned long testText() {
tft.fillScreen(ILI9488_BLACK);
unsigned long start = micros();
tft.setCursor(0, 0);
tft.setTextColor(ILI9488_WHITE); tft.setTextSize(1);
tft.println("Hello World!");
tft.setTextColor(ILI9488_YELLOW); tft.setTextSize(2);
tft.println(1234.56);
tft.setTextColor(ILI9488_RED); tft.setTextSize(3);
tft.println(0xDEADBEEF, HEX);
tft.println();
tft.setTextColor(ILI9488_GREEN);
tft.setTextSize(5);
tft.println("Groop");
tft.setTextSize(2);
tft.println("I implore thee,");
tft.setTextSize(1);
tft.println("my foonting turlingdromes.");
tft.println("And hooptiously drangle me");
tft.println("with crinkly bindlewurdles,");
tft.println("Or I will rend thee");
tft.println("in the gobberwarts");
tft.println("with my blurglecruncheon,");
tft.println("see if I don't!");
return micros() - start;
}

unsigned long testLines(uint16_t color) {
unsigned long start, t;
int x1, y1, x2, y2,
w = tft.width(),
h = tft.height();

tft.fillScreen(ILI9488_BLACK);

x1 = y1 = 0;
y2 = h - 1;
start = micros();
for(x2=0; x2<w; x2+=6) tft.drawLine(x1, y1, x2, y2, color);
x2 = w - 1;
for(y2=0; y2<h; y2+=6) tft.drawLine(x1, y1, x2, y2, color);
t = micros() - start; // fillScreen doesn't count against timing

tft.fillScreen(ILI9488_BLACK);

x1 = w - 1;
y1 = 0;
y2 = h - 1;
start = micros();
for(x2=0; x2<w; x2+=6) tft.drawLine(x1, y1, x2, y2, color);
x2 = 0;
for(y2=0; y2<h; y2+=6) tft.drawLine(x1, y1, x2, y2, color);
t += micros() - start;

tft.fillScreen(ILI9488_BLACK);

x1 = 0;
y1 = h - 1;
y2 = 0;
start = micros();
for(x2=0; x2<w; x2+=6) tft.drawLine(x1, y1, x2, y2, color);
x2 = w - 1;
for(y2=0; y2<h; y2+=6) tft.drawLine(x1, y1, x2, y2, color);
t += micros() - start;

tft.fillScreen(ILI9488_BLACK);

x1 = w - 1;
y1 = h - 1;
y2 = 0;
start = micros();
for(x2=0; x2<w; x2+=6) tft.drawLine(x1, y1, x2, y2, color);
x2 = 0;
for(y2=0; y2<h; y2+=6) tft.drawLine(x1, y1, x2, y2, color);

return micros() - start;
}

unsigned long testFastLines(uint16_t color1, uint16_t color2) {
unsigned long start;
int x, y, w = tft.width(), h = tft.height();

tft.fillScreen(ILI9488_BLACK);
start = micros();
for(y=0; y<h; y+=5) tft.drawFastHLine(0, y, w, color1);
for(x=0; x<w; x+=5) tft.drawFastVLine(x, 0, h, color2);

return micros() - start;
}

unsigned long testRects(uint16_t color) {
unsigned long start;
int n, i, i2,
cx = tft.width() / 2,
cy = tft.height() / 2;

tft.fillScreen(ILI9488_BLACK);
n = min(tft.width(), tft.height());
start = micros();
for(i=2; i<n; i+=6) {
i2 = i / 2;
tft.drawRect(cx-i2, cy-i2, i, i, color);
}

return micros() - start;
}

unsigned long testFilledRects(uint16_t color1, uint16_t color2) {
unsigned long start, t = 0;
int n, i, i2,
cx = tft.width() / 2 - 1,
cy = tft.height() / 2 - 1;

tft.fillScreen(ILI9488_BLACK);
n = min(tft.width(), tft.height());
for(i=n; i>0; i-=6) {
i2 = i / 2;
start = micros();
tft.fillRect(cx-i2, cy-i2, i, i, color1);
t += micros() - start;
// Outlines are not included in timing results
tft.drawRect(cx-i2, cy-i2, i, i, color2);
}

return t;
}

unsigned long testFilledCircles(uint8_t radius, uint16_t color) {
unsigned long start;
int x, y, w = tft.width(), h = tft.height(), r2 = radius * 2;

tft.fillScreen(ILI9488_BLACK);
start = micros();
for(x=radius; x<w; x+=r2) {
for(y=radius; y<h; y+=r2) {
tft.fillCircle(x, y, radius, color);
}
}

return micros() - start;
}

unsigned long testCircles(uint8_t radius, uint16_t color) {
unsigned long start;
int x, y, r2 = radius * 2,
w = tft.width() + radius,
h = tft.height() + radius;

// Screen is not cleared for this one -- this is
// intentional and does not affect the reported time.
start = micros();
for(x=0; x<w; x+=r2) {
for(y=0; y<h; y+=r2) {
tft.drawCircle(x, y, radius, color);
}
}

return micros() - start;
}

unsigned long testTriangles() {
unsigned long start;
int n, i, cx = tft.width() / 2 - 1,
cy = tft.height() / 2 - 1;

tft.fillScreen(ILI9488_BLACK);
n = min(cx, cy);
start = micros();
for(i=0; i<n; i+=5) {
tft.drawTriangle(
cx , cy - i, // peak
cx - i, cy + i, // bottom left
cx + i, cy + i, // bottom right
tft.color565(0, 0, i));
}

return micros() - start;
}

unsigned long testFilledTriangles() {
unsigned long start, t = 0;
int i, cx = tft.width() / 2 - 1,
cy = tft.height() / 2 - 1;

tft.fillScreen(ILI9488_BLACK);
start = micros();
for(i=min(cx,cy); i>10; i-=5) {
start = micros();
tft.fillTriangle(cx, cy - i, cx - i, cy + i, cx + i, cy + i,
tft.color565(0, i, i));
t += micros() - start;
tft.drawTriangle(cx, cy - i, cx - i, cy + i, cx + i, cy + i,
tft.color565(i, i, 0));
}

return t;
}

unsigned long testRoundRects() {
unsigned long start;
int w, i, i2,
cx = tft.width() / 2 - 1,
cy = tft.height() / 2 - 1;

tft.fillScreen(ILI9488_BLACK);
w = min(tft.width(), tft.height());
start = micros();
for(i=0; i<w; i+=6) {
i2 = i / 2;
tft.drawRoundRect(cx-i2, cy-i2, i, i, i/8, tft.color565(i, 0, 0));
}

return micros() - start;
}

unsigned long testFilledRoundRects() {
unsigned long start;
int i, i2,
cx = tft.width() / 2 - 1,
cy = tft.height() / 2 - 1;

tft.fillScreen(ILI9488_BLACK);
start = micros();
for(i=min(tft.width(), tft.height()); i>20; i-=6) {
i2 = i / 2;
tft.fillRoundRect(cx-i2, cy-i2, i, i, i/8, tft.color565(0, i, 0));
}

return micros() - start;
}
/***************************************************
STM32 Support added by Jaret Burkett at OSHlab.com

This is our library for the Adafruit ILI9488 Breakout and Shield
----> http://www.adafruit.com/products/1651

Written by Limor Fried/Ladyada for Adafruit Industries.
MIT license, all text above must be included in any redistribution
****************************************************/

ifndef ILI9488H

define ILI9488H

if ARDUINO >= 100

#include "Arduino.h"
#include "Print.h"

else

#include "WProgram.h"

endif

include

ifdef __AVR

#include

elif defined(ESP8266)

#include

endif

if defined(ARDUINO_STM32_FEATHER) || defined(ARDUINO_ARCH_RP2040)

typedef volatile uint32_t RwReg;

endif

if defined (AVR) || defined(TEENSYDUINO) || defined (arm) || defined (STM32F1)

define USE_FAST_PINIO

endif

if defined(ARDUINO_ARCH_RP2040)

undef USE_FAST_PINIO

endif

define ILI9488_TFTWIDTH 320

define ILI9488_TFTHEIGHT 480

define ILI9488_NOP 0x00

define ILI9488_SWRESET 0x01

define ILI9488_RDDID 0x04

define ILI9488_RDDST 0x09

define ILI9488_SLPIN 0x10

define ILI9488_SLPOUT 0x11

define ILI9488_PTLON 0x12

define ILI9488_NORON 0x13

define ILI9488_RDMODE 0x0A

define ILI9488_RDMADCTL 0x0B

define ILI9488_RDPIXFMT 0x0C

define ILI9488_RDIMGFMT 0x0D

define ILI9488_RDSELFDIAG 0x0F

define ILI9488_INVOFF 0x20

define ILI9488_INVON 0x21

define ILI9488_GAMMASET 0x26

define ILI9488_DISPOFF 0x28

define ILI9488_DISPON 0x29

define ILI9488_CASET 0x2A

define ILI9488_PASET 0x2B

define ILI9488_RAMWR 0x2C

define ILI9488_RAMRD 0x2E

define ILI9488_PTLAR 0x30

define ILI9488_MADCTL 0x36

define ILI9488_PIXFMT 0x3A

define ILI9488_FRMCTR1 0xB1

define ILI9488_FRMCTR2 0xB2

define ILI9488_FRMCTR3 0xB3

define ILI9488_INVCTR 0xB4

define ILI9488_DFUNCTR 0xB6

define ILI9488_PWCTR1 0xC0

define ILI9488_PWCTR2 0xC1

define ILI9488_PWCTR3 0xC2

define ILI9488_PWCTR4 0xC3

define ILI9488_PWCTR5 0xC4

define ILI9488_VMCTR1 0xC5

define ILI9488_VMCTR2 0xC7

define ILI9488_RDID1 0xDA

define ILI9488_RDID2 0xDB

define ILI9488_RDID3 0xDC

define ILI9488_RDID4 0xDD

define ILI9488_GMCTRP1 0xE0

define ILI9488_GMCTRN1 0xE1

define ILI9488_PWCTR6 0xFC

// Color definitions

define ILI9488_BLACK 0x0000 /* 0, 0, 0 */

define ILI9488_NAVY 0x000F /* 0, 0, 128 */

define ILI9488_DARKGREEN 0x03E0 /* 0, 128, 0 */

define ILI9488_DARKCYAN 0x03EF /* 0, 128, 128 */

define ILI9488_MAROON 0x7800 /* 128, 0, 0 */

define ILI9488_PURPLE 0x780F /* 128, 0, 128 */

define ILI9488_OLIVE 0x7BE0 /* 128, 128, 0 */

define ILI9488_LIGHTGREY 0xC618 /* 192, 192, 192 */

define ILI9488_DARKGREY 0x7BEF /* 128, 128, 128 */

define ILI9488_BLUE 0x001F /* 0, 0, 255 */

define ILI9488_GREEN 0x07E0 /* 0, 255, 0 */

define ILI9488_CYAN 0x07FF /* 0, 255, 255 */

define ILI9488_RED 0xF800 /* 255, 0, 0 */

define ILI9488_MAGENTA 0xF81F /* 255, 0, 255 */

define ILI9488_YELLOW 0xFFE0 /* 255, 255, 0 */

define ILI9488_WHITE 0xFFFF /* 255, 255, 255 */

define ILI9488_ORANGE 0xFD20 /* 255, 165, 0 */

define ILI9488_GREENYELLOW 0xAFE5 /* 173, 255, 47 */

define ILI9488_PINK 0xF81F

class ILI9488 : public Adafruit_GFX {

public:

ILI9488(int8_t _CS, int8_t _DC, int8_t _MOSI, int8_t _SCLK,
int8_t _RST, int8_t _MISO);
ILI9488(int8_t _CS, int8_t _DC, int8_t _RST = -1);

void begin(void),
setAddrWindow(uint16_t x0, uint16_t y0, uint16_t x1, uint16_t y1),
setScrollArea(uint16_t topFixedArea, uint16_t bottomFixedArea),
scroll(uint16_t pixels),
pushColor(uint16_t color),
pushColors(uint16_t data, uint8_t len, boolean first),
drawImage(const uint8_t img, uint16_t x, uint16_t y, uint16_t w, uint16_t h),
fillScreen(uint16_t color),
drawPixel(int16_t x, int16_t y, uint16_t color),
drawFastVLine(int16_t x, int16_t y, int16_t h, uint16_t color),
drawFastHLine(int16_t x, int16_t y, int16_t w, uint16_t color),
fillRect(int16_t x, int16_t y, int16_t w, int16_t h,
uint16_t color),
setRotation(uint8_t r),
invertDisplay(boolean i);
uint16_t color565(uint8_t r, uint8_t g, uint8_t b);

/* These are not for current use, 8-bit protocol only! /
uint8_t readdata(void),
readcommand8(uint8_t reg, uint8_t index = 0);
/
uint16_t readcommand16(uint8_t);
uint32_t readcommand32(uint8_t);
void dummyclock(void);
*/

void spiwrite(uint8_t),
writecommand(uint8_t c),
write16BitColor(uint16_t color),
writedata(uint8_t d),
commandList(uint8_t *addr);
uint8_t spiread(void);

private:
uint8_t tabcolor;

boolean hwSPI;

if defined (AVR) || defined(TEENSYDUINO)

uint8_t mySPCR;
volatile uint8_t *mosiport, *clkport, *dcport, *rsport, *csport;
int8_t _cs, _dc, _rst, _mosi, _miso, _sclk;
uint8_t mosipinmask, clkpinmask, cspinmask, dcpinmask;
////This def is for the Arduino.ORG M0!!!
//#elif defined(ARDUINO_SAM_ZERO)
// volatile PORT_OUT_Type *mosiport, *clkport, *dcport, *rsport, *csport;
// int32_t _cs, _dc, _rst, _mosi, _miso, _sclk;
// PORT_OUT_Type mosipinmask, clkpinmask, cspinmask, dcpinmask;

elif defined (STM32F1) || defined (VARIANT_ARDUINO_STM32) || defined (STM32F100xE) || defined (STM32F101xE) || defined (STM32F101xG) || defined (STM32F103xE) || defined (STM32F103xG) || defined (STM32F105xC) || defined (STM32F107xC)

uint8_t mySPCR;

volatile uint32_t *mosiport, *clkport, *dcport, *rsport, *csport;

int32_t  _cs, _dc, _rst, _mosi, _miso, _sclk;

uint32_t  mosipinmask, clkpinmask, cspinmask, dcpinmask;

elif defined (arm)

volatile RwReg *mosiport, *clkport, *dcport, *rsport, *csport;

int32_t  _cs, _dc, _rst, _mosi, _miso, _sclk;

uint32_t  mosipinmask, clkpinmask, cspinmask, dcpinmask;

elif defined (ESP8266)

int32_t  _cs, _dc, _rst, _mosi, _miso, _sclk;

else

int8_t  _cs, _dc, _rst, _mosi, _miso, _sclk;

endif

};

endif

notebook 3d printer

jay jordan — Mon, 25 Dec 2023 16:01:56 +0000

define X_STEP_PIN 54

define X_DIR_PIN 55

define X_ENABLE_PIN 38

define X_MIN_PIN 3

define X_MAX_PIN 2

define Y_STEP_PIN 60

define Y_DIR_PIN 61

define Y_ENABLE_PIN 56

define Y_MIN_PIN 14

define Y_MAX_PIN 15

define Z_STEP_PIN 46

define Z_DIR_PIN 48

define Z_ENABLE_PIN 62

define Z_MIN_PIN 18

define Z_MAX_PIN 19

define E_STEP_PIN 26

define E_DIR_PIN 28

define E_ENABLE_PIN 24

define Q_STEP_PIN 36

define Q_DIR_PIN 34

define Q_ENABLE_PIN 30

define SDPOWER -1

define SDSS 53

define LED_PIN 13

define FAN_PIN 9

define PS_ON_PIN 12

define KILL_PIN -1

define HEATER_0_PIN 10

define HEATER_1_PIN 8

define TEMP_0_PIN 13 // ANALOG NUMBERING

define TEMP_1_PIN 14 // ANALOG NUMBERING

void setup() {

pinMode(FAN_PIN , OUTPUT);

pinMode(HEATER_0_PIN , OUTPUT);

pinMode(HEATER_1_PIN , OUTPUT);

pinMode(LED_PIN , OUTPUT);

pinMode(X_STEP_PIN , OUTPUT);

pinMode(X_DIR_PIN , OUTPUT);

pinMode(X_ENABLE_PIN , OUTPUT);

pinMode(Y_STEP_PIN , OUTPUT);

pinMode(Y_DIR_PIN , OUTPUT);

pinMode(Y_ENABLE_PIN , OUTPUT);

pinMode(Z_STEP_PIN , OUTPUT);

pinMode(Z_DIR_PIN , OUTPUT);

pinMode(Z_ENABLE_PIN , OUTPUT);

pinMode(E_STEP_PIN , OUTPUT);

pinMode(E_DIR_PIN , OUTPUT);

pinMode(E_ENABLE_PIN , OUTPUT);

pinMode(Q_STEP_PIN , OUTPUT);

pinMode(Q_DIR_PIN , OUTPUT);

pinMode(Q_ENABLE_PIN , OUTPUT);

digitalWrite(X_ENABLE_PIN , LOW);

digitalWrite(Y_ENABLE_PIN , LOW);

digitalWrite(Z_ENABLE_PIN , LOW);

digitalWrite(E_ENABLE_PIN , LOW);

digitalWrite(Q_ENABLE_PIN , LOW);

}

void loop () {

if (millis() %1000 <500)

digitalWrite(LED_PIN, HIGH);

else

digitalWrite(LED_PIN, LOW);

if (millis() %1000 <300) {

digitalWrite(HEATER_0_PIN, HIGH);

digitalWrite(HEATER_1_PIN, LOW);

digitalWrite(FAN_PIN, LOW);

} else if (millis() %1000 <600) {

digitalWrite(HEATER_0_PIN, LOW);

digitalWrite(HEATER_1_PIN, HIGH);

digitalWrite(FAN_PIN, LOW);

} else {

digitalWrite(HEATER_0_PIN, LOW);

digitalWrite(HEATER_1_PIN, LOW);

digitalWrite(FAN_PIN, HIGH);

}

if (millis() %10000 <5000) {

digitalWrite(X_DIR_PIN , HIGH);

digitalWrite(Y_DIR_PIN , HIGH);

digitalWrite(Z_DIR_PIN , HIGH);

digitalWrite(E_DIR_PIN , HIGH);

digitalWrite(Q_DIR_PIN , HIGH);

}

else {

digitalWrite(X_DIR_PIN , LOW);

digitalWrite(Y_DIR_PIN , LOW);

digitalWrite(Z_DIR_PIN , LOW);

digitalWrite(E_DIR_PIN , LOW);

digitalWrite(Q_DIR_PIN , LOW);

}

digitalWrite(X_STEP_PIN , HIGH);

digitalWrite(Y_STEP_PIN , HIGH);

digitalWrite(Z_STEP_PIN , HIGH);

digitalWrite(E_STEP_PIN , HIGH);

digitalWrite(Q_STEP_PIN , HIGH);

delay(1);

digitalWrite(X_STEP_PIN , LOW);

digitalWrite(Y_STEP_PIN , LOW);

digitalWrite(Z_STEP_PIN , LOW);

digitalWrite(E_STEP_PIN , LOW);

digitalWrite(Q_STEP_PIN , LOW);

}

ifndef THERMISTORTABLES_H_

define THERMISTORTABLES_H_

define OVERSAMPLENR 16

if (THERMISTORHEATER_0 == 1) || (THERMISTORHEATER_1 == 1) || (THERMISTORHEATER_2 == 1) || (THERMISTORBED == 1) //100k bed thermistor

endif

if (THERMISTORHEATER_0 == 2) || (THERMISTORHEATER_1 == 2) || (THERMISTORHEATER_2 == 2) || (THERMISTORBED == 2) //200k bed thermistor

endif

if (THERMISTORHEATER_0 == 3) || (THERMISTORHEATER_1 == 3) || (THERMISTORHEATER_2 == 3) || (THERMISTORBED == 3) //mendel-parts

endif

if (THERMISTORHEATER_0 == 4) || (THERMISTORHEATER_1 == 4) || (THERMISTORHEATER_2 == 4) || (THERMISTORBED == 4) //10k thermistor

endif

if (THERMISTORHEATER_0 == 5) || (THERMISTORHEATER_1 == 5) || (THERMISTORHEATER_2 == 5) || (THERMISTORBED == 5) //100k ParCan thermistor (104GT-2)

endif

if (THERMISTORHEATER_0 == 6) || (THERMISTORHEATER_1 == 6) || (THERMISTORHEATER_2 == 6) || (THERMISTORBED == 6) // 100k Epcos thermistor

endif

if (THERMISTORHEATER_0 == 7) || (THERMISTORHEATER_1 == 7) || (THERMISTORHEATER_2 == 7) || (THERMISTORBED == 7) // 100k Honeywell 135-104LAG-J01

endif

define TT_NAME(_N) temptable ## _N

define TT_NAME(_N) _TT_NAME(_N)

ifdef THERMISTORHEATER_0

#define heater_0_temptable TT_NAME(THERMISTORHEATER_0)
#define heater_0_temptable_len (sizeof(heater_0_temptable)/sizeof(*heater_0_temptable))

else

ifdef HEATER_0_USES_THERMISTOR

#error No heater 0 thermistor table specified

else // HEATER_0_USES_THERMISTOR

#define heater_0_temptable 0
#define heater_0_temptable_len 0

endif // HEATER_0_USES_THERMISTOR

endif

ifdef THERMISTORHEATER_1

#define heater_1_temptable TT_NAME(THERMISTORHEATER_1)
#define heater_1_temptable_len (sizeof(heater_1_temptable)/sizeof(*heater_1_temptable))

else

ifdef HEATER_1_USES_THERMISTOR

#error No heater 1 thermistor table specified

else // HEATER_1_USES_THERMISTOR

#define heater_1_temptable 0
#define heater_1_temptable_len 0

endif // HEATER_1_USES_THERMISTOR

endif

ifdef THERMISTORHEATER_2

#define heater_2_temptable TT_NAME(THERMISTORHEATER_2)
#define heater_2_temptable_len (sizeof(heater_2_temptable)/sizeof(*heater_2_temptable))

else

ifdef HEATER_2_USES_THERMISTOR

#error No heater 2 thermistor table specified

else // HEATER_2_USES_THERMISTOR

#define heater_2_temptable 0
#define heater_2_temptable_len 0

endif // HEATER_2_USES_THERMISTOR

endif

ifdef THERMISTORBED

#define bedtemptable TT_NAME(THERMISTORBED)
#define bedtemptable_len (sizeof(bedtemptable)/sizeof(*bedtemptable))

else

ifdef BED_USES_THERMISTOR

#error No bed thermistor table specified

endif // BED_USES_THERMISTOR

endif

endif //THERMISTORTABLES_H_

include "thermistortables.h"

define X_STEP_PIN 54

define X_DIR_PIN 55

define X_ENABLE_PIN 38

define X_MIN_PIN 3

define X_MAX_PIN 2

define Y_STEP_PIN 60

define Y_DIR_PIN 61

define Y_ENABLE_PIN 56

define Y_MIN_PIN 14

define Y_MAX_PIN 15

define Z_STEP_PIN 46

define Z_DIR_PIN 48

define Z_ENABLE_PIN 62

define Z_MIN_PIN 18

define Z_MAX_PIN 19

define E_STEP_PIN 26

define E_DIR_PIN 28

define E_ENABLE_PIN 24

define Q_STEP_PIN 36

define Q_DIR_PIN 34

define Q_ENABLE_PIN 30

define SDPOWER -1

define EXTRUDERS 3

define TEMP_SENSOR_AD595_OFFSET 0.0

define TEMP_SENSOR_AD595_GAIN 1.0

define THERMISTORHEATER_0 1

define THERMISTORHEATER_1 1

define THERMISTORHEATER_2 1

define HEATER_0_USES_THERMISTOR 1

define HEATER_1_USES_THERMISTOR 1

define HEATER_2_USES_THERMISTOR 1

static void *heater_ttbl_map[EXTRUDERS] = { (void *)heater_0_temptable

if EXTRUDERS > 1

                                       , (void *)heater_1_temptable

endif

if EXTRUDERS > 2

                                       , (void *)heater_2_temptable

endif

if EXTRUDERS > 3

#error Unsupported number of extruders

endif

};

static int heater_ttbllen_map[EXTRUDERS] = { heater_0_temptable_len

if EXTRUDERS > 1

                                        , heater_1_temptable_len

endif

if EXTRUDERS > 2

                                        , heater_2_temptable_len

endif

if EXTRUDERS > 3

#error Unsupported number of extruders

endif

};

#define PGM_RD_W(x) (short)pgm_read_word(&x)

define SDSS 53

define LED_PIN 13

define FAN_PIN 9

define PS_ON_PIN 12

define KILL_PIN -1

define HEATER_0_PIN 10

define HEATER_1_PIN 8

define TEMP_0_PIN 15 // ANALOG NUMBERING

define TEMP_1_PIN 14 // ANALOG NUMBERING

define TEMP_2_PIN 13 // ANALOG NUMBERING

void setup() {

pinMode(TEMP_0_PIN , INPUT);

pinMode(TEMP_1_PIN , INPUT);

pinMode(TEMP_2_PIN , INPUT);

pinMode(FAN_PIN , OUTPUT);

pinMode(HEATER_0_PIN , OUTPUT);

pinMode(HEATER_1_PIN , OUTPUT);

pinMode(LED_PIN , OUTPUT);

pinMode(X_STEP_PIN , OUTPUT);

pinMode(X_DIR_PIN , OUTPUT);

pinMode(X_ENABLE_PIN , OUTPUT);

pinMode(Y_STEP_PIN , OUTPUT);

pinMode(Y_DIR_PIN , OUTPUT);

pinMode(Y_ENABLE_PIN , OUTPUT);

pinMode(Z_STEP_PIN , OUTPUT);

pinMode(Z_DIR_PIN , OUTPUT);

pinMode(Z_ENABLE_PIN , OUTPUT);

pinMode(E_STEP_PIN , OUTPUT);

pinMode(E_DIR_PIN , OUTPUT);

pinMode(E_ENABLE_PIN , OUTPUT);

pinMode(Q_STEP_PIN , OUTPUT);

pinMode(Q_DIR_PIN , OUTPUT);

pinMode(Q_ENABLE_PIN , OUTPUT);

digitalWrite(X_ENABLE_PIN , LOW);

digitalWrite(Y_ENABLE_PIN , LOW);

digitalWrite(Z_ENABLE_PIN , LOW);

digitalWrite(E_ENABLE_PIN , LOW);

digitalWrite(Q_ENABLE_PIN , LOW);

Serial.begin(115200);

}

float analog2temp(int raw, uint8_t e) {

#ifdef HEATER_0_USES_MAX6675

if (e == 0)

{

 return 0.25 * raw;

}

#endif

if(heater_ttbl_map[e] != 0)

{

float celsius = 0;

byte i;

short (tt)[][2] = (short ()[][2])(heater_ttbl_map[e]);

raw = (1023 * OVERSAMPLENR) - raw;

for (i=1; i<heater_ttbllen_map[e]; i++)

{

 if ((PGM_RD_W((*tt)[i][0]) > raw) && ((float)(PGM_RD_W((*tt)[i][0]) - PGM_RD_W((*tt)[i-1][0])) >0))

 {

   celsius = PGM_RD_W((*tt)[i-1][1]) +

     (raw - PGM_RD_W((*tt)[i-1][0])) *

     (float)(PGM_RD_W((*tt)[i][1]) - PGM_RD_W((*tt)[i-1][1])) /

     (float)(PGM_RD_W((*tt)[i][0]) - PGM_RD_W((*tt)[i-1][0]));

   break;

 }

}

// Overflow: Set to last value in the table

if (i == heater_ttbllen_map[e]) celsius = PGM_RD_W((*tt)[i-1][1]);

return celsius;

}

return ((raw * ((5.0 * 100.0) / 1024.0) / OVERSAMPLENR) * TEMP_SENSOR_AD595_GAIN) + TEMP_SENSOR_AD595_OFFSET;

}

unsigned long prevMillis;

void loop () {

if (millis() %1000 <500)

digitalWrite(LED_PIN, HIGH);

else

digitalWrite(LED_PIN, LOW);

if (millis() %1000 <300) {

digitalWrite(HEATER_0_PIN, HIGH);

digitalWrite(HEATER_1_PIN, LOW);

digitalWrite(FAN_PIN, LOW);

} else if (millis() %1000 <600) {

digitalWrite(HEATER_0_PIN, LOW);

digitalWrite(HEATER_1_PIN, HIGH);

digitalWrite(FAN_PIN, LOW);

} else {

digitalWrite(HEATER_0_PIN, LOW);

digitalWrite(HEATER_1_PIN, LOW);

digitalWrite(FAN_PIN, HIGH);

}

if (millis() %2000 <1000) {

digitalWrite(X_DIR_PIN , HIGH);

digitalWrite(Y_DIR_PIN , HIGH);

digitalWrite(Z_DIR_PIN , HIGH);

digitalWrite(E_DIR_PIN , HIGH);

digitalWrite(Q_DIR_PIN , HIGH);

}

else {

digitalWrite(X_DIR_PIN , LOW);

digitalWrite(Y_DIR_PIN , LOW);

digitalWrite(Z_DIR_PIN , LOW);

digitalWrite(E_DIR_PIN , LOW);

digitalWrite(Q_DIR_PIN , LOW);

}

digitalWrite(X_STEP_PIN , HIGH);

digitalWrite(Y_STEP_PIN , HIGH);

digitalWrite(Z_STEP_PIN , HIGH);

digitalWrite(E_STEP_PIN , HIGH);

digitalWrite(Q_STEP_PIN , HIGH);

delay(1);

digitalWrite(X_STEP_PIN , LOW);

digitalWrite(Y_STEP_PIN , LOW);

digitalWrite(Z_STEP_PIN , LOW);

digitalWrite(E_STEP_PIN , LOW);

digitalWrite(Q_STEP_PIN , LOW);

if (millis() -prevMillis >500){

prevMillis=millis();

int t = analogRead( TEMP_0_PIN);

Serial.print("T0 ");

Serial.print(t);

Serial.print("/");

Serial.print(analog2temp(1024 - t,0),0);

Serial.print(" T1 ");

t = analogRead( TEMP_1_PIN);

Serial.print(t);

Serial.print("/");

Serial.print(analog2temp(1024 - t,1),0);

Serial.print(" T2 ");

t = analogRead( TEMP_2_PIN);

Serial.print(t);

Serial.print("/");

Serial.println(analog2temp(1024 - t,2),0);

}

smart watch printer

jay jordan — Mon, 25 Dec 2023 16:00:27 +0000

include // Подключаем библиотеку для работы по программной шине UART

include // Подключаем библиотеку для работы с принтером

SoftwareSerial mySerial(5, 6); // Объявляем объект библиотеки SoftwareSerial, указывая задействованные выводы Arduino (RX=5-зелёный, TX=6-синий). Можно назначить другие выводы Arduino
Adafruit_Thermal printer(&mySerial); // Объявляем объект библиотеки Adafruit_Thermal, указывая ссылку на созданный ранее объект mySerial библиотеки SoftwareSerial
char* RUS(char*); // Объявляем функцию перевода русских символов из кодировки UTF-8 в кодировку CP866
//
void setup(){ // Код функции setup выполняется только 1 раз, при старте скетча
mySerial.begin(9600); // Инициируем передачу данных по программной шине UART на скорости 9600. Функцию begin объекта mySerial нужно вызвать до вызова функции begin объекта printer!
printer.begin(); // Инициируем работу с термопринтером. В качестве параметра можно указать время нагрева пикселей от 3 (0,03 мс) до 255 (2,55 мс), чем выше тем темнее пикселы. Значение по умолчанию = 120 (1,20 мс)
printer.setCodePage(CODEPAGE_CP866); // Устанавливаем кодовую таблицу CP866 с поддержкой русского языка
printer.setLineHeight(24); // Устанавливаем межстрочный интервал в 2,4 мм (равен высоте текста), чтоб вертикальные линии таблицы не имели промежутков
printer.println(""); // Выводим пустую строку. Это рекомендуется делать для корректной работы некоторых принтеров после инициализации.
printer.write(0xC9); // Выводим символ ╔
for(int i=0; i<29; i++){printer.write(0xCD);} // Выводим символ ═ в цикле (29 символов в одной строке). Ширина таблицы 31 символ, а не 32 (максимальное число символов в строке), для того что бы ячейки таблицы были одинаковой ширины
printer.write(0xBB); // Выводим символ ╗
printer.feed(); // Прокручиваем ленту на 1 строку, для перехода на новую строку. В этом месте можно было бы написать printer.println("") или printer.print("\r\n"), но printer.feed() действует быстрее
printer.write(0xBA); // Выводим символ ║
for(int i=0; i<9; i++){printer.write(0x20);} // Выводим пробел в цикле (9 пробелов в одной строке)
printer.print(RUS("IARDUINO.RU")); // Выводим текст без перехода на новую строку
for(int i=0; i<9; i++){printer.write(0x20);} // Выводим пробел в цикле (9 пробелов в одной строке)
printer.write(0xBA); // Выводим символ ║
printer.feed(); // Прокручиваем ленту на 1 строку, для перехода на новую строку. В этом месте можно было бы написать printer.println("") или printer.print("\r\n"), но printer.feed() действует быстрее
printer.write(0xCC); // Выводим символ ╠
for(int i=0; i<14; i++){printer.write(0xCD);} // Выводим символ ═ в цикле (14 символов в одной строке)
printer.write(0xD1); // Выводим символ ╤
for(int i=0; i<14; i++){printer.write(0xCD);} // Выводим символ ═ в цикле (14 символов в одной строке)
printer.write(0xB9); // Выводим символ ╣
printer.feed(); // Прокручиваем ленту на 1 строку, для перехода на новую строку. В этом месте можно было бы написать printer.println("") или printer.print("\r\n"), но printer.feed() действует быстрее
printer.write(0xBA); // Выводим символ ║
for(int i=0; i<5; i++){printer.write(0x20);} // Выводим пробел в цикле (5 пробелов в одной строке)
printer.print(RUS("ВСЁ")); // Выводим текст без перехода на новую строку
for(int i=0; i<6; i++){printer.write(0x20);} // Выводим пробел в цикле (6 пробелов в одной строке)
printer.write(0xB3); // Выводим символ │
for(int i=0; i<5; i++){printer.write(0x20);} // Выводим пробел в цикле (5 пробелов в одной строке)
printer.print(RUS("ДЛЯ")); // Выводим текст без перехода на новую строку
for(int i=0; i<6; i++){printer.write(0x20);} // Выводим пробел в цикле (6 пробелов в одной строке)
printer.write(0xBA); // Выводим символ ║
printer.feed(); // Прокручиваем ленту на 1 строку, для перехода на новую строку. В этом месте можно было бы написать printer.println("") или printer.print("\r\n"), но printer.feed() действует быстрее
printer.write(0xC7); // Выводим символ ╟
for(int i=0; i<14; i++){printer.write(0xC4);} // Выводим символ ─ в цикле (14 символов в одной строке)
printer.write(0xC5); // Выводим символ ┼
for(int i=0; i<14; i++){printer.write(0xC4);} // Выводим символ ─ в цикле (14 символов в одной строке)
printer.write(0xB6); // Выводим символ ╢
printer.feed(); // Прокручиваем ленту на 1 строку, для перехода на новую строку. В этом месте можно было бы написать printer.println("") или printer.print("\r\n"), но printer.feed() действует быстрее
printer.write(0xBA); // Выводим символ ║
for(int i=0; i<4; i++){printer.write(0x20);} // Выводим пробел в цикле (4 пробела в одной строке)
printer.print(RUS("РАДИО")); // Выводим текст без перехода на новую строку
for(int i=0; i<5; i++){printer.write(0x20);} // Выводим пробел в цикле (5 пробелов в одной строке)
printer.write(0xB3); // Выводим символ │
for(int i=0; i<2; i++){printer.write(0x20);} // Выводим пробел в цикле (2 пробела в одной строке)
printer.print(RUS("ЛЮБИТЕЛЕЙ")); // Выводим текст без перехода на новую строку
for(int i=0; i<3; i++){printer.write(0x20);} // Выводим пробел в цикле (3 пробела в одной строке)
printer.write(0xBA); // Выводим символ ║
printer.feed(); // Прокручиваем ленту на 1 строку, для перехода на новую строку. В этом месте можно было бы написать printer.println("") или printer.print("\r\n"), но printer.feed() действует быстрее
printer.write(0xC8); // Выводим символ ╚
for(int i=0; i<14; i++){printer.write(0xCD);} // Выводим символ ═ в цикле (14 символов в одной строке)
printer.write(0xCF); // Выводим символ ╧
for(int i=0; i<14; i++){printer.write(0xCD);} // Выводим символ ═ в цикле (14 символов в одной строке)
printer.write(0xBC); // Выводим символ ╝
printer.println(""); // Выводим пустую строку.
printer.feed(3); // Прокручиваем ленту на 3 строки, чтоб можно было оторвать ленту.
printer.setDefault(); // Устанавливаем настройки принтера по умолчанию.
//
} //
//
void loop(){} //
//
char* RUS(char* str){ // Определяем функцию которая преобразует код русских символов из кодировки UTF-8 в кодировку CP866
uint8_t i=0, j=0; // Определяем переменные: i - счетчик входящих символов, j - счетчик исходящих символов
while(str[i]){ // Проходим по всем символам строки str, пока не встретим символ конца строки (код 0)
if(uint8_t(str[i]) == 0xD0 && uint8_t(str[i+1]) >= 0x90 && uint8_t(str[i+1]) <= 0xBF ){str[j] = (uint8_t) str[i+1]-0x10; i++;}else // Символы «А-Я а-п» (код UTF-8: D090-D0AF D0B0-D0BF) сохраняем в кодировке CP866: код 80-9F A0-AF (символ занимал 2 байта, а стал занимать 1 байт)
if(uint8_t(str[i]) == 0xD1 && uint8_t(str[i+1]) >= 0x80 && uint8_t(str[i+1]) <= 0x8F ){str[j] = (uint8_t) str[i+1]+0x60; i++;}else // Символы «р-я» (код UTF-8: D180-D18F) сохраняем в кодировке CP866: код E0-EF (символ занимал 2 байта, а стал занимать 1 байт)
if(uint8_t(str[i]) == 0xD0 && uint8_t(str[i+1]) == 0x81 ){str[j] = 0xF0; i++;}else // Символ «Ё» (код UTF-8: D081) сохраняем в кодировке CP866: код F0 (символ занимал 2 байта, а стал занимать 1 байт)
if(uint8_t(str[i]) == 0xD1 && uint8_t(str[i+1]) == 0x91 ){str[j] = 0xF1; i++;}else // Символ «ё» (код UTF-8: D191) сохраняем в кодировке CP866: код F1 (символ занимал 2 байта, а стал занимать 1 байт)
{str[j] = (uint8_t) str[i];} j++; i++; // Остальные символы оставляем как есть, без преобразования, но их место в строке могло сдвинуться, если до них были встречены русские символы
} while(j<i){str[j]=0; j++;} return str; // Так как место занимаемое символами в строке могло уменьшиться, заполняем оставшиеся байты символами конца строки (код 0)
}

include

include "U8glib.h"

include "SoftwareSerial.h"

include

define nextButton 7 //define the pin numbers for the buttons

define previousButton 5

define menuButton 4

define mot 9

define buzz A3

SoftwareSerial bluetooth(2,3); //Use software serial for bluetooth

const unsigned char PROGMEM ICON_BITMAP_1[] =
{ //Android Logo
0x00,0x00,
0x00,0x00,
0x04,0x40,
0x07,0xc0,
0x0f,0xe0,
0x0b,0xa0,
0x1f,0xf0,
0x00,0x00,
0x5f,0xf4,
0x5f,0xf4,
0x5f,0xf4,
0x5f,0xf4,
0x1f,0xf0,
0x0c,0x60,
0x0c,0x60,
0x00,0x00
};

const unsigned char PROGMEM ICON_BITMAP_20[] =
{ //chat
0x00,0x00,
0x00,0x00,
0x3f,0xf8,
0x40,0x04,
0x40,0x04,
0x40,0x04,
0x40,0x04,
0x49,0x24,
0x40,0x04,
0x40,0x04,
0x40,0x04,
0x3f,0xc8,
0x00,0x28,
0x00,0x18,
0x00,0x08,
0x00,0x00
};

const unsigned char PROGMEM ICON_BITMAP_65[] =
{ //bar signal
0x00,0x00,
0x00,0x00,
0x3f,0xe0,
0x10,0x40,
0x08,0x80,
0x05,0x00,
0x02,0x00,
0x02,0x00,
0x02,0x00,
0x00,0x0c,
0x00,0x6c,
0x03,0x6c,
0x1b,0x6c,
0x1b,0x6c,
0x00,0x00,
0x00,0x00
};

int i,c=0,t=0;

boolean clockUp = true;
boolean menuShow = false;
boolean selectButtonbool = false;
boolean newMessage = false;
boolean newCall = false;
boolean newCallR = false;
boolean newNote = false;
boolean newBuzz = false;

byte hours = 0;
byte minutes = 0;
byte seconds = 0;
byte day = 0;
byte date = 0;
byte month = 0;
int year = 0;

int k,j,n1,n2,n3,n4,n5,n6,n7,n8,N1,N2,N3,N4,N5,N6,N7,N8 = 0;
float x1,x2,ans = 0.0;

char DateBuffer[30];
char* TimeStorage [6];
char* vout;

String monthw;
String number;
String numberR;
String NoteS;
String message; //Variable for SMS messages
String blReceived; //Storage for strings received from bluetooth

char msg[150]; //Char array for SMS
char numb[15];
char numbR[15];
char note[300];
String op[4]={"+","-","*","/"};

byte menuSelection = 0; //Menu
byte menuSelections = 0; //Settings
byte menuSelectiona = 0; //Apps
byte len; //Length of message
byte len1;
byte len2;
byte l;

static unsigned long lastTick = 0;

//U8GLIB_SSD1306_ADAFRUIT_128X64 u8g(U8G_I2C_OPT_NO_ACK|U8G_I2C_OPT_FAST);
//U8GLIB_SSD1306_128X64 u8g(U8G_I2C_OPT_DEV_0|U8G_I2C_OPT_NO_ACK|U8G_I2C_OPT_FAST); // I2C / TWI
U8GLIB_SSD1306_128X64 u8g(U8G_I2C_OPT_NO_ACK|U8G_I2C_OPT_FAST);
//U8GLIB_SH1106_128X64_2X u8g(13, 11, 10, 9,8); // SW SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9, RST = 8

void setup(void) {
// flip screen, if required
//u8g.setRot180();

pinMode(nextButton,INPUT); //Set digital pins as inputs
pinMode(previousButton,INPUT);
pinMode(menuButton,INPUT);
pinMode(mot,OUTPUT);
pinMode(buzz,OUTPUT);

Serial.begin(9600);
bluetooth.begin(9600);

digitalWrite(nextButton,HIGH); //Enable internal pull up on all buttons
digitalWrite(previousButton,HIGH);
digitalWrite(menuButton,HIGH);
digitalWrite(mot,HIGH);
delay(500);
digitalWrite(mot,LOW);
drawStartUp();

delay(4000);

}//end of setup

void loop() {
int k,j,n1,n2,n3,n4,n5,n6,n7,n8,N1,N2,N3,N4,N5,N6,N7,N8 = 0;
float x1,x2,ans = 0.0;
t++;
if(t>160)
{
sleep();
}
if(digitalRead(menuButton)==LOW)
t=0;
if(bluetooth.available() > 0 /&& bluetooth.find("(")/)
{
blReceived = bluetooth.readString();
if(blReceived.startsWith("1")) //1 is the preamble date
{
digitalWrite(mot,HIGH);
delay(1000);
digitalWrite(mot,LOW);
seconds++;
blReceived.toCharArray(DateBuffer,blReceived.length()+1);
vout = strtok(DateBuffer,",");
for(int i=0;i<=6;i++)
{
//if(TimeStorage[i] = NULL)
//{Serial.println("Exited Loop");
// break;}
TimeStorage[i] = strtok(NULL,",");
delay(10);
}
//int example = bluetooth.parseInt();
day = atoi(TimeStorage[0] - 1);
date = atoi(TimeStorage[1]);
month = atoi(TimeStorage[2]);
year = atoi(TimeStorage[3]);
hours = atoi(TimeStorage[4]);
minutes = atoi(TimeStorage[5]);
seconds = atoi(TimeStorage[6]);
blReceived="";
t=0;
}
else if (blReceived.startsWith("2"))
{
digitalWrite(mot,HIGH);
delay(1000);
digitalWrite(mot,LOW);
seconds++;
newMessage = true;
message = blReceived;
//sms();
//delay(300000);
blReceived="";
t=0;
}
else if (blReceived.startsWith("3"))
{
digitalWrite(mot,HIGH);
delay(1000);
digitalWrite(mot,LOW);
seconds++;
newCall = true;
number = blReceived;
//num();
//delay(300000);
blReceived="";
t=0;
}
else if (blReceived.startsWith("4"))
{
digitalWrite(mot,HIGH);
delay(1000);
digitalWrite(mot,LOW);
newCallR = true;
numberR = blReceived;
t=0;
u8g.firstPage();
do
{
u8g.setFont(u8g_font_unifont);
u8g.setPrintPos(0,20);
u8g.print("Calling...");
u8g.setPrintPos(0,40);
u8g.print(numberR);
len2 = numberR.length();

  number.toCharArray(numbR, len2+1);
  //Serial.println(len2);
  if(len2<15)
  {
     //Serial.println("If");
     for (int i = 0;(i-1)<len2;i++)
     {
        //Serial.println("Enter for loop");
        u8g.setPrintPos(i*8,30);
        u8g.print(numbR[i-15]);
        delay(10);
        if(numbR[i-16] == '\0')
        { 
           //Serial.println("Break!!");
           break;
           //delay(3000);
        }
     }
  }

}
while (u8g.nextPage());
blReceived="";
delay(15000);
seconds=seconds+15;
newCallR = false;
}
else if (blReceived.startsWith("5"))
{
digitalWrite(mot,HIGH);
delay(1000);
digitalWrite(mot,LOW);
seconds++;
newNote = true;
NoteS = blReceived;
//notes();
//delay(300000);
blReceived="";
t=0;
}
else if (blReceived.startsWith("6"))
{
newBuzz = true;
Buzz();
blReceived="";
t=0;
}

/Serial.println(day-1);
Serial.println(date);
Serial.println(month);
Serial.println(year);
Serial.println(hours);
Serial.println(minutes);
Serial.println(seconds);/
} //end of if for datetime

/Serial.println(day-1);
Serial.println(date);
Serial.println(month);
Serial.println(year);
Serial.println(hours);
Serial.println(minutes);
Serial.println(seconds);/

/*else if(bluetooth.available() > 0 && bluetooth.find("CMD")==true)
{
Serial.println("ENTERED MESSAGE");
message = bluetooth.readString();
Serial.println(message);
//delay(300000);
}
*/

if(digitalRead(previousButton)==LOW && digitalRead(nextButton)==LOW) //button is activated
{
seconds=seconds+4;

if(menuShow == false) //To toggle the menu states
{
menuShow = true;
delay(100);
menu(); //Get back the menu selection number

if(menuSelection == 4)
{
seconds=seconds+4;
delay(100);
menuSelection = 0;
while(digitalRead(menuButton)== HIGH)
{
HA();
delay(10);
}
}
if(menuSelection == 3)
{
seconds=seconds+4;
settings();
if(menuSelections == 2)
{
seconds=seconds+4;
delay(100);
menuSelections=0;
delay(100);
while(digitalRead(menuButton)== HIGH)
{
notice();
}
delay(100);
}
if(menuSelections == 3)
{
seconds=seconds+4;
delay(100);
menuSelections=0;
while(digitalRead(menuButton)==HIGH)
{
torch();
delay(10);
}
}
if(menuSelections == 4)
{
seconds=seconds+4;
delay(100);
menuSelections=0;
while(digitalRead(menuButton)==HIGH)
{
bluetooth.write("1");
delay(1000);
bluetooth.write("");
}
}
bluetooth.write("");
bluetooth.write("2");
bluetooth.write("");
}
if(menuSelection == 2)
{
seconds=seconds+4;
apps();
if(menuSelectiona == 2)
{

seconds=seconds+4;
delay(100);
menuSelectiona = 0;
while(digitalRead(menuButton)==HIGH)
{
Calc();
}
bluetooth.write("");

}

    if(menuSelectiona == 3)
    {
       seconds=seconds+4;
       delay(100);
       menuSelectiona = 0;
       while(digitalRead(menuButton)== HIGH)
       {sms();}
       delay(100);
    }
    if(menuSelectiona == 4)
    {
       seconds=seconds+4;
       delay(100);
       menuSelectiona = 0;
       while(digitalRead(menuButton)== HIGH)
       {call();}
       delay(100);
    }
 }

}
if(menuShow == true)
{
menuShow = false;
delay(100);

}
}//end of if
advanceTime();
delay(30);
}//end of loop

void sleep()
{
u8g.firstPage();
do{}
while(u8g.nextPage());
}

void advanceTime()
{
if(millis()-lastTick>950) //somehow
{
lastTick = millis();
seconds++;
}

if (seconds > 59)
{
minutes++;
seconds = 0;
}

if (minutes >59)
{
hours++;
minutes = 0;
}

if (hours > 23)
{
hours = 0;
minutes = 0;
date+=1;
}
draw();

}

//**------------------U8Glib Functions------------------**
void HA()
{
u8g.firstPage();

do {
bluetooth.write("3");
u8g.setFont(u8g_font_unifont);
u8g.setPrintPos(0,10);
u8g.print("Home Automation");
u8g.setFont(u8g_font_unifont);
u8g.setPrintPos(30,10);
u8g.print("In Development");
bluetooth.write("");
} while( u8g.nextPage() );
}

void Buzz()
{
while(c<5)
{
for(i=1;i<256;i++)
{
analogWrite(buzz,i);
delay(3.92);
}
for(i=256;i>0;i--)
{
analogWrite(buzz,i);
delay(3.92);
}
c++;
}
c=0;
newBuzz=false;
}

void drawStartUp()
{
u8g.firstPage();
do
{
//u8g_prepare();
u8g.setColorIndex(0);
u8g.drawBox(0,0,127,63);
u8g.setColorIndex(1);
u8g.setFont(u8g_font_7x14r);
u8g.setPrintPos(5,10);
u8g.print("Developed By:-");
u8g.setFont(u8g_font_fur17r);
u8g.setPrintPos(10,38);
u8g.print("USER");
u8g.setFont(u8g_font_7x14r);
u8g.setPrintPos(5,62);
u8g.print("V402");
}
while(u8g.nextPage());
} //end of drawStartUp

void menu()
{

u8g.setColorIndex(1);
//u8g.drawCircle(20,20,14);
menuSelection = 1;
while(digitalRead(menuButton) == HIGH)
{
if(digitalRead(nextButton) == LOW)
{
delay(20);
menuSelection++;
delay(50);
}

 if(digitalRead(previousButton) == LOW)
 {
    delay(20);
    menuSelection--;
    delay(50);
 }

 if(menuSelection > 4)
 {menuSelection = 1;}

 if(menuSelection < 1)
 {menuSelection = 4;}
 //draw picture here
 drawMenu();

 delay(50); //For debouncing

 //draw menus here

}//end of while loop
}//end of menu

void drawMenu()
{
u8g.firstPage();
do
{
u8g.setFont(u8g_font_6x10r);
u8g.setPrintPos(30,8);
u8g.print("--- Menu ---");
//u8g.setPrintPos(0,10);
//u8g.print(menuSelection);
u8g.drawFrame(0,(menuSelection*13)-3,128,13); //Box height is 13 pixels
u8g.drawLine(0,10,128,10);

  //Draw menu options
  u8g.drawStr(3,20,"Return");
  u8g.drawStr(3,20+13,"Apps");
  u8g.drawStr(3,20+13+13,"Settings");
  u8g.drawStr(3,20+13+13+13,"Home Auto(Beta)");
  //u8g.drawStr(3,20+13+13+13,"More");

}
while(u8g.nextPage());
}

void apps()
{
u8g.setColorIndex(1);
//u8g.drawCircle(20,20,14);
menuSelectiona = 1;
delay(200);
while(digitalRead(menuButton) == HIGH)
{
if(digitalRead(nextButton) == LOW)
{
delay(20);
menuSelectiona++;
Serial.println("Up");
delay(50);
}

  if(digitalRead(previousButton) == LOW)
  {
     delay(20);
     menuSelectiona--;
     delay(50);
  }

  if(menuSelectiona > 4)
  {menuSelectiona = 1;}

  if(menuSelectiona < 1)
  {menuSelectiona = 4;}
  //draw picture here
drawApps();
delay(50); //For debouncing

}//end of while loop
}

void notice()
{
u8g.firstPage();
do
{
u8g.setFont(u8g_font_6x10r);
//u8g.print(NoteS);
l = NoteS.length();
NoteS.toCharArray(note, l+1);
//Serial.println(len);
if(l>0)
{
for(i=0;i<20;i++)
{
u8g.setPrintPos(i*6,8);
u8g.print(note[i]);
delay(10);
}
}
if(l>20)
{
for(i=20;i<40;i++)
{
u8g.setPrintPos((i-20)*6,17);
u8g.print(note[i]);
delay(10);
}
}
if(l>40)
{
for(i=40;i<60;i++)
{
u8g.setPrintPos((i-40)*6,26);
u8g.print(note[i]);
delay(10);
}
}
if(l>60)
{
for(i=60;i<80;i++)
{
u8g.setPrintPos((i-60)*6,35);
u8g.print(note[i]);
delay(10);
}
}
if(l>80)
{
for(i=80;i<100;i++)
{
u8g.setPrintPos((i-80)*6,43);
u8g.print(note[i]);
delay(10);
}
}
if(l>100)
{
for(i=100;i<120;i++)
{
u8g.setPrintPos((i-100)*6,51);
u8g.print(note[i]);
delay(10);
}
}
if(l>120)
{
for(i=120;i<140;i++)
{
u8g.setPrintPos((i-120)*6,59);
u8g.print(note[i]);
delay(10);
}
}
}
while (u8g.nextPage());
delay(30);
newNote = false;
}

void torch()
{
u8g.firstPage();
do{u8g.drawBox(0,0,127,63);}
while(u8g.nextPage());
}

void drawApps()
{
u8g.firstPage();
do
{
u8g.setFont(u8g_font_6x10r);
u8g.setPrintPos(5,8);
u8g.print("--- Applications ---");
//u8g.setPrintPos(0,10);
//u8g.print(menuSelection);
u8g.drawFrame(0,(menuSelectiona*13)-3,128,13); //Box height is 13 pixels
u8g.drawLine(0,10,128,10);

  //Draw menu options
  u8g.drawStr(3,20,"Return");
  u8g.drawStr(3,20+13,"CALC");
  u8g.drawStr(3,20+13+13,"SMS");
  u8g.drawStr(3,20+13+13+13,"CALLS");
  //u8g.drawStr(3,20+13+13+13,"More");

}

while(u8g.nextPage());
}

void settings()
{
u8g.setColorIndex(1);
//u8g.drawCircle(20,20,14);
menuSelections = 1;
delay(200);
while(digitalRead(menuButton) == HIGH)
{

if(digitalRead(nextButton) == LOW)
{
delay(20);
menuSelections++;
Serial.println("Up");
delay(50);
}

  if(digitalRead(previousButton) == LOW)
  {
     delay(20);
     menuSelections--;
     delay(50);
  }

  if(menuSelections > 4)
  {menuSelections = 1;}

  if(menuSelections < 1)
  {menuSelections = 4;}
  //draw picture here
  drawSettings();

  delay(50); //For debouncing

}//end of while loop
}

void sms()
{
u8g.firstPage();
do
{
u8g.setFont(u8g_font_unifont);
u8g.setPrintPos(0,10);
u8g.print(message);
len = message.length();

  message.toCharArray(msg, len+1);
  //Serial.println(len);
  if(len>16)
  {
     //Serial.println("If");
     for (int i = 0;(i-1)<len;i++)
     {
        //Serial.println("Enter for loop");
        u8g.setPrintPos(i*8,30);
        u8g.print(msg[i+16]);
        delay(10);
        if(msg[i+17] == '\0')
        { 
           //Serial.println("Break!!");
           break;
           //delay(3000);
        }
     }
  }

  if(len>32)
  {
     //Serial.println("If");
     for (int i = 0;(i-1)<len;i++)
     {
        //Serial.println("Enter for loop");
        u8g.setPrintPos(i*8,50);
        u8g.print(msg[i+32]);
        delay(10);
        if(msg[i+33] == '\0')
        { 
           //Serial.println("Break!!");
           break;
           //delay(3000);
        }
     }
  }

}
while (u8g.nextPage());
delay(30);
newMessage = false;
}

void call()
{
u8g.firstPage();
do
{
u8g.setFont(u8g_font_unifont);
u8g.setPrintPos(0,10);
u8g.print(number);
len1 = number.length();

  number.toCharArray(numb, len1+1);
  //Serial.println(len1);
  if(len1<15)
  {
     //Serial.println("If");
     for (int i = 0;(i-1)<len1;i++)
     {
        //Serial.println("Enter for loop");
        u8g.setPrintPos(i*8,30);
        u8g.print(numb[i-15]);
        delay(10);
        if(numb[i-16] == '\0')
        { 
           //Serial.println("Break!!");
           break;
           //delay(3000);
        }
     }
  }

}
while (u8g.nextPage());
delay(30);
newCall = false;
}

void drawSettings()
{
u8g.firstPage();
do
{
u8g.setFont(u8g_font_6x10r);
u8g.setPrintPos(15,8);
u8g.print("--- Settings ---");
//u8g.setPrintPos(0,10);
//u8g.print(menuSelection);
u8g.drawFrame(0,(menuSelections*13)-3,128,13); //Box height is 13 pixels
u8g.drawLine(0,10,128,10);

  //Draw menu options
  u8g.drawStr(3,20,"Return");
  u8g.drawStr(3,20+13,"Notes");
  u8g.drawStr(3,20+13+13,"Torch");
  u8g.drawStr(3,20+13+13+13,"Find My Phone");

}
while(u8g.nextPage());
}

void CalcPrintdata()
{
u8g.setPrintPos(50,25);
u8g.print(n3);
u8g.setPrintPos(40,25);
u8g.print(n4);
u8g.setPrintPos(30,25);
u8g.print(n5);
u8g.setPrintPos(20,25);
u8g.print(n6);
u8g.setPrintPos(60,25);
u8g.print(".");
u8g.setPrintPos(70,25);
u8g.print(n7);
u8g.setPrintPos(80,25);
u8g.print(n8);
u8g.setPrintPos(3,37);
u8g.print(op[k]);
u8g.setPrintPos(50,37);
u8g.print(N3);
u8g.setPrintPos(40,37);
u8g.print(N4);
u8g.setPrintPos(30,37);
u8g.print(N5);
u8g.setPrintPos(20,37);
u8g.print(N6);
u8g.setPrintPos(60,37);
u8g.print(".");
u8g.setPrintPos(70,37);
u8g.print(N7);
u8g.setPrintPos(80,37);
u8g.print(N8);
u8g.setPrintPos(5,46);
u8g.print("---------------");

u8g.setPrintPos(5,54);
u8g.print(ans);
}

void Calc()
{
u8g.firstPage();
do{
u8g.setFont(u8g_font_unifont);
u8g.setPrintPos(0,10);
u8g.print("Calculator:-");
if(digitalRead(previousButton) == LOW)
{
j++;
delay(300);
if(j>12)
j = 0;
}
if(digitalRead(nextButton)==LOW && digitalRead(previousButton)==LOW)
{
j=13;
delay(300);
}
if(j==0)
{
CalcPrintdata();
if(digitalRead(nextButton) == LOW)
{
n6++;
delay(300);
}
if(n6>9)
n6=0;
}
if(j==1)
{
CalcPrintdata();
if(digitalRead(nextButton) == LOW)
{
n5++;
delay(300);
}
if(n5>9)
n5=0;
}
if(j==2)
{
CalcPrintdata();
if(digitalRead(nextButton) == LOW)
{
n4++;
delay(300);
}
if(n4>9)
n4=0;
}
if(j==3)
{
CalcPrintdata();
if(digitalRead(nextButton) == LOW)
{
n3++;
delay(300);
}
if(n3>9)
n3=0;
}
if(j==4)
{
CalcPrintdata();
if(digitalRead(nextButton) == LOW)
{
n7++;
delay(300);
}
if(n7>9)
n7=0;
}
if(j==5)
{
CalcPrintdata();
if(digitalRead(nextButton) == LOW)
{
n8++;
delay(300);
}
if(n8>9)
n8=0;
}
if(j==6)
{
CalcPrintdata();
if(digitalRead(nextButton) == LOW)
{
k++;
delay(300);
}
if(k>3)
k=0;
}
if(j==7)
{
CalcPrintdata();
if(digitalRead(nextButton) == LOW)
{
N6++;
delay(300);
...

smart watch with 3d printer function

jay jordan — Mon, 25 Dec 2023 15:58:15 +0000

define X_STEP_PIN 54

define X_DIR_PIN 55

define X_ENABLE_PIN 38

define X_MIN_PIN 3

define X_MAX_PIN 2

define Y_STEP_PIN 60

define Y_DIR_PIN 61

define Y_ENABLE_PIN 56

define Y_MIN_PIN 14

define Y_MAX_PIN 15

define Z_STEP_PIN 46

define Z_DIR_PIN 48

define Z_ENABLE_PIN 62

define Z_MIN_PIN 18

define Z_MAX_PIN 19

define E_STEP_PIN 26

define E_DIR_PIN 28

define E_ENABLE_PIN 24

define Q_STEP_PIN 36

define Q_DIR_PIN 34

define Q_ENABLE_PIN 30

define SDPOWER -1

define SDSS 53

define LED_PIN 13

define FAN_PIN 9

define PS_ON_PIN 12

define KILL_PIN -1

define HEATER_0_PIN 10

define HEATER_1_PIN 8

define TEMP_0_PIN 13 // ANALOG NUMBERING

define TEMP_1_PIN 14 // ANALOG NUMBERING

void setup() {

pinMode(FAN_PIN , OUTPUT);

pinMode(HEATER_0_PIN , OUTPUT);

pinMode(HEATER_1_PIN , OUTPUT);

pinMode(LED_PIN , OUTPUT);

pinMode(X_STEP_PIN , OUTPUT);

pinMode(X_DIR_PIN , OUTPUT);

pinMode(X_ENABLE_PIN , OUTPUT);

pinMode(Y_STEP_PIN , OUTPUT);

pinMode(Y_DIR_PIN , OUTPUT);

pinMode(Y_ENABLE_PIN , OUTPUT);

pinMode(Z_STEP_PIN , OUTPUT);

pinMode(Z_DIR_PIN , OUTPUT);

pinMode(Z_ENABLE_PIN , OUTPUT);

pinMode(E_STEP_PIN , OUTPUT);

pinMode(E_DIR_PIN , OUTPUT);

pinMode(E_ENABLE_PIN , OUTPUT);

pinMode(Q_STEP_PIN , OUTPUT);

pinMode(Q_DIR_PIN , OUTPUT);

pinMode(Q_ENABLE_PIN , OUTPUT);

digitalWrite(X_ENABLE_PIN , LOW);

digitalWrite(Y_ENABLE_PIN , LOW);

digitalWrite(Z_ENABLE_PIN , LOW);

digitalWrite(E_ENABLE_PIN , LOW);

digitalWrite(Q_ENABLE_PIN , LOW);

}

void loop () {

if (millis() %1000 <500)

digitalWrite(LED_PIN, HIGH);

else

digitalWrite(LED_PIN, LOW);

if (millis() %1000 <300) {

digitalWrite(HEATER_0_PIN, HIGH);

digitalWrite(HEATER_1_PIN, LOW);

digitalWrite(FAN_PIN, LOW);

} else if (millis() %1000 <600) {

digitalWrite(HEATER_0_PIN, LOW);

digitalWrite(HEATER_1_PIN, HIGH);

digitalWrite(FAN_PIN, LOW);

} else {

digitalWrite(HEATER_0_PIN, LOW);

digitalWrite(HEATER_1_PIN, LOW);

digitalWrite(FAN_PIN, HIGH);

}

if (millis() %10000 <5000) {

digitalWrite(X_DIR_PIN , HIGH);

digitalWrite(Y_DIR_PIN , HIGH);

digitalWrite(Z_DIR_PIN , HIGH);

digitalWrite(E_DIR_PIN , HIGH);

digitalWrite(Q_DIR_PIN , HIGH);

}

else {

digitalWrite(X_DIR_PIN , LOW);

digitalWrite(Y_DIR_PIN , LOW);

digitalWrite(Z_DIR_PIN , LOW);

digitalWrite(E_DIR_PIN , LOW);

digitalWrite(Q_DIR_PIN , LOW);

}

digitalWrite(X_STEP_PIN , HIGH);

digitalWrite(Y_STEP_PIN , HIGH);

digitalWrite(Z_STEP_PIN , HIGH);

digitalWrite(E_STEP_PIN , HIGH);

digitalWrite(Q_STEP_PIN , HIGH);

delay(1);

digitalWrite(X_STEP_PIN , LOW);

digitalWrite(Y_STEP_PIN , LOW);

digitalWrite(Z_STEP_PIN , LOW);

digitalWrite(E_STEP_PIN , LOW);

digitalWrite(Q_STEP_PIN , LOW);

}

ifndef THERMISTORTABLES_H_

define THERMISTORTABLES_H_

define OVERSAMPLENR 16

if (THERMISTORHEATER_0 == 1) || (THERMISTORHEATER_1 == 1) || (THERMISTORHEATER_2 == 1) || (THERMISTORBED == 1) //100k bed thermistor

endif

if (THERMISTORHEATER_0 == 2) || (THERMISTORHEATER_1 == 2) || (THERMISTORHEATER_2 == 2) || (THERMISTORBED == 2) //200k bed thermistor

endif

if (THERMISTORHEATER_0 == 3) || (THERMISTORHEATER_1 == 3) || (THERMISTORHEATER_2 == 3) || (THERMISTORBED == 3) //mendel-parts

endif

if (THERMISTORHEATER_0 == 4) || (THERMISTORHEATER_1 == 4) || (THERMISTORHEATER_2 == 4) || (THERMISTORBED == 4) //10k thermistor

endif

if (THERMISTORHEATER_0 == 5) || (THERMISTORHEATER_1 == 5) || (THERMISTORHEATER_2 == 5) || (THERMISTORBED == 5) //100k ParCan thermistor (104GT-2)

endif

if (THERMISTORHEATER_0 == 6) || (THERMISTORHEATER_1 == 6) || (THERMISTORHEATER_2 == 6) || (THERMISTORBED == 6) // 100k Epcos thermistor

endif

if (THERMISTORHEATER_0 == 7) || (THERMISTORHEATER_1 == 7) || (THERMISTORHEATER_2 == 7) || (THERMISTORBED == 7) // 100k Honeywell 135-104LAG-J01

endif

define TT_NAME(_N) temptable ## _N

define TT_NAME(_N) _TT_NAME(_N)

ifdef THERMISTORHEATER_0

#define heater_0_temptable TT_NAME(THERMISTORHEATER_0)
#define heater_0_temptable_len (sizeof(heater_0_temptable)/sizeof(*heater_0_temptable))

else

ifdef HEATER_0_USES_THERMISTOR

#error No heater 0 thermistor table specified

else // HEATER_0_USES_THERMISTOR

#define heater_0_temptable 0
#define heater_0_temptable_len 0

endif // HEATER_0_USES_THERMISTOR

endif

ifdef THERMISTORHEATER_1

#define heater_1_temptable TT_NAME(THERMISTORHEATER_1)
#define heater_1_temptable_len (sizeof(heater_1_temptable)/sizeof(*heater_1_temptable))

else

ifdef HEATER_1_USES_THERMISTOR

#error No heater 1 thermistor table specified

else // HEATER_1_USES_THERMISTOR

#define heater_1_temptable 0
#define heater_1_temptable_len 0

endif // HEATER_1_USES_THERMISTOR

endif

ifdef THERMISTORHEATER_2

#define heater_2_temptable TT_NAME(THERMISTORHEATER_2)
#define heater_2_temptable_len (sizeof(heater_2_temptable)/sizeof(*heater_2_temptable))

else

ifdef HEATER_2_USES_THERMISTOR

#error No heater 2 thermistor table specified

else // HEATER_2_USES_THERMISTOR

#define heater_2_temptable 0
#define heater_2_temptable_len 0

endif // HEATER_2_USES_THERMISTOR

endif

ifdef THERMISTORBED

#define bedtemptable TT_NAME(THERMISTORBED)
#define bedtemptable_len (sizeof(bedtemptable)/sizeof(*bedtemptable))

else

ifdef BED_USES_THERMISTOR

#error No bed thermistor table specified

endif // BED_USES_THERMISTOR

endif

endif //THERMISTORTABLES_H_

include "thermistortables.h"

define X_STEP_PIN 54

define X_DIR_PIN 55

define X_ENABLE_PIN 38

define X_MIN_PIN 3

define X_MAX_PIN 2

define Y_STEP_PIN 60

define Y_DIR_PIN 61

define Y_ENABLE_PIN 56

define Y_MIN_PIN 14

define Y_MAX_PIN 15

define Z_STEP_PIN 46

define Z_DIR_PIN 48

define Z_ENABLE_PIN 62

define Z_MIN_PIN 18

define Z_MAX_PIN 19

define E_STEP_PIN 26

define E_DIR_PIN 28

define E_ENABLE_PIN 24

define Q_STEP_PIN 36

define Q_DIR_PIN 34

define Q_ENABLE_PIN 30

define SDPOWER -1

define EXTRUDERS 3

define TEMP_SENSOR_AD595_OFFSET 0.0

define TEMP_SENSOR_AD595_GAIN 1.0

define THERMISTORHEATER_0 1

define THERMISTORHEATER_1 1

define THERMISTORHEATER_2 1

define HEATER_0_USES_THERMISTOR 1

define HEATER_1_USES_THERMISTOR 1

define HEATER_2_USES_THERMISTOR 1

static void *heater_ttbl_map[EXTRUDERS] = { (void *)heater_0_temptable

if EXTRUDERS > 1

                                       , (void *)heater_1_temptable

endif

if EXTRUDERS > 2

                                       , (void *)heater_2_temptable

endif

if EXTRUDERS > 3

#error Unsupported number of extruders

endif

};

static int heater_ttbllen_map[EXTRUDERS] = { heater_0_temptable_len

if EXTRUDERS > 1

                                        , heater_1_temptable_len

endif

if EXTRUDERS > 2

                                        , heater_2_temptable_len

endif

if EXTRUDERS > 3

#error Unsupported number of extruders

endif

};

#define PGM_RD_W(x) (short)pgm_read_word(&x)

define SDSS 53

define LED_PIN 13

define FAN_PIN 9

define PS_ON_PIN 12

define KILL_PIN -1

define HEATER_0_PIN 10

define HEATER_1_PIN 8

define TEMP_0_PIN 15 // ANALOG NUMBERING

define TEMP_1_PIN 14 // ANALOG NUMBERING

define TEMP_2_PIN 13 // ANALOG NUMBERING

void setup() {

pinMode(TEMP_0_PIN , INPUT);

pinMode(TEMP_1_PIN , INPUT);

pinMode(TEMP_2_PIN , INPUT);

pinMode(FAN_PIN , OUTPUT);

pinMode(HEATER_0_PIN , OUTPUT);

pinMode(HEATER_1_PIN , OUTPUT);

pinMode(LED_PIN , OUTPUT);

pinMode(X_STEP_PIN , OUTPUT);

pinMode(X_DIR_PIN , OUTPUT);

pinMode(X_ENABLE_PIN , OUTPUT);

pinMode(Y_STEP_PIN , OUTPUT);

pinMode(Y_DIR_PIN , OUTPUT);

pinMode(Y_ENABLE_PIN , OUTPUT);

pinMode(Z_STEP_PIN , OUTPUT);

pinMode(Z_DIR_PIN , OUTPUT);

pinMode(Z_ENABLE_PIN , OUTPUT);

pinMode(E_STEP_PIN , OUTPUT);

pinMode(E_DIR_PIN , OUTPUT);

pinMode(E_ENABLE_PIN , OUTPUT);

pinMode(Q_STEP_PIN , OUTPUT);

pinMode(Q_DIR_PIN , OUTPUT);

pinMode(Q_ENABLE_PIN , OUTPUT);

digitalWrite(X_ENABLE_PIN , LOW);

digitalWrite(Y_ENABLE_PIN , LOW);

digitalWrite(Z_ENABLE_PIN , LOW);

digitalWrite(E_ENABLE_PIN , LOW);

digitalWrite(Q_ENABLE_PIN , LOW);

Serial.begin(115200);

}

float analog2temp(int raw, uint8_t e) {

#ifdef HEATER_0_USES_MAX6675

if (e == 0)

{

 return 0.25 * raw;

}

#endif

if(heater_ttbl_map[e] != 0)

{

float celsius = 0;

byte i;

short (tt)[][2] = (short ()[][2])(heater_ttbl_map[e]);

raw = (1023 * OVERSAMPLENR) - raw;

for (i=1; i<heater_ttbllen_map[e]; i++)

{

 if ((PGM_RD_W((*tt)[i][0]) > raw) && ((float)(PGM_RD_W((*tt)[i][0]) - PGM_RD_W((*tt)[i-1][0])) >0))

 {

   celsius = PGM_RD_W((*tt)[i-1][1]) +

     (raw - PGM_RD_W((*tt)[i-1][0])) *

     (float)(PGM_RD_W((*tt)[i][1]) - PGM_RD_W((*tt)[i-1][1])) /

     (float)(PGM_RD_W((*tt)[i][0]) - PGM_RD_W((*tt)[i-1][0]));

   break;

 }

}

// Overflow: Set to last value in the table

if (i == heater_ttbllen_map[e]) celsius = PGM_RD_W((*tt)[i-1][1]);

return celsius;

}

return ((raw * ((5.0 * 100.0) / 1024.0) / OVERSAMPLENR) * TEMP_SENSOR_AD595_GAIN) + TEMP_SENSOR_AD595_OFFSET;

}

unsigned long prevMillis;

void loop () {

if (millis() %1000 <500)

digitalWrite(LED_PIN, HIGH);

else

digitalWrite(LED_PIN, LOW);

if (millis() %1000 <300) {

digitalWrite(HEATER_0_PIN, HIGH);

digitalWrite(HEATER_1_PIN, LOW);

digitalWrite(FAN_PIN, LOW);

} else if (millis() %1000 <600) {

digitalWrite(HEATER_0_PIN, LOW);

digitalWrite(HEATER_1_PIN, HIGH);

digitalWrite(FAN_PIN, LOW);

} else {

digitalWrite(HEATER_0_PIN, LOW);

digitalWrite(HEATER_1_PIN, LOW);

digitalWrite(FAN_PIN, HIGH);

}

if (millis() %2000 <1000) {

digitalWrite(X_DIR_PIN , HIGH);

digitalWrite(Y_DIR_PIN , HIGH);

digitalWrite(Z_DIR_PIN , HIGH);

digitalWrite(E_DIR_PIN , HIGH);

digitalWrite(Q_DIR_PIN , HIGH);

}

else {

digitalWrite(X_DIR_PIN , LOW);

digitalWrite(Y_DIR_PIN , LOW);

digitalWrite(Z_DIR_PIN , LOW);

digitalWrite(E_DIR_PIN , LOW);

digitalWrite(Q_DIR_PIN , LOW);

}

digitalWrite(X_STEP_PIN , HIGH);

digitalWrite(Y_STEP_PIN , HIGH);

digitalWrite(Z_STEP_PIN , HIGH);

digitalWrite(E_STEP_PIN , HIGH);

digitalWrite(Q_STEP_PIN , HIGH);

delay(1);

digitalWrite(X_STEP_PIN , LOW);

digitalWrite(Y_STEP_PIN , LOW);

digitalWrite(Z_STEP_PIN , LOW);

digitalWrite(E_STEP_PIN , LOW);

digitalWrite(Q_STEP_PIN , LOW);

if (millis() -prevMillis >500){

prevMillis=millis();

int t = analogRead( TEMP_0_PIN);

Serial.print("T0 ");

Serial.print(t);

Serial.print("/");

Serial.print(analog2temp(1024 - t,0),0);

Serial.print(" T1 ");

t = analogRead( TEMP_1_PIN);

Serial.print(t);

Serial.print("/");

Serial.print(analog2temp(1024 - t,1),0);

Serial.print(" T2 ");

t = analogRead( TEMP_2_PIN);

Serial.print(t);

Serial.print("/");

Serial.println(analog2temp(1024 - t,2),0);

}

include

include "U8glib.h"

include "SoftwareSerial.h"

include

define nextButton 7 //define the pin numbers for the buttons

define previousButton 5

define menuButton 4

define mot 9

define buzz A3

SoftwareSerial bluetooth(2,3); //Use software serial for bluetooth

int i,c=0,t=0;

byte hours = 0;
byte minutes = 0;
byte seconds = 0;
byte day = 0;
byte date = 0;
byte month = 0;
int year = 0;

int k,j,n1,n2,n3,n4,n5,n6,n7,n8,N1,N2,N3,N4,N5,N6,N7,N8 = 0;
float x1,x2,ans = 0.0;

char DateBuffer[30];
char* TimeStorage [6];
char* vout;

String monthw;
String number;
String numberR;
String NoteS;
String message; //Variable for SMS messages
String blReceived; //Storage for strings received from bluetooth

char msg[150]; //Char array for SMS
char numb[15];
char numbR[15];
char note[300];
String op[4]={"+","-","*","/"};

byte menuSelection = 0; //Menu
byte menuSelections = 0; //Settings
byte menuSelectiona = 0; //Apps
byte len; //Length of message
byte len1;
byte len2;
byte l;

static unsigned long lastTick = 0;

void setup(void) {
// flip screen, if required
//u8g.setRot180();

pinMode(nextButton,INPUT); //Set digital pins as inputs
pinMode(previousButton,INPUT);
pinMode(menuButton,INPUT);
pinMode(mot,OUTPUT);
pinMode(buzz,OUTPUT);

Serial.begin(9600);
bluetooth.begin(9600);

}//end of setup

  number.toCharArray(numbR, len2+1);
  //Serial.println(len2);
  if(len2<15)
  {
     //Serial.println("If");
     for (int i = 0;(i-1)<len2;i++)
     {
        //Serial.println("Enter for loop");
        u8g.setPrintPos(i*8,30);
        u8g.print(numbR[i-15]);
        delay(10);
        if(numbR[i-16] == '\0')
        { 
           //Serial.println("Break!!");
           break;
           //delay(3000);
        }
     }
  }

/Serial.println(day-1);
Serial.println(date);
Serial.println(month);
Serial.println(year);
Serial.println(hours);
Serial.println(minutes);
Serial.println(seconds);/
} //end of if for datetime

/Serial.println(day-1);
Serial.println(date);
Serial.println(month);
Serial.println(year);
Serial.println(hours);
Serial.println(minutes);
Serial.println(seconds);/

/*else if(bluetooth.available() > 0 && bluetooth.find("CMD")==true)
{
Serial.println("ENTERED MESSAGE");
message = bluetooth.readString();
Serial.println(message);
//delay(300000);
}
*/

    if(menuSelectiona == 3)
    {
       seconds=seconds+4;
       delay(100);
       menuSelectiona = 0;
       while(digitalRead(menuButton)== HIGH)
       {sms();}
       delay(100);
    }
    if(menuSelectiona == 4)
    {
       seconds=seconds+4;
       delay(100);
       menuSelectiona = 0;
       while(digitalRead(menuButton)== HIGH)
       {call();}
       delay(100);
    }
 }

}
if(menuShow == true)
{
menuShow = false;
delay(100);

}
}//end of if
advanceTime();
delay(30);
}//end of loop

void sleep()
{
u8g.firstPage();
do{}
while(u8g.nextPage());
}

void advanceTime()
{
if(millis()-lastTick>950) //somehow
{
lastTick = millis();
seconds++;
}

if (seconds > 59)
{
minutes++;
seconds = 0;
}

if (minutes >59)
{
hours++;
minutes = 0;
}

if (hours > 23)
{
hours = 0;
minutes = 0;
date+=1;
}
draw();

}

void Buzz()
{
while(c<5)
{
for(i=1;i<256;i++)
{
analogWrite(buzz,i);
delay(3.92);
}
for(i=256;i>0;i--)
{
analogWrite(buzz,i);
delay(3.92);
}
c++;
}
c=0;
newBuzz=false;
}

 if(digitalRead(previousButton) == LOW)
 {
    delay(20);
    menuSelection--;
    delay(50);
 }

 if(menuSelection > 4)
 {menuSelection = 1;}

 if(menuSelection < 1)
 {menuSelection = 4;}
 //draw picture here
 drawMenu();

 delay(50); //For debouncing

 //draw menus here

}//end of while loop
}//end of menu

  //Draw menu options
  u8g.drawStr(3,20,"Return");
  u8g.drawStr(3,20+13,"Apps");
  u8g.drawStr(3,20+13+13,"Settings");
  u8g.drawStr(3,20+13+13+13,"Home Auto(Beta)");
  //u8g.drawStr(3,20+13+13+13,"More");

}
while(u8g.nextPage());
}

  if(digitalRead(previousButton) == LOW)
  {
     delay(20);
     menuSelectiona--;
     delay(50);
  }

  if(menuSelectiona > 4)
  {menuSelectiona = 1;}

  if(menuSelectiona < 1)
  {menuSelectiona = 4;}
  //draw picture here
drawApps();
delay(50); //For debouncing

}//end of while loop
}

void torch()
{
u8g.firstPage();
do{u8g.drawBox(0,0,127,63);}
while(u8g.nextPage());
}

  //Draw menu options
  u8g.drawStr(3,20,"Return");
  u8g.drawStr(3,20+13,"CALC");
  u8g.drawStr(3,20+13+13,"SMS");
  u8g.drawStr(3,20+13+13+13,"CALLS");
  //u8g.drawStr(3,20+13+13+13,"More");

}

while(u8g.nextPage());
}

  if(digitalRead(previousButton) == LOW)
  {
     delay(20);
     menuSelections--;
     delay(50);
  }

  if(menuSelections > 4)
  {menuSelections = 1;}

  if(menuSelections < 1)
  {menuSelections = 4;}
  //draw picture here
  drawSettings();

  delay(50); //For debouncing

}//end of while loop
}

void sms()
{
u8g.firstPage();
do
{
u8g.setFont(u8g_font_unifont);
u8g.setPrintPos(0,10);
u8g.print(message);
len = message.length();

  message.toCharArray(msg, len+1);
  //Serial.println(len);
  if(len>16)
  {
     //Serial.println("If");
     for (int i = 0;(i-1)<len;i++)
     {
        //Serial.println("Enter for loop");
        u8g.setPrintPos(i*8,30);
        u8g.print(msg[i+16]);
        delay(10);
        if(msg[i+17] == '\0')
        { 
           //Serial.println("Break!!");
           break;
           //delay(3000);
        }
     }
  }

  if(len>32)
  {
     //Serial.println("If");
     for (int i = 0;(i-1)<len;i++)
     {
        //Serial.println("Enter for loop");
        u8g.setPrintPos(i*8,50);
        u8g.print(msg[i+32]);
        delay(10);
        if(msg[i+33] == '\0')
        { 
           //Serial.println("Break!!");
           break;
           //delay(3000);
        }
     }
  }

}
while (u8g.nextPage());
delay(30);
newMessage = false;
}

void call()
{
u8g.firstPage();
do
{
u8g.setFont(u8g_font_unifont);
u8g.setPrintPos(0,10);
u8g.print(number);
len1 = number.length();

  number.toCharArray(numb, len1+1);
  //Serial.println(len1);
  if(len1<15)
  {
     //Serial.println("If");
     for (int i = 0;(i-1)<len1;i++)
     {
        //Serial.println("Enter for loop");
        u8g.setPrintPos(i*8,30);
        u8g.print(numb[i-15]);
        delay(10);
        if(numb[i-16] == '\0')
        { 
           //Serial.println("Break!!");
           break;
           //delay(3000);
        }
     }
  }

}
while (u8g.nextPage());
delay(30);
newCall = false;
}

  //Draw menu options
  u8g.drawStr(3,20,"Return");
  u8g.drawStr(3,20+13,"Notes");
  u8g.drawStr(3,20+13+13,"Torch");
  u8g.drawStr(3,20+13+13+13,"Find My Phone");

}
while(u8g.nextPage());
}

notebook heater

jay jordan — Mon, 25 Dec 2023 15:55:30 +0000

include "U8glib.h"

int analogInput = 0;
int Percent ; //We want it as a whole number
float Voltageout = 0.0;
float Voltage = 0.0; //We want it with decimal places
float R1 = 97000.0; //resistance
float R2 = 10000.0; //resistance
int value = 0;

U8GLIB_SH1106_128X64 u8g(10, 9, 12, 11, 13); // pinout, see page

void draw(void)
{
u8g.setFont(u8g_font_helvB14r); // font
u8g.drawStr(19, 16, "BATTERY");
u8g.setPrintPos(7,55);
u8g.setFont(u8g_font_helvB18r);
u8g.println(Percent); //Prints Percent
u8g.println("%");
u8g.setPrintPos(63,55);
u8g.setFont(u8g_font_helvB18r); //A slightly larger font
u8g.println(Voltage); //Prints the voltage
u8g.println("V");
u8g.drawRFrame(0, 23, 128, 1, 0);
}
void setup(){
pinMode(analogInput, INPUT);
}
void loop(){
value = analogRead(analogInput);
Voltageout = (value * 5.0) / 1024.0;
Voltage = Voltageout / (R2/(R1+R2));
if (Voltage<1) {
Voltage=0.0; // get rid of unwanted readings
}
if (Voltage>5.00) { // if Reading are too large
Voltage= Voltage/10;
Percent = ((Voltage-3)/(4.2-3))100; //votage divided by max cell votage times 100 = the cells current percentage
}
u8g.firstPage();

do
{
draw();

}
while( u8g.nextPage() );
delay(500);
/

Создано ArduinoGetStarted.com *
Этот пример кода находится в общественном достоянии на странице учебного пособия * : https://arduinogetstarted.com/tutorials/arduino-heating-system */

включить

включить <дальнюю температуру.h>

определить вывод ДАТЧИКА 2 // Вывод Arduino, подключенный к контакту DQ датчика DS18B20

определить вывод RELAY_PIN A5 // Вывод Arduino, подключенный к реле, которое подключено к нагревательному элементу

TEMP_THRESHOLD_UPPER = 20; // верхний порог температуры, который, в свою очередь, связан с нагревательным элементом, измените желаемое значение на
int const TEMP_THRESHOLD_LOWER = 15; // нижний порог температуры, измените желаемое значение на

OneWire(SENSOR_PIN); // настройте экземпляр OneWire сдатчиками
(&OneWire); // передайте OneWire в библиотеку DallasTemperature

// температура в Градусах Цельсия

void .
Serial.begin(9600); // инициализировать последовательные
датчики.begin(); // инициализировать
pinMode датчика(RELAY_PIN, ВЫХОД); // инициализировать цифровой вывод в качестве выходного
}

loop void() {
sensors.requestTemperatures(); // отправить команду для получения температуры
temperature = sensors.getTempCByIndex(0); / / считывание температуры в градусах Цельсия

если(температура > TEMP_THRESHOLD_UPPER) {
Серийный номер.println(,,,)"Нагревательный элемент выключен");
digitalWrite(RELAY_PIN, НИЗКИЙ уровень); // выключить
} else if(температура < TEMP_THRESHOLD_LOWER){
Serial.println("Нагревательный элемент включен");
digitalWrite(RELAY_PIN, ВЫСОКИЙ уровень); // включить
}

задержка(500) ;
}

portable television with hologram function

jay jordan — Mon, 25 Dec 2023 15:54:02 +0000

/***

Required libraries:
https://github.com/moononournation/Arduino_GFX.git
https://github.com/pschatzmann/arduino-libhelix.git
https://github.com/bitbank2/JPEGDEC.git */

// Audio and video code

// ffmpeg -i office1.mp4 -ar 44100 -ac 1 -ab 24k -filter:a loudnorm -filter:a "volume=-5dB" office1.aac
// ffmpeg -i office1.mp4 -vf "fps=25,scale=-1:240:flags=lanczos,crop=288:in_h:(in_w-288)/2:0" -q:v 11 office1.mjpeg
// auto fall back to MP3 if AAC file not available

define AAC_FILENAME "/.aac"

define MP3_FILENAME "/.mp3"

// #define MP3_FILENAME "/EP05.mp3"

define MJPEG_FILENAME "/.mjpeg"

// #define MJPEG_FILENAME "/EP05.mjpeg"
// #define MJPEG_FILENAME "/320_30fps.mjpeg"

define FPS 25

define MJPEG_BUFFER_SIZE (288 * 240 * 2 / 8)

// #define MJPEG_BUFFER_SIZE (320 * 240 * 2 / 8)

define AUDIOASSIGNCORE 1

define DECODEASSIGNCORE 0

define DRAWASSIGNCORE 1

include

/* Arduino_GFX */

include

define GFX_BL DF_GFX_BL // default backlight pin, you may replace DF_GFX_BL to actual backlight pin

Arduino_DataBus bus = create_default_Arduino_DataBus();
// Arduino_GFX *gfx = new Arduino_ILI9341(bus, DF_GFX_RST, 3 / rotation /, false / IPS /);
Arduino_GFX *gfx = new Arduino_ST7789(bus, DF_GFX_RST, 1 / rotation /, true / IPS /, 240 / width /, 288 / height /, 0 / col offset 1 /, 20 / row offset 1 /, 0 / col offset 2 /, 12 / row offset 2 */);

/* variables */
static int next_frame = 0;
static int skipped_frames = 0;
static unsigned long start_ms, curr_ms, next_frame_ms;

/* audio */

include "esp32_audio_task.h"

/* MJPEG Video */

include "mjpeg_decode_draw_task.h"

void setup()
{
disableCore0WDT();

WiFi.mode(WIFI_OFF);
Serial.begin(115200);
// while (!Serial);

// Init Display
gfx->begin(80000000);
gfx->fillScreen(BLACK);

ifdef GFX_BL

pinMode(GFX_BL, OUTPUT);
digitalWrite(GFX_BL, HIGH);

endif

Serial.println("Init I2S");
gfx->println("Init I2S");

if defined(ESP32) && (CONFIG_IDF_TARGET_ESP32)

esp_err_t ret_val = i2s_init(I2S_NUM_0, 44100, -1 /* MCLK /, 25 / SCLK /, 26 / LRCK /, 32 / DOUT /, -1 / DIN */);

elif defined(ESP32) && (CONFIG_IDF_TARGET_ESP32S2)

esp_err_t ret_val = i2s_init(I2S_NUM_0, 44100, -1 /* MCLK /, 4 / SCLK /, 5 / LRCK /, 18 / DOUT /, -1 / DIN */);

elif defined(ESP32) && (CONFIG_IDF_TARGET_ESP32S3)

esp_err_t ret_val = i2s_init(I2S_NUM_0, 44100, 42 /* MCLK /, 46 / SCLK /, 45 / LRCK /, 43 / DOUT /, 44 / DIN */);

elif defined(ESP32) && (CONFIG_IDF_TARGET_ESP32C3)

esp_err_t ret_val = i2s_init(I2S_NUM_0, 44100, -1 /* MCLK /, 10 / SCLK /, 19 / LRCK /, 18 / DOUT /, -1 / DIN */);

endif

if (ret_val != ESP_OK)
{
Serial.printf("i2s_init failed: %d\n", ret_val);
}
i2s_zero_dma_buffer(I2S_NUM_0);

Serial.println("Init FS");
gfx->println("Init FS");
// if (!LittleFS.begin(false, "/root"))
// if (!SPIFFS.begin(false, "/root"))
// if (!FFat.begin(false, "/root"))
SPIClass spi = SPIClass(HSPI);
// spi.begin(14 /* SCK /, 2 / MISO /, 15 / MOSI /, 13 / CS /);
spi.begin(14 / SCK /, 4 / MISO /, 15 / MOSI /, 13 / CS /);
if (!SD.begin(13, spi, 80000000))
// if ((!SD_MMC.begin("/root")) && (!SD_MMC.begin("/root")) && (!SD_MMC.begin("/root")) && (!SD_MMC.begin("/root"))) / 4-bit SD bus mode /
// if ((!SD_MMC.begin("/root", true)) && (!SD_MMC.begin("/root", true)) && (!SD_MMC.begin("/root", true)) && (!SD_MMC.begin("/root", true))) / 1-bit SD bus mode */
{
Serial.println("ERROR: File system mount failed!");
gfx->println("ERROR: File system mount failed!");
}
else
{
bool aac_file_available = false;
Serial.println("Open AAC file: " AAC_FILENAME);
gfx->println("Open AAC file: " AAC_FILENAME);
// File aFile = LittleFS.open(AAC_FILENAME);
// File aFile = SPIFFS.open(AAC_FILENAME);
// File aFile = FFat.open(AAC_FILENAME);
File aFile = SD.open(AAC_FILENAME);
// File aFile = SD_MMC.open(AAC_FILENAME);
if (aFile)
{
aac_file_available = true;
}
else
{
Serial.println("Open MP3 file: " MP3_FILENAME);
gfx->println("Open MP3 file: " MP3_FILENAME);
// aFile = LittleFS.open(MP3_FILENAME);
// aFile = SPIFFS.open(MP3_FILENAME);
// aFile = FFat.open(MP3_FILENAME);
aFile = SD.open(MP3_FILENAME);
// aFile = SD_MMC.open(MP3_FILENAME);
}

if (!aFile || aFile.isDirectory())
{
  Serial.println("ERROR: Failed to open " AAC_FILENAME " or " MP3_FILENAME " file for reading");
  gfx->println("ERROR: Failed to open " AAC_FILENAME " or " MP3_FILENAME " file for reading");
}
else
{
  Serial.println("Open MJPEG file: " MJPEG_FILENAME);
  gfx->println("Open MJPEG file: " MJPEG_FILENAME);
  // File vFile = LittleFS.open(MJPEG_FILENAME);
  // File vFile = SPIFFS.open(MJPEG_FILENAME);
  // File vFile = FFat.open(MJPEG_FILENAME);
  File vFile = SD.open(MJPEG_FILENAME);
  // File vFile = SD_MMC.open(MJPEG_FILENAME);
  if (!vFile || vFile.isDirectory())
  {
    Serial.println("ERROR: Failed to open " MJPEG_FILENAME " file for reading");
    gfx->println("ERROR: Failed to open " MJPEG_FILENAME " file for reading");
  }
  else
  {
    Serial.println("Init video");
    gfx->println("Init video");
    mjpeg_setup(&vFile, MJPEG_BUFFER_SIZE, drawMCU,
                false /* useBigEndian */, DECODEASSIGNCORE, DRAWASSIGNCORE);

    Serial.println("Start play audio task");
    gfx->println("Start play audio task");
    BaseType_t ret_val;
    if (aac_file_available)
    {
      ret_val = aac_player_task_start(&aFile, AUDIOASSIGNCORE);
    }
    else
    {
      ret_val = mp3_player_task_start(&aFile, AUDIOASSIGNCORE);
    }
    if (ret_val != pdPASS)
    {
      Serial.printf("Audio player task start failed: %d\n", ret_val);
      gfx->printf("Audio player task start failed: %d\n", ret_val);
    }

    Serial.println("Start play video");
    gfx->println("Start play video");
    start_ms = millis();
    curr_ms = millis();
    next_frame_ms = start_ms + (++next_frame * 1000 / FPS / 2);
    while (vFile.available() && mjpeg_read_frame()) // Read video
    {
      total_read_video_ms += millis() - curr_ms;
      curr_ms = millis();

      if (millis() < next_frame_ms) // check show frame or skip frame
      {
        // Play video
        mjpeg_draw_frame();
        total_decode_video_ms += millis() - curr_ms;
        curr_ms = millis();
      }
      else
      {
        ++skipped_frames;
        Serial.println("Skip frame");
      }

      while (millis() < next_frame_ms)
      {
        vTaskDelay(pdMS_TO_TICKS(1));
      }

      curr_ms = millis();
      next_frame_ms = start_ms + (++next_frame * 1000 / FPS);
    }
    int time_used = millis() - start_ms;
    int total_frames = next_frame - 1;
    Serial.println("AV end");
    vFile.close();
    aFile.close();

    int played_frames = total_frames - skipped_frames;
    float fps = 1000.0 * played_frames / time_used;
    total_decode_audio_ms -= total_play_audio_ms;
    // total_decode_video_ms -= total_show_video_ms;
    Serial.printf("Played frames: %d\n", played_frames);
    Serial.printf("Skipped frames: %d (%0.1f %%)\n", skipped_frames, 100.0 * skipped_frames / total_frames);
    Serial.printf("Time used: %d ms\n", time_used);
    Serial.printf("Expected FPS: %d\n", FPS);
    Serial.printf("Actual FPS: %0.1f\n", fps);
    Serial.printf("Read audio: %lu ms (%0.1f %%)\n", total_read_audio_ms, 100.0 * total_read_audio_ms / time_used);
    Serial.printf("Decode audio: %lu ms (%0.1f %%)\n", total_decode_audio_ms, 100.0 * total_decode_audio_ms / time_used);
    Serial.printf("Play audio: %lu ms (%0.1f %%)\n", total_play_audio_ms, 100.0 * total_play_audio_ms / time_used);
    Serial.printf("Read video: %lu ms (%0.1f %%)\n", total_read_video_ms, 100.0 * total_read_video_ms / time_used);
    Serial.printf("Decode video: %lu ms (%0.1f %%)\n", total_decode_video_ms, 100.0 * total_decode_video_ms / time_used);
    Serial.printf("Show video: %lu ms (%0.1f %%)\n", total_show_video_ms, 100.0 * total_show_video_ms / time_used);

define CHART_MARGIN 64

define LEGEND_A_COLOR 0x1BB6

define LEGEND_B_COLOR 0xFBE1

define LEGEND_C_COLOR 0x2D05

define LEGEND_D_COLOR 0xD125

define LEGEND_E_COLOR 0x9337

define LEGEND_F_COLOR 0x8AA9

define LEGEND_G_COLOR 0xE3B8

define LEGEND_H_COLOR 0x7BEF

define LEGEND_I_COLOR 0xBDE4

define LEGEND_J_COLOR 0x15F9

    // gfx->setCursor(0, 0);
    gfx->setTextColor(WHITE);
    gfx->printf("Played frames: %d\n", played_frames);
    gfx->printf("Skipped frames: %d (%0.1f %%)\n", skipped_frames, 100.0 * skipped_frames / total_frames);
    gfx->printf("Time used: %d ms\n", time_used);
    gfx->printf("Expected FPS: %d\n", FPS);
    gfx->printf("Actual FPS: %0.1f\n\n", fps);

    int16_t r1 = ((gfx->height() - CHART_MARGIN - CHART_MARGIN) / 2);
    int16_t r2 = r1 / 2;
    int16_t cx = gfx->width() - r1 - 10;
    int16_t cy = r1 + CHART_MARGIN;

    float arc_start1 = 0;
    float arc_end1 = arc_start1 + max(2.0, 360.0 * total_read_audio_ms / time_used);
    for (int i = arc_start1 + 1; i < arc_end1; i += 2)
    {
      gfx->fillArc(cx, cy, r1, r2, arc_start1 - 90.0, i - 90.0, LEGEND_A_COLOR);
    }
    gfx->fillArc(cx, cy, r1, r2, arc_start1 - 90.0, arc_end1 - 90.0, LEGEND_A_COLOR);
    gfx->setTextColor(LEGEND_A_COLOR);
    gfx->printf("Read audio: %lu ms (%0.1f %%)\n", total_read_audio_ms, 100.0 * total_read_audio_ms / time_used);

    float arc_start2 = arc_end1;
    float arc_end2 = arc_start2 + max(2.0, 360.0 * total_decode_audio_ms / time_used);
    for (int i = arc_start2 + 1; i < arc_end2; i += 2)
    {
      gfx->fillArc(cx, cy, r1, r2, arc_start2 - 90.0, i - 90.0, LEGEND_B_COLOR);
    }
    gfx->fillArc(cx, cy, r1, r2, arc_start2 - 90.0, arc_end2 - 90.0, LEGEND_B_COLOR);
    gfx->setTextColor(LEGEND_B_COLOR);
    gfx->printf("Decode audio: %lu ms (%0.1f %%)\n", total_decode_audio_ms, 100.0 * total_decode_audio_ms / time_used);
    gfx->setTextColor(LEGEND_J_COLOR);
    gfx->printf("Play audio: %lu ms (%0.1f %%)\n", total_play_audio_ms, 100.0 * total_play_audio_ms / time_used);

    float arc_start3 = arc_end2;
    float arc_end3 = arc_start3 + max(2.0, 360.0 * total_read_video_ms / time_used);
    for (int i = arc_start3 + 1; i < arc_end3; i += 2)
    {
      gfx->fillArc(cx, cy, r1, r2, arc_start3 - 90.0, i - 90.0, LEGEND_C_COLOR);
    }
    gfx->fillArc(cx, cy, r1, r2, arc_start3 - 90.0, arc_end3 - 90.0, LEGEND_C_COLOR);
    gfx->setTextColor(LEGEND_C_COLOR);
    gfx->printf("Read video: %lu ms (%0.1f %%)\n", total_read_video_ms, 100.0 * total_read_video_ms / time_used);

    float arc_start4 = arc_end3;
    float arc_end4 = arc_start4 + max(2.0, 360.0 * total_show_video_ms / time_used);
    for (int i = arc_start4 + 1; i < arc_end4; i += 2)
    {
      gfx->fillArc(cx, cy, r1, r2, arc_start4 - 90.0, i - 90.0, LEGEND_D_COLOR);
    }
    gfx->fillArc(cx, cy, r1, r2, arc_start4 - 90.0, arc_end4 - 90.0, LEGEND_D_COLOR);
    gfx->setTextColor(LEGEND_D_COLOR);
    gfx->printf("Show video: %lu ms (%0.1f %%)\n", total_show_video_ms, 100.0 * total_show_video_ms / time_used);

    float arc_start5 = 0;
    float arc_end5 = arc_start5 + max(2.0, 360.0 * total_decode_video_ms / time_used);
    for (int i = arc_start5 + 1; i < arc_end5; i += 2)
    {
      gfx->fillArc(cx, cy, r2, 0, arc_start5 - 90.0, i - 90.0, LEGEND_E_COLOR);
    }
    gfx->fillArc(cx, cy, r2, 0, arc_start5 - 90.0, arc_end5 - 90.0, LEGEND_E_COLOR);
    gfx->setTextColor(LEGEND_E_COLOR);
    gfx->printf("Decode video: %lu ms (%0.1f %%)\n", total_decode_video_ms, 100.0 * total_decode_video_ms / time_used);
  }
  // delay(60000);

ifdef GFX_BL

  // digitalWrite(GFX_BL, LOW);

endif

  // gfx->displayOff();
  // esp_deep_sleep_start();
}

}
}

void loop()
{
}

include "driver/i2s.h"

include "AACDecoderHelix.h"

include "MP3DecoderHelix.h"

static unsigned long total_read_audio_ms = 0;
static unsigned long total_decode_audio_ms = 0;
static unsigned long total_play_audio_ms = 0;

esp_err_t ret_val = ESP_OK;

i2s_config_t i2s_config;
i2s_config.mode = (i2s_mode_t)(I2S_MODE_MASTER | I2S_MODE_TX);
i2s_config.sample_rate = sample_rate;
i2s_config.bits_per_sample = I2S_BITS_PER_SAMPLE_16BIT;
i2s_config.channel_format = I2S_CHANNEL_FMT_RIGHT_LEFT;
i2s_config.communication_format = I2S_COMM_FORMAT_STAND_I2S;
i2s_config.intr_alloc_flags = ESP_INTR_FLAG_LEVEL1;
i2s_config.dma_buf_count = 8;
i2s_config.dma_buf_len = 160;
i2s_config.use_apll = false;
i2s_config.tx_desc_auto_clear = true;
i2s_config.fixed_mclk = 0;
i2s_config.mclk_multiple = I2S_MCLK_MULTIPLE_DEFAULT;
i2s_config.bits_per_chan = I2S_BITS_PER_CHAN_16BIT;

i2s_pin_config_t pin_config;
pin_config.mck_io_num = mck_io_num;
pin_config.bck_io_num = bck_io_num;
pin_config.ws_io_num = ws_io_num;
pin_config.data_out_num = data_out_num;
pin_config.data_in_num = data_in_num;

ret_val |= i2s_driver_install(i2s_num, &i2s_config, 0, NULL);
ret_val |= i2s_set_pin(i2s_num, &pin_config);

return ret_val;

}

static int _samprate = 0;
static void aacAudioDataCallback(AACFrameInfo &info, int16_t pwm_buffer, size_t len)
{
unsigned long s = millis();
if (_samprate != info.sampRateOut)
{
// log_i("bitRate: %d, nChans: %d, sampRateCore: %d, sampRateOut: %d, bitsPerSample: %d, outputSamps: %d, profile: %d, tnsUsed: %d, pnsUsed: %d",
// info.bitRate, info.nChans, info.sampRateCore, info.sampRateOut, info.bitsPerSample, info.outputSamps, info.profile, info.tnsUsed, info.pnsUsed);
i2s_set_clk(_i2s_num, info.sampRateOut / sample_rate /, info.bitsPerSample / bits_cfg /, (info.nChans == 2) ? I2S_CHANNEL_STEREO : I2S_CHANNEL_MONO / channel /);
_samprate = info.sampRateOut;
}
size_t i2s_bytes_written = 0;
i2s_write(_i2s_num, pwm_buffer, len * 2, &i2s_bytes_written, portMAX_DELAY);
// log_i("len: %d, i2s_bytes_written: %d", len, i2s_bytes_written);
total_play_audio_ms += millis() - s;
}
static void mp3AudioDataCallback(MP3FrameInfo &info, int16_t *pwm_buffer, size_t len)
{
unsigned long s = millis();
if (_samprate != info.samprate)
{
log_i("bitrate: %d, nChans: %d, samprate: %d, bitsPerSample: %d, outputSamps: %d, layer: %d, version: %d",
info.bitrate, info.nChans, info.samprate, info.bitsPerSample, info.outputSamps, info.layer, info.version);
i2s_set_clk(_i2s_num, info.samprate / sample_rate /, info.bitsPerSample / bits_cfg /, (info.nChans == 2) ? I2S_CHANNEL_STEREO : I2S_CHANNEL_MONO / channel */);
_samprate = info.samprate;
}
size_t i2s_bytes_written = 0;
i2s_write(_i2s_num, pwm_buffer, len * 2, &i2s_bytes_written, portMAX_DELAY);
// log_i("len: %d, i2s_bytes_written: %d", len, i2s_bytes_written);
total_play_audio_ms += millis() - s;
}

static uint8_t _frame[MP3_MAX_FRAME_SIZE]; // MP3_MAX_FRAME_SIZE is smaller, so always use MP3_MAX_FRAME_SIZE

static libhelix::AACDecoderHelix _aac(aacAudioDataCallback);
static void aac_player_task(void *pvParam)
{
Stream *input = (Stream *)pvParam;

int r, w;
unsigned long ms = millis();
while (r = input->readBytes(_frame, MP3_MAX_FRAME_SIZE))
{
    total_read_audio_ms += millis() - ms;
    ms = millis();

    while (r > 0)
    {
        w = _aac.write(_frame, r);
        // log_i("r: %d, w: %d\n", r, w);
        r -= w;
    }
    total_decode_audio_ms += millis() - ms;
    ms = millis();
}
log_i("AAC stop.");

vTaskDelete(NULL);

}

static libhelix::MP3DecoderHelix _mp3(mp3AudioDataCallback);
static void mp3_player_task(void *pvParam)
{
Stream *input = (Stream *)pvParam;

int r, w;
unsigned long ms = millis();
while (r = input->readBytes(_frame, MP3_MAX_FRAME_SIZE))
{
    total_read_audio_ms += millis() - ms;
    ms = millis();

    while (r > 0)
    {
        w = _mp3.write(_frame, r);
        // log_i("r: %d, w: %d\n", r, w);
        r -= w;
    }
    total_decode_audio_ms += millis() - ms;
    ms = millis();
}
log_i("MP3 stop.");

vTaskDelete(NULL);

}

static BaseType_t aac_player_task_start(Stream *input, BaseType_t audioAssignCore)
{
_aac.begin();

return xTaskCreatePinnedToCore(
    (TaskFunction_t)aac_player_task,
    (const char *const)"AAC Player Task",
    (const uint32_t)2000,
    (void *const)input,
    (UBaseType_t)configMAX_PRIORITIES - 1,
    (TaskHandle_t *const)NULL,
    (const BaseType_t)audioAssignCore);

}

static BaseType_t mp3_player_task_start(Stream *input, BaseType_t audioAssignCore)
{
_mp3.begin();

return xTaskCreatePinnedToCore(
    (TaskFunction_t)mp3_player_task,
    (const char *const)"MP3 Player Task",
    (const uint32_t)2000,
    (void *const)input,
    (UBaseType_t)configMAX_PRIORITIES - 1,
    (TaskHandle_t *const)NULL,
    (const BaseType_t)audioAssignCore);

}

define READ_BUFFER_SIZE 1024

// #define MAXOUTPUTSIZE (MAX_BUFFERED_PIXELS / 16 / 16)

define MAXOUTPUTSIZE (288 / 3 / 16)

define NUMBER_OF_DECODE_BUFFER 3

define NUMBER_OF_DRAW_BUFFER 9

include

typedef struct
{
int32_t size;
uint8_t *buf;
} mjpegBuf;

typedef struct
{
xQueueHandle xqh;
JPEG_DRAW_CALLBACK *drawFunc;
} paramDrawTask;

typedef struct
{
xQueueHandle xqh;
mjpegBuf *mBuf;
JPEG_DRAW_CALLBACK *drawFunc;
} paramDecodeTask;

static JPEGDRAW jpegdraws[NUMBER_OF_DRAW_BUFFER];
static int _draw_queue_cnt = 0;
static JPEGDEC _jpegDec;
static xQueueHandle _xqh;
static bool _useBigEndian;

static unsigned long total_read_video_ms = 0;
static unsigned long total_decode_video_ms = 0;
static unsigned long total_show_video_ms = 0;

Stream *_input;

int32_t _mjpegBufSize;

uint8_t *_read_buf;
int32_t _mjpeg_buf_offset = 0;

TaskHandle_t _decodeTask;
TaskHandle_t _draw_task;
paramDecodeTask _pDecodeTask;
paramDrawTask _pDrawTask;
uint8_t *_mjpeg_buf;
uint8_t _mBufIdx = 0;

int32_t _inputindex = 0;
int32_t _buf_read;
int32_t _remain = 0;
mjpegBuf _mjpegBufs[NUMBER_OF_DECODE_BUFFER];

// log_i("queueDrawMCU start.");
++_draw_queue_cnt;
xQueueSend(_xqh, &j, portMAX_DELAY);
// log_i("queueDrawMCU end.");

return 1;
}

_jpegDec.openRAM(mBuf->buf, mBuf->size, p->drawFunc);

// _jpegDec.setMaxOutputSize(MAXOUTPUTSIZE);
if (_useBigEndian)
{
  _jpegDec.setPixelType(RGB565_BIG_ENDIAN);
}
_jpegDec.setMaxOutputSize(MAXOUTPUTSIZE);
_jpegDec.decode(0, 0, 0);
_jpegDec.close();

total_decode_video_ms += millis() - s;

}
vQueueDelete(p->xqh);
log_i("decode_task end.");
vTaskDelete(NULL);
}

if (!_read_buf)
{
_read_buf = (uint8_t *)malloc(READ_BUFFER_SIZE);
}
if (_read_buf)
{
log_i("Read buffer allocated.");
}

return true;
}

  // log_i("i: %d", i);
  memcpy(_mjpeg_buf + _mjpeg_buf_offset, _p, i);
  _mjpeg_buf_offset += i;
  int32_t o = _buf_read - i;
  if (o > 0)
  {
    // log_i("o: %d", o);
    memcpy(_read_buf, _p + i, o);
    _buf_read = _input->readBytes(_read_buf + o, READ_BUFFER_SIZE - o);
    _p = _read_buf;
    _inputindex += _buf_read;
    _buf_read += o;
    // log_i("_buf_read: %d", _buf_read);
  }
  else
  {
    _buf_read = _input->readBytes(_read_buf, READ_BUFFER_SIZE);
    _p = _read_buf;
    _inputindex += _buf_read;
  }
  i = 0;
}
if (found_FFD9)
{
  // log_i("Found FFD9 at: %d.", _mjpeg_buf_offset);
  if (_mjpeg_buf_offset > _mjpegBufSize) {
    log_e("_mjpeg_buf_offset(%d) > _mjpegBufSize (%d)", _mjpeg_buf_offset, _mjpegBufSize);
  }
  return true;
}

}

return false;
}

return true;
}
//include libraries:

include "LedControl.h"

include // Font library

include // DS1307 clock

include "RTClib.h" // DS1307 clock

include // Button library by Alexander Brevig

// Setup LED Matrix

// pin 10 is connected to the DataIn on the display
// pin 12 is connected to the CLK on the display
// pin 11 is connected to LOAD on the display(cs)
LedControl lc = LedControl(10, 12, 11, 4); //sets the 3 pins as 12, 11 & 10 and then sets 4 displays (max is 8 displays)

//global variables
byte intensity = 7; // Default intensity/brightness (0-15)
byte clock_mode = 0; // Default clock mode. Default = 0 (basic_mode)
bool random_mode = 0; // Define random mode - changes the display type every few hours. Default = 0 (off)
byte old_mode = clock_mode; // Stores the previous clock mode, so if we go to date or whatever, we know what mode to go back to after.
bool ampm = 0; // Define 12 or 24 hour time. 0 = 24 hour. 1 = 12 hour
byte change_mode_time = 0; // Holds hour when clock mode will next change if in random mode.
unsigned long delaytime = 500; // We always wait a bit between updates of the display
int rtc[7]; // Holds real time clock output

char days[7][4] = {
"Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"
}; //day array - used in slide, basic_mode and jumble modes (The DS1307 outputs 1-7 values for day of week)
char daysfull[7][9] = {
"Sunday", "Monday", "Tuesday", "Wed", "Thursday", "Friday", "Saturday"
};
char suffix[4][3] = {
"st", "nd", "rd", "th"
}; //date suffix array, used in slide, basic_mode and jumble modes. e,g, 1st 2nd ...

//define constants

define NUM_DISPLAY_MODES 3 // Number display modes (conting zero as the first mode)

define NUM_SETTINGS_MODES 4 // Number settings modes = 6 (conting zero as the first mode)

define SLIDE_DELAY 20 // The time in milliseconds for the slide effect per character in slide mode. Make this higher for a slower effect

define cls clear_display // Clear display

RTC_DS1307 ds1307; // Create RTC object

Button buttonA = Button(2, BUTTON_PULLUP); // Setup button A (using button library)
Button buttonB = Button(3, BUTTON_PULLUP); // Setup button B (using button library)

void setup() {

digitalWrite(2, HIGH); // turn on pullup resistor for button on pin 2
digitalWrite(3, HIGH); // turn on pullup resistor for button on pin 3
digitalWrite(4, HIGH); // turn on pullup resistor for button on pin 4

Serial.begin(9600); //start serial

//initialize the 4 matrix panels
//we have already set the number of devices when we created the LedControl
int devices = lc.getDeviceCount();
//we have to init all devices in a loop
for (int address = 0; address < devices; address++) {
/The MAX72XX is in power-saving mode on startup/
lc.shutdown(address, false);
/* Set the brightness to a medium values /
lc.setIntensity(address, intensity);
/ and clear the display */
lc.clearDisplay(address);
}

//Setup DS1307 RTC

ifdef AVR

Wire.begin();

else

Wire1.begin(); // Shield I2C pins connect to alt I2C bus on Arduino

endif

ds1307.begin(); //start RTC Clock

if (! ds1307.isrunning()) {
Serial.println("RTC is NOT running!");
ds1307.adjust(DateTime(DATE, TIME)); // sets the RTC to the date & time this sketch was compiled
}
//Show software version & hello message
printver();

//enable red led
digitalWrite(13, HIGH);
}

void loop() {

//run the clock with whatever mode is set by clock_mode - the default is set at top of code.
switch (clock_mode){

case 0:
basic_mode();
break;
case 1:
small_mode();
break;
case 2:
slide();
break;
case 3:
word_clock();
break;
case 4:
setup_menu();
break;
}
}

//plot a point on the display
void plot (byte x, byte y, byte val) {

//select which matrix depending on the x coord
byte address;
if (x >= 0 && x <= 7) {
address = 3;
}
if (x >= 8 && x <= 15) {
address = 2;
x = x - 8;
}
if (x >= 16 && x <= 23) {
address = 1;
x = x - 16;
}
if (x >= 24 && x <= 31) {
address = 0;
x = x - 24;
}

if (val == 1) {
// lc.setLed(address, y, x, true);
lc.setLed(address, 7-y, x, true);
} else {
// lc.setLed(address, y, x, false);
lc.setLed(address, 7-y, x, false);
}
}

//clear screen
void clear_display() {
for (byte address = 0; address < 4; address++) {
lc.clearDisplay(address);
}
}

//fade screen down
void fade_down() {

//fade from global intensity to 1
for (byte i = intensity; i > 0; i--) {
for (byte address = 0; address < 4; address++) {
lc.setIntensity(address, i);
}
delay(30); //change this to change fade down speed
}

clear_display(); //clear display completely (off)

//reset intentsity to global val
for (byte address = 0; address < 4; address++) {
lc.setIntensity(address, intensity);
}
}

//power up led test & display software version number
void printver() {

byte i = 0;
char ver_a[9] = "Vers 1.0";
char ver_b[9] = " Hello! ";

//test all leds.
for (byte x = 0; x <= 31; x++) {
for (byte y = 0; y <= 7; y++) {
plot(x, y, 1);
}
}
delay(500);
fade_down();

while (ver_a[i]) {
puttinychar((i * 4), 1, ver_a[i]);
delay(35);
i++;
}
delay(700);
fade_down();
i = 0;
while (ver_b[i]) {
puttinychar((i * 4), 1, ver_b[i]);
delay(35);
i++;
}
delay(700);
fade_down();
}

// puttinychar
// Copy a 3x5 character glyph from the myfont data structure to display memory, with its upper left at the given coordinate
// This is unoptimized and simply uses plot() to draw each dot.
void puttinychar(byte x, byte y, char c)
{
byte dots;
if (c >= 'A' && c <= 'Z' || (c >= 'a' && c <= 'z') ) {
c &= 0x1F; // A-Z maps to 1-26
}
else if (c >= '0' && c <= '9') {
c = (c - '0') + 32;
}
else if (c == ' ') {
c = 0; // space
}
else if (c == '.') {
c = 27; // full stop
}
else if (c == ':') {
c = 28; // colon
}
else if (c == '\'') {
c = 29; // single quote mark
}
else if (c == '!') {
c = 30; // single quote mark
}
else if (c == '?') {
c = 31; // single quote mark
}

for (byte col = 0; col < 3; col++) {
dots = pgm_read_byte_near(&mytinyfont[c][col]);
for (char row = 0; row < 5; row++) {
if (dots & (16 >> row))
plot(x + col, y + row, 1);
else
plot(x + col, y + row, 0);
}
}
}

void putnormalchar(byte x, byte y, char c)
{

byte dots;
// if (c >= 'A' && c <= 'Z' || (c >= 'a' && c <= 'z') ) {
// c &= 0x1F; // A-Z maps to 1-26
// }
if (c >= 'A' && c <= 'Z' ) {
c &= 0x1F; // A-Z maps to 1-26
}
else if (c >= 'a' && c <= 'z') {
c = (c - 'a') + 41; // A-Z maps to 41-67
}
else if (c >= '0' && c <= '9') {
c = (c - '0') + 31;
}
else if (c == ' ') {
c = 0; // space
}
else if (c == '.') {
c = 27; // full stop
}
else if (c == '\'') {
c = 28; // single quote mark
}
else if (c == ':') {
c = 29; // clock_mode selector arrow
}
else if (c == '>') {
c = 30; // clock_mode selector arrow
}
else if (c >= -80 && c <= -67) {
c *= -1;
}

for (char col = 0; col < 5; col++) {
dots = pgm_read_byte_near(&myfont[c][col]);
for (char row = 0; row < 7; row++) {
//check coords are on screen before trying to plot
//if ((x >= 0) && (x <= 31) && (y >= 0) && (y <= 7)){

  if (dots & (64 >> row)) {   // only 7 rows.
    plot(x + col, y + row, 1);
  } else {
    plot(x + col, y + row, 0);
  }
  //}
}

}
}

//small_mode
//show the time in small 3x5 characters with seconds display

void small_mode() {

char textchar[8]; // the 16 characters on the display
byte mins = 100; //mins
byte secs = rtc[0]; //seconds
byte old_secs = secs; //holds old seconds value - from last time seconds were updated o display - used to check if seconds have changed

cls();

//run clock main loop as long as run_mode returns true
while (run_mode()) {

get_time();

//check for button press
if (buttonA.uniquePress()) {
  switch_mode();
  return;
}
if (buttonB.uniquePress()) {
  display_date();
  return;
}

//if secs changed then update them on the display
secs = rtc[0];
if (secs != old_secs) {

  //secs
  char buffer[3];
  itoa(secs, buffer, 10);

  //fix - as otherwise if num has leading zero, e.g. "03" secs, itoa coverts this to chars with space "3 ".
  if (secs < 10) {
    buffer[1] = buffer[0];
    buffer[0] = '0';
  }

  puttinychar( 20, 1, ':'); //seconds colon
  puttinychar( 24, 1, buffer[0]); //seconds
  puttinychar( 28, 1, buffer[1]); //seconds
  old_secs = secs;
}

//if minute changes change time
if (mins != rtc[1]) {

  //reset these for comparison next time
  mins = rtc[1];
  byte hours = rtc[2];
  if (hours > 12) {
    hours = hours - ampm * 12;
  }
  if (hours < 1) {
    hours = hours + ampm * 12;
  }


  //byte dow  = rtc[3]; // the DS1307 outputs 0 - 6 where 0 = Sunday0 - 6 where 0 = Sunday.
  //byte date = rtc[4];

  //set characters
  char buffer[3];
  itoa(hours, buffer, 10);

  //fix - as otherwise if num has leading zero, e.g. "03" hours, itoa coverts this to chars with space "3 ".
  if (hours < 10) {
    buffer[1] = buffer[0];
    //if we are in 12 hour mode blank the leading zero.
    if (ampm) {
      buffer[0] = ' ';
    }
    else {
      buffer[0] = '0';
    }
  }
  //set hours chars
  textchar[0] = buffer[0];
  textchar[1] = buffer[1];
  textchar[2] = ':';

  itoa (mins, buffer, 10);
  if (mins < 10) {
    buffer[1] = buffer[0];
    buffer[0] = '0';
  }
  //set mins characters
  textchar[3] = buffer[0];
  textchar[4] = buffer[1];

  //do seconds
  textchar[5] = ':';
  buffer[3];
  secs = rtc[0];
  itoa(secs, buffer, 10);

  //fix - as otherwise if num has leading zero, e.g. "03" secs, itoa coverts this to chars with space "3 ".
  if (secs < 10) {
    buffer[1] = buffer[0];
    buffer[0] = '0';
  }
  //set seconds
  textchar[6] = buffer[0];
  textchar[7] = buffer[1];

  byte x = 0;
  byte y = 0;

  //print each char
  for (byte x = 0; x < 6 ; x++) {
    puttinychar( x * 4, 1, textchar[x]);
  }
}
delay(50);

}
fade_down();
}

// basic_mode()
// show the time in 5x7 characters
void basic_mode()
{
cls();

char buffer[3]; //for int to char conversion to turn rtc values into chars we can print on screen
byte offset = 0; //used to offset the x postition of the digits and centre the display when we are in 12 hour mode and the clock shows only 3 digits. e.g. 3:21
byte x, y; //used to draw a clear box over the left hand "1" of the display when we roll from 12:59 -> 1:00am in 12 hour mode.

//do 12/24 hour conversion if ampm set to 1
byte hours = rtc[2];

if (hours > 12) {
hours = hours - ampm * 12;
}
if (hours < 1) {
hours = hours + ampm * 12;
}

//do offset conversion
if (ampm && hours < 10) {
offset = 2;
}

//set the next minute we show the date at
//set_next_date();

// initially set mins to value 100 - so it wll never equal rtc[1] on the first loop of the clock, meaning we draw the clock display when we enter the function
byte secs = 100;
byte mins = 100;
int count = 0;

//run clock main loop as long as run_mode returns true
while (run_mode()) {

//get the time from the clock chip
get_time();

//check for button press
if (buttonA.uniquePress()) {
  switch_mode();
  return;
}
if (buttonB.uniquePress()) {
  display_date();
  return;
}

//check whether it's time to automatically display the date
//check_show_date();

//draw the flashing : as on if the secs have changed.
if (secs != rtc[0]) {

  //update secs with new value
  secs = rtc[0];

  //draw :
  plot (15 - offset, 2, 1); //top point
  plot (15 - offset, 5, 1); //bottom point
  count = 400;
}

//if count has run out, turn off the :
if (count == 0) {
  plot (15 - offset, 2, 0); //top point
  plot (15 - offset, 5, 0); //bottom point
}
else {
  count--;
}

//re draw the display if button pressed or if mins != rtc[1] i.e. if the time has changed from what we had stored in mins, (also trigggered on first entering function when mins is 100)
if (mins != rtc[1]) {

  //update mins and hours with the new values
  mins = rtc[1];
  hours = rtc[2];

  //adjust hours of ampm set to 12 hour mode
  if (hours > 12) {
    hours = hours - ampm * 12;
  }
  if (hours < 1) {
    hours = hours + ampm * 12;
  }

  itoa(hours, buffer, 10);

  //if hours < 10 the num e.g. "3" hours, itoa coverts this to chars with space "3 " which we dont want
  if (hours < 10) {
    buffer[1] = buffer[0];
    buffer[0] = '0';
  }

  //print hours
  //if we in 12 hour mode and hours < 10, then don't print the leading zero, and set the offset so we centre the display with 3 digits.
  if (ampm && hours < 10) {
    offset = 2;

    //if the time is 1:00am clear the entire display as the offset changes at this time and we need to blank out the old 12:59
    if ((hours == 1 && mins == 0) ) {
      cls();
    }
  }
  else {
    //else no offset and print hours tens digit
    offset = 0;

    //if the time is 10:00am clear the entire display as the offset changes at this time and we need to blank out the old 9:59
    if (hours == 10 && mins == 0) {
      cls();
    }


    putnormalchar(1,  0, buffer[0]);
  }
  //print hours ones digit
  putnormalchar(7 - offset, 0, buffer[1]);


  //print mins
  //add leading zero if mins < 10
  itoa (mins, buffer, 10);
  if (mins < 10) {
    buffer[1] = buffer[0];
    buffer[0] = '0';
  }
  //print mins tens and ones digits
  putnormalchar(19 - offset, 0, buffer[0]);
  putnormalchar(25 - offset, 0, buffer[1]);
}

}
fade_down();
}

//like basic_mode but with slide effect
void slide() {

byte digits_old[4] = {99, 99, 99, 99}; //old values we store time in. Set to somthing that will never match the time initially so all digits get drawn wnen the mode starts
byte digits_new[4]; //new digits time will slide to reveal
byte digits_x_pos[4] = {25, 19, 7, 1}; //x pos for which to draw each digit at

char old_char[2]; //used when we use itoa to transpose the current digit (type byte) into a char to pass to the animation function
char new_char[2]; //used when we use itoa to transpose the new digit (type byte) into a char to pass to the animation function

//old_chars - stores the 5 day and date suffix chars on the display. e.g. "mon" and "st". We feed these into the slide animation as the current char when these chars are updated.
//We sent them as A initially, which are used when the clocl enters the mode and no last chars are stored.
//char old_chars[6] = "AAAAA";

//plot the clock colon on the display
cls();
putnormalchar( 13, 0, ':');

byte old_secs = rtc[0]; //store seconds in old_secs. We compare secs and old secs. WHen they are different we redraw the display

//run clock main loop as long as run_mode returns true
while (run_mode()) {

get_time();

//check for button press
if (buttonA.uniquePress()) {
  switch_mode();
  return;
}
  if (buttonB.uniquePress()) {
  display_date();
  return;
}

//if secs have changed then update the display
if (rtc[0] != old_secs) {
  old_secs = rtc[0];

  //do 12/24 hour conversion if ampm set to 1
  byte hours = rtc[2];
  if (hours > 12) {
    hours = hours - ampm * 12;
  }
  if (hours < 1) {
    hours = hours + ampm * 12;
  }

  //split all date and time into individual digits - stick in digits_new array

  //rtc[0] = secs                        //array pos and digit stored
  //digits_new[0] = (rtc[0]%10);           //0 - secs ones
  //digits_new[1] = ((rtc[0]/10)%10);      //1 - secs tens
  //rtc[1] = mins
  digits_new[0] = (rtc[1] % 10);         //2 - mins ones
  digits_new[1] = ((rtc[1] / 10) % 10);  //3 - mins tens
  //rtc[2] = hours
  digits_new[2] = (hours % 10);         //4 - hour ones
  digits_new[3] = ((hours / 10) % 10);  //5 - hour tens
  //rtc[4] = date
  //digits_new[6] = (rtc[4]%10);           //6 - date ones
  //digits_new[7] = ((rtc[4]/10)%10);      //7 - date tens

  //draw initial screen of all chars. After this we just draw the changes.

  //compare digits 0 to 3 (mins and hours)
  for (byte i = 0; i <= 3; i++) {
    //see if digit has changed...
    if (digits_old[i] != digits_new[i]) {

      //run 9 step animation sequence for each in turn
      for (byte seq = 0; seq <= 8 ; seq++) {

        //convert digit to string
        itoa(digits_old[i], old_char, 10);
        itoa(digits_new[i], new_char, 10);

        //if set to 12 hour mode and we're on digit 2 (hours tens mode) then check to see if this is a zero. If it is, blank it instead so we get 2.00pm not 02.00pm
        if (ampm && i == 3) {
          if (digits_new[3] == 0) {
            new_char[0] = ' ';
          }
          if (digits_old[3] == 0) {
            old_char[0] = ' ';
          }
        }
        //draw the animation frame for each digit
        slideanim(digits_x_pos[i], 0, seq, old_char[0], new_char[0]);
        delay(SLIDE_DELAY);
      }
    }
  }

  /*
  //compare date digit 6 (ones) and (7) tens - if either of these change we need to update the date line. We compare date tens as say from Jan 31 -> Feb 01 then ones digit doesn't change
  if ((digits_old[6] != digits_new[6]) || (digits_old[7] != digits_new[7])) {
    //change the day shown. Loop below goes through each of the 3 chars in turn e.g. "MON"
    for (byte day_char = 0; day_char <=2 ; day_char++){
      //run the anim sequence for each char
      for (byte seq = 0; seq <=8 ; seq++){
        //the day (0 - 6) Read this number into the days char array. the seconds number in the array 0-2 gets the 3 chars of the day name, e.g. m o n
        slideanim(6*day_char,8,seq,old_chars[day_char],days[rtc[3]][day_char]); //6 x day_char gives us the x pos for the char
        delay(SLIDE_DELAY);
      }
      //save the old day chars into the old_chars array at array pos 0-2. We use this next time we change the day and feed it to the animation as the current char. The updated char is fed in as the new char.
      old_chars[day_char] = days[rtc[3]][day_char];
    }

    //change the date tens digit (if needed) and ones digit. (the date ones digit wil alwaus change, but putting this in the 'if' loop makes it a bit neater code wise.)
    for (byte i = 7; i >= 6; i--){
      if (digits_old[i] != digits_new[i]) {
        for (byte seq = 0; seq <=8 ; seq++){
          itoa(digits_old[i],old_char,10);
          itoa(digits_new[i],new_char,10);
          slideanim(digits_x_pos[i],8,seq,old_char[0],new_char[0]);
          delay(SLIDE_DELAY);
        }
      }
    }

    //print the day suffix "nd" "rd" "th" etc. First work out date 2 letter suffix - eg st, nd, rd, th
    byte s = 3; //the pos to read our suffix array from.
    byte date = rtc[4];
    if(date == 1 || date == 21 || date == 31) {
      s = 0;
    }
    else if (date == 2 || date == 22) {
      s = 1;
    }
    else if (date == 3 || date == 23) {
      s = 2;
    }

    for (byte suffix_char = 0; suffix_char <=1 ; suffix_char++){
      for (byte seq = 0; seq <=8 ; seq++){
        slideanim((suffix_char*6)+36,8,seq,old_chars[suffix_char+3],suffix[s][suffix_char]); // we pass in the old_char array char as the current char and the suffix array as the new char
        delay(SLIDE_DELAY);
      }
      //save the suffic char in the old chars array at array pos 3 and 5.  We use these chars next time we change the suffix and feed it to the animation as the current char. The updated char is fed in as the new char.
      old_chars[suffix_char+3] = suffix[s][suffix_char];
    }
  }//end do date line
  */


  //save digita array tol old for comparison next loop
  for (byte i = 0; i <= 3; i++) {
    digits_old[i] =  digits_new[i];
  }
}//secs/oldsecs

}//while loop
fade_down();
}

//called by slide
//this draws the animation of one char sliding on and the other sliding off. There are 8 steps in the animation, we call the function to draw one of the steps from 0-7
//inputs are are char x and y, animation frame sequence (0-7) and the current and new chars being drawn.
void slideanim(byte x, byte y, byte sequence, char current_c, char new_c) {

// To slide one char off and another on we need 9 steps or frames in sequence...

// seq# 0123456 <-rows of the display
// | |||||||
// seq0 0123456 START - all rows of the display 0-6 show the current characters rows 0-6
// seq1 012345 current char moves down one row on the display. We only see it's rows 0-5. There are at display positions 1-6 There is a blank row inserted at the top
// seq2 6 01234 current char moves down 2 rows. we now only see rows 0-4 at display rows 2-6 on the display. Row 1 of the display is blank. Row 0 shows row 6 of the new char
// seq3 56 0123
// seq4 456 012 half old / half new char
// seq5 3456 01
// seq6 23456 0
// seq7 123456
// seq8 0123456 END - all rows show the new char

//from above we can see...
//currentchar runs 0-6 then 0-5 then 0-4 all the way to 0. starting Y position increases by 1 row each time.
//new char runs 6 then 5-6 then 4-6 then 3-6. starting Y position increases by 1 row each time.

//if sequence number is below 7, we need to draw the current char
if (sequence < 7) {
byte dots;
// if (current_c >= 'A' && || (current_c >= 'a' && current_c <= 'z') ) {
// current_c &= 0x1F; // A-Z maps to 1-26
// }
if (current_c >= 'A' && current_c <= 'Z' ) {
current_c &= 0x1F; // A-Z maps to 1-26
}
else if (current_c >= 'a' && current_c <= 'z') {
current_c = (current_c - 'a') + 41; // A-Z maps to 41-67
}
else if (current_c >= '0' && current_c <= '9') {
current_c = (current_c - '0') + 31;
}
else if (current_c == ' ') {
current_c = 0; // space
}
else if (current_c == '.') {
current_c = 27; // full stop
}
else if (current_c == '\'') {
current_c = 28; // single quote mark
}
else if (current_c == ':') {
current_c = 29; //colon
}
else if (current_c == '>') {
current_c = 30; // clock_mode selector arrow
}

byte curr_char_row_max = 7 - sequence; //the maximum number of rows to draw is 6 - sequence number
byte start_y = sequence; //y position to start at - is same as sequence number. We inc this each loop

//plot each row up to row maximum (calculated from sequence number)
for (byte curr_char_row = 0; curr_char_row <= curr_char_row_max; curr_char_row++) {
  for (byte col = 0; col < 5; col++) {
    dots = pgm_read_byte_near(&myfont[current_c][col]);
    if (dots & (64 >> curr_char_row))
      plot(x + col, y + start_y, 1); //plot led on
    else
      plot(x + col, y + start_y, 0); //else plot led off
  }
  start_y++;//add one to y so we draw next row one down
}

}

//draw a blank line between the characters if sequence is between 1 and 7. If we don't do this we get the remnants of the current chars last position left on the display
if (sequence >= 1 && sequence <= 8) {
for (byte col = 0; col < 5; col++) {
plot(x + col, y + (sequence - 1), 0); //the y position to draw the line is equivalent to the sequence number - 1
}
}

//if sequence is above 2, we also need to start drawing the new char
if (sequence >= 2) {

//work out char
byte dots;
//if (new_c >= 'A' && new_c <= 'Z' || (new_c >= 'a' && new_c <= 'z') ) {
//  new_c &= 0x1F;   // A-Z maps to 1-26
//}
if (new_c >= 'A' && new_c <= 'Z' ) {
  new_c &= 0x1F;   // A-Z maps to 1-26
}
else if (new_c >= 'a' && new_c <= 'z') {
  new_c = (new_c - 'a') + 41;   // A-Z maps to 41-67
}
else if (new_c >= '0' && new_c <= '9') {
  new_c = (new_c - '0') + 31;
}
else if (new_c == ' ') {
  new_c = 0; // space
}
else if (new_c == '.') {
  new_c = 27; // full stop
}
else if (new_c == '\'') {
  new_c = 28; // single quote mark
}
else if (new_c == ':') {
  new_c = 29; // clock_mode selector arrow
}
else if (new_c == '>') {
  new_c = 30; // clock_mode selector arrow
}

byte newcharrowmin = 6 - (sequence - 2); //minimumm row num to draw for new char - this generates an output of 6 to 0 when fed sequence numbers 2-8. This is the minimum row to draw for the new char
byte start_y = 0; //y position to start at - is same as sequence number. we inc it each row

//plot each row up from row minimum (calculated by sequence number) up to 6
for (byte newcharrow = newcharrowmin; newcharrow <= 6; newcharrow++) {
  for (byte col = 0; col < 5; col++) {
    dots = pgm_read_byte_near(&myfont[new_c][col]);
    if (dots & (64 >> newcharrow))
      plot(x + col, y + start_y, 1); //plot led on
    else
      plot(x + col, y + start_y, 0); //else plot led off
  }
  start_y++;//add one to y so we draw next row one down
}

}
}

//print a clock using words rather than numbers
void word_clock() {

cls();

char numbers[19][10] = {
"one", "two", "three", "four", "five", "six", "seven", "eight", "nine", "ten",
"eleven", "twelve", "thirteen", "fourteen", "fifteen", "sixteen", "seventeen", "eighteen", "nineteen"
};
char numberstens[5][7] = {
"ten", "twenty", "thirty", "forty", "fifty"
};

//potentially 3 lines to display
char str_a[8];
char str_b[8];
char str_c[8];

//byte hours_y, mins_y; //hours and mins and positions for hours and mins lines

byte hours = rtc[2];
if (hours > 12) {
hours = hours - ampm * 12;
}
if (hours < 1) {
hours = hours + ampm * 12;
}

get_time(); //get the time from the clock chip
byte old_mins = 100; //store mins in old_mins. We compare mins and old mins & when they are different we redraw the display. Set this to 100 initially so display is drawn when mode starts.
byte mins;

//run clock main loop as long as run_mode returns true
while (run_mode()) {

//check for button press
if (buttonA.uniquePress()) {
  switch_mode();
  return;
}
if (buttonB.uniquePress()) {
  display_date();
}

get_time(); //get the time from the clock chip
mins = rtc[1];  //get mins


//if mins is different from old_mins - redraw display
if (mins != old_mins) {

  //update old_mins with current mins value
  old_mins = mins;

  //reset these for comparison next time
  mins = rtc[1];
  hours = rtc[2];

  //make hours into 12 hour format
  if (hours > 12) {
    hours = hours - 12;
  }
  if (hours == 0) {
    hours = 12;
  }

  //split mins value up into two separate digits
  int minsdigit = rtc[1] % 10;
  byte minsdigitten = (rtc[1] / 10) % 10;

  //if mins <= 10 , then top line has to read "minsdigti past" and bottom line reads hours
  if (mins < 10) {
    strcpy (str_a, numbers[minsdigit - 1]);
    strcpy (str_b, "PAST");
    strcpy (str_c, numbers[hours - 1]);
  }

  //if mins = 10, cant use minsdigit as above, so soecial case to print 10 past /n hour.
  if (mins == 10) {
    strcpy (str_a, numbers[9]);
    strcpy (str_b, " PAST");
    strcpy (str_c, numbers[hours - 1]);
  }

  //if time is not on the hour - i.e. both mins digits are not zero,
  //then make first line read "hours" and 2 & 3rd lines read "minstens"  "mins" e.g. "three /n twenty /n one"
  else if (minsdigitten != 0 && minsdigit != 0  ) {

    strcpy (str_a, numbers[hours - 1]);

    //if mins is in the teens, use teens from the numbers array for the 2nd line, e.g. "fifteen"
    //if (mins >= 11 && mins <= 19) {
    if (mins <= 19) {
      strcpy (str_b, numbers[mins - 1]);
    }
    else {
      strcpy (str_b, numberstens[minsdigitten - 1]);

      strcpy (str_c, numbers[minsdigit - 1]);
    }
  }
  // if mins digit is zero, don't print it. read read "hours" "minstens" e.g. "three /n twenty"
  else if (minsdigitten != 0 && minsdigit == 0  ) {
    strcpy (str_a, numbers[hours - 1]);
    strcpy (str_b, numberstens[minsdigitten - 1]);
    strcpy (str_c, "");
  }

  //if both mins are zero, i.e. it is on the hour, the top line reads "hours" and bottom line reads "o'clock"
  else if (minsdigitten == 0 && minsdigit == 0  ) {
    strcpy (str_a, numbers[hours - 1]);
    strcpy (str_b, "O'CLOCK");
    strcpy (str_c, "");
  }

}//end worknig out time

//run in a loop
//print line a "twelve"
byte len = 0;
while (str_a[len]) {
  len++;
}; //get length of message
byte offset_top = (31 - ((len - 1) * 4)) / 2; //

//plot hours line
byte i = 0;
while (str_a[i]) {
  puttinychar((i * 4) + offset_top, 1, str_a[i]);
  i++;
}

//hold display but check for button presses
int counter = 1000;
while (counter > 0){
  //check for button press
  if (buttonA.uniquePress()) {
    switch_mode();
    return;
  }
  if (buttonB.uniquePress()) {
    display_date();
  }
delay(1);
counter--;
}
fade_down();

//print line b
len = 0;
while (str_b[len]) {
  len++;
}; //get length of message
offset_top = (31 - ((len - 1) * 4)) / 2; 

i = 0;
while (str_b[i]) {
  puttinychar((i * 4) + offset_top, 1, str_b[i]);
  i++;
}

//hold display but check for button presses
counter = 1000;
while (counter > 0){
  if (buttonA.uniquePress()) {
    switch_mode();
    return;
  }
  if (buttonB.uniquePress()) {
    display_date();
  }
  delay(1);
  counter--;
}
fade_down();

//print line c if there.
len = 0;
while (str_c[len]) {
  len++;
}; //get length of message
offset_top = (31 - ((len - 1) * 4)) / 2; 

i = 0;
while (str_c[i]) {
  puttinychar((i * 4) + offset_top, 1, str_c[i]);
  i++;
}
counter = 1000;
while (counter > 0){
  //check for button press
  if (buttonA.uniquePress()) {
    switch_mode();
    return;
  }
  if (buttonB.uniquePress()) {
    display_date();
  }  
  delay(1);
  counter--;
}
fade_down();


//hold display blank but check for button presses before starting again.
counter = 1000;
while (counter > 0){
   //check for button press
  if (buttonA.uniquePress()) {
    switch_mode();
    return;
  }
  if (buttonB.uniquePress()) {
    display_date();
  }  
  delay(1);
  counter--;
}

}
fade_down();
}

/// scroll message - not used at present - too slow.
void scroll() {

char message[] = {"Hello There "};

cls();
byte p = 6; //current pos in string
byte chara[] = {0, 1, 2, 3, 4, 5}; //chars from string
int x[] = {0, 6, 12, 18, 24, 30}; //xpos for each char
byte y = 0; //y pos

// clear_buffer();

while (message[p] != '\0') {

//draw all 6 chars
for (byte c = 0; c < 6; c++) {

  putnormalchar(x[c],y,message[ chara[c] ]);


  //draw a line of pixels turned off after each char,otherwise the gaps between the chars have pixels left in them from the previous char
  for (byte yy = 0 ; yy < 8; yy ++) {
    plot(x[c] + 5, yy, 0);
  }

  //take one off each chars position
  x[c] = x[c] - 1;
}

//reset a char if it's gone off screen
for (byte i = 0; i <= 5; i++) {
  if (x[i] < -5 ) {
    x[i] = 31;
    chara[i] = p;
    p++;
  }
}

}
}

//display_date - print the day of week, date and month with a flashing cursor effect
void display_date()
{

cls();
//read the date from the DS1307

byte dow = rtc[3]; // day of week 0 = Sunday
byte date = rtc[4];
byte month = rtc[5] - 1;

//array of month names to print on the display. Some are shortened as we only have 8 characters across to play with
char monthnames[12][9] = {
"January", "February", "March", "April", "May", "June", "July", "August", "Sept", "October", "November", "December"
};

//print the day name

//get length of text in pixels, that way we can centre it on the display by divindin the remaining pixels b2 and using that as an offset
byte len = 0;
while(daysfull[dow][len]) {
len++;
};
byte offset = (31 - ((len-1)*4)) / 2; //our offset to centre up the text

//print the name

int i = 0;
while(daysfull[dow][i])
{
puttinychar((i*4) + offset , 1, daysfull[dow][i]);
i++;
}
delay(1000);
fade_down();
cls();

// print date numerals
char buffer[3];
itoa(date,buffer,10);
offset = 10; //offset to centre text if 3 chars - e.g. 3rd

// first work out date 2 letter suffix - eg st, nd, rd, th etc
// char suffix[4][3]={"st", "nd", "rd", "th" }; is defined at top of code
byte s = 3;
if(date == 1 || date == 21 || date == 31) {
s = 0;
}
else if (date == 2 || date == 22) {
s = 1;
}
else if (date == 3 || date == 23) {
s = 2;
}

//print the 1st date number
puttinychar(0+offset, 1, buffer[0]);

//if date is under 10 - then we only have 1 digit so set positions of sufix etc one character nearer
byte suffixposx = 4;

//if date over 9 then print second number and set xpos of suffix to be 1 char further away
if (date > 9){
suffixposx = 8;
puttinychar(4+offset, 1, buffer[1]);
offset = 8; //offset to centre text if 4 chars
}

//print the 2 suffix characters
puttinychar(suffixposx+offset, 1, suffix[s][0]);
puttinychar(suffixposx+4+offset, 1, suffix[s][1]);

delay(1000);
fade_down();

//print the month name

//get length of text in pixels, that way we can centre it on the display by divindin the remaining pixels b2 and using that as an offset
len = 0;
while(monthnames[month][len]) {
len++;
};
offset = (31 - ((len-1)*4)) / 2; //our offset to centre up the text
i = 0;
while(monthnames[month][i])
{

puttinychar((i*4) +offset, 1, monthnames[month][i]);
i++;
}

delay(1000);
fade_down();
}

//dislpay menu to change the clock mode
void switch_mode() {

//remember mode we are in. We use this value if we go into settings mode, so we can change back from settings mode (6) to whatever mode we were in.
old_mode = clock_mode;

char* modes[] = {
"Basic", "Small", "Slide", "Words", "Setup"
};

byte next_clock_mode;
byte firstrun = 1;

//loop waiting for button (timeout after 35 loops to return to mode X)
for (int count = 0; count < 35 ; count++) {

//if user hits button, change the clock_mode
if (buttonA.uniquePress() || firstrun == 1) {

  count = 0;
  cls();

  if (firstrun == 0) {
    clock_mode++;
  }
  if (clock_mode > NUM_DISPLAY_MODES + 1 ) {
    clock_mode = 0;
  }

  //print arrown and current clock_mode name on line one and print next clock_mode name on line two
  char str_top[9];

  //strcpy (str_top, "-");
  strcpy (str_top, modes[clock_mode]);

  next_clock_mode = clock_mode + 1;
  if (next_clock_mode >  NUM_DISPLAY_MODES + 1 ) {
    next_clock_mode = 0;
  }

  byte i = 0;
  while (str_top[i]) {
    putnormalchar(i * 6, 0, str_top[i]);
    i++;
  }
  firstrun = 0;
}
delay(50);

}
}

//run clock main loop as long as run_mode returns true
byte run_mode() {

//if random mode is on... check the hour when we change mode.
if (random_mode) {
//if hour value in change mode time = hours. then reurn false = i.e. exit mode.
if (change_mode_time == rtc[2]) {
//set the next random clock mode and time to change it
set_next_random();
//exit the current mode.
return 0;
}
}
//else return 1 - keep running in this mode
return 1;
}

//set the next hour the clock will change mode when random mode is on
void set_next_random() {

//set the next hour the clock mode will change - current time plus 1 - 4 hours
get_time();
change_mode_time = rtc[2] + random (1, 5);

//if change_mode_time now happens to be over 23, then set it to between 1 and 3am
if (change_mode_time > 23) {
change_mode_time = random (1, 4);
}

//set the new clock mode
clock_mode = random(0, NUM_DISPLAY_MODES + 1); //pick new random clock mode
}

//dislpay menu to change the clock settings
void setup_menu() {

char* set_modes[] = {
"Rndom", "24 Hr","Set", "Brght", "Exit"};
if (ampm == 0) {
set_modes[1] = ("12 Hr");
}

byte setting_mode = 0;
byte next_setting_mode;
byte firstrun = 1;

//loop waiting for button (timeout after 35 loops to return to mode X)
for(int count=0; count < 35 ; count++) {

//if user hits button, change the clock_mode
if(buttonA.uniquePress() || firstrun == 1){

  count = 0;
  cls();

  if (firstrun == 0) { 
    setting_mode++; 
  } 
  if (setting_mode > NUM_SETTINGS_MODES) { 
    setting_mode = 0; 
  }

  //print arrown and current clock_mode name on line one and print next clock_mode name on line two
  char str_top[9];

  strcpy (str_top, set_modes[setting_mode]);

  next_setting_mode = setting_mode + 1;
  if (next_setting_mode > NUM_SETTINGS_MODES) { 
    next_setting_mode = 0; 
  }

  byte i = 0;
  while(str_top[i]) {
    putnormalchar(i*6, 0, str_top[i]); 
    i++;
  }

  firstrun = 0;
}
delay(50);

}

//pick the mode
switch(setting_mode){
case 0:
set_random();
break;
case 1:
set_ampm();
break;
case 2:
set_time();
break;
case 3:
set_intensity();
break;
case 4:
//exit menu
break;
}

//change the clock from mode 6 (settings) back to the one it was in before
clock_mode=old_mode;
}

//toggle random mode - pick a different clock mode every few hours
void set_random(){
cls();

char text_a[9] = "Off";
char text_b[9] = "On";
byte i = 0;

//if random mode is on, turn it off
if (random_mode){

//turn random mode off
random_mode = 0;

//print a message on the display
while(text_a[i]) {
  putnormalchar((i*6), 0, text_a[i]);
  i++;
}

} else {
//turn randome mode on.
random_mode = 1;

//set hour mode will change
set_next_random();

//print a message on the display
while(text_b[i]) {
  putnormalchar((i*6), 0, text_b[i]);
  i++;
}

}
delay(1500); //leave the message up for a second or so
}

//set 12 or 24 hour clock
void set_ampm() {

// AM/PM or 24 hour clock mode - flip the bit (makes 0 into 1, or 1 into 0 for ampm mode)
ampm = (ampm ^ 1);
cls();
}

//change screen intensityintensity
void set_intensity() {

cls();

byte i = 0;
char text[7] = "Bright";
while(text[i]) {
puttinychar((i*4)+4, 0, text[i]);
i++;
}

//wait for button input
while (!buttonA.uniquePress()) {

levelbar (0,6,(intensity*2)+2,2);    //display the intensity level as a bar
while (buttonB.isPressed()) {

  if(intensity == 15) { 
    intensity = 0;
    cls (); 
  } 
  else {
    intensity++; 
  }
  //print the new value 
  i = 0;
  while(text[i]) {
    puttinychar((i*4)+4, 0, text[i]);
    i++;
  }

  //display the intensity level as a bar
  levelbar (0,6,(intensity*2)+2,2);    

  //change the brightness setting on the displays
  for (byte address = 0; address < 4; address++) {
    lc.setIntensity(address, intensity);
  }
  delay(150);
}

}
}

// display a horizontal bar on the screen at offset xposr by ypos with height and width of xbar, ybar
void levelbar (byte xpos, byte ypos, byte xbar, byte ybar) {
for (byte x = 0; x < xbar; x++) {
for (byte y = 0; y <= ybar; y++) {
plot(x+xpos, y+ypos, 1);
}
}
}

//set time and date routine
void set_time() {

cls();

//fill settings with current clock values read from clock
get_time();
byte set_min = rtc[1];
byte set_hr = rtc[2];
byte set_date = rtc[4];
byte set_mnth = rtc[5];
int set_yr = rtc[6];

//Set function - we pass in: which 'set' message to show at top, current value, reset value, and rollover limit.
set_date = set_value(2, set_date, 1, 31);
set_mnth = set_value(3, set_mnth, 1, 12);
set_yr = set_value(4, set_yr, 2013, 2099);
set_hr = set_value(1, set_hr, 0, 23);
set_min = set_value(0, set_min, 0, 59);

ds1307.adjust(DateTime(set_yr, set_mnth, set_date, set_hr, set_min));

cls();
}

//used to set min, hr, date, month, year values. pass
//message = which 'set' message to print,
//current value = current value of property we are setting
//reset_value = what to reset value to if to rolls over. E.g. mins roll from 60 to 0, months from 12 to 1
//rollover limit = when value rolls over
int set_value(byte message, int current_value, int reset_value, int rollover_limit){

cls();
char messages[6][17] = {
"Set Mins", "Set Hour", "Set Day", "Set Mnth", "Set Year"};

//Print "set xyz" top line
byte i = 0;
while(messages[message][i])
{
puttinychar(i*4 , 1, messages[message][i]);
i++;
}

delay(2000);
cls();

//print digits bottom line
char buffer[5] = " ";
itoa(current_value,buffer,10);
puttinychar(0 , 1, buffer[0]);
puttinychar(4 , 1, buffer[1]);
puttinychar(8 , 1, buffer[2]);
puttinychar(12, 1, buffer[3]);

delay(300);
//wait for button input
while (!buttonA.uniquePress()) {

while (buttonB.isPressed()){

  if(current_value < rollover_limit) { 
    current_value++;
  } 
  else {
    current_value = reset_value;
  }
  //print the new value
  itoa(current_value, buffer ,10);
  puttinychar(0 , 1, buffer[0]); 
  puttinychar(4 , 1, buffer[1]); 
  puttinychar(8 , 1, buffer[2]); 
  puttinychar(12, 1, buffer[3]);    
  delay(150);
}

}
return current_value;
}

void get_time()
{
//get time
DateTime now = ds1307.now();
//save time to array
rtc[6] = now.year();
rtc[5] = now.month();
rtc[4] = now.day();
rtc[3] = now.dayOfTheWeek(); //returns 0-6 where 0 = Sunday
rtc[2] = now.hour();
rtc[1] = now.minute();
rtc[0] = now.second();

//flash arduino led on pin 13 every second
//if ( (rtc[0] % 2) == 0) {
// digitalWrite(13, HIGH);
//}
//else {
// digitalWrite(13, LOW);
//}

//print the time to the serial port - useful for debuging RTC issues
/*
Serial.print(rtc[2]);
Serial.print(":");
Serial.print(rtc[1]);
Serial.print(":");
Serial.println(rtc[0]);
*/
}

mini computer with hologram function

jay jordan — Mon, 25 Dec 2023 15:51:27 +0000

Author: Tony DiCola & James DeVito

Permission is hereby granted, free of charge, to any person obtaining a copy

of this software and associated documentation files (the "Software"), to deal

in the Software without restriction, including without limitation the rights

to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

copies of the Software, and to permit persons to whom the Software is

furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in

all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN

THE SOFTWARE.

import time

import Adafruit_GPIO.SPI as SPI
import Adafruit_SSD1306

from PIL import Image
from PIL import ImageDraw
from PIL import ImageFont

import subprocess

Raspberry Pi pin configuration:

RST = None # on the PiOLED this pin isnt used

Note the following are only used with SPI:

DC = 23
SPI_PORT = 0
SPI_DEVICE = 0

Beaglebone Black pin configuration:

RST = 'P9_12'

Note the following are only used with SPI:

DC = 'P9_15'

SPI_PORT = 1

SPI_DEVICE = 0

128x32 display with hardware I2C:

disp = Adafruit_SSD1306.SSD1306_128_32(rst=RST)

128x64 display with hardware I2C:

disp = Adafruit_SSD1306.SSD1306_128_64(rst=RST)

Note you can change the I2C address by passing an i2c_address parameter like:

disp = Adafruit_SSD1306.SSD1306_128_64(rst=RST, i2c_address=0x3C)

Alternatively you can specify an explicit I2C bus number, for example

with the 128x32 display you would use:

disp = Adafruit_SSD1306.SSD1306_128_32(rst=RST, i2c_bus=2)

128x32 display with hardware SPI:

disp = Adafruit_SSD1306.SSD1306_128_32(rst=RST, dc=DC, spi=SPI.SpiDev(SPI_PORT, SPI_DEVICE, max_speed_hz=8000000))

128x64 display with hardware SPI:

disp = Adafruit_SSD1306.SSD1306_128_64(rst=RST, dc=DC, spi=SPI.SpiDev(SPI_PORT, SPI_DEVICE, max_speed_hz=8000000))

Alternatively you can specify a software SPI implementation by providing

digital GPIO pin numbers for all the required display pins. For example

on a Raspberry Pi with the 128x32 display you might use:

disp = Adafruit_SSD1306.SSD1306_128_32(rst=RST, dc=DC, sclk=18, din=25, cs=22)

Initialize library.

disp.begin()

Clear display.

disp.clear()
disp.display()

Create blank image for drawing.

Make sure to create image with mode '1' for 1-bit color.

width = disp.width
height = disp.height
image = Image.new('1', (width, height))

Get drawing object to draw on image.

draw = ImageDraw.Draw(image)

Draw a black filled box to clear the image.

draw.rectangle((0,0,width,height), outline=0, fill=0)

Draw some shapes.

First define some constants to allow easy resizing of shapes.

padding = -2
top = padding
bottom = height-padding

Move left to right keeping track of the current x position for drawing shapes.

x = 0

Load default font.

font = ImageFont.load_default()

Alternatively load a TTF font. Make sure the .ttf font file is in the same directory as the python script!

Some other nice fonts to try: http://www.dafont.com/bitmap.php

font = ImageFont.truetype('Minecraftia.ttf', 8)

while True:

# Draw a black filled box to clear the image.
draw.rectangle((0,0,width,height), outline=0, fill=0)

# Shell scripts for system monitoring from here : https://unix.stackexchange.com/questions/119126/command-to-display-memory-usage-disk-usage-and-cpu-load
cmd = "hostname -I |cut -f 2 -d ' '"
IP = subprocess.check_output(cmd, shell = True )
cmd = "top -bn1 | grep load | awk '{printf \"CPU Load: %.2f\", $(NF-2)}'"
CPU = subprocess.check_output(cmd, shell = True )
cmd = "free -m | awk 'NR==2{printf \"Mem: %s/%sMB %.2f%%\", $3,$2,$3*100/$2 }'"
MemUsage = subprocess.check_output(cmd, shell = True )
cmd = "df -h | awk '$NF==\"/\"{printf \"Disk: %d/%dGB %s\", $3,$2,$5}'"
Disk = subprocess.check_output(cmd, shell = True )
cmd = "vcgencmd measure_temp |cut -f 2 -d '='"
temp = subprocess.check_output(cmd, shell = True )

# Write two lines of text.

draw.text((x, top), "IP: " + str(IP,'utf-8'), font=font, fill=255)
draw.text((x, top+8), str(CPU,'utf-8') + " " + str(temp,'utf-8') , font=font, fill=255)
draw.text((x, top+16), str(MemUsage,'utf-8'), font=font, fill=255)
draw.text((x, top+25), str(Disk,'utf-8'), font=font, fill=255)

# Display image.
disp.image(image)
disp.display()
time.sleep(.1)
# Copyright (c) 2014 Adafruit Industries

Author: Tony DiCola

Permission is hereby granted, free of charge, to any person obtaining a copy

of this software and associated documentation files (the "Software"), to deal

in the Software without restriction, including without limitation the rights

to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

copies of the Software, and to permit persons to whom the Software is

furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in

all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN

THE SOFTWARE.

from future import division
import logging
import time

import Adafruit_GPIO as GPIO
import Adafruit_GPIO.SPI as SPI

Constants

SSD1306_I2C_ADDRESS = 0x3C # 011110+SA0+RW - 0x3C or 0x3D
SSD1306_SETCONTRAST = 0x81
SSD1306_DISPLAYALLON_RESUME = 0xA4
SSD1306_DISPLAYALLON = 0xA5
SSD1306_NORMALDISPLAY = 0xA6
SSD1306_INVERTDISPLAY = 0xA7
SSD1306_DISPLAYOFF = 0xAE
SSD1306_DISPLAYON = 0xAF
SSD1306_SETDISPLAYOFFSET = 0xD3
SSD1306_SETCOMPINS = 0xDA
SSD1306_SETVCOMDETECT = 0xDB
SSD1306_SETDISPLAYCLOCKDIV = 0xD5
SSD1306_SETPRECHARGE = 0xD9
SSD1306_SETMULTIPLEX = 0xA8
SSD1306_SETLOWCOLUMN = 0x00
SSD1306_SETHIGHCOLUMN = 0x10
SSD1306_SETSTARTLINE = 0x40
SSD1306_MEMORYMODE = 0x20
SSD1306_COLUMNADDR = 0x21
SSD1306_PAGEADDR = 0x22
SSD1306_COMSCANINC = 0xC0
SSD1306_COMSCANDEC = 0xC8
SSD1306_SEGREMAP = 0xA0
SSD1306_CHARGEPUMP = 0x8D
SSD1306_EXTERNALVCC = 0x1
SSD1306_SWITCHCAPVCC = 0x2

Scrolling constants

SSD1306_ACTIVATE_SCROLL = 0x2F
SSD1306_DEACTIVATE_SCROLL = 0x2E
SSD1306_SET_VERTICAL_SCROLL_AREA = 0xA3
SSD1306_RIGHT_HORIZONTAL_SCROLL = 0x26
SSD1306_LEFT_HORIZONTAL_SCROLL = 0x27
SSD1306_VERTICAL_AND_RIGHT_HORIZONTAL_SCROLL = 0x29
SSD1306_VERTICAL_AND_LEFT_HORIZONTAL_SCROLL = 0x2A

class SSD1306Base(object):
"""Base class for SSD1306-based OLED displays. Implementors should subclass
and provide an implementation for the _initialize function.
"""

def __init__(self, width, height, rst, dc=None, sclk=None, din=None, cs=None,
             gpio=None, spi=None, i2c_bus=None, i2c_address=SSD1306_I2C_ADDRESS,
             i2c=None):
    self._log = logging.getLogger('Adafruit_SSD1306.SSD1306Base')
    self._spi = None
    self._i2c = None
    self.width = width
    self.height = height
    self._pages = height//8
    self._buffer = [0]*(width*self._pages)
    # Default to platform GPIO if not provided.
    self._gpio = gpio
    if self._gpio is None:
        self._gpio = GPIO.get_platform_gpio()
    # Setup reset pin.
    self._rst = rst
    if not self._rst is None:
        self._gpio.setup(self._rst, GPIO.OUT)
    # Handle hardware SPI
    if spi is not None:
        self._log.debug('Using hardware SPI')
        self._spi = spi
        self._spi.set_clock_hz(8000000)
    # Handle software SPI
    elif sclk is not None and din is not None and cs is not None:
        self._log.debug('Using software SPI')
        self._spi = SPI.BitBang(self._gpio, sclk, din, None, cs)
    # Handle hardware I2C
    elif i2c is not None:
        self._log.debug('Using hardware I2C with custom I2C provider.')
        self._i2c = i2c.get_i2c_device(i2c_address)
    else:
        self._log.debug('Using hardware I2C with platform I2C provider.')
        import Adafruit_GPIO.I2C as I2C
        if i2c_bus is None:
            self._i2c = I2C.get_i2c_device(i2c_address)
        else:
            self._i2c = I2C.get_i2c_device(i2c_address, busnum=i2c_bus)
    # Initialize DC pin if using SPI.
    if self._spi is not None:
        if dc is None:
            raise ValueError('DC pin must be provided when using SPI.')
        self._dc = dc
        self._gpio.setup(self._dc, GPIO.OUT)

def _initialize(self):
    raise NotImplementedError

def command(self, c):
    """Send command byte to display."""
    if self._spi is not None:
        # SPI write.
        self._gpio.set_low(self._dc)
        self._spi.write([c])
    else:
        # I2C write.
        control = 0x00   # Co = 0, DC = 0
        self._i2c.write8(control, c)

def data(self, c):
    """Send byte of data to display."""
    if self._spi is not None:
        # SPI write.
        self._gpio.set_high(self._dc)
        self._spi.write([c])
    else:
        # I2C write.
        control = 0x40   # Co = 0, DC = 0
        self._i2c.write8(control, c)

def begin(self, vccstate=SSD1306_SWITCHCAPVCC):
    """Initialize display."""
    # Save vcc state.
    self._vccstate = vccstate
    # Reset and initialize display.
    self.reset()
    self._initialize()
    # Turn on the display.
    self.command(SSD1306_DISPLAYON)

def reset(self):
    """Reset the display."""
    if self._rst is None:
        return
    # Set reset high for a millisecond.
    self._gpio.set_high(self._rst)
    time.sleep(0.001)
    # Set reset low for 10 milliseconds.
    self._gpio.set_low(self._rst)
    time.sleep(0.010)
    # Set reset high again.
    self._gpio.set_high(self._rst)

def display(self):
    """Write display buffer to physical display."""
    self.command(SSD1306_COLUMNADDR)
    self.command(0)              # Column start address. (0 = reset)
    self.command(self.width-1)   # Column end address.
    self.command(SSD1306_PAGEADDR)
    self.command(0)              # Page start address. (0 = reset)
    self.command(self._pages-1)  # Page end address.
    # Write buffer data.
    if self._spi is not None:
        # Set DC high for data.
        self._gpio.set_high(self._dc)
        # Write buffer.
        self._spi.write(self._buffer)
    else:
        for i in range(0, len(self._buffer), 16):
            control = 0x40   # Co = 0, DC = 0
            self._i2c.writeList(control, self._buffer[i:i+16])

def image(self, image):
    """Set buffer to value of Python Imaging Library image.  The image should
    be in 1 bit mode and a size equal to the display size.
    """
    if image.mode != '1':
        raise ValueError('Image must be in mode 1.')
    imwidth, imheight = image.size
    if imwidth != self.width or imheight != self.height:
        raise ValueError('Image must be same dimensions as display ({0}x{1}).' \
            .format(self.width, self.height))
    # Grab all the pixels from the image, faster than getpixel.
    pix = image.load()
    # Iterate through the memory pages
    index = 0
    for page in range(self._pages):
        # Iterate through all x axis columns.
        for x in range(self.width):
            # Set the bits for the column of pixels at the current position.
            bits = 0
            # Don't use range here as it's a bit slow
            for bit in [0, 1, 2, 3, 4, 5, 6, 7]:
                bits = bits << 1
                bits |= 0 if pix[(x, page*8+7-bit)] == 0 else 1
            # Update buffer byte and increment to next byte.
            self._buffer[index] = bits
            index += 1

def clear(self):
    """Clear contents of image buffer."""
    self._buffer = [0]*(self.width*self._pages)

def set_contrast(self, contrast):
    """Sets the contrast of the display.  Contrast should be a value between
    0 and 255."""
    if contrast < 0 or contrast > 255:
        raise ValueError('Contrast must be a value from 0 to 255 (inclusive).')
    self.command(SSD1306_SETCONTRAST)
    self.command(contrast)

def dim(self, dim):
    """Adjusts contrast to dim the display if dim is True, otherwise sets the
    contrast to normal brightness if dim is False.
    """
    # Assume dim display.
    contrast = 0
    # Adjust contrast based on VCC if not dimming.
    if not dim:
        if self._vccstate == SSD1306_EXTERNALVCC:
            contrast = 0x9F
        else:
            contrast = 0xCF
        self.set_contrast(contrast)

class SSD1306_128_64(SSD1306Base):
def init(self, rst, dc=None, sclk=None, din=None, cs=None, gpio=None,
spi=None, i2c_bus=None, i2c_address=SSD1306_I2C_ADDRESS,
i2c=None):
# Call base class constructor.
super(SSD1306_128_64, self).init(128, 64, rst, dc, sclk, din, cs,
gpio, spi, i2c_bus, i2c_address, i2c)

def _initialize(self):
    # 128x64 pixel specific initialization.
    self.command(SSD1306_DISPLAYOFF)                    # 0xAE
    self.command(SSD1306_SETDISPLAYCLOCKDIV)            # 0xD5
    self.command(0x80)                                  # the suggested ratio 0x80
    self.command(SSD1306_SETMULTIPLEX)                  # 0xA8
    self.command(0x3F)
    self.command(SSD1306_SETDISPLAYOFFSET)              # 0xD3
    self.command(0x0)                                   # no offset
    self.command(SSD1306_SETSTARTLINE | 0x0)            # line #0
    self.command(SSD1306_CHARGEPUMP)                    # 0x8D
    if self._vccstate == SSD1306_EXTERNALVCC:
        self.command(0x10)
    else:
        self.command(0x14)
    self.command(SSD1306_MEMORYMODE)                    # 0x20
    self.command(0x00)                                  # 0x0 act like ks0108
    self.command(SSD1306_SEGREMAP | 0x1)
    self.command(SSD1306_COMSCANDEC)
    self.command(SSD1306_SETCOMPINS)                    # 0xDA
    self.command(0x12)
    self.command(SSD1306_SETCONTRAST)                   # 0x81
    if self._vccstate == SSD1306_EXTERNALVCC:
        self.command(0x9F)
    else:
        self.command(0xCF)
    self.command(SSD1306_SETPRECHARGE)                  # 0xd9
    if self._vccstate == SSD1306_EXTERNALVCC:
        self.command(0x22)
    else:
        self.command(0xF1)
    self.command(SSD1306_SETVCOMDETECT)                 # 0xDB
    self.command(0x40)
    self.command(SSD1306_DISPLAYALLON_RESUME)           # 0xA4
    self.command(SSD1306_NORMALDISPLAY)                 # 0xA6

class SSD1306_128_32(SSD1306Base):
def init(self, rst, dc=None, sclk=None, din=None, cs=None, gpio=None,
spi=None, i2c_bus=None, i2c_address=SSD1306_I2C_ADDRESS,
i2c=None):
# Call base class constructor.
super(SSD1306_128_32, self).init(128, 32, rst, dc, sclk, din, cs,
gpio, spi, i2c_bus, i2c_address, i2c)

def _initialize(self):
    # 128x32 pixel specific initialization.
    self.command(SSD1306_DISPLAYOFF)                    # 0xAE
    self.command(SSD1306_SETDISPLAYCLOCKDIV)            # 0xD5
    self.command(0x80)                                  # the suggested ratio 0x80
    self.command(SSD1306_SETMULTIPLEX)                  # 0xA8
    self.command(0x1F)
    self.command(SSD1306_SETDISPLAYOFFSET)              # 0xD3
    self.command(0x0)                                   # no offset
    self.command(SSD1306_SETSTARTLINE | 0x0)            # line #0
    self.command(SSD1306_CHARGEPUMP)                    # 0x8D
    if self._vccstate == SSD1306_EXTERNALVCC:
        self.command(0x10)
    else:
        self.command(0x14)
    self.command(SSD1306_MEMORYMODE)                    # 0x20
    self.command(0x00)                                  # 0x0 act like ks0108
    self.command(SSD1306_SEGREMAP | 0x1)
    self.command(SSD1306_COMSCANDEC)
    self.command(SSD1306_SETCOMPINS)                    # 0xDA
    self.command(0x02)
    self.command(SSD1306_SETCONTRAST)                   # 0x81
    self.command(0x8F)
    self.command(SSD1306_SETPRECHARGE)                  # 0xd9
    if self._vccstate == SSD1306_EXTERNALVCC:
        self.command(0x22)
    else:
        self.command(0xF1)
    self.command(SSD1306_SETVCOMDETECT)                 # 0xDB
    self.command(0x40)
    self.command(SSD1306_DISPLAYALLON_RESUME)           # 0xA4
    self.command(SSD1306_NORMALDISPLAY)                 # 0xA6

class SSD1306_96_16(SSD1306Base):
def init(self, rst, dc=None, sclk=None, din=None, cs=None, gpio=None,
spi=None, i2c_bus=None, i2c_address=SSD1306_I2C_ADDRESS,
i2c=None):
# Call base class constructor.
super(SSD1306_96_16, self).init(96, 16, rst, dc, sclk, din, cs,
gpio, spi, i2c_bus, i2c_address, i2c)

def _initialize(self):
    # 128x32 pixel specific initialization.
    self.command(SSD1306_DISPLAYOFF)                    # 0xAE
    self.command(SSD1306_SETDISPLAYCLOCKDIV)            # 0xD5
    self.command(0x60)                                  # the suggested ratio 0x60
    self.command(SSD1306_SETMULTIPLEX)                  # 0xA8
    self.command(0x0F)
    self.command(SSD1306_SETDISPLAYOFFSET)              # 0xD3
    self.command(0x0)                                   # no offset
    self.command(SSD1306_SETSTARTLINE | 0x0)            # line #0
    self.command(SSD1306_CHARGEPUMP)                    # 0x8D
    if self._vccstate == SSD1306_EXTERNALVCC:
        self.command(0x10)
    else:
        self.command(0x14)
    self.command(SSD1306_MEMORYMODE)                    # 0x20
    self.command(0x00)                                  # 0x0 act like ks0108
    self.command(SSD1306_SEGREMAP | 0x1)
    self.command(SSD1306_COMSCANDEC)
    self.command(SSD1306_SETCOMPINS)                    # 0xDA
    self.command(0x02)
    self.command(SSD1306_SETCONTRAST)                   # 0x81
    self.command(0x8F)
    self.command(SSD1306_SETPRECHARGE)                  # 0xd9
    if self._vccstate == SSD1306_EXTERNALVCC:
        self.command(0x22)
    else:
        self.command(0xF1)
    self.command(SSD1306_SETVCOMDETECT)                 # 0xDB
    self.command(0x40)
    self.command(SSD1306_DISPLAYALLON_RESUME)           # 0xA4
    self.command(SSD1306_NORMALDISPLAY)                 # 0xA6
    /***********************************************************************

Mini Clock v1.0, Jul 2014 by Nick Hall
Distributed under the terms of the GPL.

For help on how to build the clock see my blog:
http://123led.wordpress.com/

Tested on IDE v1.6.5

***********************************************************************/

//include libraries:

include "LedControl.h"

include // Font library

include // DS1307 clock

include "RTClib.h" // DS1307 clock

include // Button library by Alexander Brevig

// Setup LED Matrix

//define constants

define NUM_DISPLAY_MODES 3 // Number display modes (conting zero as the first mode)

define NUM_SETTINGS_MODES 4 // Number settings modes = 6 (conting zero as the first mode)

define SLIDE_DELAY 20 // The time in milliseconds for the slide effect per character in slide mode. Make this higher for a slower effect

define cls clear_display // Clear display

RTC_DS1307 ds1307; // Create RTC object

Button buttonA = Button(2, BUTTON_PULLUP); // Setup button A (using button library)
Button buttonB = Button(3, BUTTON_PULLUP); // Setup button B (using button library)

void setup() {

Serial.begin(9600); //start serial

//Setup DS1307 RTC

ifdef AVR

Wire.begin();

else

Wire1.begin(); // Shield I2C pins connect to alt I2C bus on Arduino

endif

ds1307.begin(); //start RTC Clock

//enable red led
digitalWrite(13, HIGH);
}

void loop() {

//run the clock with whatever mode is set by clock_mode - the default is set at top of code.
switch (clock_mode){

case 0:
basic_mode();
break;
case 1:
small_mode();
break;
case 2:
slide();
break;
case 3:
word_clock();
break;
case 4:
setup_menu();
break;
}
}

//plot a point on the display
void plot (byte x, byte y, byte val) {

if (val == 1) {
// lc.setLed(address, y, x, true);
lc.setLed(address, 7-y, x, true);
} else {
// lc.setLed(address, y, x, false);
lc.setLed(address, 7-y, x, false);
}
}

//clear screen
void clear_display() {
for (byte address = 0; address < 4; address++) {
lc.clearDisplay(address);
}
}

//fade screen down
void fade_down() {

clear_display(); //clear display completely (off)

//reset intentsity to global val
for (byte address = 0; address < 4; address++) {
lc.setIntensity(address, intensity);
}
}

//power up led test & display software version number
void printver() {

byte i = 0;
char ver_a[9] = "Vers 1.0";
char ver_b[9] = " Hello! ";

//test all leds.
for (byte x = 0; x <= 31; x++) {
for (byte y = 0; y <= 7; y++) {
plot(x, y, 1);
}
}
delay(500);
fade_down();

void putnormalchar(byte x, byte y, char c)
{

  if (dots & (64 >> row)) {   // only 7 rows.
    plot(x + col, y + row, 1);
  } else {
    plot(x + col, y + row, 0);
  }
  //}
}

}
}

//small_mode
//show the time in small 3x5 characters with seconds display

void small_mode() {

cls();

//run clock main loop as long as run_mode returns true
while (run_mode()) {

get_time();

//check for button press
if (buttonA.uniquePress()) {
  switch_mode();
  return;
}
if (buttonB.uniquePress()) {
  display_date();
  return;
}

//if secs changed then update them on the display
secs = rtc[0];
if (secs != old_secs) {

  //secs
  char buffer[3];
  itoa(secs, buffer, 10);

  //fix - as otherwise if num has leading zero, e.g. "03" secs, itoa coverts this to chars with space "3 ".
  if (secs < 10) {
    buffer[1] = buffer[0];
    buffer[0] = '0';
  }

  puttinychar( 20, 1, ':'); //seconds colon
  puttinychar( 24, 1, buffer[0]); //seconds
  puttinychar( 28, 1, buffer[1]); //seconds
  old_secs = secs;
}

//if minute changes change time
if (mins != rtc[1]) {

  //reset these for comparison next time
  mins = rtc[1];
  byte hours = rtc[2];
  if (hours > 12) {
    hours = hours - ampm * 12;
  }
  if (hours < 1) {
    hours = hours + ampm * 12;
  }


  //byte dow  = rtc[3]; // the DS1307 outputs 0 - 6 where 0 = Sunday0 - 6 where 0 = Sunday.
  //byte date = rtc[4];

  //set characters
  char buffer[3];
  itoa(hours, buffer, 10);

  //fix - as otherwise if num has leading zero, e.g. "03" hours, itoa coverts this to chars with space "3 ".
  if (hours < 10) {
    buffer[1] = buffer[0];
    //if we are in 12 hour mode blank the leading zero.
    if (ampm) {
      buffer[0] = ' ';
    }
    else {
      buffer[0] = '0';
    }
  }
  //set hours chars
  textchar[0] = buffer[0];
  textchar[1] = buffer[1];
  textchar[2] = ':';

  itoa (mins, buffer, 10);
  if (mins < 10) {
    buffer[1] = buffer[0];
    buffer[0] = '0';
  }
  //set mins characters
  textchar[3] = buffer[0];
  textchar[4] = buffer[1];

  //do seconds
  textchar[5] = ':';
  buffer[3];
  secs = rtc[0];
  itoa(secs, buffer, 10);

  //fix - as otherwise if num has leading zero, e.g. "03" secs, itoa coverts this to chars with space "3 ".
  if (secs < 10) {
    buffer[1] = buffer[0];
    buffer[0] = '0';
  }
  //set seconds
  textchar[6] = buffer[0];
  textchar[7] = buffer[1];

  byte x = 0;
  byte y = 0;

  //print each char
  for (byte x = 0; x < 6 ; x++) {
    puttinychar( x * 4, 1, textchar[x]);
  }
}
delay(50);

}
fade_down();
}

// basic_mode()
// show the time in 5x7 characters
void basic_mode()
{
cls();

//do 12/24 hour conversion if ampm set to 1
byte hours = rtc[2];

if (hours > 12) {
hours = hours - ampm * 12;
}
if (hours < 1) {
hours = hours + ampm * 12;
}

//do offset conversion
if (ampm && hours < 10) {
offset = 2;
}

//set the next minute we show the date at
//set_next_date();

//run clock main loop as long as run_mode returns true
while (run_mode()) {

//get the time from the clock chip
get_time();

//check for button press
if (buttonA.uniquePress()) {
  switch_mode();
  return;
}
if (buttonB.uniquePress()) {
  display_date();
  return;
}

//check whether it's time to automatically display the date
//check_show_date();

//draw the flashing : as on if the secs have changed.
if (secs != rtc[0]) {

  //update secs with new value
  secs = rtc[0];

  //draw :
  plot (15 - offset, 2, 1); //top point
  plot (15 - offset, 5, 1); //bottom point
  count = 400;
}

//if count has run out, turn off the :
if (count == 0) {
  plot (15 - offset, 2, 0); //top point
  plot (15 - offset, 5, 0); //bottom point
}
else {
  count--;
}

//re draw the display if button pressed or if mins != rtc[1] i.e. if the time has changed from what we had stored in mins, (also trigggered on first entering function when mins is 100)
if (mins != rtc[1]) {

  //update mins and hours with the new values
  mins = rtc[1];
  hours = rtc[2];

  //adjust hours of ampm set to 12 hour mode
  if (hours > 12) {
    hours = hours - ampm * 12;
  }
  if (hours < 1) {
    hours = hours + ampm * 12;
  }

  itoa(hours, buffer, 10);

  //if hours < 10 the num e.g. "3" hours, itoa coverts this to chars with space "3 " which we dont want
  if (hours < 10) {
    buffer[1] = buffer[0];
    buffer[0] = '0';
  }

  //print hours
  //if we in 12 hour mode and hours < 10, then don't print the leading zero, and set the offset so we centre the display with 3 digits.
  if (ampm && hours < 10) {
    offset = 2;

    //if the time is 1:00am clear the entire display as the offset changes at this time and we need to blank out the old 12:59
    if ((hours == 1 && mins == 0) ) {
      cls();
    }
  }
  else {
    //else no offset and print hours tens digit
    offset = 0;

    //if the time is 10:00am clear the entire display as the offset changes at this time and we need to blank out the old 9:59
    if (hours == 10 && mins == 0) {
      cls();
    }


    putnormalchar(1,  0, buffer[0]);
  }
  //print hours ones digit
  putnormalchar(7 - offset, 0, buffer[1]);


  //print mins
  //add leading zero if mins < 10
  itoa (mins, buffer, 10);
  if (mins < 10) {
    buffer[1] = buffer[0];
    buffer[0] = '0';
  }
  //print mins tens and ones digits
  putnormalchar(19 - offset, 0, buffer[0]);
  putnormalchar(25 - offset, 0, buffer[1]);
}

}
fade_down();
}

//like basic_mode but with slide effect
void slide() {

//plot the clock colon on the display
cls();
putnormalchar( 13, 0, ':');

byte old_secs = rtc[0]; //store seconds in old_secs. We compare secs and old secs. WHen they are different we redraw the display

//run clock main loop as long as run_mode returns true
while (run_mode()) {

get_time();

//check for button press
if (buttonA.uniquePress()) {
  switch_mode();
  return;
}
  if (buttonB.uniquePress()) {
  display_date();
  return;
}

//if secs have changed then update the display
if (rtc[0] != old_secs) {
  old_secs = rtc[0];

  //do 12/24 hour conversion if ampm set to 1
  byte hours = rtc[2];
  if (hours > 12) {
    hours = hours - ampm * 12;
  }
  if (hours < 1) {
    hours = hours + ampm * 12;
  }

  //split all date and time into individual digits - stick in digits_new array

  //rtc[0] = secs                        //array pos and digit stored
  //digits_new[0] = (rtc[0]%10);           //0 - secs ones
  //digits_new[1] = ((rtc[0]/10)%10);      //1 - secs tens
  //rtc[1] = mins
  digits_new[0] = (rtc[1] % 10);         //2 - mins ones
  digits_new[1] = ((rtc[1] / 10) % 10);  //3 - mins tens
  //rtc[2] = hours
  digits_new[2] = (hours % 10);         //4 - hour ones
  digits_new[3] = ((hours / 10) % 10);  //5 - hour tens
  //rtc[4] = date
  //digits_new[6] = (rtc[4]%10);           //6 - date ones
  //digits_new[7] = ((rtc[4]/10)%10);      //7 - date tens

  //draw initial screen of all chars. After this we just draw the changes.

  //compare digits 0 to 3 (mins and hours)
  for (byte i = 0; i <= 3; i++) {
    //see if digit has changed...
    if (digits_old[i] != digits_new[i]) {

      //run 9 step animation sequence for each in turn
      for (byte seq = 0; seq <= 8 ; seq++) {

        //convert digit to string
        itoa(digits_old[i], old_char, 10);
        itoa(digits_new[i], new_char, 10);

        //if set to 12 hour mode and we're on digit 2 (hours tens mode) then check to see if this is a zero. If it is, blank it instead so we get 2.00pm not 02.00pm
        if (ampm && i == 3) {
          if (digits_new[3] == 0) {
            new_char[0] = ' ';
          }
          if (digits_old[3] == 0) {
            old_char[0] = ' ';
          }
        }
        //draw the animation frame for each digit
        slideanim(digits_x_pos[i], 0, seq, old_char[0], new_char[0]);
        delay(SLIDE_DELAY);
      }
    }
  }

  /*
  //compare date digit 6 (ones) and (7) tens - if either of these change we need to update the date line. We compare date tens as say from Jan 31 -> Feb 01 then ones digit doesn't change
  if ((digits_old[6] != digits_new[6]) || (digits_old[7] != digits_new[7])) {
    //change the day shown. Loop below goes through each of the 3 chars in turn e.g. "MON"
    for (byte day_char = 0; day_char <=2 ; day_char++){
      //run the anim sequence for each char
      for (byte seq = 0; seq <=8 ; seq++){
        //the day (0 - 6) Read this number into the days char array. the seconds number in the array 0-2 gets the 3 chars of the day name, e.g. m o n
        slideanim(6*day_char,8,seq,old_chars[day_char],days[rtc[3]][day_char]); //6 x day_char gives us the x pos for the char
        delay(SLIDE_DELAY);
      }
      //save the old day chars into the old_chars array at array pos 0-2. We use this next time we change the day and feed it to the animation as the current char. The updated char is fed in as the new char.
      old_chars[day_char] = days[rtc[3]][day_char];
    }

    //change the date tens digit (if needed) and ones digit. (the date ones digit wil alwaus change, but putting this in the 'if' loop makes it a bit neater code wise.)
    for (byte i = 7; i >= 6; i--){
      if (digits_old[i] != digits_new[i]) {
        for (byte seq = 0; seq <=8 ; seq++){
          itoa(digits_old[i],old_char,10);
          itoa(digits_new[i],new_char,10);
          slideanim(digits_x_pos[i],8,seq,old_char[0],new_char[0]);
          delay(SLIDE_DELAY);
        }
      }
    }

    //print the day suffix "nd" "rd" "th" etc. First work out date 2 letter suffix - eg st, nd, rd, th
    byte s = 3; //the pos to read our suffix array from.
    byte date = rtc[4];
    if(date == 1 || date == 21 || date == 31) {
      s = 0;
    }
    else if (date == 2 || date == 22) {
      s = 1;
    }
    else if (date == 3 || date == 23) {
      s = 2;
    }

    for (byte suffix_char = 0; suffix_char <=1 ; suffix_char++){
      for (byte seq = 0; seq <=8 ; seq++){
        slideanim((suffix_char*6)+36,8,seq,old_chars[suffix_char+3],suffix[s][suffix_char]); // we pass in the old_char array char as the current char and the suffix array as the new char
        delay(SLIDE_DELAY);
      }
      //save the suffic char in the old chars array at array pos 3 and 5.  We use these chars next time we change the suffix and feed it to the animation as the current char. The updated char is fed in as the new char.
      old_chars[suffix_char+3] = suffix[s][suffix_char];
    }
  }//end do date line
  */


  //save digita array tol old for comparison next loop
  for (byte i = 0; i <= 3; i++) {
    digits_old[i] =  digits_new[i];
  }
}//secs/oldsecs

}//while loop
fade_down();
}

// To slide one char off and another on we need 9 steps or frames in sequence...

byte curr_char_row_max = 7 - sequence; //the maximum number of rows to draw is 6 - sequence number
byte start_y = sequence; //y position to start at - is same as sequence number. We inc this each loop

//plot each row up to row maximum (calculated from sequence number)
for (byte curr_char_row = 0; curr_char_row <= curr_char_row_max; curr_char_row++) {
  for (byte col = 0; col < 5; col++) {
    dots = pgm_read_byte_near(&myfont[current_c][col]);
    if (dots & (64 >> curr_char_row))
      plot(x + col, y + start_y, 1); //plot led on
    else
      plot(x + col, y + start_y, 0); //else plot led off
  }
  start_y++;//add one to y so we draw next row one down
}

}

//if sequence is above 2, we also need to start drawing the new char
if (sequence >= 2) {

//work out char
byte dots;
//if (new_c >= 'A' && new_c <= 'Z' || (new_c >= 'a' && new_c <= 'z') ) {
//  new_c &= 0x1F;   // A-Z maps to 1-26
//}
if (new_c >= 'A' && new_c <= 'Z' ) {
  new_c &= 0x1F;   // A-Z maps to 1-26
}
else if (new_c >= 'a' && new_c <= 'z') {
  new_c = (new_c - 'a') + 41;   // A-Z maps to 41-67
}
else if (new_c >= '0' && new_c <= '9') {
  new_c = (new_c - '0') + 31;
}
else if (new_c == ' ') {
  new_c = 0; // space
}
else if (new_c == '.') {
  new_c = 27; // full stop
}
else if (new_c == '\'') {
  new_c = 28; // single quote mark
}
else if (new_c == ':') {
  new_c = 29; // clock_mode selector arrow
}
else if (new_c == '>') {
  new_c = 30; // clock_mode selector arrow
}

byte newcharrowmin = 6 - (sequence - 2); //minimumm row num to draw for new char - this generates an output of 6 to 0 when fed sequence numbers 2-8. This is the minimum row to draw for the new char
byte start_y = 0; //y position to start at - is same as sequence number. we inc it each row

//plot each row up from row minimum (calculated by sequence number) up to 6
for (byte newcharrow = newcharrowmin; newcharrow <= 6; newcharrow++) {
  for (byte col = 0; col < 5; col++) {
    dots = pgm_read_byte_near(&myfont[new_c][col]);
    if (dots & (64 >> newcharrow))
      plot(x + col, y + start_y, 1); //plot led on
    else
      plot(x + col, y + start_y, 0); //else plot led off
  }
  start_y++;//add one to y so we draw next row one down
}

}
}

//print a clock using words rather than numbers
void word_clock() {

cls();

//potentially 3 lines to display
char str_a[8];
char str_b[8];
char str_c[8];

//byte hours_y, mins_y; //hours and mins and positions for hours and mins lines

byte hours = rtc[2];
if (hours > 12) {
hours = hours - ampm * 12;
}
if (hours < 1) {
hours = hours + ampm * 12;
}

//run clock main loop as long as run_mode returns true
while (run_mode()) {

//check for button press
if (buttonA.uniquePress()) {
  switch_mode();
  return;
}
if (buttonB.uniquePress()) {
  display_date();
}

get_time(); //get the time from the clock chip
mins = rtc[1];  //get mins


//if mins is different from old_mins - redraw display
if (mins != old_mins) {

  //update old_mins with current mins value
  old_mins = mins;

  //reset these for comparison next time
  mins = rtc[1];
  hours = rtc[2];

  //make hours into 12 hour format
  if (hours > 12) {
    hours = hours - 12;
  }
  if (hours == 0) {
    hours = 12;
  }

  //split mins value up into two separate digits
  int minsdigit = rtc[1] % 10;
  byte minsdigitten = (rtc[1] / 10) % 10;

  //if mins <= 10 , then top line has to read "minsdigti past" and bottom line reads hours
  if (mins < 10) {
    strcpy (str_a, numbers[minsdigit - 1]);
    strcpy (str_b, "PAST");
    strcpy (str_c, numbers[hours - 1]);
  }

  //if mins = 10, cant use minsdigit as above, so soecial case to print 10 past /n hour.
  if (mins == 10) {
    strcpy (str_a, numbers[9]);
    strcpy (str_b, " PAST");
    strcpy (str_c, numbers[hours - 1]);
  }

  //if time is not on the hour - i.e. both mins digits are not zero,
  //then make first line read "hours" and 2 & 3rd lines read "minstens"  "mins" e.g. "three /n twenty /n one"
  else if (minsdigitten != 0 && minsdigit != 0  ) {

    strcpy (str_a, numbers[hours - 1]);

    //if mins is in the teens, use teens from the numbers array for the 2nd line, e.g. "fifteen"
    //if (mins >= 11 && mins <= 19) {
    if (mins <= 19) {
      strcpy (str_b, numbers[mins - 1]);
    }
    else {
      strcpy (str_b, numberstens[minsdigitten - 1]);

      strcpy (str_c, numbers[minsdigit - 1]);
    }
  }
  // if mins digit is zero, don't print it. read read "hours" "minstens" e.g. "three /n twenty"
  else if (minsdigitten != 0 && minsdigit == 0  ) {
    strcpy (str_a, numbers[hours - 1]);
    strcpy (str_b, numberstens[minsdigitten - 1]);
    strcpy (str_c, "");
  }

  //if both mins are zero, i.e. it is on the hour, the top line reads "hours" and bottom line reads "o'clock"
  else if (minsdigitten == 0 && minsdigit == 0  ) {
    strcpy (str_a, numbers[hours - 1]);
    strcpy (str_b, "O'CLOCK");
    strcpy (str_c, "");
  }

}//end worknig out time

//run in a loop
//print line a "twelve"
byte len = 0;
while (str_a[len]) {
  len++;
}; //get length of message
byte offset_top = (31 - ((len - 1) * 4)) / 2; //

//plot hours line
byte i = 0;
while (str_a[i]) {
  puttinychar((i * 4) + offset_top, 1, str_a[i]);
  i++;
}

//hold display but check for button presses
int counter = 1000;
while (counter > 0){
  //check for button press
  if (buttonA.uniquePress()) {
    switch_mode();
    return;
  }
  if (buttonB.uniquePress()) {
    display_date();
  }
delay(1);
counter--;
}
fade_down();

//print line b
len = 0;
while (str_b[len]) {
  len++;
}; //get length of message
offset_top = (31 - ((len - 1) * 4)) / 2; 

i = 0;
while (str_b[i]) {
  puttinychar((i * 4) + offset_top, 1, str_b[i]);
  i++;
}

//hold display but check for button presses
counter = 1000;
while (counter > 0){
  if (buttonA.uniquePress()) {
    switch_mode();
    return;
  }
  if (buttonB.uniquePress()) {
    display_date();
  }
  delay(1);
  counter--;
}
fade_down();

//print line c if there.
len = 0;
while (str_c[len]) {
  len++;
}; //get length of message
offset_top = (31 - ((len - 1) * 4)) / 2; 

i = 0;
while (str_c[i]) {
  puttinychar((i * 4) + offset_top, 1, str_c[i]);
  i++;
}
counter = 1000;
while (counter > 0){
  //check for button press
  if (buttonA.uniquePress()) {
    switch_mode();
    return;
  }
  if (buttonB.uniquePress()) {
    display_date();
  }  
  delay(1);
  counter--;
}
fade_down();


//hold display blank but check for button presses before starting again.
counter = 1000;
while (counter > 0){
   //check for button press
  if (buttonA.uniquePress()) {
    switch_mode();
    return;
  }
  if (buttonB.uniquePress()) {
    display_date();
  }  
  delay(1);
  counter--;
}

}
fade_down();
}

/// scroll message - not used at present - too slow.
void scroll() {

char message[] = {"Hello There "};

cls();
byte p = 6; //current pos in string
byte chara[] = {0, 1, 2, 3, 4, 5}; //chars from string
int x[] = {0, 6, 12, 18, 24, 30}; //xpos for each char
byte y = 0; //y pos

// clear_buffer();

while (message[p] != '\0') {

//draw all 6 chars
for (byte c = 0; c < 6; c++) {

  putnormalchar(x[c],y,message[ chara[c] ]);


  //draw a line of pixels turned off after each char,otherwise the gaps between the chars have pixels left in them from the previous char
  for (byte yy = 0 ; yy < 8; yy ++) {
    plot(x[c] + 5, yy, 0);
  }

  //take one off each chars position
  x[c] = x[c] - 1;
}

//reset a char if it's gone off screen
for (byte i = 0; i <= 5; i++) {
  if (x[i] < -5 ) {
    x[i] = 31;
    chara[i] = p;
    p++;
  }
}

}
}

//display_date - print the day of week, date and month with a flashing cursor effect
void display_date()
{

cls();
//read the date from the DS1307

byte dow = rtc[3]; // day of week 0 = Sunday
byte date = rtc[4];
byte month = rtc[5] - 1;

//print the day name

//print the name

int i = 0;
while(daysfull[dow][i])
{
puttinychar((i*4) + offset , 1, daysfull[dow][i]);
i++;
}
delay(1000);
fade_down();
cls();

// print date numerals
char buffer[3];
itoa(date,buffer,10);
offset = 10; //offset to centre text if 3 chars - e.g. 3rd

//print the 1st date number
puttinychar(0+offset, 1, buffer[0]);

//if date is under 10 - then we only have 1 digit so set positions of sufix etc one character nearer
byte suffixposx = 4;

//print the 2 suffix characters
puttinychar(suffixposx+offset, 1, suffix[s][0]);
puttinychar(suffixposx+4+offset, 1, suffix[s][1]);

delay(1000);
fade_down();

//print the month name

delay(1000);
fade_down();
}

//dislpay menu to change the clock mode
void switch_mode() {

//remember mode we are in. We use this value if we go into settings mode, so we can change back from settings mode (6) to whatever mode we were in.
old_mode = clock_mode;

char* modes[] = {
"Basic", "Small", "Slide", "Words", "Setup"
};

byte next_clock_mode;
byte firstrun = 1;

//loop waiting for button (timeout after 35 loops to return to mode X)
for (int count = 0; count < 35 ; count++) {

//if user hits button, change the clock_mode
if (buttonA.uniquePress() || firstrun == 1) {

  count = 0;
  cls();

  if (firstrun == 0) {
    clock_mode++;
  }
  if (clock_mode > NUM_DISPLAY_MODES + 1 ) {
    clock_mode = 0;
  }

  //print arrown and current clock_mode name on line one and print next clock_mode name on line two
  char str_top[9];

  //strcpy (str_top, "-");
  strcpy (str_top, modes[clock_mode]);

  next_clock_mode = clock_mode + 1;
  if (next_clock_mode >  NUM_DISPLAY_MODES + 1 ) {
    next_clock_mode = 0;
  }

  byte i = 0;
  while (str_top[i]) {
    putnormalchar(i * 6, 0, str_top[i]);
    i++;
  }
  firstrun = 0;
}
delay(50);