uint8_t ProgramData::printVoltageString() const
{
if(battery.type == Unknown) {
lcdPrintVoltage(getVoltage(), 7);
return 7;
} else {
uint8_t r = 5+2+1;
lcdPrintVoltage(getVoltage(), 5);
lcdPrintChar('/');
lcdPrintUInt(battery.cells);
lcdPrintChar('C');
return r;
}
}
void lcdPrintEValue(uint16_t x, int8_t dig, bool dot)
{
const char prefix = ' ';
if(dig<=0)
return;
int8_t xdig = digits(x/1000);
xdig+=1+3; // m or .
for(;xdig<dig;dig--)
lcdPrintChar(prefix);
if(dig >= xdig && !dot) {
xdig = digits(x);
dig--; //m
for(;xdig<dig;dig--)
lcdPrintChar(prefix);
lcdPrintUInt(x);
lcdPrintChar('m');
} else if(dig < xdig - 4) {
lcdPrintInf(dig);
} else {
lcdPrintUInt(x/1000);
x%=1000;
dig -= xdig - 4;
if(dig-- >0) lcdPrintChar('.');
if(dig-- >0) lcdPrintDigit(x/100);
x%=100;
if(dig-- >0) lcdPrintDigit(x/10);
x%=10;
if(dig-- >0) lcdPrintDigit(x);
}
}
void ProgramData::printProgramData(uint8_t index)
{
loadProgramData(index);
if(battery.type != None) {
Screen::StartInfo::printBatteryString();
lcdPrintSpace1();
}
switch(battery.type) {
case None:
lcdPrintUInt(index+1);
lcdPrintChar(':');
break;
case Unknown:
Screen::StartInfo::printVoltageString(9);
break;
case LED:
lcdPrintCurrent(battery.Ic,5);
lcdPrintSpace1();
Screen::StartInfo::printVoltageString(4);
break;
default:
lcdPrintCharge(battery.capacity, 7);
lcdPrintChar('/');
lcdPrintUInt(battery.cells);
break;
}
}
void SettingsMenu::printUARTSpeed() const
{
//TODO: add printULong
uint32_t s = p_.getUARTspeed();
s/=100;
lcdPrintUnsigned(s,5);
lcdPrintChar('0');
lcdPrintChar('0');
}
void Screen::displayAnimation()
{
for (uint8_t i=0; i<16; i++) {
lcdSetCursor(15-i,1);
lcdPrintChar(255);
lcdSetCursor(i,0);
lcdPrintChar(255);
Time::delayDoIdle(10);
}
}
void lcdPrintPercentage(AnalogInputs::ValueType p, int8_t dig)
{
if(dig > 0) {
lcdPrintUnsigned(p,--dig);
lcdPrintChar('%');
}
}
void lcdPrintTemperature(AnalogInputs::ValueType t, int8_t dig)
{
if(dig > 0) {
lcdPrintTemperature_(t,--dig);
lcdPrintChar('C');
}
}
void SettingsMenu::printDeltaT(AnalogInputs::ValueType dt)
{
lcdPrintUnsigned(dt/100, 3);
lcdPrintChar('.');
lcdPrintDigit((dt%100)/10);
lcdPrint_P(PSTR("C/m"));
}
void Screen::printChar_Time() {
char c = 'N';
if(smps.isPowerOn()) {
c = 'C';
} else if(discharger.isPowerOn()) {
c = 'D';
if(smps.isPowerOn()) c = 'E';
} else if(balancer.isWorking()) {
c = 'B';
}
lcdPrintChar(c);
lcdPrintChar(' ');
lcdPrintTime(getTimeSec());
lcdPrintChar(' ');
}
void Screen::Cycle::displayCycles()
{
uint8_t c, time = Blink::blinkTime_/8;
uint8_t all_scr = ProgramDCcycle::currentCycle/2 + 1;
c = time % all_scr;
lcdSetCursor0_0();
lcdPrintUnsigned(c+1, 1);
lcdPrintChar(SCREEN_EMPTY_CELL_CHAR);
lcdPrintTime(cyclesHistoryTime[c*2], 6);
lcdPrintSpace1();
lcdPrintChar(SCREEN_FULL_CELL_CHAR);
lcdPrintTime(cyclesHistoryTime[c*2+1], 6);
lcdPrintSpaces();
lcdSetCursor0_1();
lcdPrintCharge(cyclesHistoryCapacity[c*2],8);
lcdPrintCharge(cyclesHistoryCapacity[c*2+1],8);
lcdPrintSpaces();
}
void lcdPrintUnsigned_sign(uint16_t x, int8_t dig, const char prefix, bool minus)
{
if(dig<=0)
return;
if(minus)
dig--;
uint8_t xdig = digits(x);
for(;xdig<dig;dig--)
lcdPrintChar(prefix);
if(minus) lcdPrintChar('-');
if(dig < xdig) {
lcdPrintInf(dig);
} else {
lcdPrintUInt(x);
}
}
void printBalancer(uint8_t cell, AnalogInputs::Type type) {
if(cell < MAX_BALANCE_CELLS) {
lcdPrintDigit(cell+1);
lcdPrintChar(':');
if(AnalogInputs::isConnected(AnalogInputs::Name(AnalogInputs::Vb1+cell))) {
lcdPrintAnalog(getBalanceValue(cell, type), 6, type);
} else {
lcdPrint_P(PSTR(" -- "));
}
}
}
void Menu::display() {
uint8_t lines = LCD_LINES;
for(uint8_t i = 0; i < lines; i++) {
lcdSetCursor(0, i);
lcdPrintChar(i == pos_ ? '>' : ' ');
if(i + begin_ < size_) {
printItem(i + begin_);
}
lcdPrintSpaces();
}
debug();
render_ = false;
}
void Screen::displayScreenCIVlimits()
{
lcdSetCursor0_0();
lcdPrintCharge(ProgramData::currentProgramData.getCapacityLimit(), 8);
lcdPrintChar(' ');
lcdPrintCurrent(ProgramData::currentProgramData.battery.Ic, 7);
lcdPrintSpaces();
lcdSetCursor0_1();
lcdPrint_P(PSTR("Limits: "));
lcdPrintVoltage(ProgramData::currentProgramData.getVoltage(ProgramData::VCharge), 7);
lcdPrintSpaces();
}
void Screen::displayStartInfo()
{
lcdSetCursor0_0();
ProgramData::currentProgramData.printBatteryString(4);
lcdPrintChar(' ');
ProgramData::currentProgramData.printVoltageString();
lcdPrintChar(' ');
printProgram2chars(Program::programType_);
lcdSetCursor0_1();
uint16_t procent = getChargeProcent();
if(procent == 100) {
if(getBlinkOff())
lcdPrintSpaces(4);
else
lcdPrint_P(PSTR("FUL "));
} else {
lcdPrintUnsigned(procent, 2);
lcdPrint_P(PSTR("% "));
}
int bindex = getBlinkIndex();
if(bindex & 1) analogInputs.printRealValue(AnalogInputs::Vout, 5);
else lcdPrintSpaces(5);
lcdPrintChar(' ');
if(ProgramData::currentProgramData.isLiXX()) {
//display balance port
if(bindex & 2) analogInputs.printRealValue(AnalogInputs::Vbalancer, 5);
else lcdPrintSpaces(5);
if(bindex & 4) lcdPrintDigit(analogInputs.getConnectedBalancePorts());
else lcdPrintChar(' ');
} else {
lcdPrintCharge(ProgramData::currentProgramData.battery.C, 6);
lcdPrintSpaces();
}
}
void Screen::displayDebugRthVth()
{
lcdSetCursor0_0();
lcdPrint_P(PSTR("V="));
//lcdPrintResistance(Rth_, 8);
lcdPrintSigned(theveninMethod.tVout_.Rth_V_);
lcdPrint_P(PSTR(" I="));
//lcdPrintResistance(Rth_, 8);
lcdPrintSigned(theveninMethod.tVout_.Rth_I_);
lcdPrintSpaces();
lcdSetCursor0_1();
lcdPrintSigned(theveninMethod.tVout_.Vth_);
lcdPrintChar(' ');
lcdPrintSigned(theveninMethod.valueTh_, 4);
lcdPrintChar(' ');
uint16_t v;
if(smps.isPowerOn()) v = smps.getValue();
else v = discharger.getValue();
lcdPrintSigned(v,4);
lcdPrintSpaces();
}
void lcdPrintAnalog(AnalogInputs::ValueType x, AnalogInputs::Type type, int8_t dig)
{
if(dig <= 0)
return;
bool dot = true;
char unit = 'U';
dig--;
switch (type) {
case AnalogInputs::Current:
dot = false;
unit ='A';
break;
case AnalogInputs::Voltage:
unit ='V';
break;
case AnalogInputs::Temperature:
return lcdPrintTemperature(x, dig+1);
case AnalogInputs::Resistance:
dot = false;
//TODO: ??Ohm
unit ='!'-45;
break;
case AnalogInputs::Unknown:
lcdPrintSigned(x, dig);
lcdPrintChar(unit);
return;
case AnalogInputs::Charge:
dot = false;
dig--;
unit ='A';
break;
}
lcdPrintEValue(x, (int8_t) dig, dot);
lcdPrintChar(unit);
if(type == AnalogInputs::Charge) lcdPrintChar('h');
}
void lcdPrintTemperature_(AnalogInputs::ValueType x, int8_t dig)
{
const char prefix = ' ';
if(dig<=0)
return;
int8_t xdig = digits(x/100);
xdig+=1+2; // .
for(;xdig<dig;dig--)
lcdPrintChar(prefix);
if(dig < xdig - 3) {
lcdPrintInf(dig);
} else {
lcdPrintUInt(x/100);
x%=100;
dig -= xdig - 3;
if(dig-- >0) lcdPrintChar('.');
if(dig-- >0) lcdPrintDigit(x/10);
x%=10;
if(dig-- >0) lcdPrintDigit(x);
}
}
void run() {
uint32_t t;
int j = 0;
int dir = 1;
do {
t = Time::getMiliseconds();
Utils::delayMicroseconds(50000);
t = Time::getMiliseconds() - t;
lcdSetCursor(0,0);
lcdPrintUInt(t);
lcdPrintSpaces();
lcdSetCursor(0,1);
for(int i=0;i<16;i++) {
lcdPrintChar(' '+i+j);
}
j+=dir;
if(j>128-16 - ' ' || j < 1) dir *= -1;
} while(true);
}
void displayBalanceInfo(uint8_t from, AnalogInputs::Type type)
{
lcdSetCursor0_0();
#ifdef ENABLE_SCREEN_KNIGHTRIDEREFFECT
knightRiderCounter += knightRiderDir;
if (knightRiderCounter==0 || knightRiderCounter>4) knightRiderDir=-knightRiderDir;
#endif
char c = ' ';
if(!::Balancer::isWorking()) {
if(!::Balancer::isStable())
c = 'm';
} else {
if(::Balancer::savedVon)
c = 'B';
else
c = 'b';
}
if (::Balancer::balance == 0) {
lcdPrintChar(c);
#ifdef ENABLE_SCREEN_KNIGHTRIDEREFFECT
char knightRiderArrow;
if (knightRiderDir > 0) knightRiderArrow='>'; else knightRiderArrow='<';
if ((c == 'm') || (c == ' ')) {
for (uint8_t i=0; i<6; i++ ) {
if (knightRiderCounter==i) lcdPrintChar(knightRiderArrow);
else lcdPrintChar(' ');
}
lcdPrintChar(' ');
} else {
lcdPrintSpaces(7);
}
#else
lcdPrintSpaces(7);
#endif
} else {
uint16_t cell = 1;
for(uint8_t i = 0; i < MAX_BALANCE_CELLS; i++) {
if(AnalogInputs::connectedBalancePortCells & cell) {
if(i == ::Balancer::minCell) {
c = SCREEN_EMPTY_CELL_CHAR; //lowest cell
} else {
if(::Balancer::balance & cell) {
if (Blink::blinkTime_ & 1) {
c = SCREEN_FULL_CELL_CHAR; //flash full/empty cells
} else {
c = SCREEN_EMPTY_CELL_CHAR; //flash full/empty cells
}
} else {
c = SCREEN_AVR_CELL_CHAR; //average cells
}
}
} else {
c = ' ';
}
lcdPrintChar(c);
cell <<= 1;
}
lcdPrintSpaces(8 - MAX_BALANCE_CELLS);
}
printBalancer(from++, type);
lcdPrintSpaces();
lcdSetCursor0_1();
printBalancer(from++, type);
printBalancer(from++, type);
lcdPrintSpaces();
}
void Screen::printCharge() {
getCharge(charge_);
lcdPrintCharge(charge_, 8);
lcdPrintChar(' ');
}
/** Write a nul terminated string
*
* Display a string of ASCII characters at the position described by the row
* and column parameters. Note that the row indicates an 8 pixel high character
* row while the column represents individual pixels. This code uses a built
* in character set where each character is 6 pixels wide.
*
* This function does not perform any word wrapping or other text layout
* functions. If the string exceeds the size of the display it will simply
* be clipped.
*
* @param row the row number (0 to 5) to display the character.
* @param col the column position (0 to 83) for the start of the left side of
* the character.
* @param str the string to display. If a character in the string is out of
* range it will be replaced with the '?' character.
*/
void lcdPrint(uint8_t row, uint8_t col, const char *str, uint8_t size) {
for(;(*str!='\0')&&(col<LCD_COL);col+=CHAR_WIDTH*size,str++) {
lcdPrintChar(row, col, *str, size);
}
}
void SettingsMenu::printTemp(AnalogInputs::ValueType t) {
lcdPrintUnsigned(t/100, 3);
lcdPrintChar('C');
}
void SettingsMenu::printVolt(AnalogInputs::ValueType v) {
lcdPrintUnsigned(v/1000, 3);
lcdPrintChar('V');
}
void lcdPrintDigit(uint8_t d)
{
d%=10;
lcdPrintChar('0'+ d);
}
void lcdPrintTime(uint16_t timeSec)
{
lcdPrintUnsigned(timeSec/60, 3, '0');
lcdPrintChar(':');
lcdPrintUnsigned(timeSec%60, 2, '0');
}
uint8_t lcdPrintSpaces(uint8_t n)
{
for(uint8_t i=0;i<n;i++)
lcdPrintChar(' ');
return n;
}
