Tick Tock / Mbed 2 deprecated CANary_9341_test

test fork

Dependencies:   SPI_TFTx2 SPI_TFTx2_ILI9341 TFT_fonts TOUCH_TFTx2 mbed

Fork of CANary_9341 by Tick Tock

displayModes.cpp@49:a3d2c5bb3cfa, 2013-04-07 (annotated)

Committer:
TickTock
Date:
Sun Apr 07 08:29:04 2013 +0000
Revision:
49:a3d2c5bb3cfa
Parent:
48:d1ce92104a1f
Child:
50:83d5864c64a0
Added graphical DTE - flickers...

Who changed what in which revision?

UserRevisionLine numberNew contents of line
TickTock 13:62e0f7f39ff5 1 //displayModes.cpp
TickTock 37:fea2c1d52c5f 2 #include "displayModes.h"
TickTock 13:62e0f7f39ff5 3
TickTock 25:ddf0ec209f03 4 char sTemp1[40];
TickTock 24:6cf76ed8c432 5 char sTemp2[16];
TickTock 13:62e0f7f39ff5 6
TickTock 42:4533b13b297d 7 void printLast (bool force, bool showButtons){
TickTock 13:62e0f7f39ff5 8 CANMessage msg;
TickTock 13:62e0f7f39ff5 9 tt.locate(0,6);
TickTock 13:62e0f7f39ff5 10 tt.foreground(Red);
TickTock 13:62e0f7f39ff5 11 tt.background(Yellow);
TickTock 13:62e0f7f39ff5 12 if(force) tt.cls(); // Just clear screen if forced - always update display
TickTock 13:62e0f7f39ff5 13 tt.set_font((unsigned char*) Arial12x12_prop); // select the font
TickTock 13:62e0f7f39ff5 14 for(int i=0; i<19; i++){
TickTock 13:62e0f7f39ff5 15 msg = lastMsg[i+indexOffset];
TickTock 13:62e0f7f39ff5 16 printf("%03x : %02x %02x %02x %02x %02x %02x %02x %02x \n",msg.id,msg.data[0],msg.data[1],msg.data[2],msg.data[3],msg.data[4],msg.data[5],msg.data[6],msg.data[7]);
TickTock 13:62e0f7f39ff5 17 }
TickTock 42:4533b13b297d 18 if((sMode==1)&&showButtons){
TickTock 25:ddf0ec209f03 19 tt.foreground(Yellow);
TickTock 25:ddf0ec209f03 20 tt.background(DarkCyan);
TickTock 25:ddf0ec209f03 21 tt.set_font((unsigned char*) Arial12x12);
TickTock 25:ddf0ec209f03 22 sprintf(sTemp1,"<up>");
TickTock 25:ddf0ec209f03 23 sprintf(sTemp2,"");
TickTock 25:ddf0ec209f03 24 showButton(0,0,sTemp1,sTemp2,3,3);
TickTock 25:ddf0ec209f03 25 sprintf(sTemp1,"<down>");
TickTock 25:ddf0ec209f03 26 showButton(2,0,sTemp1,sTemp2,3,3);
TickTock 25:ddf0ec209f03 27 }
TickTock 13:62e0f7f39ff5 28 }
TickTock 13:62e0f7f39ff5 29
TickTock 42:4533b13b297d 30 void printChanged (bool force, bool showButtons){
TickTock 13:62e0f7f39ff5 31 CANMessage msg;
TickTock 13:62e0f7f39ff5 32 unsigned char i,j;
TickTock 13:62e0f7f39ff5 33 tt.locate(0,6);
TickTock 13:62e0f7f39ff5 34 tt.foreground(Red);
TickTock 13:62e0f7f39ff5 35 tt.background(Yellow);
TickTock 13:62e0f7f39ff5 36 if(force) tt.cls(); // Just clear screen if forced - always update display
TickTock 13:62e0f7f39ff5 37 tt.set_font((unsigned char*) Arial12x12_prop); // select the font
TickTock 13:62e0f7f39ff5 38 i=0;
TickTock 13:62e0f7f39ff5 39 j=indexOffset;
TickTock 13:62e0f7f39ff5 40 do{
TickTock 13:62e0f7f39ff5 41 j=j<99?j+1:j;
TickTock 13:62e0f7f39ff5 42 if(msgChanged[j]>0){
TickTock 13:62e0f7f39ff5 43 msg = lastMsg[j];
TickTock 13:62e0f7f39ff5 44 printf("%03x : %02x %02x %02x %02x %02x %02x %02x %02x \n",msg.id,msg.data[0],msg.data[1],msg.data[2],msg.data[3],msg.data[4],msg.data[5],msg.data[6],msg.data[7]);
TickTock 13:62e0f7f39ff5 45 i++;
TickTock 13:62e0f7f39ff5 46 }// if changed
TickTock 13:62e0f7f39ff5 47 }while(i<19&&j<99);
TickTock 42:4533b13b297d 48 if((sMode==1)&&showButtons){
TickTock 40:0e6e71a7323f 49 tt.foreground(Yellow);
TickTock 40:0e6e71a7323f 50 tt.background(DarkCyan);
TickTock 40:0e6e71a7323f 51 tt.set_font((unsigned char*) Arial12x12);
TickTock 40:0e6e71a7323f 52 sprintf(sTemp1,"<up>");
TickTock 40:0e6e71a7323f 53 sprintf(sTemp2,"");
TickTock 40:0e6e71a7323f 54 showButton(0,0,sTemp1,sTemp2,3,3);
TickTock 44:6262a9fd1e56 55 sprintf(sTemp1," <down>");
TickTock 44:6262a9fd1e56 56 showButton(2,0,sTemp1,sTemp2,3,3);
TickTock 44:6262a9fd1e56 57 sprintf(sTemp1," Reset");
TickTock 44:6262a9fd1e56 58 sprintf(sTemp2," Baseline");
TickTock 40:0e6e71a7323f 59 showButton(1,0,sTemp1,sTemp2,3,3);
TickTock 40:0e6e71a7323f 60 }
TickTock 13:62e0f7f39ff5 61 }
TickTock 13:62e0f7f39ff5 62
TickTock 42:4533b13b297d 63 void printLog (bool force, bool showButtons){
TickTock 13:62e0f7f39ff5 64 static unsigned char lastDisplayLoc = 0;
TickTock 13:62e0f7f39ff5 65 if(force||displayLoc!=lastDisplayLoc){ //only update if changed
TickTock 13:62e0f7f39ff5 66 tt.foreground(Amber);
TickTock 13:62e0f7f39ff5 67 tt.background(Black);
TickTock 13:62e0f7f39ff5 68 tt.cls();
TickTock 13:62e0f7f39ff5 69 tt.locate(0,6);
TickTock 13:62e0f7f39ff5 70 tt.set_font((unsigned char*) Arial12x12);
TickTock 13:62e0f7f39ff5 71 for(int i=0; i<19; i++){
TickTock 13:62e0f7f39ff5 72 printf("%s",displayLog[displayLoc]);
TickTock 13:62e0f7f39ff5 73 displayLoc=displayLoc>17?0:displayLoc+1;
TickTock 13:62e0f7f39ff5 74 }
TickTock 13:62e0f7f39ff5 75 }
TickTock 13:62e0f7f39ff5 76 lastDisplayLoc=displayLoc;
TickTock 13:62e0f7f39ff5 77 }
TickTock 13:62e0f7f39ff5 78
TickTock 42:4533b13b297d 79 void mainDisplay (bool force, bool showButtons){
TickTock 13:62e0f7f39ff5 80 unsigned short gids, SOC, packV;
TickTock 13:62e0f7f39ff5 81 static unsigned short lgids=0, lSOC=0, lpackV=0;
TickTock 49:a3d2c5bb3cfa 82 static float lkW=0, laccV=0, lmpkWh=0;
TickTock 13:62e0f7f39ff5 83 CANMessage msg;
TickTock 13:62e0f7f39ff5 84
TickTock 13:62e0f7f39ff5 85 msg = lastMsg[indexLastMsg[0x5bc]]; //Get gids
TickTock 13:62e0f7f39ff5 86 gids = (msg.data[0]<<2)+(msg.data[1]>>6);
TickTock 13:62e0f7f39ff5 87 msg = lastMsg[indexLastMsg[0x55b]]; //Get SOC
TickTock 13:62e0f7f39ff5 88 SOC = (msg.data[0]<<2)+(msg.data[1]>>6);
TickTock 13:62e0f7f39ff5 89 msg = lastMsg[indexLastMsg[0x1db]]; //Get pack volts
TickTock 13:62e0f7f39ff5 90 packV = (msg.data[2]<<2)+(msg.data[3]>>6);
TickTock 13:62e0f7f39ff5 91
TickTock 13:62e0f7f39ff5 92 tt.background(Navy);
TickTock 38:155ec32c5e91 93 tt.foreground(Yellow);
TickTock 38:155ec32c5e91 94 tt.set_font((unsigned char*) Arial28x28);
TickTock 13:62e0f7f39ff5 95 if(force) tt.cls();
TickTock 48:d1ce92104a1f 96 if(skin==ttSkin){
TickTock 49:a3d2c5bb3cfa 97 if(force||gids!=lgids||mpkWh[9]!=lmpkWh){
TickTock 48:d1ce92104a1f 98 tt.locate(10,10);
TickTock 48:d1ce92104a1f 99 printf("%4d gids \n",gids);
TickTock 49:a3d2c5bb3cfa 100 tt.locate(10,40);
TickTock 49:a3d2c5bb3cfa 101 printf("%4.1f kWh \n",(float)(gids-5)*0.075);
TickTock 48:d1ce92104a1f 102 tt.set_font((unsigned char*) SCProSB31x55);
TickTock 48:d1ce92104a1f 103 tt.foreground(Green);
TickTock 48:d1ce92104a1f 104 tt.locate(60,96);
TickTock 49:a3d2c5bb3cfa 105 printf("%4.1f mi \n",mpkWh[9]*((float)(gids-5)*.075)); // Use 1 minute average
TickTock 48:d1ce92104a1f 106 lgids=gids;
TickTock 49:a3d2c5bb3cfa 107 lmpkWh-mpkWh[9];
TickTock 48:d1ce92104a1f 108 tt.foreground(Yellow);
TickTock 48:d1ce92104a1f 109 tt.set_font((unsigned char*) Arial28x28);
TickTock 48:d1ce92104a1f 110 }
TickTock 48:d1ce92104a1f 111 if(force||SOC!=lSOC){
TickTock 48:d1ce92104a1f 112 tt.locate(200,10);
TickTock 48:d1ce92104a1f 113 printf("%4.1f%s\n",(float)SOC/10,"% ");
TickTock 48:d1ce92104a1f 114 lSOC=SOC;
TickTock 48:d1ce92104a1f 115 }
TickTock 48:d1ce92104a1f 116 if(force||packV!=lpackV){
TickTock 48:d1ce92104a1f 117 tt.locate(200,200);
TickTock 48:d1ce92104a1f 118 printf("%4.1fV \n",(float)packV/2);
TickTock 48:d1ce92104a1f 119 lpackV=packV;
TickTock 48:d1ce92104a1f 120 }
TickTock 48:d1ce92104a1f 121 if(force||accV!=laccV){
TickTock 48:d1ce92104a1f 122 tt.locate(20,200);
TickTock 48:d1ce92104a1f 123 printf("%3.1fV \n",accV);
TickTock 48:d1ce92104a1f 124 laccV=accV;
TickTock 48:d1ce92104a1f 125 }
TickTock 49:a3d2c5bb3cfa 126 if(force||kW[0]!=lkW){
TickTock 48:d1ce92104a1f 127 tt.locate(180,40);
TickTock 49:a3d2c5bb3cfa 128 printf("%3.2fkW \n",kW[0]);
TickTock 49:a3d2c5bb3cfa 129 //printf("%3.1f mpkWh \n",mpkWh[0]);
TickTock 49:a3d2c5bb3cfa 130 lkW=kW[0];
TickTock 48:d1ce92104a1f 131 }
TickTock 48:d1ce92104a1f 132 }else {//if(skin==ggSkin){
TickTock 48:d1ce92104a1f 133 if(force||gids!=lgids){
TickTock 48:d1ce92104a1f 134 tt.locate(10,10);
TickTock 48:d1ce92104a1f 135 printf("%4d GIDs \n",gids);
TickTock 48:d1ce92104a1f 136
TickTock 48:d1ce92104a1f 137 tt.locate(40,40); // gg - add GIDs Percent of 281
TickTock 48:d1ce92104a1f 138 printf("%4.1f%s \n", (float)gids*0.355872, "% ") ;
TickTock 48:d1ce92104a1f 139 tt.locate(20,70);
TickTock 48:d1ce92104a1f 140 //printf("%4.1f kWh \n",(float)gids*0.08); // is input, not usable
TickTock 48:d1ce92104a1f 141 printf("%4.1f kwh \n",(float)gids*0.075); // gg - closer to usable
TickTock 48:d1ce92104a1f 142
TickTock 48:d1ce92104a1f 143 tt.set_font((unsigned char*) SCProSB31x55);
TickTock 48:d1ce92104a1f 144 tt.foreground(Green);
TickTock 48:d1ce92104a1f 145 //tt.locate(60,96);
TickTock 48:d1ce92104a1f 146 tt.locate(60,116); // gg - move down a little
TickTock 48:d1ce92104a1f 147 printf("%4.1f mi \n",(float)(gids-5)*0.31); // Approx for now
TickTock 48:d1ce92104a1f 148 lgids=gids;
TickTock 48:d1ce92104a1f 149 tt.foreground(Yellow);
TickTock 48:d1ce92104a1f 150 tt.set_font((unsigned char*) Arial28x28);
TickTock 48:d1ce92104a1f 151 }
TickTock 48:d1ce92104a1f 152
TickTock 48:d1ce92104a1f 153 if(force||SOC!=lSOC){
TickTock 48:d1ce92104a1f 154 tt.locate(200,10);
TickTock 48:d1ce92104a1f 155 printf("%4.1f%s\n",(float)SOC/10,"% ");
TickTock 48:d1ce92104a1f 156 lSOC=SOC;
TickTock 48:d1ce92104a1f 157 }
TickTock 48:d1ce92104a1f 158 if(force||packV!=lpackV){
TickTock 48:d1ce92104a1f 159 tt.locate(200,200);
TickTock 48:d1ce92104a1f 160 printf("%4.1fV \n",(float)packV/2);
TickTock 48:d1ce92104a1f 161 lpackV=packV;
TickTock 48:d1ce92104a1f 162 }
TickTock 48:d1ce92104a1f 163 if(force||accV!=laccV){
TickTock 48:d1ce92104a1f 164 tt.locate(20,200);
TickTock 48:d1ce92104a1f 165 printf("%3.1fV \n",accV);
TickTock 48:d1ce92104a1f 166 laccV=accV;
TickTock 48:d1ce92104a1f 167 }
TickTock 49:a3d2c5bb3cfa 168 if(force||kW[0]!=lkW){
TickTock 48:d1ce92104a1f 169 tt.locate(160,40); // gg - move left to keep from wrap
TickTock 49:a3d2c5bb3cfa 170 printf("%3.2fkw \n",kW[0]); // use small w to save space
TickTock 49:a3d2c5bb3cfa 171 lkW=kW[0];
TickTock 48:d1ce92104a1f 172 }
TickTock 35:5acbd8a64a89 173 }
TickTock 13:62e0f7f39ff5 174 }
TickTock 13:62e0f7f39ff5 175
TickTock 42:4533b13b297d 176 void braking (bool force, bool showButtons, bool prdata=false){
TickTock 28:f24ac05645d9 177 unsigned long targetBraking, regenBraking;
TickTock 28:f24ac05645d9 178 static unsigned long maxTarget = 1000, maxRegen = 1000, tarDivReg = 1000;
TickTock 28:f24ac05645d9 179 unsigned long temp;
TickTock 28:f24ac05645d9 180 static unsigned char lastPressure[4] = {200,200,200,200};
TickTock 28:f24ac05645d9 181 unsigned char i,r,t;
TickTock 37:fea2c1d52c5f 182 static unsigned char lr=0, lt=0;
TickTock 37:fea2c1d52c5f 183 signed short steering;
TickTock 37:fea2c1d52c5f 184 unsigned short s;
TickTock 37:fea2c1d52c5f 185 static unsigned short ls;
TickTock 37:fea2c1d52c5f 186 unsigned char throttle;
TickTock 37:fea2c1d52c5f 187 static unsigned char lthrottle;
TickTock 48:d1ce92104a1f 188 short steerOutBounds = 0 ;
TickTock 28:f24ac05645d9 189 CANMessage msg;
TickTock 28:f24ac05645d9 190
TickTock 48:d1ce92104a1f 191 //---------------
TickTock 37:fea2c1d52c5f 192 msg = lastMsg[indexLastMsg[0x180]]; //Get Throttle position
TickTock 37:fea2c1d52c5f 193 throttle = msg.data[5];
TickTock 48:d1ce92104a1f 194
TickTock 48:d1ce92104a1f 195 // ---- steering ----
TickTock 37:fea2c1d52c5f 196 msg = lastMsg[indexLastMsg[0x002]]; //Get Steering angle
TickTock 37:fea2c1d52c5f 197 steering = (msg.data[1]<<8)+msg.data[0];
TickTock 48:d1ce92104a1f 198
TickTock 48:d1ce92104a1f 199 if(skin==ttSkin){
TickTock 48:d1ce92104a1f 200 s= (unsigned short) ((steering/10)+160)%310; // this modulo wraps display
TickTock 48:d1ce92104a1f 201 }else{// if(skin==ggSkin){
TickTock 48:d1ce92104a1f 202 // do not go off screen left or right. gg - steering
TickTock 48:d1ce92104a1f 203 short ss = (short) ((steering/15)+160); // less gain 10 -> 15
TickTock 48:d1ce92104a1f 204 if(ss<0) { ss=0; steerOutBounds = 1; }
TickTock 48:d1ce92104a1f 205 if(ss>310) { ss=310; steerOutBounds = 1; }
TickTock 48:d1ce92104a1f 206 s = (unsigned short) ss;
TickTock 48:d1ce92104a1f 207 }
TickTock 48:d1ce92104a1f 208
TickTock 48:d1ce92104a1f 209 //--------------
TickTock 28:f24ac05645d9 210 msg = lastMsg[indexLastMsg[0x1cb]]; //Get Target and Regen
TickTock 28:f24ac05645d9 211 regenBraking = (msg.data[0]<<3)+(msg.data[1]>>5);
TickTock 28:f24ac05645d9 212 targetBraking = (msg.data[2]<<3)+(msg.data[3]>>5);
TickTock 28:f24ac05645d9 213 if ((targetBraking>50)&&(regenBraking>50)){
TickTock 28:f24ac05645d9 214 temp = targetBraking;
TickTock 28:f24ac05645d9 215 temp *= 1000;
TickTock 28:f24ac05645d9 216 temp /= regenBraking;
TickTock 28:f24ac05645d9 217 if (temp<tarDivReg) tarDivReg=temp;
TickTock 28:f24ac05645d9 218 }
TickTock 28:f24ac05645d9 219 if (targetBraking>maxTarget) maxTarget=targetBraking;
TickTock 28:f24ac05645d9 220 if (regenBraking>maxRegen) maxRegen=regenBraking;
TickTock 28:f24ac05645d9 221
TickTock 28:f24ac05645d9 222 msg = lastMsg[indexLastMsg[0x1ca]]; //Get brake pressure
TickTock 28:f24ac05645d9 223 tt.background(Navy);
TickTock 28:f24ac05645d9 224 if (force) {
TickTock 28:f24ac05645d9 225 tt.cls();
TickTock 28:f24ac05645d9 226 tt.rect(0,111,170,239,White);
TickTock 28:f24ac05645d9 227 tt.line(0,207,170,207,White);
TickTock 28:f24ac05645d9 228 tt.line(0,175,170,175,White);
TickTock 28:f24ac05645d9 229 tt.line(0,143,170,143,White);
TickTock 28:f24ac05645d9 230 lastPressure[0] = 200;
TickTock 28:f24ac05645d9 231 lastPressure[1] = 200;
TickTock 28:f24ac05645d9 232 lastPressure[2] = 200;
TickTock 28:f24ac05645d9 233 lastPressure[3] = 200;
TickTock 28:f24ac05645d9 234 }
TickTock 48:d1ce92104a1f 235
TickTock 48:d1ce92104a1f 236 // display the steering position small square
TickTock 37:fea2c1d52c5f 237 if (s!=ls){
TickTock 48:d1ce92104a1f 238 // steering position has moved
TickTock 48:d1ce92104a1f 239 //tt.fillrect(ls,5,ls+9,14, Navy); // blank old position
TickTock 48:d1ce92104a1f 240
TickTock 48:d1ce92104a1f 241 //---- gg - steering red
TickTock 48:d1ce92104a1f 242 // box is blanked by top of Braking bar, so move up 5
TickTock 48:d1ce92104a1f 243 tt.fillrect(ls,0,ls+9,9, Navy); // blank old position
TickTock 48:d1ce92104a1f 244 if( steerOutBounds != 0 ) // draw out-of-bounds as a red box
TickTock 48:d1ce92104a1f 245 tt.fillrect(s,0,s+9,9, Red); // draw out-of-bounds position
TickTock 48:d1ce92104a1f 246 else
TickTock 48:d1ce92104a1f 247 tt.fillrect(s,0,s+9,9, White); // draw new in-bounds position
TickTock 48:d1ce92104a1f 248
TickTock 48:d1ce92104a1f 249 //----
TickTock 37:fea2c1d52c5f 250 //tt.foreground(Yellow);
TickTock 37:fea2c1d52c5f 251 //tt.set_font((unsigned char*) Arial28x28);
TickTock 37:fea2c1d52c5f 252 //tt.locate(10,40);
TickTock 37:fea2c1d52c5f 253 //printf("%d %d \n",s,ls);
TickTock 37:fea2c1d52c5f 254 ls=s;
TickTock 37:fea2c1d52c5f 255 }
TickTock 48:d1ce92104a1f 256
TickTock 37:fea2c1d52c5f 257 if (throttle!=lthrottle){
TickTock 37:fea2c1d52c5f 258 if (throttle>239) throttle=239;
TickTock 37:fea2c1d52c5f 259 if(throttle<lthrottle){
TickTock 37:fea2c1d52c5f 260 tt.fillrect(280,239-lthrottle,310,239-throttle,Navy);
TickTock 37:fea2c1d52c5f 261 }else{
TickTock 37:fea2c1d52c5f 262 tt.fillrect(280,239-throttle,310,239,Yellow);
TickTock 37:fea2c1d52c5f 263 }
TickTock 37:fea2c1d52c5f 264 lthrottle=throttle;
TickTock 37:fea2c1d52c5f 265 }
TickTock 37:fea2c1d52c5f 266
TickTock 28:f24ac05645d9 267 // plot bar graph for each wheel pressure
TickTock 28:f24ac05645d9 268 for (i=0; i<4; i++){
TickTock 28:f24ac05645d9 269 if (msg.data[i]<239) {
TickTock 28:f24ac05645d9 270 if (msg.data[i]>lastPressure[i]){
TickTock 28:f24ac05645d9 271 tt.fillrect(10+40*i,239-msg.data[i],40+40*i,239,Red);
TickTock 28:f24ac05645d9 272 } else if (msg.data[i]<lastPressure[i]) {
TickTock 28:f24ac05645d9 273 tt.fillrect(10+40*i,238-lastPressure[i],40+40*i,238-msg.data[i],Navy);
TickTock 28:f24ac05645d9 274 }
TickTock 28:f24ac05645d9 275 lastPressure[i]=msg.data[i];
TickTock 28:f24ac05645d9 276 }
TickTock 28:f24ac05645d9 277 }
TickTock 28:f24ac05645d9 278
TickTock 28:f24ac05645d9 279 temp = targetBraking;
TickTock 28:f24ac05645d9 280 temp *=200;
TickTock 28:f24ac05645d9 281 temp /= maxTarget;
TickTock 28:f24ac05645d9 282 t = (char) temp;
TickTock 28:f24ac05645d9 283 if (t>200) t=200;
TickTock 28:f24ac05645d9 284 temp = regenBraking;
TickTock 28:f24ac05645d9 285 temp *= tarDivReg;
TickTock 28:f24ac05645d9 286 temp /= maxTarget;
TickTock 28:f24ac05645d9 287 temp /= 5;
TickTock 28:f24ac05645d9 288 r = (char) temp;
TickTock 28:f24ac05645d9 289 if (r>200) r=200;
TickTock 28:f24ac05645d9 290 if(lr!=r&&prdata){
TickTock 28:f24ac05645d9 291 tt.foreground(Yellow);
TickTock 28:f24ac05645d9 292 tt.set_font((unsigned char*) Arial28x28);
TickTock 28:f24ac05645d9 293 tt.locate(100,40);
TickTock 28:f24ac05645d9 294 printf("%d %d \n",regenBraking,maxRegen);
TickTock 28:f24ac05645d9 295 tt.locate(100,70);
TickTock 28:f24ac05645d9 296 printf("%3.1f (%3.1f%s) \n",(float)tarDivReg/10,(float)regenBraking*tarDivReg/targetBraking/10,"%");
TickTock 28:f24ac05645d9 297 }
TickTock 28:f24ac05645d9 298 if(lt!=t&&prdata){
TickTock 28:f24ac05645d9 299 tt.foreground(Yellow);
TickTock 28:f24ac05645d9 300 tt.set_font((unsigned char*) Arial28x28);
TickTock 28:f24ac05645d9 301 tt.locate(100,10);
TickTock 28:f24ac05645d9 302 printf("%d %d \n",targetBraking,maxTarget);
TickTock 28:f24ac05645d9 303 }
TickTock 28:f24ac05645d9 304 if (r>t) t=r; //Should never happen
TickTock 28:f24ac05645d9 305 if((lr!=r||lt!=t)&&!prdata){
TickTock 37:fea2c1d52c5f 306 tt.fillrect(190,10,260,239-t,Navy);
TickTock 37:fea2c1d52c5f 307 tt.fillrect(190,239-t,260,239-r,Red);
TickTock 37:fea2c1d52c5f 308 tt.fillrect(190,239-r,260,239,Green);
TickTock 28:f24ac05645d9 309 }
TickTock 28:f24ac05645d9 310 lt=t;
TickTock 28:f24ac05645d9 311 lr=r;
TickTock 28:f24ac05645d9 312 }
TickTock 28:f24ac05645d9 313
TickTock 42:4533b13b297d 314 void cpData(bool force, bool showButtons){
TickTock 36:dbd39c315258 315 short unsigned max, min, jv, i, bd;
TickTock 36:dbd39c315258 316 unsigned avg;
TickTock 36:dbd39c315258 317 if(force){
TickTock 36:dbd39c315258 318 tt.foreground(White);
TickTock 36:dbd39c315258 319 tt.background(Navy);
TickTock 36:dbd39c315258 320 tt.set_font((unsigned char*) Arial12x12_prop); // select the font
TickTock 36:dbd39c315258 321 max=0;
TickTock 36:dbd39c315258 322 min=9999;
TickTock 36:dbd39c315258 323 avg=0;
TickTock 36:dbd39c315258 324 for(i=0; i<96; i++){
TickTock 36:dbd39c315258 325 bd=(battData[i*2+3]<<8)+battData[i*2+4];
TickTock 36:dbd39c315258 326 avg+=bd;
TickTock 36:dbd39c315258 327 if(bd>max) max=bd;
TickTock 36:dbd39c315258 328 if(bd<min) min=bd;
TickTock 36:dbd39c315258 329 }
TickTock 36:dbd39c315258 330 avg /= 96;
TickTock 36:dbd39c315258 331 if(min<3713) {
TickTock 36:dbd39c315258 332 jv=avg-(max-avg)*1.5;
TickTock 36:dbd39c315258 333 } else { // Only compute judgement value if min cellpair meets <= 3712mV requirement
TickTock 36:dbd39c315258 334 jv=0;
TickTock 36:dbd39c315258 335 }
TickTock 36:dbd39c315258 336 tt.cls();
TickTock 36:dbd39c315258 337 tt.locate(0,6);
TickTock 36:dbd39c315258 338 printf(" MAX MIN AVG CVLI T1 T2 T3 T4\n %04d %04d %04d %04d %02dC %02dC %02dC %02dC\n\n",max,min,avg,jv,battData[224+5],battData[224+8],battData[224+11],battData[224+14]);
TickTock 36:dbd39c315258 339 tt.locate(0,36);
TickTock 36:dbd39c315258 340 for(i=0; i<16; i++){
TickTock 36:dbd39c315258 341 printf("%02d-%02d : %04d %04d %04d %04d %04d %04d\n",i*6+1,i*6+6,(battData[i*12+3]<<8)+battData[i*12+4],(battData[i*12+5]<<8)+battData[i*12+6],(battData[i*12+7]<<8)+battData[i*12+8],(battData[i*12+9]<<8)+battData[i*12+10],(battData[i*12+11]<<8)+battData[i*12+12],(battData[i*12+13]<<8)+battData[i*12+14]);
TickTock 36:dbd39c315258 342 }
TickTock 36:dbd39c315258 343 tt.rect(8+0*41,16,40+0*41,28,Green);
TickTock 36:dbd39c315258 344 tt.rect(8+1*41,16,40+1*41,28,Yellow);
TickTock 36:dbd39c315258 345 //tt.rect(8+2*41,16,40+2*41,28,White);
TickTock 36:dbd39c315258 346 tt.rect(8+3*41,16,40+3*41,28,Red);
TickTock 36:dbd39c315258 347 for(i=0; i<96; i++){
TickTock 36:dbd39c315258 348 bd=(battData[i*2+3]<<8)+battData[i*2+4];
TickTock 36:dbd39c315258 349 if(bd>0){
TickTock 36:dbd39c315258 350 if(bd==max) tt.rect(58+(i%6)*41,34+(int)(i/6)*12,90+(i%6)*41,46+(int)(i/6)*12,Green);
TickTock 36:dbd39c315258 351 //if(bd==avg) tt.rect(58+(i%6)*41,34+(int)(i/6)*12,90+(i%6)*41,46+(int)(i/6)*12,White);
TickTock 36:dbd39c315258 352 if(bd==min) tt.rect(58+(i%6)*41,34+(int)(i/6)*12,90+(i%6)*41,46+(int)(i/6)*12,Yellow);
TickTock 36:dbd39c315258 353 if(bd<jv) tt.rect(58+(i%6)*41,34+(int)(i/6)*12,90+(i%6)*41,46+(int)(i/6)*12,Red);
TickTock 36:dbd39c315258 354 }
TickTock 36:dbd39c315258 355 }
TickTock 36:dbd39c315258 356 showCP=false;
TickTock 36:dbd39c315258 357 }
TickTock 42:4533b13b297d 358 if((sMode==1)&&showButtons){
TickTock 36:dbd39c315258 359 tt.foreground(Yellow);
TickTock 36:dbd39c315258 360 tt.background(DarkCyan);
TickTock 36:dbd39c315258 361 tt.set_font((unsigned char*) Arial12x12);
TickTock 44:6262a9fd1e56 362 sprintf(sTemp1," Request");
TickTock 44:6262a9fd1e56 363 sprintf(sTemp2," CP data");
TickTock 44:6262a9fd1e56 364 showButton(1,0,sTemp1,sTemp2,3,3);
TickTock 44:6262a9fd1e56 365 }
TickTock 44:6262a9fd1e56 366 }
TickTock 44:6262a9fd1e56 367
TickTock 44:6262a9fd1e56 368 //----------------
TickTock 48:d1ce92104a1f 369 // gg - cpbars
TickTock 48:d1ce92104a1f 370 void cpBarPlot(bool force, bool showButtons){
TickTock 48:d1ce92104a1f 371 short unsigned max, min, jv, i, bd;
TickTock 48:d1ce92104a1f 372 unsigned avg;
TickTock 48:d1ce92104a1f 373 short unsigned nBar[96] ; // bar height over min
TickTock 48:d1ce92104a1f 374
TickTock 48:d1ce92104a1f 375 if(force){
TickTock 48:d1ce92104a1f 376 tt.foreground(White);
TickTock 48:d1ce92104a1f 377 tt.background(Navy);
TickTock 48:d1ce92104a1f 378 tt.set_font((unsigned char*) Arial12x12_prop); // select the font
TickTock 48:d1ce92104a1f 379 max=0;
TickTock 48:d1ce92104a1f 380 min=9999;
TickTock 48:d1ce92104a1f 381 avg=0;
TickTock 48:d1ce92104a1f 382
TickTock 48:d1ce92104a1f 383 // calc each cell-pair voltage, find max and min
TickTock 48:d1ce92104a1f 384 for(i=0; i<96; i++){
TickTock 48:d1ce92104a1f 385 bd=(battData[i*2+3]<<8)+battData[i*2+4];
TickTock 48:d1ce92104a1f 386 nBar[i] = bd; // init to bar height
TickTock 48:d1ce92104a1f 387 avg+=bd;
TickTock 48:d1ce92104a1f 388 if(bd>max) max=bd;
TickTock 48:d1ce92104a1f 389 if(bd<min) min=bd;
TickTock 48:d1ce92104a1f 390 }
TickTock 48:d1ce92104a1f 391 avg /= 96;
TickTock 48:d1ce92104a1f 392
TickTock 48:d1ce92104a1f 393 if(min<3713) {
TickTock 48:d1ce92104a1f 394 jv=avg-(max-avg)*1.5;
TickTock 48:d1ce92104a1f 395 } else { // Only compute judgement value if min cellpair meets <= 3712mV requirement
TickTock 48:d1ce92104a1f 396 jv=0;
TickTock 48:d1ce92104a1f 397 }
TickTock 48:d1ce92104a1f 398
TickTock 48:d1ce92104a1f 399 //------------------
TickTock 48:d1ce92104a1f 400 tt.cls();
TickTock 48:d1ce92104a1f 401
TickTock 48:d1ce92104a1f 402 // show as vertical bar plot
TickTock 48:d1ce92104a1f 403 int xWinMin = 26;
TickTock 48:d1ce92104a1f 404 int xWinMax = 316;
TickTock 48:d1ce92104a1f 405 int yWinMin = 50;
TickTock 48:d1ce92104a1f 406 int yWinMax = 150;
TickTock 48:d1ce92104a1f 407 // draw the Bar Graph Frame, 2 pixels wide
TickTock 48:d1ce92104a1f 408 tt.rect( xWinMin-1,yWinMin-1, xWinMax+1,yWinMax+1,Red);
TickTock 48:d1ce92104a1f 409 tt.rect( xWinMin-2,yWinMin-2, xWinMax+2,yWinMax+2,Green);
TickTock 48:d1ce92104a1f 410
TickTock 48:d1ce92104a1f 411 // bar heights
TickTock 48:d1ce92104a1f 412 int height = yWinMax - yWinMin ;
TickTock 48:d1ce92104a1f 413 int iBarValMax = max - min ; // zero to N
TickTock 48:d1ce92104a1f 414
TickTock 48:d1ce92104a1f 415 //----------------
TickTock 48:d1ce92104a1f 416 if( iBarValMax == 0 ) {
TickTock 48:d1ce92104a1f 417 // for testing
TickTock 48:d1ce92104a1f 418 min = 3501 ;
TickTock 48:d1ce92104a1f 419 //max = min + 95*2 ; // for tall values
TickTock 48:d1ce92104a1f 420 max = min + 95/4 ; // for small values
TickTock 48:d1ce92104a1f 421 avg = ( max + min ) / 2;
TickTock 48:d1ce92104a1f 422 iBarValMax = max - min ; // zero to N
TickTock 48:d1ce92104a1f 423 for(int i=0; i<96; i++) {
TickTock 48:d1ce92104a1f 424 //nBar[i] = i*2 + min ; // test tall values
TickTock 48:d1ce92104a1f 425 nBar[i] = i/4 + min ; // test small values
TickTock 48:d1ce92104a1f 426 }
TickTock 48:d1ce92104a1f 427 }
TickTock 48:d1ce92104a1f 428 //---------------
TickTock 48:d1ce92104a1f 429 float nBarScale = float(height) / iBarValMax ;
TickTock 48:d1ce92104a1f 430 if( nBarScale < 0.1 ) nBarScale = 0.1 ;
TickTock 48:d1ce92104a1f 431
TickTock 48:d1ce92104a1f 432 // do the Bar-height scaling
TickTock 48:d1ce92104a1f 433 for(int i=0; i<96; i++){
TickTock 48:d1ce92104a1f 434 nBar[i] -= min ; // now, 0 to N = iBinValMax
TickTock 48:d1ce92104a1f 435 nBar[i] *= nBarScale ; // scale, as needed
TickTock 48:d1ce92104a1f 436 }
TickTock 48:d1ce92104a1f 437
TickTock 48:d1ce92104a1f 438 // values, for now
TickTock 48:d1ce92104a1f 439 tt.locate( 0, yWinMax+40 );
TickTock 48:d1ce92104a1f 440 printf(" MAX MIN AVG CVLI T1 T2 T3 T4\n %04d %04d %04d %04d %02dC %02dC %02dC %02dC\n\n",
TickTock 48:d1ce92104a1f 441 max,min,avg,jv,
TickTock 48:d1ce92104a1f 442 battData[224+5],battData[224+8],
TickTock 48:d1ce92104a1f 443 battData[224+11],battData[224+14]);
TickTock 48:d1ce92104a1f 444
TickTock 48:d1ce92104a1f 445 // label the X axis (approximate)
TickTock 48:d1ce92104a1f 446 tt.locate( 2, yWinMax+5); printf("%04d", min );
TickTock 48:d1ce92104a1f 447 //tt.locate( 2, yWinMin-14 ); printf("%04d = %04d from %1.4f", max, int( height / nBarScale ) + min, nBarScale );
TickTock 48:d1ce92104a1f 448 tt.locate( 2, yWinMin-14 ); printf("%04d = (%d) mv range.", max , max - min );
TickTock 48:d1ce92104a1f 449
TickTock 48:d1ce92104a1f 450 //---------------
TickTock 48:d1ce92104a1f 451 // show the bars
TickTock 48:d1ce92104a1f 452 int nBarWidth = 2 ;
TickTock 48:d1ce92104a1f 453 int nBarSpace = 1 ; // 1 for testing
TickTock 48:d1ce92104a1f 454
TickTock 48:d1ce92104a1f 455 int xPos = xWinMin + 2 ; // start one from the left
TickTock 48:d1ce92104a1f 456
TickTock 48:d1ce92104a1f 457 for( int i=0; i<96; i++) {
TickTock 48:d1ce92104a1f 458 height = nBar[i] ;
TickTock 48:d1ce92104a1f 459 if( height > 100 ) height = 100 ; // clip tops
TickTock 48:d1ce92104a1f 460
TickTock 48:d1ce92104a1f 461 // draw the bar, is always inside x-window
TickTock 48:d1ce92104a1f 462 tt.fillrect( xPos,yWinMax-height, xPos+nBarWidth-1,yWinMax, Green);
TickTock 48:d1ce92104a1f 463
TickTock 48:d1ce92104a1f 464 // tic mark the y axis each 5
TickTock 48:d1ce92104a1f 465 if(i%5 == 4){
TickTock 48:d1ce92104a1f 466 tt.line( xPos,yWinMax+2, xPos,yWinMax+5, White); // a white tick mark
TickTock 48:d1ce92104a1f 467 tt.line( xPos+1,yWinMax+2, xPos+1,yWinMax+5, White); // a white tick mark, to widen
TickTock 48:d1ce92104a1f 468 //tt.rect( xPos,yWinMax+2, xPos+1,yWinMax+5, White); // a white 2-wide tick mark is SLOW
TickTock 48:d1ce92104a1f 469 }
TickTock 48:d1ce92104a1f 470 // label the y axis each 10
TickTock 48:d1ce92104a1f 471 if(i%10 == 9){
TickTock 48:d1ce92104a1f 472 tt.locate( xPos-6, yWinMax+8 );
TickTock 48:d1ce92104a1f 473 printf("%02d\n", i+1 );
TickTock 48:d1ce92104a1f 474 }
TickTock 48:d1ce92104a1f 475
TickTock 48:d1ce92104a1f 476 // step to the next bar position
TickTock 48:d1ce92104a1f 477 xPos += nBarWidth + nBarSpace ;
TickTock 48:d1ce92104a1f 478 }
TickTock 48:d1ce92104a1f 479
TickTock 48:d1ce92104a1f 480 showCP=false;
TickTock 48:d1ce92104a1f 481 }
TickTock 48:d1ce92104a1f 482
TickTock 48:d1ce92104a1f 483 // handle the button
TickTock 48:d1ce92104a1f 484 if(sMode==1&&showButtons){
TickTock 48:d1ce92104a1f 485 tt.foreground(Yellow);
TickTock 48:d1ce92104a1f 486 tt.background(DarkCyan);
TickTock 48:d1ce92104a1f 487 tt.set_font((unsigned char*) Arial12x12);
TickTock 48:d1ce92104a1f 488 sprintf(sTemp1," Request");
TickTock 48:d1ce92104a1f 489 sprintf(sTemp2," CP data");
TickTock 48:d1ce92104a1f 490 showButton(1,0,sTemp1,sTemp2,3,3);
TickTock 48:d1ce92104a1f 491 }
TickTock 48:d1ce92104a1f 492 }
TickTock 48:d1ce92104a1f 493
TickTock 48:d1ce92104a1f 494 //----------------
TickTock 44:6262a9fd1e56 495 // gg - hist
TickTock 47:9cc7d876dd6d 496 void cpHistogram(bool force, bool showButtons){
TickTock 44:6262a9fd1e56 497 short unsigned max, min, jv, i, bd;
TickTock 44:6262a9fd1e56 498 unsigned avg;
TickTock 44:6262a9fd1e56 499 if(force){
TickTock 44:6262a9fd1e56 500 tt.foreground(White);
TickTock 44:6262a9fd1e56 501 tt.background(Navy);
TickTock 44:6262a9fd1e56 502 tt.set_font((unsigned char*) Arial12x12_prop); // select the font
TickTock 44:6262a9fd1e56 503 max=0;
TickTock 44:6262a9fd1e56 504 min=9999;
TickTock 44:6262a9fd1e56 505 avg=0;
TickTock 44:6262a9fd1e56 506 for(i=0; i<96; i++){
TickTock 44:6262a9fd1e56 507 bd=(battData[i*2+3]<<8)+battData[i*2+4];
TickTock 44:6262a9fd1e56 508 avg+=bd;
TickTock 44:6262a9fd1e56 509 if(bd>max) max=bd;
TickTock 44:6262a9fd1e56 510 if(bd<min) min=bd;
TickTock 44:6262a9fd1e56 511 }
TickTock 44:6262a9fd1e56 512 avg /= 96;
TickTock 44:6262a9fd1e56 513 if(min<3713) {
TickTock 44:6262a9fd1e56 514 jv=avg-(max-avg)*1.5;
TickTock 44:6262a9fd1e56 515 } else { // Only compute judgement value if min cellpair meets <= 3712mV requirement
TickTock 44:6262a9fd1e56 516 jv=0;
TickTock 44:6262a9fd1e56 517 }
TickTock 44:6262a9fd1e56 518
TickTock 44:6262a9fd1e56 519 //------------------
TickTock 44:6262a9fd1e56 520 tt.cls();
TickTock 44:6262a9fd1e56 521
TickTock 44:6262a9fd1e56 522 // show as histogram
TickTock 44:6262a9fd1e56 523 int xWinMin = 20;
TickTock 44:6262a9fd1e56 524 int xWinMax = 300;
TickTock 44:6262a9fd1e56 525 int yWinMin = 50;
TickTock 44:6262a9fd1e56 526 int yWinMax = 150;
TickTock 44:6262a9fd1e56 527 // draw the Histogram Frame, 2 pixels wide
TickTock 44:6262a9fd1e56 528 tt.rect( xWinMin-1,yWinMin-1, xWinMax+1,yWinMax+1,Red);
TickTock 44:6262a9fd1e56 529 tt.rect( xWinMin-2,yWinMin-2, xWinMax+2,yWinMax+2,Green);
TickTock 44:6262a9fd1e56 530
TickTock 44:6262a9fd1e56 531 // binning
TickTock 44:6262a9fd1e56 532 short nBin[301] ; // bins to count Min values in nBin[0], etc.
TickTock 44:6262a9fd1e56 533 int height ;
TickTock 44:6262a9fd1e56 534 int iBinIndxMax = 300 ;
TickTock 44:6262a9fd1e56 535 int iBinValMax = max - min ; // zero to N
TickTock 44:6262a9fd1e56 536 if( iBinValMax > iBinIndxMax ) iBinValMax = iBinIndxMax ;
TickTock 44:6262a9fd1e56 537
TickTock 44:6262a9fd1e56 538 // clean the bins
TickTock 44:6262a9fd1e56 539 for(int i=0; i<=iBinIndxMax; i++) {
TickTock 44:6262a9fd1e56 540 nBin[i] = 0;
TickTock 44:6262a9fd1e56 541 }
TickTock 44:6262a9fd1e56 542
TickTock 44:6262a9fd1e56 543 // do the bin counting
TickTock 44:6262a9fd1e56 544 for(int i=0; i<96; i++){
TickTock 44:6262a9fd1e56 545 bd=(battData[i*2+3]<<8)+battData[i*2+4] - min ;
TickTock 44:6262a9fd1e56 546 if( bd > iBinValMax ) bd = iBinValMax ;
TickTock 44:6262a9fd1e56 547 nBin[bd] ++ ;
TickTock 44:6262a9fd1e56 548 }
TickTock 44:6262a9fd1e56 549
TickTock 44:6262a9fd1e56 550 //----------------
TickTock 44:6262a9fd1e56 551 if( iBinValMax == 0 ) {
TickTock 44:6262a9fd1e56 552 // for testing
TickTock 44:6262a9fd1e56 553 min = 10 ;
TickTock 44:6262a9fd1e56 554 max = 50 ;
TickTock 44:6262a9fd1e56 555 avg = ( max + min ) / 2;
TickTock 44:6262a9fd1e56 556 iBinValMax = max - min ;
TickTock 44:6262a9fd1e56 557 for(int i=0; i<=(iBinValMax/2); i++) {
TickTock 44:6262a9fd1e56 558 nBin[i] = i ;
TickTock 44:6262a9fd1e56 559 nBin[iBinValMax-i] = i ;
TickTock 44:6262a9fd1e56 560 }
TickTock 44:6262a9fd1e56 561 }
TickTock 44:6262a9fd1e56 562
TickTock 48:d1ce92104a1f 563 // the values, for now
TickTock 48:d1ce92104a1f 564 tt.locate( 0, yWinMax+40 );
TickTock 48:d1ce92104a1f 565 printf(" MAX MIN AVG CVLI T1 T2 T3 T4\n %04d %04d %04d %04d %02dC %02dC %02dC %02dC\n\n",max,min,avg,jv,battData[224+5],battData[224+8],battData[224+11],battData[224+14]);
TickTock 48:d1ce92104a1f 566
TickTock 44:6262a9fd1e56 567 //---------------
TickTock 44:6262a9fd1e56 568 // show the bars
TickTock 44:6262a9fd1e56 569 int nBarWidth = 3 ;
TickTock 44:6262a9fd1e56 570 int nBarSpace = 1 ; // 1 for testing
TickTock 44:6262a9fd1e56 571
TickTock 44:6262a9fd1e56 572 int xPos = (xWinMin + xWinMax) / 2 ;
TickTock 44:6262a9fd1e56 573 xPos -= (avg-min) * (nBarWidth + nBarSpace) ;
TickTock 44:6262a9fd1e56 574
TickTock 44:6262a9fd1e56 575 for( int i=0; i<=iBinValMax; i++) {
TickTock 44:6262a9fd1e56 576 height = 4 * nBin[i] ;
TickTock 44:6262a9fd1e56 577 if( height > 100 ) height = 100 ; // clip tops
TickTock 44:6262a9fd1e56 578
TickTock 44:6262a9fd1e56 579 // if inside the window, draw the bar
TickTock 44:6262a9fd1e56 580 if( ( xPos + nBarWidth < xWinMax ) && ( xPos > xWinMin ) )
TickTock 44:6262a9fd1e56 581 tt.fillrect( xPos,yWinMax-height, xPos+nBarWidth-1,yWinMax, Green);
TickTock 44:6262a9fd1e56 582
TickTock 44:6262a9fd1e56 583 // step to the next bar position
TickTock 44:6262a9fd1e56 584 xPos += nBarWidth + nBarSpace ;
TickTock 44:6262a9fd1e56 585 }
TickTock 44:6262a9fd1e56 586
TickTock 44:6262a9fd1e56 587 showCP=false;
TickTock 44:6262a9fd1e56 588 }
TickTock 44:6262a9fd1e56 589
TickTock 44:6262a9fd1e56 590 // handle the button
TickTock 47:9cc7d876dd6d 591 if(sMode==1&&showButtons){
TickTock 44:6262a9fd1e56 592 tt.foreground(Yellow);
TickTock 44:6262a9fd1e56 593 tt.background(DarkCyan);
TickTock 44:6262a9fd1e56 594 tt.set_font((unsigned char*) Arial12x12);
TickTock 44:6262a9fd1e56 595 sprintf(sTemp1," Request");
TickTock 44:6262a9fd1e56 596 sprintf(sTemp2," CP data");
TickTock 36:dbd39c315258 597 showButton(1,0,sTemp1,sTemp2,3,3);
TickTock 36:dbd39c315258 598 }
TickTock 36:dbd39c315258 599 }
TickTock 36:dbd39c315258 600
TickTock 48:d1ce92104a1f 601 //---------------
TickTock 42:4533b13b297d 602 void config1(bool force, bool showButtons){
TickTock 36:dbd39c315258 603 if (force) {
TickTock 36:dbd39c315258 604 tt.background(Black);
TickTock 36:dbd39c315258 605 tt.cls();
TickTock 36:dbd39c315258 606 }
TickTock 36:dbd39c315258 607 tt.foreground(Yellow);
TickTock 36:dbd39c315258 608 tt.background(DarkCyan);
TickTock 36:dbd39c315258 609 tt.set_font((unsigned char*) Arial12x12);
TickTock 36:dbd39c315258 610 sprintf(sTemp1," Calibrate");
TickTock 36:dbd39c315258 611 sprintf(sTemp2," Touch");
TickTock 36:dbd39c315258 612 showButton(0,0,sTemp1,sTemp2,3,3);
TickTock 36:dbd39c315258 613 sprintf(sTemp1," Reset");
TickTock 36:dbd39c315258 614 sprintf(sTemp2,"");
TickTock 36:dbd39c315258 615 showButton(1,0,sTemp1,sTemp2,3,3);
TickTock 36:dbd39c315258 616 sprintf(sTemp1," Save");
TickTock 36:dbd39c315258 617 sprintf(sTemp2," Config");
TickTock 36:dbd39c315258 618 showButton(2,0,sTemp1,sTemp2,3,3);
TickTock 48:d1ce92104a1f 619
TickTock 48:d1ce92104a1f 620 //------- second row -----
TickTock 36:dbd39c315258 621 if (logEn) {
TickTock 36:dbd39c315258 622 sprintf(sTemp1," Disable");
TickTock 36:dbd39c315258 623 } else {
TickTock 36:dbd39c315258 624 sprintf(sTemp1," Enable");
TickTock 36:dbd39c315258 625 }
TickTock 36:dbd39c315258 626 sprintf(sTemp2," Logging");
TickTock 36:dbd39c315258 627 showButton(0,1,sTemp1,sTemp2,3,3);
TickTock 48:d1ce92104a1f 628
TickTock 36:dbd39c315258 629 if (repeatPoll) {
TickTock 36:dbd39c315258 630 sprintf(sTemp1," Disable");
TickTock 36:dbd39c315258 631 } else {
TickTock 36:dbd39c315258 632 sprintf(sTemp1," Enable");
TickTock 36:dbd39c315258 633 }
TickTock 36:dbd39c315258 634 sprintf(sTemp2," Auto CP");
TickTock 36:dbd39c315258 635 showButton(1,1,sTemp1,sTemp2,3,3);
TickTock 48:d1ce92104a1f 636
TickTock 48:d1ce92104a1f 637 // add Enable/Disable Batt Log gg - yesBattLog
TickTock 48:d1ce92104a1f 638 if (yesBattLog) {
TickTock 48:d1ce92104a1f 639 sprintf(sTemp1," Disable");
TickTock 48:d1ce92104a1f 640 } else {
TickTock 48:d1ce92104a1f 641 sprintf(sTemp1," Enable");
TickTock 48:d1ce92104a1f 642 }
TickTock 48:d1ce92104a1f 643 sprintf(sTemp2," Batt Log");
TickTock 48:d1ce92104a1f 644 showButton(2,1,sTemp1,sTemp2,3,3);
TickTock 36:dbd39c315258 645 }
TickTock 36:dbd39c315258 646
TickTock 42:4533b13b297d 647 void pbScreen(bool force, bool showButtons){
TickTock 36:dbd39c315258 648 if (force) {
TickTock 36:dbd39c315258 649 tt.background(Black);
TickTock 36:dbd39c315258 650 tt.cls();
TickTock 36:dbd39c315258 651 }
TickTock 36:dbd39c315258 652 tt.foreground(Yellow);
TickTock 36:dbd39c315258 653 tt.background(DarkCyan);
TickTock 36:dbd39c315258 654 tt.set_font((unsigned char*) Arial12x12);
TickTock 36:dbd39c315258 655 if(playbackOpen){
TickTock 36:dbd39c315258 656 sprintf(sTemp1,"Slower");
TickTock 36:dbd39c315258 657 sprintf(sTemp2," <--");
TickTock 36:dbd39c315258 658 showButton(0,0,sTemp1,sTemp2,3,3);
TickTock 36:dbd39c315258 659 if(playbackEn){
TickTock 36:dbd39c315258 660 sprintf(sTemp1," Pause");
TickTock 36:dbd39c315258 661 }else{
TickTock 36:dbd39c315258 662 sprintf(sTemp1," Run");
TickTock 36:dbd39c315258 663 }
TickTock 36:dbd39c315258 664 sprintf(sTemp2," %4.3f ",playbackInt);
TickTock 36:dbd39c315258 665 showButton(1,0,sTemp1,sTemp2,3,3);
TickTock 36:dbd39c315258 666 sprintf(sTemp1,"Faster");
TickTock 36:dbd39c315258 667 sprintf(sTemp2," -->");
TickTock 36:dbd39c315258 668 showButton(2,0,sTemp1,sTemp2,3,3);
TickTock 36:dbd39c315258 669 }
TickTock 36:dbd39c315258 670 if(playbackOpen){
TickTock 36:dbd39c315258 671 sprintf(sTemp1," Stop");
TickTock 36:dbd39c315258 672 }else{
TickTock 36:dbd39c315258 673 sprintf(sTemp1," Start");
TickTock 36:dbd39c315258 674 }
TickTock 36:dbd39c315258 675 sprintf(sTemp2,"Playback");
TickTock 36:dbd39c315258 676 showButton(1,1,sTemp1,sTemp2,3,3);
TickTock 36:dbd39c315258 677 }
TickTock 36:dbd39c315258 678
TickTock 42:4533b13b297d 679 void showDateTime(bool force, bool showButtons){
TickTock 36:dbd39c315258 680 struct tm t; // pointer to a static tm structure
TickTock 36:dbd39c315258 681 time_t seconds ;
TickTock 36:dbd39c315258 682 tt.foreground(Yellow);
TickTock 44:6262a9fd1e56 683 tt.background(Black);
TickTock 36:dbd39c315258 684 if (force) {
TickTock 36:dbd39c315258 685 tt.cls();
TickTock 36:dbd39c315258 686 seconds = time(NULL);
TickTock 36:dbd39c315258 687 t = *localtime(&seconds) ;
TickTock 36:dbd39c315258 688
TickTock 36:dbd39c315258 689 tt.locate(10,10);
TickTock 43:e7f6f80590e3 690 tt.set_font((unsigned char*) Arial12x12);
TickTock 36:dbd39c315258 691 strftime(sTemp1, 32, "%a %m/%d/%Y %X \n", &t);
TickTock 36:dbd39c315258 692 printf("%s",sTemp1);
TickTock 42:4533b13b297d 693 if((sMode==1)&&showButtons){
TickTock 36:dbd39c315258 694 sprintf(sTemp2,"");
TickTock 36:dbd39c315258 695 switch(dtMode){
TickTock 36:dbd39c315258 696 case 0:
TickTock 36:dbd39c315258 697 sprintf(sTemp1,"Year");
TickTock 36:dbd39c315258 698 break;
TickTock 36:dbd39c315258 699 case 1:
TickTock 36:dbd39c315258 700 sprintf(sTemp1,"Month");
TickTock 36:dbd39c315258 701 break;
TickTock 36:dbd39c315258 702 case 2:
TickTock 36:dbd39c315258 703 sprintf(sTemp1,"Day");
TickTock 36:dbd39c315258 704 break;
TickTock 36:dbd39c315258 705 case 3:
TickTock 36:dbd39c315258 706 sprintf(sTemp1,"Hour");
TickTock 36:dbd39c315258 707 break;
TickTock 36:dbd39c315258 708 case 4:
TickTock 36:dbd39c315258 709 sprintf(sTemp1,"Minute");
TickTock 36:dbd39c315258 710 break;
TickTock 36:dbd39c315258 711 case 5:
TickTock 36:dbd39c315258 712 sprintf(sTemp1,"Second");
TickTock 36:dbd39c315258 713 break;
TickTock 36:dbd39c315258 714 case 6:
TickTock 36:dbd39c315258 715 sprintf(sTemp1,"Select");
TickTock 36:dbd39c315258 716 break;
TickTock 36:dbd39c315258 717 default:
TickTock 36:dbd39c315258 718 break;
TickTock 36:dbd39c315258 719 }
TickTock 44:6262a9fd1e56 720 tt.background(DarkCyan);
TickTock 36:dbd39c315258 721 showButton(0,1,sTemp1,sTemp2,3,3);
TickTock 36:dbd39c315258 722 sprintf(sTemp1," UP");
TickTock 36:dbd39c315258 723 showButton(1,1,sTemp1,sTemp2,3,3);
TickTock 36:dbd39c315258 724 sprintf(sTemp1," DOWN");
TickTock 36:dbd39c315258 725 showButton(2,1,sTemp1,sTemp2,3,3);
TickTock 36:dbd39c315258 726 }
TickTock 36:dbd39c315258 727 }
TickTock 36:dbd39c315258 728 }
TickTock 36:dbd39c315258 729
TickTock 42:4533b13b297d 730 void dteDisplay(bool force, bool showButtons){
TickTock 49:a3d2c5bb3cfa 731 unsigned short i,x,y,lx,ly;
TickTock 37:fea2c1d52c5f 732 tt.background(Navy);
TickTock 49:a3d2c5bb3cfa 733 tt.foreground(Yellow);
TickTock 49:a3d2c5bb3cfa 734 if(force||updateDTE){
TickTock 49:a3d2c5bb3cfa 735 tt.cls();
TickTock 49:a3d2c5bb3cfa 736 tt.set_font((unsigned char*) Arial12x12);
TickTock 49:a3d2c5bb3cfa 737 for(i=0;i<10;i++){
TickTock 49:a3d2c5bb3cfa 738 y=200-i*20;
TickTock 49:a3d2c5bb3cfa 739 tt.locate(10,y-8);
TickTock 49:a3d2c5bb3cfa 740 printf("%d.0\n",i);
TickTock 49:a3d2c5bb3cfa 741 tt.line(40,y,280,y,LightGrey);
TickTock 49:a3d2c5bb3cfa 742 }
TickTock 49:a3d2c5bb3cfa 743
TickTock 49:a3d2c5bb3cfa 744 x=50+0*6;
TickTock 49:a3d2c5bb3cfa 745 tt.locate(x-8,226);
TickTock 49:a3d2c5bb3cfa 746 printf("sec\n");
TickTock 49:a3d2c5bb3cfa 747 tt.line(x,10,x,220,LightGrey);
TickTock 49:a3d2c5bb3cfa 748 x=50+9*6;
TickTock 49:a3d2c5bb3cfa 749 tt.locate(x-8,226);
TickTock 49:a3d2c5bb3cfa 750 printf("min\n");
TickTock 49:a3d2c5bb3cfa 751 tt.line(x,10,x,220,LightGrey);
TickTock 49:a3d2c5bb3cfa 752 x=50+18*6;
TickTock 49:a3d2c5bb3cfa 753 tt.locate(x-8,226);
TickTock 49:a3d2c5bb3cfa 754 printf("hour\n");
TickTock 49:a3d2c5bb3cfa 755 tt.line(x,10,x,220,LightGrey);
TickTock 49:a3d2c5bb3cfa 756 x=50+25*6;
TickTock 49:a3d2c5bb3cfa 757 tt.locate(x-8,226);
TickTock 49:a3d2c5bb3cfa 758 printf("day\n");
TickTock 49:a3d2c5bb3cfa 759 tt.line(x,10,x,220,LightGrey);
TickTock 49:a3d2c5bb3cfa 760 x=50+32*6;
TickTock 49:a3d2c5bb3cfa 761 tt.locate(x-8,226);
TickTock 49:a3d2c5bb3cfa 762 printf("mon\n");
TickTock 49:a3d2c5bb3cfa 763 tt.line(x,10,x,220,LightGrey);
TickTock 49:a3d2c5bb3cfa 764 x=50+38*6;
TickTock 49:a3d2c5bb3cfa 765 tt.locate(x-8,226);
TickTock 49:a3d2c5bb3cfa 766 printf("year\n");
TickTock 49:a3d2c5bb3cfa 767 tt.line(x,10,x,220,LightGrey);
TickTock 49:a3d2c5bb3cfa 768
TickTock 49:a3d2c5bb3cfa 769 lx=50;
TickTock 49:a3d2c5bb3cfa 770 ly=mpkWh[0]*20;
TickTock 49:a3d2c5bb3cfa 771 if(ly<200) {
TickTock 49:a3d2c5bb3cfa 772 ly=200-ly;
TickTock 49:a3d2c5bb3cfa 773 }else{
TickTock 49:a3d2c5bb3cfa 774 ly=0;
TickTock 49:a3d2c5bb3cfa 775 }
TickTock 49:a3d2c5bb3cfa 776 tt.fillcircle(lx,ly,4,Green);
TickTock 49:a3d2c5bb3cfa 777
TickTock 49:a3d2c5bb3cfa 778 for(i=1;i<39;i++){
TickTock 49:a3d2c5bb3cfa 779 x=50+i*6;
TickTock 49:a3d2c5bb3cfa 780 y=mpkWh[i]*20;
TickTock 49:a3d2c5bb3cfa 781 if(y<200) {
TickTock 49:a3d2c5bb3cfa 782 y=200-y;
TickTock 49:a3d2c5bb3cfa 783 }else{
TickTock 49:a3d2c5bb3cfa 784 y=0;
TickTock 49:a3d2c5bb3cfa 785 }
TickTock 49:a3d2c5bb3cfa 786 tt.circle(x,y,2,Green);
TickTock 49:a3d2c5bb3cfa 787 tt.line(lx,ly,x,y,White);
TickTock 49:a3d2c5bb3cfa 788 lx=x;
TickTock 49:a3d2c5bb3cfa 789 ly=y;
TickTock 49:a3d2c5bb3cfa 790 }
TickTock 49:a3d2c5bb3cfa 791 updateDTE=false;
TickTock 37:fea2c1d52c5f 792 }
TickTock 37:fea2c1d52c5f 793 }
TickTock 37:fea2c1d52c5f 794
TickTock 36:dbd39c315258 795 void updateDisplay(char display){
TickTock 36:dbd39c315258 796 bool changed;
TickTock 36:dbd39c315258 797 changed = dMode[display]!=lastDMode[display];
TickTock 36:dbd39c315258 798 tt.set_display(display);
TickTock 36:dbd39c315258 799 switch (dMode[display]) {
TickTock 36:dbd39c315258 800 case logScreen:
TickTock 42:4533b13b297d 801 printLog(changed,(display==whichTouched));
TickTock 36:dbd39c315258 802 break;
TickTock 41:8d4609ea7259 803 case mainScreen:
TickTock 42:4533b13b297d 804 mainDisplay(changed,(display==whichTouched));
TickTock 36:dbd39c315258 805 break;
TickTock 36:dbd39c315258 806 case brakeScreen:
TickTock 42:4533b13b297d 807 braking(changed,(display==whichTouched));
TickTock 36:dbd39c315258 808 break;
TickTock 41:8d4609ea7259 809 case dteScreen:
TickTock 42:4533b13b297d 810 dteDisplay(changed,(display==whichTouched));
TickTock 37:fea2c1d52c5f 811 break;
TickTock 36:dbd39c315258 812 case monitorScreen:
TickTock 42:4533b13b297d 813 printLast(changed,(display==whichTouched));
TickTock 36:dbd39c315258 814 break;
TickTock 36:dbd39c315258 815 case changedScreen:
TickTock 42:4533b13b297d 816 printChanged(changed,(display==whichTouched));
TickTock 36:dbd39c315258 817 break;
TickTock 36:dbd39c315258 818 case cpScreen:
TickTock 42:4533b13b297d 819 cpData(changed||showCP,(display==whichTouched));
TickTock 36:dbd39c315258 820 break;
TickTock 36:dbd39c315258 821 case config1Screen:
TickTock 42:4533b13b297d 822 config1(changed,(display==whichTouched));
TickTock 36:dbd39c315258 823 break;
TickTock 38:155ec32c5e91 824 case playbackScreen:
TickTock 42:4533b13b297d 825 pbScreen(changed,(display==whichTouched));
TickTock 36:dbd39c315258 826 break;
TickTock 36:dbd39c315258 827 case dateScreen:
TickTock 42:4533b13b297d 828 showDateTime(changed,(display==whichTouched));
TickTock 36:dbd39c315258 829 break;
TickTock 44:6262a9fd1e56 830 case cpHistScreen: // gg - hist
TickTock 47:9cc7d876dd6d 831 cpHistogram(changed||showCP,(display==whichTouched));
TickTock 44:6262a9fd1e56 832 break;
TickTock 48:d1ce92104a1f 833 case cpBarScreen: // gg - cpbars
TickTock 48:d1ce92104a1f 834 cpBarPlot(changed||showCP,(display==whichTouched));
TickTock 48:d1ce92104a1f 835 break;
TickTock 36:dbd39c315258 836 default:
TickTock 43:e7f6f80590e3 837 if (changed){
TickTock 43:e7f6f80590e3 838 tt.background(Black);
TickTock 43:e7f6f80590e3 839 tt.cls();
TickTock 43:e7f6f80590e3 840 }
TickTock 36:dbd39c315258 841 break;
TickTock 36:dbd39c315258 842 }
TickTock 36:dbd39c315258 843 lastDMode[display]=dMode[display];
TickTock 36:dbd39c315258 844
TickTock 42:4533b13b297d 845 if(display==whichTouched){
TickTock 42:4533b13b297d 846 switch (sMode) {
TickTock 42:4533b13b297d 847 case 1: // Select screens
TickTock 42:4533b13b297d 848 tt.foreground(Yellow);
TickTock 42:4533b13b297d 849 tt.background(DarkCyan);
TickTock 42:4533b13b297d 850 tt.set_font((unsigned char*) Arial12x12);
TickTock 42:4533b13b297d 851 sprintf(sTemp1,"<-Prev");
TickTock 42:4533b13b297d 852 sprintf(sTemp2,"");
TickTock 42:4533b13b297d 853 showButton(0,2,sTemp1,sTemp2,3,3);
TickTock 43:e7f6f80590e3 854 sprintf(sTemp1," Next->");
TickTock 42:4533b13b297d 855 showButton(2,2,sTemp1,sTemp2,3,3);
TickTock 43:e7f6f80590e3 856 sprintf(sTemp1," Select");
TickTock 42:4533b13b297d 857 switch (dMode[display]) {
TickTock 44:6262a9fd1e56 858 case offScreen:
TickTock 43:e7f6f80590e3 859 sprintf(sTemp2," Off");
TickTock 42:4533b13b297d 860 break;
TickTock 44:6262a9fd1e56 861 case logScreen:
TickTock 43:e7f6f80590e3 862 sprintf(sTemp2," Log");
TickTock 42:4533b13b297d 863 break;
TickTock 44:6262a9fd1e56 864 case mainScreen:
TickTock 43:e7f6f80590e3 865 sprintf(sTemp2," Main");
TickTock 42:4533b13b297d 866 break;
TickTock 44:6262a9fd1e56 867 case brakeScreen:
TickTock 42:4533b13b297d 868 sprintf(sTemp2," Braking");
TickTock 42:4533b13b297d 869 break;
TickTock 44:6262a9fd1e56 870 case dteScreen:
TickTock 43:e7f6f80590e3 871 sprintf(sTemp2," DTE");
TickTock 42:4533b13b297d 872 break;
TickTock 44:6262a9fd1e56 873 case monitorScreen:
TickTock 43:e7f6f80590e3 874 sprintf(sTemp2," Monitor");
TickTock 42:4533b13b297d 875 break;
TickTock 44:6262a9fd1e56 876 case changedScreen:
TickTock 42:4533b13b297d 877 sprintf(sTemp2,"Delta Mon");
TickTock 42:4533b13b297d 878 break;
TickTock 44:6262a9fd1e56 879 case cpScreen:
TickTock 43:e7f6f80590e3 880 sprintf(sTemp2," Cell Pair");
TickTock 42:4533b13b297d 881 break;
TickTock 44:6262a9fd1e56 882 case config1Screen:
TickTock 43:e7f6f80590e3 883 sprintf(sTemp2," Config");
TickTock 42:4533b13b297d 884 break;
TickTock 44:6262a9fd1e56 885 case playbackScreen:
TickTock 43:e7f6f80590e3 886 sprintf(sTemp2," Playback");
TickTock 42:4533b13b297d 887 break;
TickTock 44:6262a9fd1e56 888 case dateScreen:
TickTock 43:e7f6f80590e3 889 sprintf(sTemp2," Set Time");
TickTock 42:4533b13b297d 890 break;
TickTock 44:6262a9fd1e56 891 case cpHistScreen: // gg - hist
TickTock 44:6262a9fd1e56 892 sprintf(sTemp2," CP Hist");
TickTock 44:6262a9fd1e56 893 break;
TickTock 48:d1ce92104a1f 894 case cpBarScreen: // gg - cpbars
TickTock 48:d1ce92104a1f 895 sprintf(sTemp2," CP Bars");
TickTock 48:d1ce92104a1f 896 break;
TickTock 42:4533b13b297d 897 }
TickTock 42:4533b13b297d 898 showButton(1,2,sTemp1,sTemp2,3,3);
TickTock 42:4533b13b297d 899 wait_ms(100); // pause a moment to reduce flicker
TickTock 42:4533b13b297d 900 break;
TickTock 42:4533b13b297d 901 case 2: // numpad
TickTock 42:4533b13b297d 902 sprintf(sTemp2,"");
TickTock 42:4533b13b297d 903 tt.foreground(Yellow);
TickTock 42:4533b13b297d 904 tt.background(DarkCyan);
TickTock 42:4533b13b297d 905 tt.set_font((unsigned char*) Arial24x23);
TickTock 42:4533b13b297d 906 sprintf(sTemp1," 1");
TickTock 42:4533b13b297d 907 showButton(0,0,sTemp1,sTemp2,4,4);
TickTock 42:4533b13b297d 908 sprintf(sTemp1," 2");
TickTock 42:4533b13b297d 909 showButton(1,0,sTemp1,sTemp2,4,4);
TickTock 42:4533b13b297d 910 sprintf(sTemp1," 3");
TickTock 42:4533b13b297d 911 showButton(2,0,sTemp1,sTemp2,4,4);
TickTock 42:4533b13b297d 912 sprintf(sTemp1," 4");
TickTock 42:4533b13b297d 913 showButton(0,1,sTemp1,sTemp2,4,4);
TickTock 42:4533b13b297d 914 sprintf(sTemp1," 5");
TickTock 42:4533b13b297d 915 showButton(1,1,sTemp1,sTemp2,4,4);
TickTock 42:4533b13b297d 916 sprintf(sTemp1," 6");
TickTock 42:4533b13b297d 917 showButton(2,1,sTemp1,sTemp2,4,4);
TickTock 42:4533b13b297d 918 sprintf(sTemp1," 7");
TickTock 42:4533b13b297d 919 showButton(0,2,sTemp1,sTemp2,4,4);
TickTock 42:4533b13b297d 920 sprintf(sTemp1," 8");
TickTock 42:4533b13b297d 921 showButton(1,2,sTemp1,sTemp2,4,4);
TickTock 42:4533b13b297d 922 sprintf(sTemp1," 9");
TickTock 42:4533b13b297d 923 showButton(2,2,sTemp1,sTemp2,4,4);
TickTock 42:4533b13b297d 924 sprintf(sTemp1," 0");
TickTock 42:4533b13b297d 925 showButton(1,3,sTemp1,sTemp2,4,4);
TickTock 42:4533b13b297d 926 sprintf(sTemp1,"<--");
TickTock 42:4533b13b297d 927 showButton(0,3,sTemp1,sTemp2,4,4);
TickTock 42:4533b13b297d 928 sprintf(sTemp1,"-->");
TickTock 42:4533b13b297d 929 showButton(2,3,sTemp1,sTemp2,4,4);
TickTock 42:4533b13b297d 930 sprintf(sTemp1,"return");
TickTock 42:4533b13b297d 931 showButton(3,3,sTemp1,sTemp2,4,4);
TickTock 42:4533b13b297d 932 case 3:
TickTock 42:4533b13b297d 933 break;
TickTock 42:4533b13b297d 934 default:
TickTock 42:4533b13b297d 935 break;
TickTock 42:4533b13b297d 936 }
TickTock 36:dbd39c315258 937 }
TickTock 36:dbd39c315258 938 }
TickTock 36:dbd39c315258 939
TickTock 36:dbd39c315258 940 void showButton(unsigned char column, unsigned char row, char * text1, char * text2, unsigned char columns, unsigned char rows){
TickTock 36:dbd39c315258 941 unsigned short x1,x2,y1,y2;
TickTock 36:dbd39c315258 942 x1=column*(320/columns)+btnGap/2;
TickTock 36:dbd39c315258 943 x2=(column+1)*(320/columns)-btnGap/2;
TickTock 36:dbd39c315258 944 y1=row*(240/rows)+btnGap/2;
TickTock 36:dbd39c315258 945 y2=(row+1)*(240/rows)-btnGap/2;
TickTock 36:dbd39c315258 946 tt.fillrect(x1,y1,x2,y2,DarkCyan);
TickTock 36:dbd39c315258 947 tt.locate(x1+btnGap,y1+btnGap);
TickTock 36:dbd39c315258 948 printf("%s\n",text1);
TickTock 36:dbd39c315258 949 tt.locate(x1+btnGap,y1+btnGap+30);
TickTock 36:dbd39c315258 950 printf("%s\n",text2);
TickTock 36:dbd39c315258 951 }
TickTock 41:8d4609ea7259 952 // below is braking screen normalized to power rather than force
TickTock 41:8d4609ea7259 953 // changed to force since power had too large a dynamic range
TickTock 42:4533b13b297d 954 /*void braking (bool force, bool showButtons, bool prdata=false){
TickTock 23:cd03f9c3395e 955 unsigned long targetBraking, regenBraking, speed;
TickTock 27:6bd073c33977 956 static unsigned long maxTarget = 20000, maxRegen = 20000, tarDivReg = 1000;
TickTock 13:62e0f7f39ff5 957 short rpm;
TickTock 13:62e0f7f39ff5 958 unsigned long temp;
TickTock 13:62e0f7f39ff5 959 static unsigned char lastPressure[4] = {200,200,200,200};
TickTock 13:62e0f7f39ff5 960 unsigned char i,r,t;
TickTock 13:62e0f7f39ff5 961 static unsigned char lr, lt;
TickTock 13:62e0f7f39ff5 962 CANMessage msg;
TickTock 13:62e0f7f39ff5 963
TickTock 13:62e0f7f39ff5 964 msg = lastMsg[indexLastMsg[0x1cb]]; //Get Target and Regen
TickTock 13:62e0f7f39ff5 965 regenBraking = (msg.data[0]<<3)+(msg.data[1]>>5);
TickTock 13:62e0f7f39ff5 966 targetBraking = (msg.data[2]<<3)+(msg.data[3]>>5);
TickTock 13:62e0f7f39ff5 967 msg = lastMsg[indexLastMsg[0x176]]; //Get rpms - not sure what this is but scales to mph with .0725
TickTock 13:62e0f7f39ff5 968 rpm = ((short)msg.data[0]<<8)+msg.data[1];
TickTock 13:62e0f7f39ff5 969 speed =rpm>0?rpm>>3:-rpm>>3; //Take absolute to get speed; div8
TickTock 23:cd03f9c3395e 970 if ((targetBraking>2039)||(speed>200)) { //Filter weird messages
TickTock 23:cd03f9c3395e 971 targetBraking = 0;
TickTock 23:cd03f9c3395e 972 regenBraking = 0;
TickTock 23:cd03f9c3395e 973 } else {
TickTock 23:cd03f9c3395e 974 if ((targetBraking>50)&&(regenBraking>50)){
TickTock 23:cd03f9c3395e 975 temp = targetBraking;
TickTock 23:cd03f9c3395e 976 temp *= 1000;
TickTock 23:cd03f9c3395e 977 temp /= regenBraking;
TickTock 23:cd03f9c3395e 978 if (temp<tarDivReg) tarDivReg=temp;
TickTock 23:cd03f9c3395e 979 }
TickTock 23:cd03f9c3395e 980 targetBraking *= speed;
TickTock 23:cd03f9c3395e 981 regenBraking *= speed;
TickTock 23:cd03f9c3395e 982 if (targetBraking>maxTarget) maxTarget=targetBraking;
TickTock 23:cd03f9c3395e 983 if (regenBraking>maxRegen) maxRegen=regenBraking;
TickTock 23:cd03f9c3395e 984 }
TickTock 23:cd03f9c3395e 985
TickTock 13:62e0f7f39ff5 986 msg = lastMsg[indexLastMsg[0x1ca]]; //Get brake pressure
TickTock 13:62e0f7f39ff5 987 tt.background(Navy);
TickTock 13:62e0f7f39ff5 988 if (force) {
TickTock 13:62e0f7f39ff5 989 tt.cls();
TickTock 13:62e0f7f39ff5 990 tt.rect(0,111,170,239,White);
TickTock 13:62e0f7f39ff5 991 tt.line(0,207,170,207,White);
TickTock 13:62e0f7f39ff5 992 tt.line(0,175,170,175,White);
TickTock 13:62e0f7f39ff5 993 tt.line(0,143,170,143,White);
TickTock 13:62e0f7f39ff5 994 lastPressure[0] = 200;
TickTock 13:62e0f7f39ff5 995 lastPressure[1] = 200;
TickTock 13:62e0f7f39ff5 996 lastPressure[2] = 200;
TickTock 13:62e0f7f39ff5 997 lastPressure[3] = 200;
TickTock 13:62e0f7f39ff5 998 }
TickTock 13:62e0f7f39ff5 999 // plot bar graph for each wheel pressure
TickTock 13:62e0f7f39ff5 1000 for (i=0; i<4; i++){
TickTock 13:62e0f7f39ff5 1001 if (msg.data[i]<239) {
TickTock 13:62e0f7f39ff5 1002 if (msg.data[i]>lastPressure[i]){
TickTock 13:62e0f7f39ff5 1003 tt.fillrect(10+40*i,239-msg.data[i],40+40*i,239,Red);
TickTock 13:62e0f7f39ff5 1004 } else if (msg.data[i]<lastPressure[i]) {
TickTock 13:62e0f7f39ff5 1005 tt.fillrect(10+40*i,238-lastPressure[i],40+40*i,238-msg.data[i],Navy);
TickTock 13:62e0f7f39ff5 1006 }
TickTock 13:62e0f7f39ff5 1007 lastPressure[i]=msg.data[i];
TickTock 13:62e0f7f39ff5 1008 }
TickTock 13:62e0f7f39ff5 1009 }
TickTock 13:62e0f7f39ff5 1010
TickTock 27:6bd073c33977 1011 temp = targetBraking;
TickTock 27:6bd073c33977 1012 temp *=200;
TickTock 27:6bd073c33977 1013 temp /= maxTarget;
TickTock 27:6bd073c33977 1014 t = (char) temp;
TickTock 27:6bd073c33977 1015 if (t>200) t=200;
TickTock 27:6bd073c33977 1016 temp = regenBraking;
TickTock 27:6bd073c33977 1017 temp *= tarDivReg;
TickTock 27:6bd073c33977 1018 temp /= maxTarget;
TickTock 27:6bd073c33977 1019 temp /= 5;
TickTock 27:6bd073c33977 1020 r = (char) temp;
TickTock 27:6bd073c33977 1021 if (r>200) r=200;
TickTock 27:6bd073c33977 1022 if(lr!=r&&prdata){
TickTock 27:6bd073c33977 1023 tt.foreground(Yellow);
TickTock 27:6bd073c33977 1024 tt.set_font((unsigned char*) Arial28x28);
TickTock 27:6bd073c33977 1025 tt.locate(100,40);
TickTock 27:6bd073c33977 1026 printf("%d %d \n",regenBraking,maxRegen);
TickTock 27:6bd073c33977 1027 tt.locate(100,70);
TickTock 27:6bd073c33977 1028 printf("%3.1f (%3.1f%s) \n",(float)tarDivReg/10,(float)regenBraking*tarDivReg/targetBraking/10,"%");
TickTock 27:6bd073c33977 1029 }
TickTock 27:6bd073c33977 1030 if(lt!=t&&prdata){
TickTock 27:6bd073c33977 1031 tt.foreground(Yellow);
TickTock 27:6bd073c33977 1032 tt.set_font((unsigned char*) Arial28x28);
TickTock 27:6bd073c33977 1033 tt.locate(100,10);
TickTock 27:6bd073c33977 1034 printf("%d %d \n",targetBraking,maxTarget);
TickTock 13:62e0f7f39ff5 1035 }
TickTock 27:6bd073c33977 1036 if (r>t) t=r; //Should never happen
TickTock 27:6bd073c33977 1037 if((lr!=r||lt!=t)&&!prdata){
TickTock 27:6bd073c33977 1038 tt.fillrect(200,10,300,239-t,Navy);
TickTock 27:6bd073c33977 1039 tt.fillrect(200,239-t,300,239-r,Red);
TickTock 27:6bd073c33977 1040 tt.fillrect(200,239-r,300,239,Green);
TickTock 27:6bd073c33977 1041 }
TickTock 27:6bd073c33977 1042 lt=t;
TickTock 27:6bd073c33977 1043 lr=r;
TickTock 36:dbd39c315258 1044 }*/