2020-12-04 06:06:00 -08:00
|
|
|
|
//#####################################################
|
|
|
|
|
//#####################################################
|
|
|
|
|
//#####################################################
|
|
|
|
|
/*
|
|
|
|
|
THIS IS THE BM DEVS DATALOGGER
|
|
|
|
|
|
|
|
|
|
THIS WORKS BY DATALOGGING BMTUNE ISR V3 PROTOCOL ON
|
|
|
|
|
THE TX/RX SERIAL PORT. THIS WORKS WITH 2X BUTTONS
|
|
|
|
|
NAVIGATION ONLY. IT ONLY WORKS FOR THE 20X04 LCD
|
|
|
|
|
|
|
|
|
|
IF YOUR SCREEN DOESNT DISPLAY ANY CHARACTERS :
|
|
|
|
|
FIND THE LINE 'LiquidCrystal_I2C lcd(0x3F, 2, 1, 0, 4, 5, 6, 7, 3, POSITIVE);'
|
|
|
|
|
AND REPLACE 0x3F BY 0x20 OR 0x27 OR 0x30
|
|
|
|
|
|
|
|
|
|
####################################################
|
|
|
|
|
ALL CREDITS GOES TO :
|
|
|
|
|
-Bouletmarc (BM Devs)
|
|
|
|
|
*/
|
|
|
|
|
//#####################################################
|
|
|
|
|
//#####################################################
|
|
|
|
|
//#####################################################
|
|
|
|
|
|
|
|
|
|
#include "Wire.h"
|
|
|
|
|
//#include <stdio.h>
|
|
|
|
|
#include <avr/pgmspace.h>
|
|
|
|
|
#include <EEPROM.h>
|
|
|
|
|
//#include <EnableInterrupt.h>
|
|
|
|
|
//#include <digitalWriteFast.h>
|
|
|
|
|
#include <SPI.h>
|
|
|
|
|
#include <SD.h>
|
|
|
|
|
|
|
|
|
|
//#####################################################
|
|
|
|
|
//#####################################################
|
|
|
|
|
//#include <LiquidCrystal_I2C.h>
|
|
|
|
|
//LiquidCrystal_I2C lcd(I2CByte, 2, 1, 0, 4, 5, 6, 7, 3, POSITIVE);
|
|
|
|
|
|
|
|
|
|
// initialize the library by associating any needed LCD interface pin
|
|
|
|
|
// with the arduino pin number it is connected to
|
|
|
|
|
#include <LiquidCrystal.h>
|
|
|
|
|
const int rs = 37, en = 39, d4 = 41, d5 = 42, d6 = 43, d7 = 44;
|
|
|
|
|
LiquidCrystal lcd(rs, en, d4, d5, d6, d7);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
void noBacklight() {
|
|
|
|
|
digitalWrite(46, LOW);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void backlight() {
|
|
|
|
|
RefreshBackLight();
|
|
|
|
|
}
|
|
|
|
|
//#####################################################
|
|
|
|
|
//#####################################################
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
//0x20-0x27 - 0x30 - 0x3F
|
|
|
|
|
//byte I2CByte = 0x27;
|
2021-01-22 13:10:37 -08:00
|
|
|
|
const int NextButton = 14; //Atmega644P=20; //Atmega328P=8
|
|
|
|
|
const int BackButton = 13; //Atmega644P=19; //Atmega328P=9
|
2020-12-04 06:06:00 -08:00
|
|
|
|
const int BackLightPin = A1; //Atmega644P=12; //Atmega328P=10
|
|
|
|
|
const int ContrastPin = A0; //Atmega644P=13; //Atmega328P=None
|
|
|
|
|
const int ChipSelectPin = 8; //Atmega644P=4; //Atmega328P=None CS Pin for SD Card
|
|
|
|
|
const int StatusLEDPin = 4; //Atmega644P=1; //Atmega328P=None LED Pin for Status
|
|
|
|
|
|
|
|
|
|
byte Brightness = 255;
|
|
|
|
|
byte BrightnessNight = 110;
|
|
|
|
|
bool NightMode = false;
|
|
|
|
|
byte ContrastLevel = 150;
|
|
|
|
|
|
|
|
|
|
byte ScreenCurrentPage = 1;
|
|
|
|
|
byte ScreenCurrentPeak = 0;
|
|
|
|
|
byte ScreenCurrentMenu = 0;
|
|
|
|
|
byte ScreenSettingSelected = 0;
|
|
|
|
|
byte ScreenOptionSelected = 0;
|
|
|
|
|
byte ThisScreenIndex = 0; //current display index number
|
|
|
|
|
byte XPos = 0;
|
|
|
|
|
byte YPos = 0;
|
|
|
|
|
char StringBuffer[20];
|
|
|
|
|
const int MaxDataValue = 79;
|
|
|
|
|
//bool EcuConnected = false;
|
|
|
|
|
bool InMain = true;
|
|
|
|
|
bool EngineRunning = false;
|
|
|
|
|
unsigned long last_datalog_time = 0;
|
|
|
|
|
bool Sleeping = false;
|
|
|
|
|
//bool J12Cut = true;
|
|
|
|
|
//bool ShowJ12 = false;
|
|
|
|
|
//bool WasAvailable = false;
|
|
|
|
|
|
|
|
|
|
int ScreenPage1[8] = {100, 0, 1, 2, 3, 9, 5, 11};
|
|
|
|
|
int ScreenPage2[8] = {200, 0, 7, 8, 14, 15, 28, 30};
|
|
|
|
|
int ScreenPage3[8] = {300, 0, 13, 20, 18, 19, 4, 5};
|
|
|
|
|
int ScreenPage4[8] = {100, 0, 100, 0, 18, 11, 19, 9};
|
|
|
|
|
int ScreenPage5[8] = {100, 0, 100, 0, 107, 0, 8, 16};
|
|
|
|
|
int ScreenPage6[8] = {100, 0, 61, 9, 53, 4, 57, 59};
|
|
|
|
|
int ScreenPage7[8] = {100, 0, 3, 12, 6, 4, 13, 26};
|
|
|
|
|
int ScreenPage8[8] = {41, 37, 35, 24, 25, 23, 17, 21};
|
|
|
|
|
|
|
|
|
|
const String BoardVersionStr = "2.0";
|
2021-04-09 19:52:06 -07:00
|
|
|
|
const String FirmwareVersionStr = "2.02";
|
2020-12-04 06:06:00 -08:00
|
|
|
|
byte ProgressBarMode = 2;
|
|
|
|
|
byte ProgressBarLeft = 0;
|
|
|
|
|
int Timeout = 150;
|
|
|
|
|
int Injectors_Size = 240;
|
|
|
|
|
byte O2Input = 0;
|
|
|
|
|
byte MapValue = 0;
|
|
|
|
|
byte UseCelcius = 1;
|
|
|
|
|
byte UseKMH = 1;
|
|
|
|
|
byte O2Type = 0;
|
|
|
|
|
double WBConversion[4] = {0, 1.3, 1, 0.71};
|
|
|
|
|
int WBModel = 0;
|
|
|
|
|
byte MapByte[4] = {186, 127, 254, 134};
|
|
|
|
|
byte Tranny[4] = {72, 113, 178, 214};
|
|
|
|
|
int TrannyModel = 0;
|
|
|
|
|
int MapModel = 0;
|
|
|
|
|
int Warning_RPM = 7600;
|
|
|
|
|
int Warning_IAT = 65;
|
|
|
|
|
int Warning_ECT = 107;
|
|
|
|
|
|
|
|
|
|
int mBarMin = -70;
|
|
|
|
|
int mBarMax = 1790;
|
|
|
|
|
int TempMin = -40;
|
|
|
|
|
int TempMax = 140;
|
|
|
|
|
|
|
|
|
|
int WaitingDelay = 0;
|
|
|
|
|
bool WaitingQuick = false;
|
|
|
|
|
|
2021-04-09 19:52:06 -07:00
|
|
|
|
const int SettingVersion = 4;
|
2020-12-04 06:06:00 -08:00
|
|
|
|
//int TimeoutCount = 0;
|
|
|
|
|
byte LastChecksum = 0;
|
|
|
|
|
const long AutoSaveTime = 120000;
|
|
|
|
|
unsigned long last_save_time = 0;
|
|
|
|
|
|
|
|
|
|
bool SDDetected = true;
|
|
|
|
|
bool SDLogging = true;
|
|
|
|
|
|
|
|
|
|
File myFile;
|
|
|
|
|
unsigned int SDFileCount = 0;
|
|
|
|
|
|
|
|
|
|
//#####################################################
|
|
|
|
|
|
|
|
|
|
void setup() {
|
|
|
|
|
FirstLoadEEPROM();
|
|
|
|
|
|
|
|
|
|
pinMode(BackButton, INPUT_PULLUP);
|
|
|
|
|
pinMode(NextButton, INPUT_PULLUP);
|
|
|
|
|
|
|
|
|
|
pinMode(StatusLEDPin, OUTPUT);
|
|
|
|
|
digitalWrite(StatusLEDPin, HIGH);
|
|
|
|
|
|
|
|
|
|
pinMode(BackLightPin, OUTPUT);
|
|
|
|
|
RefreshBackLight();
|
|
|
|
|
//pinMode(ContrastPin,OUTPUT);
|
|
|
|
|
//analogWrite(ContrastPin, ContrastLevel); // PWM values from 0 to 255 (0% – 100% duty cycle)
|
|
|
|
|
|
|
|
|
|
//#######################################################
|
|
|
|
|
//Atmega644 Interrupt
|
|
|
|
|
//enableInterrupt(BackButton, pin_ISR1, CHANGE);
|
|
|
|
|
//enableInterrupt(NextButton, pin_ISR2, CHANGE);
|
|
|
|
|
|
|
|
|
|
digitalWrite(38, LOW); //RW Pins on Atmega64A
|
|
|
|
|
//#######################################################
|
|
|
|
|
|
|
|
|
|
ReCalcValueRange();
|
|
|
|
|
|
|
|
|
|
//###################
|
|
|
|
|
//screen start
|
|
|
|
|
lcd.begin(20, 4);
|
|
|
|
|
lcd.clear();
|
|
|
|
|
ResetBufferIndex();
|
|
|
|
|
GetInfosString(20);
|
|
|
|
|
PrintTextAnimated(20, 4, 0);
|
|
|
|
|
|
|
|
|
|
//delay(200);
|
|
|
|
|
ResetBufferIndex();
|
|
|
|
|
Add_String(BoardVersionStr);
|
|
|
|
|
//PrintTextAnimated(3, 15, 0);
|
|
|
|
|
writeBigStringAnimated(6, 1);
|
|
|
|
|
|
|
|
|
|
//delay(200);
|
|
|
|
|
ResetBufferIndex();
|
|
|
|
|
Add_String("Firmware V" + FirmwareVersionStr);
|
|
|
|
|
PrintTextAnimated(20, 3, 3);
|
|
|
|
|
|
|
|
|
|
/*delay(200);
|
|
|
|
|
ResetBufferIndex();
|
|
|
|
|
Add_String(FirmwareVersionStr);
|
|
|
|
|
PrintTextAnimated(20, 8, 2);*/
|
|
|
|
|
|
|
|
|
|
/*delay(200);
|
|
|
|
|
ResetBufferIndex();
|
|
|
|
|
GetInfosString(21);
|
|
|
|
|
PrintTextAnimated(20, 3, 3);*/
|
|
|
|
|
|
|
|
|
|
delay(700);
|
|
|
|
|
//lcd.clear();
|
|
|
|
|
//###################
|
|
|
|
|
|
|
|
|
|
Serial.begin(38400);
|
|
|
|
|
Serial1.begin(38400);
|
|
|
|
|
//ScanForI2C();
|
|
|
|
|
//ScanForSD();
|
|
|
|
|
|
|
|
|
|
digitalWrite(StatusLEDPin, LOW);
|
|
|
|
|
lcd.clear();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void ScanForSD() {
|
|
|
|
|
if (!SD.begin(ChipSelectPin)) {
|
|
|
|
|
SDDetected = false;
|
|
|
|
|
Serial.println("Card failed, or not present");
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (SDDetected) {
|
|
|
|
|
SDFileCount = 0;
|
|
|
|
|
/*while (SD.exists("BMDatalogger" + SDFileCount + ".bml")) {
|
|
|
|
|
SDFileCount++;
|
|
|
|
|
Serial.println("BMDatalogger" + SDFileCount + ".bml already exists!");
|
|
|
|
|
}*/
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void ReCalcValueRange() {
|
|
|
|
|
mBarMin = (int) ((((long) MapByte[1] * 256) + (long) MapByte[0]) - 32768);
|
|
|
|
|
mBarMax = (int) ((((long) MapByte[3] * 256) + (long) MapByte[2]) - 32768);
|
|
|
|
|
|
|
|
|
|
if (UseCelcius == 0) {
|
|
|
|
|
TempMin = TempMin * 1.8 + 32.0;
|
|
|
|
|
TempMax = TempMax * 1.8 + 32.0;
|
|
|
|
|
Warning_IAT = Warning_IAT * 1.8 + 32.0;
|
|
|
|
|
Warning_ECT = Warning_ECT * 1.8 + 32.0;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
//#####################################################
|
|
|
|
|
|
|
|
|
|
void loop() {
|
|
|
|
|
RefreshBackLight();
|
|
|
|
|
//analogWrite(ContrastPin, ContrastLevel); // PWM values from 0 to 255 (0% – 100% duty cycle)
|
|
|
|
|
//ConnectBT();
|
|
|
|
|
//CheckButtons();
|
|
|
|
|
|
|
|
|
|
if (millis() - last_save_time > AutoSaveTime) {
|
|
|
|
|
AutoSaveEEPROM();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
//############################
|
|
|
|
|
while (WaitingDelay > 0) {
|
|
|
|
|
if (InMain && WaitingQuick) ScreenMain();
|
|
|
|
|
if (!InMain && WaitingQuick) Display();
|
|
|
|
|
delay(1);
|
|
|
|
|
WaitingDelay--;
|
|
|
|
|
CheckButtons();
|
|
|
|
|
if (WaitingDelay <= 0) {
|
|
|
|
|
//if (!WaitingQuick) lcd.clear();
|
|
|
|
|
//if (WaitingQuick) WaitingQuick = false;
|
|
|
|
|
WaitingQuick = false;
|
|
|
|
|
}
|
|
|
|
|
//if (WaitingQuick) WaitingQuick = false;
|
|
|
|
|
}
|
|
|
|
|
//############################
|
|
|
|
|
|
|
|
|
|
if (millis() - last_datalog_time > Timeout) {
|
|
|
|
|
//if (TimeoutCount >= Timeout) {
|
|
|
|
|
/*if (!J12Cut) {
|
|
|
|
|
ScreenJ12();
|
|
|
|
|
}
|
|
|
|
|
else {*/
|
|
|
|
|
GetData();
|
|
|
|
|
SetEngineRunning();
|
|
|
|
|
ApplyPeak();
|
|
|
|
|
//TimeoutCount = 0;
|
|
|
|
|
//}
|
|
|
|
|
last_datalog_time = millis();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
//if (!ShowJ12) {
|
|
|
|
|
SetSpeedTime();
|
|
|
|
|
GetWarnings();
|
|
|
|
|
|
|
|
|
|
if (InMain) ScreenMain();
|
|
|
|
|
if (!InMain) Display();
|
|
|
|
|
//}
|
|
|
|
|
|
|
|
|
|
CheckButtons();
|
|
|
|
|
|
|
|
|
|
//_delay_us(100);
|
|
|
|
|
//TimeoutCount++;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
//#####################################################
|
|
|
|
|
|
|
|
|
|
/*void ScanForI2C() {
|
|
|
|
|
// Leonardo: wait for serial port to connect
|
|
|
|
|
while (!Serial) { }
|
|
|
|
|
|
|
|
|
|
//scan
|
|
|
|
|
byte count = 0;
|
|
|
|
|
Wire.begin();
|
|
|
|
|
for (byte i = 1; i < 120; i++)
|
|
|
|
|
{
|
|
|
|
|
Wire.beginTransmission (i);
|
|
|
|
|
if (Wire.endTransmission () == 0)
|
|
|
|
|
{
|
|
|
|
|
if (i != I2CByte)
|
|
|
|
|
{
|
|
|
|
|
I2CByte = i;
|
|
|
|
|
|
|
|
|
|
Serial.println ();
|
|
|
|
|
Serial.print ("I2CByte Address not set correctly, please set to: ");
|
|
|
|
|
Serial.print ("0x");
|
|
|
|
|
Serial.print (i, HEX);
|
|
|
|
|
|
|
|
|
|
//Enless Loop
|
|
|
|
|
//while(true) { } //desactivated due to New AutoConnect
|
|
|
|
|
}
|
|
|
|
|
count++;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}*/
|
|
|
|
|
|
|
|
|
|
//#####################################################
|
|
|
|
|
|
|
|
|
|
void FirstLoadEEPROM() {
|
|
|
|
|
if (EEPROM.read(0) != SettingVersion) {
|
2021-04-09 19:52:06 -07:00
|
|
|
|
SaveLoadEEPROM(true); //save (never created this version settings before)
|
2020-12-04 06:06:00 -08:00
|
|
|
|
}
|
|
|
|
|
SaveLoadEEPROM(false); //load
|
|
|
|
|
LastChecksum = GetSettingsSum();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void AutoSaveEEPROM() {
|
|
|
|
|
last_save_time = millis();
|
|
|
|
|
|
|
|
|
|
byte NewChecksum = GetSettingsSum();
|
|
|
|
|
if (NewChecksum != LastChecksum) {
|
|
|
|
|
if (EEPROM.read(1) != NewChecksum) {
|
|
|
|
|
EEPROM.write(0, SettingVersion);
|
|
|
|
|
EEPROM.write(1, NewChecksum);
|
|
|
|
|
SaveLoadEEPROM(true); //save
|
|
|
|
|
LastChecksum = GetSettingsSum();
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
//SaveLoadEEPROM(false); //load
|
|
|
|
|
//LastChecksum = GetSettingsSum();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
byte GetSettingsSum() {
|
|
|
|
|
byte num = 0;
|
|
|
|
|
num = (byte) (num + SettingVersion);
|
|
|
|
|
num = (byte) (num + ScreenCurrentPage);
|
|
|
|
|
num = (byte) (num + ScreenCurrentPeak);
|
|
|
|
|
num = (byte) (num + ScreenCurrentMenu);
|
|
|
|
|
if (Sleeping) num = (byte) (num + 1);
|
|
|
|
|
if (InMain) num = (byte) (num + 1);
|
|
|
|
|
num = (byte) (num + Brightness);
|
|
|
|
|
num = (byte) (num + BrightnessNight);
|
|
|
|
|
if (NightMode) num = (byte) (num + 1);
|
|
|
|
|
num = (byte) (num + ScreenSettingSelected);
|
|
|
|
|
num = (byte) (num + ScreenOptionSelected);
|
2021-04-09 19:52:06 -07:00
|
|
|
|
for (byte i = 0; i < 8; i++) {
|
2020-12-04 06:06:00 -08:00
|
|
|
|
num = (byte) (num + GetMSBFromInt(ScreenPage1[i]));
|
|
|
|
|
num = (byte) (num + GetLSBFromInt(ScreenPage1[i]));
|
|
|
|
|
}
|
2021-04-09 19:52:06 -07:00
|
|
|
|
for (byte i = 0; i < 8; i++) {
|
2020-12-04 06:06:00 -08:00
|
|
|
|
num = (byte) (num + GetMSBFromInt(ScreenPage2[i]));
|
|
|
|
|
num = (byte) (num + GetLSBFromInt(ScreenPage2[i]));
|
|
|
|
|
}
|
2021-04-09 19:52:06 -07:00
|
|
|
|
for (byte i = 0; i < 8; i++) {
|
2020-12-04 06:06:00 -08:00
|
|
|
|
num = (byte) (num + GetMSBFromInt(ScreenPage3[i]));
|
|
|
|
|
num = (byte) (num + GetLSBFromInt(ScreenPage3[i]));
|
|
|
|
|
}
|
2021-04-09 19:52:06 -07:00
|
|
|
|
for (byte i = 0; i < 8; i++) {
|
2020-12-04 06:06:00 -08:00
|
|
|
|
num = (byte) (num + GetMSBFromInt(ScreenPage4[i]));
|
|
|
|
|
num = (byte) (num + GetLSBFromInt(ScreenPage4[i]));
|
|
|
|
|
}
|
2021-04-09 19:52:06 -07:00
|
|
|
|
for (byte i = 0; i < 8; i++) {
|
2020-12-04 06:06:00 -08:00
|
|
|
|
num = (byte) (num + GetMSBFromInt(ScreenPage5[i]));
|
|
|
|
|
num = (byte) (num + GetLSBFromInt(ScreenPage5[i]));
|
|
|
|
|
}
|
2021-04-09 19:52:06 -07:00
|
|
|
|
for (byte i = 0; i < 8; i++) {
|
2020-12-04 06:06:00 -08:00
|
|
|
|
num = (byte) (num + GetMSBFromInt(ScreenPage6[i]));
|
|
|
|
|
num = (byte) (num + GetLSBFromInt(ScreenPage6[i]));
|
|
|
|
|
}
|
2021-04-09 19:52:06 -07:00
|
|
|
|
for (byte i = 0; i < 8; i++) {
|
2020-12-04 06:06:00 -08:00
|
|
|
|
num = (byte) (num + GetMSBFromInt(ScreenPage7[i]));
|
|
|
|
|
num = (byte) (num + GetLSBFromInt(ScreenPage7[i]));
|
|
|
|
|
}
|
2021-04-09 19:52:06 -07:00
|
|
|
|
for (byte i = 0; i < 8; i++) {
|
2020-12-04 06:06:00 -08:00
|
|
|
|
num = (byte) (num + GetMSBFromInt(ScreenPage8[i]));
|
|
|
|
|
num = (byte) (num + GetLSBFromInt(ScreenPage8[i]));
|
|
|
|
|
}
|
|
|
|
|
num = (byte) (num + ProgressBarMode);
|
|
|
|
|
num = (byte) (num + ProgressBarLeft);
|
|
|
|
|
|
|
|
|
|
num = (byte) (num + GetMSBFromInt(Timeout));
|
|
|
|
|
num = (byte) (num + GetLSBFromInt(Timeout));
|
|
|
|
|
num = (byte) (num + GetMSBFromInt(Injectors_Size));
|
|
|
|
|
num = (byte) (num + GetLSBFromInt(Injectors_Size));
|
|
|
|
|
|
|
|
|
|
num = (byte) (num + O2Input);
|
|
|
|
|
num = (byte) (num + MapValue);
|
|
|
|
|
num = (byte) (num + UseCelcius);
|
|
|
|
|
num = (byte) (num + UseKMH);
|
|
|
|
|
num = (byte) (num + O2Type);
|
|
|
|
|
//missing WB table
|
2021-04-09 19:52:06 -07:00
|
|
|
|
for (byte i = 0; i < 4; i++) {
|
2020-12-04 06:06:00 -08:00
|
|
|
|
//(int) (ThisDouble * 100)
|
|
|
|
|
num = (byte) (num + GetMSBFromInt((int) (WBConversion[i] * 100)));
|
|
|
|
|
num = (byte) (num + GetLSBFromInt((int) (WBConversion[i] * 100)));
|
|
|
|
|
//num = (byte) (num + GetMSBFromDouble(WBConversion[i]));
|
|
|
|
|
//num = (byte) (num + GetLSBFromDouble(WBConversion[i]));
|
|
|
|
|
}
|
|
|
|
|
num = (byte) (num + WBModel);
|
2021-04-09 19:52:06 -07:00
|
|
|
|
for (byte i = 0; i < 4; i++) num = (byte) (num + MapByte[i]);
|
|
|
|
|
for (byte i = 0; i < 4; i++) num = (byte) (num + Tranny[i]);
|
2020-12-04 06:06:00 -08:00
|
|
|
|
num = (byte) (num + TrannyModel);
|
|
|
|
|
num = (byte) (num + MapModel);
|
|
|
|
|
|
|
|
|
|
num = (byte) (num + GetMSBFromInt(Warning_RPM));
|
|
|
|
|
num = (byte) (num + GetLSBFromInt(Warning_RPM));
|
|
|
|
|
num = (byte) (num + GetMSBFromInt(Warning_IAT + 40));
|
|
|
|
|
num = (byte) (num + GetLSBFromInt(Warning_IAT + 40));
|
|
|
|
|
num = (byte) (num + GetMSBFromInt(Warning_ECT + 40));
|
|
|
|
|
num = (byte) (num + GetLSBFromInt(Warning_ECT + 40));
|
|
|
|
|
num = (byte) (num + GetMSBFromInt(mBarMin + 300));
|
|
|
|
|
num = (byte) (num + GetLSBFromInt(mBarMin + 300));
|
|
|
|
|
num = (byte) (num + GetMSBFromInt(mBarMax));
|
|
|
|
|
num = (byte) (num + GetLSBFromInt(mBarMax));
|
|
|
|
|
num = (byte) (num + GetMSBFromInt(TempMin + 40));
|
|
|
|
|
num = (byte) (num + GetLSBFromInt(TempMin + 40));
|
|
|
|
|
num = (byte) (num + GetMSBFromInt(TempMax + 40));
|
|
|
|
|
num = (byte) (num + GetLSBFromInt(TempMax + 40));
|
|
|
|
|
|
|
|
|
|
return num;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*byte GetMSBFromDouble(double ThisDouble) {
|
|
|
|
|
int ThisInt = (int) (ThisDouble * 100);
|
|
|
|
|
return GetMSBFromInt(int ThisInt);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
byte GetLSBFromDouble(double ThisDouble) {
|
|
|
|
|
int ThisInt = (int) (ThisDouble * 100);
|
|
|
|
|
return GetLSBFromInt(int ThisInt);
|
|
|
|
|
}*/
|
|
|
|
|
|
|
|
|
|
byte GetMSBFromInt(int ThisInt) {
|
|
|
|
|
byte MSB = (byte) (ThisInt / 256);
|
|
|
|
|
return MSB;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
byte GetLSBFromInt(int ThisInt) {
|
|
|
|
|
byte MSB = (byte) (ThisInt / 256);
|
|
|
|
|
byte LSB = (byte) (ThisInt - MSB);
|
|
|
|
|
return LSB;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void SaveLoadEEPROM(bool IsSaving) {
|
|
|
|
|
int CurrAddr = 5;
|
|
|
|
|
|
|
|
|
|
if (IsSaving) EEPROM.write(CurrAddr, ScreenCurrentPage);
|
|
|
|
|
else ScreenCurrentPage = EEPROM.read(CurrAddr);
|
|
|
|
|
|
|
|
|
|
ScreenCurrentPeak = CheckThisByte(IsSaving, CurrAddr, ScreenCurrentPeak);
|
|
|
|
|
CurrAddr++;
|
|
|
|
|
ScreenCurrentMenu = CheckThisByte(IsSaving, CurrAddr, ScreenCurrentMenu);
|
|
|
|
|
CurrAddr++;
|
|
|
|
|
Sleeping = CheckThisBool(IsSaving, CurrAddr, Sleeping);
|
|
|
|
|
CurrAddr++;
|
|
|
|
|
InMain = CheckThisBool(IsSaving, CurrAddr, InMain);
|
|
|
|
|
CurrAddr++;
|
|
|
|
|
Brightness = CheckThisByte(IsSaving, CurrAddr, Brightness);
|
|
|
|
|
CurrAddr++;
|
|
|
|
|
BrightnessNight = CheckThisByte(IsSaving, CurrAddr, BrightnessNight);
|
|
|
|
|
CurrAddr++;
|
|
|
|
|
NightMode = CheckThisBool(IsSaving, CurrAddr, NightMode);
|
|
|
|
|
CurrAddr++;
|
|
|
|
|
ScreenSettingSelected = CheckThisByte(IsSaving, CurrAddr, ScreenSettingSelected);
|
|
|
|
|
CurrAddr++;
|
|
|
|
|
ScreenOptionSelected = CheckThisByte(IsSaving, CurrAddr, ScreenOptionSelected);
|
|
|
|
|
CurrAddr++;
|
|
|
|
|
|
|
|
|
|
//#####################################################################
|
2021-04-09 19:52:06 -07:00
|
|
|
|
for (byte i = 0; i < 8; i++) {
|
2020-12-04 06:06:00 -08:00
|
|
|
|
ScreenPage1[i] = CheckThisInt(IsSaving, CurrAddr, ScreenPage1[i]);
|
|
|
|
|
CurrAddr++;
|
|
|
|
|
CurrAddr++;
|
|
|
|
|
}
|
2021-04-09 19:52:06 -07:00
|
|
|
|
for (byte i = 0; i < 8; i++) {
|
2020-12-04 06:06:00 -08:00
|
|
|
|
ScreenPage2[i] = CheckThisInt(IsSaving, CurrAddr, ScreenPage2[i]);
|
|
|
|
|
CurrAddr++;
|
|
|
|
|
CurrAddr++;
|
|
|
|
|
}
|
2021-04-09 19:52:06 -07:00
|
|
|
|
for (byte i = 0; i < 8; i++) {
|
2020-12-04 06:06:00 -08:00
|
|
|
|
ScreenPage3[i] = CheckThisInt(IsSaving, CurrAddr, ScreenPage3[i]);
|
|
|
|
|
CurrAddr++;
|
|
|
|
|
CurrAddr++;
|
|
|
|
|
}
|
2021-04-09 19:52:06 -07:00
|
|
|
|
for (byte i = 0; i < 8; i++) {
|
2020-12-04 06:06:00 -08:00
|
|
|
|
ScreenPage4[i] = CheckThisInt(IsSaving, CurrAddr, ScreenPage4[i]);
|
|
|
|
|
CurrAddr++;
|
|
|
|
|
CurrAddr++;
|
|
|
|
|
}
|
2021-04-09 19:52:06 -07:00
|
|
|
|
for (byte i = 0; i < 8; i++) {
|
2020-12-04 06:06:00 -08:00
|
|
|
|
ScreenPage5[i] = CheckThisInt(IsSaving, CurrAddr, ScreenPage5[i]);
|
|
|
|
|
CurrAddr++;
|
|
|
|
|
CurrAddr++;
|
|
|
|
|
}
|
2021-04-09 19:52:06 -07:00
|
|
|
|
for (byte i = 0; i < 8; i++) {
|
2020-12-04 06:06:00 -08:00
|
|
|
|
ScreenPage6[i] = CheckThisInt(IsSaving, CurrAddr, ScreenPage6[i]);
|
|
|
|
|
CurrAddr++;
|
|
|
|
|
CurrAddr++;
|
|
|
|
|
}
|
2021-04-09 19:52:06 -07:00
|
|
|
|
for (byte i = 0; i < 8; i++) {
|
2020-12-04 06:06:00 -08:00
|
|
|
|
ScreenPage7[i] = CheckThisInt(IsSaving, CurrAddr, ScreenPage7[i]);
|
|
|
|
|
CurrAddr++;
|
|
|
|
|
CurrAddr++;
|
|
|
|
|
}
|
2021-04-09 19:52:06 -07:00
|
|
|
|
for (byte i = 0; i < 8; i++) {
|
2020-12-04 06:06:00 -08:00
|
|
|
|
ScreenPage8[i] = CheckThisInt(IsSaving, CurrAddr, ScreenPage8[i]);
|
|
|
|
|
CurrAddr++;
|
|
|
|
|
CurrAddr++;
|
|
|
|
|
}
|
|
|
|
|
//#####################################################################
|
|
|
|
|
|
|
|
|
|
ProgressBarMode = CheckThisByte(IsSaving, CurrAddr, ProgressBarMode);
|
|
|
|
|
CurrAddr++;
|
|
|
|
|
ProgressBarLeft = CheckThisByte(IsSaving, CurrAddr, ProgressBarLeft);
|
|
|
|
|
CurrAddr++;
|
|
|
|
|
|
|
|
|
|
Timeout = CheckThisInt(IsSaving, CurrAddr, Timeout);
|
|
|
|
|
CurrAddr++;
|
|
|
|
|
CurrAddr++;
|
|
|
|
|
Injectors_Size = CheckThisInt(IsSaving, CurrAddr, Injectors_Size);
|
|
|
|
|
CurrAddr++;
|
|
|
|
|
CurrAddr++;
|
|
|
|
|
|
|
|
|
|
O2Input = CheckThisByte(IsSaving, CurrAddr, O2Input);
|
|
|
|
|
CurrAddr++;
|
|
|
|
|
MapValue = CheckThisByte(IsSaving, CurrAddr, MapValue);
|
|
|
|
|
CurrAddr++;
|
|
|
|
|
UseCelcius = CheckThisByte(IsSaving, CurrAddr, UseCelcius);
|
|
|
|
|
CurrAddr++;
|
|
|
|
|
UseKMH = CheckThisByte(IsSaving, CurrAddr, UseKMH);
|
|
|
|
|
CurrAddr++;
|
|
|
|
|
O2Type = CheckThisByte(IsSaving, CurrAddr, O2Type);
|
|
|
|
|
CurrAddr++;
|
|
|
|
|
|
|
|
|
|
//Missing WB Conversion (double here)
|
2021-04-09 19:52:06 -07:00
|
|
|
|
for (byte i = 0; i < 4; i++) {
|
2020-12-04 06:06:00 -08:00
|
|
|
|
WBConversion[i] = CheckThisDouble(IsSaving, CurrAddr, WBConversion[i]);
|
|
|
|
|
CurrAddr++;
|
|
|
|
|
CurrAddr++;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
WBModel = CheckThisByte(IsSaving, CurrAddr, WBModel);
|
|
|
|
|
CurrAddr++;
|
|
|
|
|
|
2021-04-09 19:52:06 -07:00
|
|
|
|
for (byte i = 0; i < 4; i++) {
|
2020-12-04 06:06:00 -08:00
|
|
|
|
MapByte[i] = CheckThisByte(IsSaving, CurrAddr, MapByte[i]);
|
|
|
|
|
CurrAddr++;
|
|
|
|
|
}
|
2021-04-09 19:52:06 -07:00
|
|
|
|
for (byte i = 0; i < 4; i++) {
|
2020-12-04 06:06:00 -08:00
|
|
|
|
Tranny[i] = CheckThisByte(IsSaving, CurrAddr, Tranny[i]);
|
|
|
|
|
CurrAddr++;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
TrannyModel = CheckThisByte(IsSaving, CurrAddr, TrannyModel);
|
|
|
|
|
CurrAddr++;
|
|
|
|
|
MapModel = CheckThisByte(IsSaving, CurrAddr, MapModel);
|
|
|
|
|
CurrAddr++;
|
|
|
|
|
|
|
|
|
|
Warning_RPM = CheckThisInt(IsSaving, CurrAddr, Warning_RPM);
|
|
|
|
|
CurrAddr++;
|
|
|
|
|
CurrAddr++;
|
|
|
|
|
Warning_IAT = CheckThisInt(IsSaving, CurrAddr, Warning_IAT + 40) - 40;
|
|
|
|
|
CurrAddr++;
|
|
|
|
|
CurrAddr++;
|
|
|
|
|
Warning_ECT = CheckThisInt(IsSaving, CurrAddr, Warning_ECT + 40) - 40;
|
|
|
|
|
CurrAddr++;
|
|
|
|
|
CurrAddr++;
|
|
|
|
|
mBarMin = CheckThisInt(IsSaving, CurrAddr, mBarMin + 300) - 300;
|
|
|
|
|
CurrAddr++;
|
|
|
|
|
CurrAddr++;
|
|
|
|
|
mBarMax = CheckThisInt(IsSaving, CurrAddr, mBarMax);
|
|
|
|
|
CurrAddr++;
|
|
|
|
|
CurrAddr++;
|
|
|
|
|
TempMin = CheckThisInt(IsSaving, CurrAddr, TempMin + 40) - 40;
|
|
|
|
|
CurrAddr++;
|
|
|
|
|
CurrAddr++;
|
|
|
|
|
TempMax = CheckThisInt(IsSaving, CurrAddr, TempMax + 40) - 40;
|
|
|
|
|
CurrAddr++;
|
|
|
|
|
CurrAddr++;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
//##################################################################
|
|
|
|
|
|
|
|
|
|
double CheckThisDouble(bool IsSaving, int CurrAddr, double ThisDouble) {
|
|
|
|
|
if (IsSaving) {
|
|
|
|
|
int ThisInt = (int) (ThisDouble * 100);
|
|
|
|
|
CheckThisInt(IsSaving, CurrAddr, ThisInt);
|
|
|
|
|
}
|
|
|
|
|
else {
|
|
|
|
|
return (double) ((double) CheckThisInt(IsSaving, CurrAddr, 9999) / 100.0);
|
|
|
|
|
}
|
|
|
|
|
return ThisDouble;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int CheckThisInt(bool IsSaving, int CurrAddr, int ThisInt) {
|
|
|
|
|
if (IsSaving) {
|
|
|
|
|
byte MSB = (byte) (ThisInt / 256);
|
|
|
|
|
byte LSB = (byte) (ThisInt - MSB);
|
|
|
|
|
WriteSingleByte(CurrAddr, MSB);
|
|
|
|
|
CurrAddr++;
|
|
|
|
|
WriteSingleByte(CurrAddr, LSB);
|
|
|
|
|
}
|
|
|
|
|
else {
|
|
|
|
|
byte MSB = ReadSingleByte(CurrAddr);
|
|
|
|
|
CurrAddr++;
|
|
|
|
|
byte LSB = ReadSingleByte(CurrAddr);
|
|
|
|
|
return ((int) LSB + ((int) MSB * 256));
|
|
|
|
|
}
|
|
|
|
|
return ThisInt;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
bool CheckThisBool(bool IsSaving, int CurrAddr, bool ThisBool) {
|
|
|
|
|
if (IsSaving) {
|
|
|
|
|
if (ThisBool) WriteSingleByte(CurrAddr, 1);
|
|
|
|
|
else WriteSingleByte(CurrAddr, 0);
|
|
|
|
|
}
|
|
|
|
|
else {
|
|
|
|
|
if (ReadSingleByte(CurrAddr) == 1) return true;
|
|
|
|
|
else return false;
|
|
|
|
|
//return ReadSingleByte(CurrAddr);
|
|
|
|
|
}
|
|
|
|
|
return ThisBool;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
byte CheckThisByte(bool IsSaving, int CurrAddr, byte ThisByte) {
|
|
|
|
|
if (IsSaving) {
|
|
|
|
|
WriteSingleByte(CurrAddr, ThisByte);
|
|
|
|
|
}
|
|
|
|
|
else {
|
|
|
|
|
return ReadSingleByte(CurrAddr);
|
|
|
|
|
}
|
|
|
|
|
return ThisByte;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void WriteSingleByte(int CurrAddr, byte ThisByte) {
|
|
|
|
|
CurrAddr++;
|
|
|
|
|
EEPROM.write(CurrAddr, ThisByte);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
byte ReadSingleByte(int CurrAddr) {
|
|
|
|
|
CurrAddr++;
|
|
|
|
|
return EEPROM.read(CurrAddr);
|
|
|
|
|
}
|
|
|
|
|
//###################################################################
|