Dual CANbus monitor and instrumentation cluster. Presently tuned for the Nissan Leaf EV.

Dependencies:   SPI_TFTx2_ILI9341 TFT_fonts TOUCH_TFTx2_ILI9341 mbed

Fork of CANary_corrupt by Tick Tock

After adding the LPC1768 platform, import as a program and do not select the "update to latest revision" box

User Guide

Eagle Schematic and Board design

/media/uploads/TickTock/canaryr6.zip

/media/uploads/TickTock/canary_sch.jpg

/media/uploads/TickTock/canaryr6brd.jpg

For LCD Rev 1.01:

/media/uploads/TickTock/lcdsch.jpg

For VCD Rev 2.00:

/media/uploads/TickTock/lcdr2.jpg

Parts List

qtyinstancepart #packagesupplierDescription
1BAT3Vhttp://www.ebay.com/itm/10x-CR2032-SMD-Battery-Holder-for-CR2032-Battery-/180938057979?pt=LH_DefaultDomain_0&hash=item2a20bfa8fbLithium 2032 coin battery holder
4C1-C4ECST1DC106R6032Tantalium capacitor 10uF
3FC1-FC3ZF1-20-01-T-WThttp://www.samtec.com/cable-systems/idc-ffc/ffc/zero-insertion.aspx20 conductor 1mm pitch flex cable connector (optional)
1FJ-20-R-08.00-4http://www.samtec.com/cable-systems/idc-ffc/ffc/zero-insertion.aspx8\" 20 conductor 1mm pitch flex connector, end reversed (optional)
2H1-H4(DON'T populate H1-H4 headers - solder mbed directly)
1H5http://www.ebay.com/itm/221186042943?ssPageName=STRK:MEWNX:IT&_trksid=p3984.m1497.l26491x12 .1\" pitch header (optional)
1H62x6 .1\" pitch header (optional)
2IC1,IC2VP230LMDSOP8http://www.ebay.com/itm/130488665247?ssPageName=STRK:MEWNX:IT&_trksid=p3984.m1497.l2649canbus transciever
1IC3LM1117-5VSOT2235V regulator
5JP*2 pin .1\" jumper header
1mbedLPC1768http://www.ebay.com/itm/200830573509?ssPageName=STRK:MEWNX:IT&_trksid=p3984.m1497.l2649mbed uC
2Q1,Q22N2222SOT23General purpose NPN transistor
1R1R393M120639K resistor
1R2R103M120610K resistor
4R4-R6R102M12061K resistor
1R3R500M120650 Ohm resistor
2TR1-TR5ZJYS81R5-2PL51TG01http://www.digikey.com/product-detail/en/ZJYS81R5-2PL51T-G01/445-2223-1-ND/765232CM Choke
1Z11N5340BGC1702-15http://www.ebay.com/itm/150878122425?ssPageName=STRK:MEWNX:IT&_trksid=p3984.m1497.l26496V, 5W Zener Diode
1Z1DC-DC conveterhttp://www.ebay.com/itm/251142727849?ssPageName=STRK:MEWNX:IT&_trksid=p3984.m1497.l264912V-7V, 3W DC-DC converter
1X1USBhttp://www.ebay.com/itm/New-Vertical-USB-2-0-A-pcb-connector-socket-USB-A-Type-/300553895292?pt=LH_DefaultDomain_0&hash=item45fa687d7cvertical USB connector
2LCD0,LCD1TFThttp://www.mikroe.com/add-on-boards/display/tft-proto/320x240 LCD with touch screen
1E0Enclosurehttp://www.shapeways.com/model/1077799/canary.html?li=user-profile&materialId=63d printed enclosure

Assembly

1) LCD Displays

I found ribbon cable is a nice way to organize the wires to the displays. There are two versions of the display and each must be wired differently. The original project used HW REV. 1.01. For that version, you'll need 12 conductors and I connected them in the following order:

1LED+
2LED-
3RST
4SDI
5WR/SCLK
6CS
7X+
8X-
9Y+
10Y-
11VDD
12GND

If, instead, you have HW REV 2.0, you will need 13 conductors with the following order:

1LED+
2LED-
3RST
4SDI
5RS (SCLK)
6WR (DC)
7CS
8X+
9X-
10Y+
11Y-
12VDD
13GND

First I connected all the GND connections (2 GND & IM0, IM1, IM3 for REV1.01 or 2 GND, RD, & IM0 for REV2.00). Do not connect the bottom GND until you have the ribbon cable connected. After making all the ribbon cable connections (connecting the GND of the ribbon cable to the bottom GND pad), solder the GND bar from the previous step to the back of the bottom GND connection. Finally, make a connection from the back side 3.3V pin to IM2 for REV1.01 or to IM1,IM2,&IM3 for REV2.00. Take a break and repeat for the second display.

Examples of REV1.01 boards:

/media/uploads/TickTock/lcdtop.jpg /media/uploads/TickTock/lcdbot.jpg

Examples of REV2.00:

/media/uploads/TickTock/rev2front.jpg /media/uploads/TickTock/rev2back.jpg

Once the two displays are complete combine all wires except CS0, CS1, X+, X-, Y+, and Y-. Connect X- of the left display to X+ of the right. Similarly connect Y- of the left display to Y+ of the right. Insulate any exposed wires.

2) PCB

Refer to the schematics to place all the components on the board. If you plan to install into the CANary 3D enclosure, DO NOT install the battery holder or the socket for the mbed and, instead, connect two wires to the VB and GND pads nearby. You will have to install the battery holder against the back wall to avoid interfering with the right-hand display and the mbed will have to be directly soldered. I have not found a socket with a low enough profile to fit in the space provided (depth of enclosure is limited by the space behind the center console). Also, I recommend keeping as much lead as possible on the Zener diode (bending it as shown to clear the back wall). Although it is operating well within parameters, the Zener gets quite hot during extended operation and the leads help dissipate the heat and keep it away from the PCB and other components.Update: Several Zeners have failed resulting in damage to some users boards so I recommend using a DC-DC converter instead to bring the 12V down to 7V.

/media/uploads/TickTock/pcbtop.jpg /media/uploads/TickTock/pcbbot.jpg

Once the PCB is populated, solder the LCDs to the PCB. CS0 connects to the right display and CS1 connects to the left. /media/uploads/TickTock/brddis.jpg

Update: The Zener diodes tended to fail after a few months so I am recommending removing them and replacing with a DC-DC converter. This will run cooler and waste less energy, too. To install, remove the left display panel to gain access to the Zener. From there, the Zener can be removed and it's pads used to connect to the DC-DC converter. I recommend setting the output voltage on the bench before installing since the trim pot is tricky to reach once installed. Set it to 7V. The input can be connected to the left pad previously occupied by the zener and the output can connect to the right. GND(-) can be connected to the bottom right pad on the 2x6 header below the flex cable connector. Make sure the GND wire lies flat so it doesn't interfere with the connection of the flex cable. /media/uploads/TickTock/dcdcinst2.jpg

Once soldered in place, the DC-DC converter can easily be mounted to the back wall with double sided tape above the battery holder. /media/uploads/TickTock/dcdcinst3.jpg

3) Testing

1)First step is to buzz out all connections from the LCDs to the pins in the main board
2)Next check the touch screen connections. On the main board, place an Ohm meter across X+ and X-. You should read 700 Ohms. Repeat for Y+ and Y-. Then test the resistance from X+ to Y+. With nothing touching the screens, it should read >100K Ohms and <1K when touching either screen.
3)When all connections are checked, solder in the mbed. Download and install the touch2 program http://mbed.org/users/TickTock/code/touch2/ to test the basic operation of the mbed and touch screens.
tips:
Touch screen is sensitive - excess flux on X+,X-,Y+,Y- connection on mbed can result in flakey operation
If touch is not working, double-check the LCD0_CS and LCD1_CS are not swapped. LCD0_CS must connect to the CS of the LCD that has X- & Y- connected to the mbed. LCD1_CS must connect to the CS of the LCD that has X+ & Y+ connected to the mbed.
4)Once touch2 works, it is time to connect to the OBD connector. I highly recommend double checking all connections from the OBD to the PCB with the cable in place before connecting to the Leaf. Buzz out all the pins in the OBS to make sure none are shorting to each other, Check that the 12V goes to the Zener (and nothing else) and the switched 12V to the resistor divider (and nothing else). Test the ground connection properly connects to ground and nothing else.
5)Once you are confident there are no shorts or wrong connections from the OBD connector, take a deep breath and plug it into your leaf. Touch2 program should come up and function. Unplug and install the latest CANary firmware. If you have the REV2.00 LCD boards, you will need to edit the precompile.h file in the TOUCH_TFTx2_w9341 library and set USE_ILI9341 to 1. Test all features before installing into the enclosure (gids, cellpair, menu system, logging) since installing and removing from the enclosure is a PITA.

/media/uploads/TickTock/pcbdone.jpg /media/uploads/TickTock/functioning.jpg

4) Enclosure

The 3D printer leaves a lot of powder behind - I used a strong spray of water to get it out of all the cracks. The enclosure comes with a rather rough finish. I recommend convincing yourself you like it, then simply lightly sand then paint before assembly. Sanding is very difficult - the nylon is very nicely fused and doesn't want to sand. I tried sandblasting and that didn't work either. I had some limited success with filler and then sanding, but only on the outside - it is too difficult to sand the face. /media/uploads/TickTock/enclosure.jpg

5) Final Assembly

Make sure you are well rested with lots of patience before attempting assembly. It is a puzzle figuring out how to get both displays and the PCB in place. Enclosure was too expensive for me to keep iterating to optimize for assembly. I ended up snipping the thin display posts shorter and using various tools to push the displays into place. Also, some USB connectors are taller than others. If you have one of the taller ones, you will have to deflect the back wall a bit while inserting the PCB (being careful not to bend the housing) to get it to it's opening in the back wall. Do use a screw in the provided post to secure the PCB as USB insertion will otherwise dislodge it.

I added an additional safety line which wraps around the center post to prevent the enclosure from becoming a projectile in the event of an accident. /media/uploads/TickTock/safety.jpg Installed: /media/uploads/TickTock/installed.jpg

Committer:
leafman
Date:
Mon Jun 10 12:00:48 2013 +0000
Branch:
Metric
Revision:
98:9f8bab96edff
Parent:
96:a6c6a6fd1d28
Child:
99:c05abf8e1cdc
Metric Initial Commit

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 92:935adef49ea4 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);
garygid 54:6ce808d0995e 22
garygid 54:6ce808d0995e 23 showButton(0,0," <up>","",4,4);
garygid 54:6ce808d0995e 24 showButton(2,0,"<down>","",4,4);
TickTock 25:ddf0ec209f03 25 }
TickTock 13:62e0f7f39ff5 26 }
TickTock 13:62e0f7f39ff5 27
TickTock 42:4533b13b297d 28 void printChanged (bool force, bool showButtons){
TickTock 13:62e0f7f39ff5 29 CANMessage msg;
TickTock 13:62e0f7f39ff5 30 unsigned char i,j;
TickTock 13:62e0f7f39ff5 31 tt.locate(0,6);
TickTock 13:62e0f7f39ff5 32 tt.foreground(Red);
TickTock 13:62e0f7f39ff5 33 tt.background(Yellow);
TickTock 13:62e0f7f39ff5 34 if(force) tt.cls(); // Just clear screen if forced - always update display
TickTock 13:62e0f7f39ff5 35 tt.set_font((unsigned char*) Arial12x12_prop); // select the font
TickTock 13:62e0f7f39ff5 36 i=0;
TickTock 13:62e0f7f39ff5 37 j=indexOffset;
TickTock 13:62e0f7f39ff5 38 do{
TickTock 13:62e0f7f39ff5 39 j=j<99?j+1:j;
TickTock 13:62e0f7f39ff5 40 if(msgChanged[j]>0){
TickTock 13:62e0f7f39ff5 41 msg = lastMsg[j];
TickTock 13:62e0f7f39ff5 42 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 92:935adef49ea4 43 i++;
TickTock 13:62e0f7f39ff5 44 }// if changed
TickTock 13:62e0f7f39ff5 45 }while(i<19&&j<99);
TickTock 42:4533b13b297d 46 if((sMode==1)&&showButtons){
TickTock 40:0e6e71a7323f 47 tt.foreground(Yellow);
TickTock 40:0e6e71a7323f 48 tt.background(DarkCyan);
TickTock 40:0e6e71a7323f 49 tt.set_font((unsigned char*) Arial12x12);
garygid 54:6ce808d0995e 50
garygid 54:6ce808d0995e 51 showButton(0,0," <up>","",4,4);
garygid 54:6ce808d0995e 52 showButton(2,0," <down>","",4,4);
garygid 54:6ce808d0995e 53 showButton(1,0," Reset","Baseline",4,4);
TickTock 40:0e6e71a7323f 54 }
TickTock 13:62e0f7f39ff5 55 }
TickTock 13:62e0f7f39ff5 56
TickTock 42:4533b13b297d 57 void printLog (bool force, bool showButtons){
TickTock 13:62e0f7f39ff5 58 static unsigned char lastDisplayLoc = 0;
TickTock 13:62e0f7f39ff5 59 if(force||displayLoc!=lastDisplayLoc){ //only update if changed
TickTock 13:62e0f7f39ff5 60 tt.foreground(Amber);
TickTock 13:62e0f7f39ff5 61 tt.background(Black);
TickTock 13:62e0f7f39ff5 62 tt.cls();
TickTock 13:62e0f7f39ff5 63 tt.locate(0,6);
TickTock 13:62e0f7f39ff5 64 tt.set_font((unsigned char*) Arial12x12);
TickTock 92:935adef49ea4 65 for(int i=0; i<19; i++){
TickTock 13:62e0f7f39ff5 66 printf("%s",displayLog[displayLoc]);
TickTock 13:62e0f7f39ff5 67 displayLoc=displayLoc>17?0:displayLoc+1;
TickTock 13:62e0f7f39ff5 68 }
TickTock 13:62e0f7f39ff5 69 }
TickTock 13:62e0f7f39ff5 70 lastDisplayLoc=displayLoc;
TickTock 13:62e0f7f39ff5 71 }
TickTock 13:62e0f7f39ff5 72
TickTock 42:4533b13b297d 73 void mainDisplay (bool force, bool showButtons){
TickTock 13:62e0f7f39ff5 74 unsigned short gids, SOC, packV;
TickTock 96:a6c6a6fd1d28 75 static unsigned short lgids=0, lSOC=0, lpackV=0, maxPS=0;
TickTock 96:a6c6a6fd1d28 76 static unsigned char lbattTemp_x4=0;
TickTock 49:a3d2c5bb3cfa 77 static float lkW=0, laccV=0, lmpkWh=0;
TickTock 13:62e0f7f39ff5 78 CANMessage msg;
TickTock 13:62e0f7f39ff5 79
TickTock 13:62e0f7f39ff5 80 msg = lastMsg[indexLastMsg[0x5bc]]; //Get gids
TickTock 13:62e0f7f39ff5 81 gids = (msg.data[0]<<2)+(msg.data[1]>>6);
TickTock 13:62e0f7f39ff5 82 msg = lastMsg[indexLastMsg[0x55b]]; //Get SOC
TickTock 13:62e0f7f39ff5 83 SOC = (msg.data[0]<<2)+(msg.data[1]>>6);
TickTock 13:62e0f7f39ff5 84 msg = lastMsg[indexLastMsg[0x1db]]; //Get pack volts
TickTock 13:62e0f7f39ff5 85 packV = (msg.data[2]<<2)+(msg.data[3]>>6);
TickTock 13:62e0f7f39ff5 86
TickTock 13:62e0f7f39ff5 87 tt.background(Navy);
TickTock 38:155ec32c5e91 88 tt.foreground(Yellow);
TickTock 38:155ec32c5e91 89 tt.set_font((unsigned char*) Arial28x28);
TickTock 13:62e0f7f39ff5 90 if(force) tt.cls();
TickTock 48:d1ce92104a1f 91 if(skin==ttSkin){
TickTock 50:83d5864c64a0 92 if(force||gids!=lgids||mpkWh[dtePeriod]!=lmpkWh){
TickTock 48:d1ce92104a1f 93 tt.locate(10,10);
TickTock 48:d1ce92104a1f 94 printf("%4d gids \n",gids);
TickTock 73:62ee8eae3a84 95 if(debugMode){
TickTock 73:62ee8eae3a84 96 if(pointerSep>maxPS){maxPS=pointerSep;}
TickTock 73:62ee8eae3a84 97 tt.locate(10,70);
TickTock 73:62ee8eae3a84 98 printf("%3d sep %3d max\n",pointerSep,maxPS);
TickTock 73:62ee8eae3a84 99 }
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);
leafman 98:9f8bab96edff 104 tt.locate(60,96);
leafman 98:9f8bab96edff 105 printf("%4.1f %s \n",convertDistance(mpkWh[dtePeriod]*((float)(gids-5)*.075)),distanceUnit()); //LM - add metric conversion
TickTock 48:d1ce92104a1f 106 lgids=gids;
TickTock 50:83d5864c64a0 107 lmpkWh=mpkWh[dtePeriod];
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 96:a6c6a6fd1d28 121 if(force||battTemp_x4!=lbattTemp_x4){
TickTock 95:248b3c25a7df 122 tt.locate(200,170);
leafman 98:9f8bab96edff 123 printf("%4.1f%s\n",convertTemperature((float)battTemp_x4*0.25f),temperatureUnit());
TickTock 95:248b3c25a7df 124 lbattTemp_x4=battTemp_x4;
TickTock 95:248b3c25a7df 125 }
TickTock 48:d1ce92104a1f 126 if(force||accV!=laccV){
TickTock 48:d1ce92104a1f 127 tt.locate(20,200);
TickTock 48:d1ce92104a1f 128 printf("%3.1fV \n",accV);
TickTock 48:d1ce92104a1f 129 laccV=accV;
TickTock 48:d1ce92104a1f 130 }
TickTock 49:a3d2c5bb3cfa 131 if(force||kW[0]!=lkW){
TickTock 48:d1ce92104a1f 132 tt.locate(180,40);
TickTock 49:a3d2c5bb3cfa 133 printf("%3.2fkW \n",kW[0]);
TickTock 49:a3d2c5bb3cfa 134 //printf("%3.1f mpkWh \n",mpkWh[0]);
TickTock 49:a3d2c5bb3cfa 135 lkW=kW[0];
TickTock 48:d1ce92104a1f 136 }
TickTock 48:d1ce92104a1f 137 }else {//if(skin==ggSkin){
TickTock 48:d1ce92104a1f 138 if(force||gids!=lgids){
TickTock 48:d1ce92104a1f 139 tt.locate(10,10);
TickTock 48:d1ce92104a1f 140 printf("%4d GIDs \n",gids);
TickTock 48:d1ce92104a1f 141
TickTock 48:d1ce92104a1f 142 tt.locate(40,40); // gg - add GIDs Percent of 281
TickTock 48:d1ce92104a1f 143 printf("%4.1f%s \n", (float)gids*0.355872, "% ") ;
TickTock 48:d1ce92104a1f 144 tt.locate(20,70);
TickTock 48:d1ce92104a1f 145 //printf("%4.1f kWh \n",(float)gids*0.08); // is input, not usable
TickTock 48:d1ce92104a1f 146 printf("%4.1f kwh \n",(float)gids*0.075); // gg - closer to usable
TickTock 48:d1ce92104a1f 147
TickTock 48:d1ce92104a1f 148 tt.set_font((unsigned char*) SCProSB31x55);
TickTock 48:d1ce92104a1f 149 tt.foreground(Green);
TickTock 48:d1ce92104a1f 150 //tt.locate(60,96);
TickTock 48:d1ce92104a1f 151 tt.locate(60,116); // gg - move down a little
leafman 98:9f8bab96edff 152 printf("%4.1f %s \n",convertDistance((float)(gids-5)*0.31),distanceUnit()); // Approx for now - LM added metric
TickTock 48:d1ce92104a1f 153 lgids=gids;
TickTock 48:d1ce92104a1f 154 tt.foreground(Yellow);
TickTock 48:d1ce92104a1f 155 tt.set_font((unsigned char*) Arial28x28);
TickTock 48:d1ce92104a1f 156 }
TickTock 48:d1ce92104a1f 157
TickTock 48:d1ce92104a1f 158 if(force||SOC!=lSOC){
TickTock 48:d1ce92104a1f 159 tt.locate(200,10);
TickTock 48:d1ce92104a1f 160 printf("%4.1f%s\n",(float)SOC/10,"% ");
TickTock 48:d1ce92104a1f 161 lSOC=SOC;
TickTock 48:d1ce92104a1f 162 }
TickTock 48:d1ce92104a1f 163 if(force||packV!=lpackV){
TickTock 48:d1ce92104a1f 164 tt.locate(200,200);
TickTock 48:d1ce92104a1f 165 printf("%4.1fV \n",(float)packV/2);
TickTock 48:d1ce92104a1f 166 lpackV=packV;
TickTock 48:d1ce92104a1f 167 }
TickTock 48:d1ce92104a1f 168 if(force||accV!=laccV){
TickTock 48:d1ce92104a1f 169 tt.locate(20,200);
TickTock 48:d1ce92104a1f 170 printf("%3.1fV \n",accV);
TickTock 48:d1ce92104a1f 171 laccV=accV;
TickTock 48:d1ce92104a1f 172 }
TickTock 49:a3d2c5bb3cfa 173 if(force||kW[0]!=lkW){
TickTock 48:d1ce92104a1f 174 tt.locate(160,40); // gg - move left to keep from wrap
TickTock 49:a3d2c5bb3cfa 175 printf("%3.2fkw \n",kW[0]); // use small w to save space
TickTock 49:a3d2c5bb3cfa 176 lkW=kW[0];
TickTock 48:d1ce92104a1f 177 }
TickTock 35:5acbd8a64a89 178 }
TickTock 13:62e0f7f39ff5 179 }
TickTock 13:62e0f7f39ff5 180
TickTock 42:4533b13b297d 181 void braking (bool force, bool showButtons, bool prdata=false){
TickTock 28:f24ac05645d9 182 unsigned long targetBraking, regenBraking;
TickTock 73:62ee8eae3a84 183 static unsigned long maxTarget = 1000, maxRegen = 1000, tardivreg_x1000 = 1000;
TickTock 28:f24ac05645d9 184 unsigned long temp;
TickTock 28:f24ac05645d9 185 static unsigned char lastPressure[4] = {200,200,200,200};
TickTock 28:f24ac05645d9 186 unsigned char i,r,t;
TickTock 37:fea2c1d52c5f 187 static unsigned char lr=0, lt=0;
TickTock 37:fea2c1d52c5f 188 signed short steering;
TickTock 37:fea2c1d52c5f 189 unsigned short s;
TickTock 37:fea2c1d52c5f 190 static unsigned short ls;
TickTock 37:fea2c1d52c5f 191 unsigned char throttle;
TickTock 37:fea2c1d52c5f 192 static unsigned char lthrottle;
TickTock 48:d1ce92104a1f 193 short steerOutBounds = 0 ;
TickTock 28:f24ac05645d9 194 CANMessage msg;
TickTock 28:f24ac05645d9 195
TickTock 48:d1ce92104a1f 196 //---------------
TickTock 37:fea2c1d52c5f 197 msg = lastMsg[indexLastMsg[0x180]]; //Get Throttle position
TickTock 37:fea2c1d52c5f 198 throttle = msg.data[5];
TickTock 48:d1ce92104a1f 199
TickTock 48:d1ce92104a1f 200 // ---- steering ----
TickTock 37:fea2c1d52c5f 201 msg = lastMsg[indexLastMsg[0x002]]; //Get Steering angle
TickTock 37:fea2c1d52c5f 202 steering = (msg.data[1]<<8)+msg.data[0];
TickTock 48:d1ce92104a1f 203
TickTock 48:d1ce92104a1f 204 if(skin==ttSkin){
TickTock 66:b7476ce7a59e 205 s= (unsigned short) ((steering/10)+155)%310; // this modulo wraps display
TickTock 48:d1ce92104a1f 206 }else{// if(skin==ggSkin){
TickTock 48:d1ce92104a1f 207 // do not go off screen left or right. gg - steering
TickTock 48:d1ce92104a1f 208 short ss = (short) ((steering/15)+160); // less gain 10 -> 15
TickTock 48:d1ce92104a1f 209 if(ss<0) { ss=0; steerOutBounds = 1; }
TickTock 48:d1ce92104a1f 210 if(ss>310) { ss=310; steerOutBounds = 1; }
TickTock 48:d1ce92104a1f 211 s = (unsigned short) ss;
TickTock 48:d1ce92104a1f 212 }
TickTock 48:d1ce92104a1f 213
TickTock 48:d1ce92104a1f 214 //--------------
TickTock 28:f24ac05645d9 215 msg = lastMsg[indexLastMsg[0x1ca]]; //Get brake pressure
TickTock 28:f24ac05645d9 216 tt.background(Navy);
TickTock 28:f24ac05645d9 217 if (force) {
TickTock 28:f24ac05645d9 218 tt.cls();
TickTock 28:f24ac05645d9 219 tt.rect(0,111,170,239,White);
TickTock 28:f24ac05645d9 220 tt.line(0,207,170,207,White);
TickTock 28:f24ac05645d9 221 tt.line(0,175,170,175,White);
TickTock 28:f24ac05645d9 222 tt.line(0,143,170,143,White);
TickTock 28:f24ac05645d9 223 lastPressure[0] = 200;
TickTock 28:f24ac05645d9 224 lastPressure[1] = 200;
TickTock 28:f24ac05645d9 225 lastPressure[2] = 200;
TickTock 28:f24ac05645d9 226 lastPressure[3] = 200;
TickTock 28:f24ac05645d9 227 }
TickTock 48:d1ce92104a1f 228
TickTock 48:d1ce92104a1f 229 // display the steering position small square
TickTock 37:fea2c1d52c5f 230 if (s!=ls){
TickTock 48:d1ce92104a1f 231 // steering position has moved
TickTock 48:d1ce92104a1f 232 //tt.fillrect(ls,5,ls+9,14, Navy); // blank old position
TickTock 48:d1ce92104a1f 233
TickTock 48:d1ce92104a1f 234 //---- gg - steering red
TickTock 48:d1ce92104a1f 235 // box is blanked by top of Braking bar, so move up 5
TickTock 48:d1ce92104a1f 236 tt.fillrect(ls,0,ls+9,9, Navy); // blank old position
TickTock 48:d1ce92104a1f 237 if( steerOutBounds != 0 ) // draw out-of-bounds as a red box
TickTock 48:d1ce92104a1f 238 tt.fillrect(s,0,s+9,9, Red); // draw out-of-bounds position
TickTock 48:d1ce92104a1f 239 else
TickTock 48:d1ce92104a1f 240 tt.fillrect(s,0,s+9,9, White); // draw new in-bounds position
TickTock 48:d1ce92104a1f 241
TickTock 48:d1ce92104a1f 242 //----
TickTock 37:fea2c1d52c5f 243 //tt.foreground(Yellow);
TickTock 37:fea2c1d52c5f 244 //tt.set_font((unsigned char*) Arial28x28);
TickTock 37:fea2c1d52c5f 245 //tt.locate(10,40);
TickTock 37:fea2c1d52c5f 246 //printf("%d %d \n",s,ls);
TickTock 37:fea2c1d52c5f 247 ls=s;
TickTock 37:fea2c1d52c5f 248 }
TickTock 48:d1ce92104a1f 249
TickTock 37:fea2c1d52c5f 250 if (throttle!=lthrottle){
TickTock 37:fea2c1d52c5f 251 if (throttle>239) throttle=239;
TickTock 37:fea2c1d52c5f 252 if(throttle<lthrottle){
TickTock 37:fea2c1d52c5f 253 tt.fillrect(280,239-lthrottle,310,239-throttle,Navy);
TickTock 37:fea2c1d52c5f 254 }else{
TickTock 37:fea2c1d52c5f 255 tt.fillrect(280,239-throttle,310,239,Yellow);
TickTock 37:fea2c1d52c5f 256 }
TickTock 37:fea2c1d52c5f 257 lthrottle=throttle;
TickTock 37:fea2c1d52c5f 258 }
TickTock 37:fea2c1d52c5f 259
TickTock 28:f24ac05645d9 260 // plot bar graph for each wheel pressure
TickTock 92:935adef49ea4 261 for (i=0; i<4; i++){
TickTock 28:f24ac05645d9 262 if (msg.data[i]<239) {
TickTock 28:f24ac05645d9 263 if (msg.data[i]>lastPressure[i]){
TickTock 28:f24ac05645d9 264 tt.fillrect(10+40*i,239-msg.data[i],40+40*i,239,Red);
TickTock 28:f24ac05645d9 265 } else if (msg.data[i]<lastPressure[i]) {
TickTock 28:f24ac05645d9 266 tt.fillrect(10+40*i,238-lastPressure[i],40+40*i,238-msg.data[i],Navy);
TickTock 28:f24ac05645d9 267 }
TickTock 28:f24ac05645d9 268 lastPressure[i]=msg.data[i];
TickTock 28:f24ac05645d9 269 }
TickTock 28:f24ac05645d9 270 }
TickTock 28:f24ac05645d9 271
TickTock 73:62ee8eae3a84 272 msg = lastMsg[indexLastMsg[0x1cb]]; //Get Target and Regen
TickTock 73:62ee8eae3a84 273 regenBraking = (msg.data[0]<<3)+(msg.data[1]>>5);
TickTock 73:62ee8eae3a84 274 targetBraking = (msg.data[2]<<3)+(msg.data[3]>>5);
TickTock 73:62ee8eae3a84 275
TickTock 73:62ee8eae3a84 276 if (targetBraking<2045){
TickTock 73:62ee8eae3a84 277 if ((targetBraking>50)&&(regenBraking>50)){
TickTock 73:62ee8eae3a84 278 temp = targetBraking;
TickTock 73:62ee8eae3a84 279 temp *= 1000;
TickTock 73:62ee8eae3a84 280 temp /= regenBraking;
TickTock 73:62ee8eae3a84 281 if (temp<tardivreg_x1000) tardivreg_x1000=temp;
TickTock 73:62ee8eae3a84 282 }
TickTock 73:62ee8eae3a84 283 if (targetBraking>maxTarget) maxTarget=targetBraking;
TickTock 73:62ee8eae3a84 284 if (regenBraking>maxRegen) maxRegen=regenBraking;
TickTock 73:62ee8eae3a84 285 temp = targetBraking;
TickTock 73:62ee8eae3a84 286 temp *=200;
TickTock 73:62ee8eae3a84 287 temp /= maxTarget;
TickTock 73:62ee8eae3a84 288 t = (char) temp;
TickTock 73:62ee8eae3a84 289 if (t>200) t=200;
TickTock 73:62ee8eae3a84 290 temp = regenBraking;
TickTock 73:62ee8eae3a84 291 temp *= tardivreg_x1000;
TickTock 73:62ee8eae3a84 292 temp /= maxTarget;
TickTock 73:62ee8eae3a84 293 temp /= 5; // 1000/200=5
TickTock 73:62ee8eae3a84 294 r = (char) temp;
TickTock 73:62ee8eae3a84 295 if (r>200) r=200;
TickTock 73:62ee8eae3a84 296 if(lr!=r&&prdata){
TickTock 73:62ee8eae3a84 297 tt.foreground(Yellow);
TickTock 73:62ee8eae3a84 298 tt.set_font((unsigned char*) Arial28x28);
TickTock 73:62ee8eae3a84 299 tt.locate(100,40);
TickTock 73:62ee8eae3a84 300 printf("%d %d \n",regenBraking,maxRegen);
TickTock 73:62ee8eae3a84 301 tt.locate(100,70);
TickTock 73:62ee8eae3a84 302 printf("%3.1f (%3.1f%s) \n",(float)tardivreg_x1000/10,(float)regenBraking*tardivreg_x1000/targetBraking/10,"%");
TickTock 73:62ee8eae3a84 303 }
TickTock 73:62ee8eae3a84 304 if(lt!=t&&prdata){
TickTock 73:62ee8eae3a84 305 tt.foreground(Yellow);
TickTock 73:62ee8eae3a84 306 tt.set_font((unsigned char*) Arial28x28);
TickTock 73:62ee8eae3a84 307 tt.locate(100,10);
TickTock 73:62ee8eae3a84 308 printf("%d %d \n",targetBraking,maxTarget);
TickTock 73:62ee8eae3a84 309 }
TickTock 73:62ee8eae3a84 310 if (r>t) t=r; //Should never happen
TickTock 73:62ee8eae3a84 311 if((lr!=r||lt!=t)&&!prdata){
TickTock 73:62ee8eae3a84 312 tt.fillrect(190,10,260,239-t,Navy);
TickTock 73:62ee8eae3a84 313 tt.fillrect(190,239-t,260,239-r,Red);
TickTock 73:62ee8eae3a84 314 tt.fillrect(190,239-r,260,239,Green);
TickTock 73:62ee8eae3a84 315 }
TickTock 73:62ee8eae3a84 316 lt=t;
TickTock 73:62ee8eae3a84 317 lr=r;
TickTock 28:f24ac05645d9 318 }
TickTock 28:f24ac05645d9 319 }
TickTock 28:f24ac05645d9 320
TickTock 42:4533b13b297d 321 void cpData(bool force, bool showButtons){
TickTock 36:dbd39c315258 322 short unsigned max, min, jv, i, bd;
TickTock 36:dbd39c315258 323 unsigned avg;
TickTock 36:dbd39c315258 324 if(force){
TickTock 36:dbd39c315258 325 tt.foreground(White);
TickTock 36:dbd39c315258 326 tt.background(Navy);
TickTock 36:dbd39c315258 327 tt.set_font((unsigned char*) Arial12x12_prop); // select the font
TickTock 36:dbd39c315258 328 max=0;
TickTock 36:dbd39c315258 329 min=9999;
TickTock 36:dbd39c315258 330 avg=0;
TickTock 92:935adef49ea4 331 for(i=0; i<96; i++){
TickTock 36:dbd39c315258 332 bd=(battData[i*2+3]<<8)+battData[i*2+4];
TickTock 36:dbd39c315258 333 avg+=bd;
TickTock 36:dbd39c315258 334 if(bd>max) max=bd;
TickTock 36:dbd39c315258 335 if(bd<min) min=bd;
TickTock 36:dbd39c315258 336 }
TickTock 36:dbd39c315258 337 avg /= 96;
TickTock 36:dbd39c315258 338 if(min<3713) {
TickTock 36:dbd39c315258 339 jv=avg-(max-avg)*1.5;
TickTock 36:dbd39c315258 340 } else { // Only compute judgement value if min cellpair meets <= 3712mV requirement
TickTock 36:dbd39c315258 341 jv=0;
TickTock 36:dbd39c315258 342 }
TickTock 36:dbd39c315258 343 tt.cls();
TickTock 36:dbd39c315258 344 tt.locate(0,6);
garygid 87:46ac3f2519d6 345 // BatDataBaseG4 * 7 = 224
leafman 98:9f8bab96edff 346 char* sTemperatureUnit = temperatureUnit();
leafman 98:9f8bab96edff 347 printf(" MAX MIN AVG CVLI T1 T2 T3 T4\n %04d %04d %04d %04d %2.0f%s %2.0f%s %2.0f%s %2.0f%s\n\n",
leafman 98:9f8bab96edff 348 max,min,avg,jv, convertTemperature(battData[224+5]),sTemperatureUnit,convertTemperature(battData[224+8]),sTemperatureUnit,
leafman 98:9f8bab96edff 349 convertTemperature(battData[224+11]),sTemperatureUnit,convertTemperature(battData[224+14]),sTemperatureUnit);
TickTock 36:dbd39c315258 350 tt.locate(0,36);
TickTock 92:935adef49ea4 351 for(i=0; i<16; i++){
garygid 87:46ac3f2519d6 352 printf("%02d-%02d : %04d %04d %04d %04d %04d %04d\n",
garygid 87:46ac3f2519d6 353 i*6+1,i*6+6,
garygid 87:46ac3f2519d6 354 (battData[i*12+3]<<8)+battData[i*12+4],(battData[i*12+5]<<8)+battData[i*12+6],
garygid 87:46ac3f2519d6 355 (battData[i*12+7]<<8)+battData[i*12+8],(battData[i*12+9]<<8)+battData[i*12+10],
garygid 87:46ac3f2519d6 356 (battData[i*12+11]<<8)+battData[i*12+12],(battData[i*12+13]<<8)+battData[i*12+14]);
TickTock 36:dbd39c315258 357 }
TickTock 36:dbd39c315258 358 tt.rect(8+0*41,16,40+0*41,28,Green);
TickTock 36:dbd39c315258 359 tt.rect(8+1*41,16,40+1*41,28,Yellow);
TickTock 36:dbd39c315258 360 //tt.rect(8+2*41,16,40+2*41,28,White);
TickTock 36:dbd39c315258 361 tt.rect(8+3*41,16,40+3*41,28,Red);
TickTock 92:935adef49ea4 362 for(i=0; i<96; i++){
TickTock 36:dbd39c315258 363 bd=(battData[i*2+3]<<8)+battData[i*2+4];
TickTock 36:dbd39c315258 364 if(bd>0){
TickTock 36:dbd39c315258 365 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 366 //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 367 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 368 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 369 }
TickTock 36:dbd39c315258 370 }
TickTock 36:dbd39c315258 371 showCP=false;
TickTock 36:dbd39c315258 372 }
TickTock 42:4533b13b297d 373 if((sMode==1)&&showButtons){
TickTock 36:dbd39c315258 374 tt.foreground(Yellow);
TickTock 36:dbd39c315258 375 tt.background(DarkCyan);
TickTock 36:dbd39c315258 376 tt.set_font((unsigned char*) Arial12x12);
garygid 54:6ce808d0995e 377
garygid 54:6ce808d0995e 378 showButton(1,0,"Request","CP Data",4,4);
TickTock 44:6262a9fd1e56 379 }
TickTock 44:6262a9fd1e56 380 }
TickTock 44:6262a9fd1e56 381
TickTock 44:6262a9fd1e56 382 //----------------
garygid 67:2022fce701d0 383 // gg - index
garygid 67:2022fce701d0 384 void showIndex(bool force, bool showButtons){
garygid 67:2022fce701d0 385
garygid 67:2022fce701d0 386 if(force){
garygid 67:2022fce701d0 387 tt.foreground(White);
garygid 67:2022fce701d0 388 tt.background(Navy);
garygid 67:2022fce701d0 389 //tt.set_font((unsigned char*) Arial12x12_prop); // select the font
garygid 67:2022fce701d0 390
garygid 67:2022fce701d0 391 tt.cls();
garygid 67:2022fce701d0 392
garygid 67:2022fce701d0 393 // add the buttons to GoTo to other screens
garygid 67:2022fce701d0 394
garygid 67:2022fce701d0 395 tt.foreground(Yellow);
garygid 67:2022fce701d0 396 tt.background(DarkCyan);
garygid 67:2022fce701d0 397 tt.set_font((unsigned char*) Arial12x12);
garygid 67:2022fce701d0 398
garygid 67:2022fce701d0 399 // top row
garygid 67:2022fce701d0 400 showButton(0,0," GoTo"," Main",4,4);
garygid 67:2022fce701d0 401 showButton(1,0," GoTo"," Brake",4,4);
garygid 67:2022fce701d0 402 showButton(2,0," GoTo"," EFF",4,4);
garygid 67:2022fce701d0 403 showButton(3,0," GoTo"," DTE",4,4);
garygid 67:2022fce701d0 404 // middle row
garygid 67:2022fce701d0 405 showButton(0,1," GoTo","CP Data",4,4);
garygid 67:2022fce701d0 406 showButton(1,1," GoTo","CP Hist",4,4);
garygid 67:2022fce701d0 407 showButton(2,1," GoTo","CP Bars",4,4);
leafman 98:9f8bab96edff 408 showButton(3,1," GoTo"," Config",4,4);
leafman 98:9f8bab96edff 409 // bottom (not Nav) row
leafman 98:9f8bab96edff 410 showButton(0,2," GoTo","Playback",4,4);
leafman 98:9f8bab96edff 411 showButton(1,2," GoTo","Set Time",4,4);
leafman 98:9f8bab96edff 412 showButton(2,2," GoTo"," Log",4,4);
garygid 67:2022fce701d0 413
garygid 67:2022fce701d0 414 showCP=false;
garygid 67:2022fce701d0 415 }
garygid 67:2022fce701d0 416
garygid 67:2022fce701d0 417 if(sMode==1&&showButtons){
garygid 67:2022fce701d0 418 tt.foreground(Yellow);
garygid 67:2022fce701d0 419 tt.background(DarkCyan);
garygid 67:2022fce701d0 420 tt.set_font((unsigned char*) Arial12x12);
garygid 67:2022fce701d0 421
garygid 67:2022fce701d0 422 // do nothing here?
garygid 67:2022fce701d0 423 }
garygid 67:2022fce701d0 424 }
garygid 67:2022fce701d0 425
garygid 67:2022fce701d0 426 //----------------
TickTock 48:d1ce92104a1f 427 // gg - cpbars
TickTock 48:d1ce92104a1f 428 void cpBarPlot(bool force, bool showButtons){
TickTock 48:d1ce92104a1f 429 short unsigned max, min, jv, i, bd;
TickTock 48:d1ce92104a1f 430 unsigned avg;
TickTock 48:d1ce92104a1f 431 short unsigned nBar[96] ; // bar height over min
TickTock 48:d1ce92104a1f 432
TickTock 48:d1ce92104a1f 433 if(force){
TickTock 48:d1ce92104a1f 434 tt.foreground(White);
TickTock 48:d1ce92104a1f 435 tt.background(Navy);
TickTock 48:d1ce92104a1f 436 tt.set_font((unsigned char*) Arial12x12_prop); // select the font
TickTock 48:d1ce92104a1f 437 max=0;
TickTock 48:d1ce92104a1f 438 min=9999;
TickTock 48:d1ce92104a1f 439 avg=0;
TickTock 48:d1ce92104a1f 440
TickTock 48:d1ce92104a1f 441 // calc each cell-pair voltage, find max and min
TickTock 92:935adef49ea4 442 for(i=0; i<96; i++){
TickTock 48:d1ce92104a1f 443 bd=(battData[i*2+3]<<8)+battData[i*2+4];
TickTock 48:d1ce92104a1f 444 nBar[i] = bd; // init to bar height
TickTock 48:d1ce92104a1f 445 avg+=bd;
TickTock 48:d1ce92104a1f 446 if(bd>max) max=bd;
TickTock 48:d1ce92104a1f 447 if(bd<min) min=bd;
TickTock 48:d1ce92104a1f 448 }
TickTock 48:d1ce92104a1f 449 avg /= 96;
TickTock 48:d1ce92104a1f 450
TickTock 48:d1ce92104a1f 451 if(min<3713) {
TickTock 48:d1ce92104a1f 452 jv=avg-(max-avg)*1.5;
TickTock 48:d1ce92104a1f 453 } else { // Only compute judgement value if min cellpair meets <= 3712mV requirement
TickTock 48:d1ce92104a1f 454 jv=0;
TickTock 48:d1ce92104a1f 455 }
TickTock 48:d1ce92104a1f 456
TickTock 48:d1ce92104a1f 457 //------------------
TickTock 48:d1ce92104a1f 458 tt.cls();
TickTock 48:d1ce92104a1f 459
TickTock 48:d1ce92104a1f 460 // show as vertical bar plot
TickTock 48:d1ce92104a1f 461 int xWinMin = 26;
TickTock 48:d1ce92104a1f 462 int xWinMax = 316;
TickTock 48:d1ce92104a1f 463 int yWinMin = 50;
TickTock 48:d1ce92104a1f 464 int yWinMax = 150;
TickTock 48:d1ce92104a1f 465 // draw the Bar Graph Frame, 2 pixels wide
TickTock 48:d1ce92104a1f 466 tt.rect( xWinMin-1,yWinMin-1, xWinMax+1,yWinMax+1,Red);
TickTock 48:d1ce92104a1f 467 tt.rect( xWinMin-2,yWinMin-2, xWinMax+2,yWinMax+2,Green);
TickTock 48:d1ce92104a1f 468
TickTock 48:d1ce92104a1f 469 // bar heights
TickTock 48:d1ce92104a1f 470 int height = yWinMax - yWinMin ;
TickTock 48:d1ce92104a1f 471 int iBarValMax = max - min ; // zero to N
TickTock 48:d1ce92104a1f 472
TickTock 48:d1ce92104a1f 473 //----------------
TickTock 48:d1ce92104a1f 474 if( iBarValMax == 0 ) {
TickTock 48:d1ce92104a1f 475 // for testing
TickTock 48:d1ce92104a1f 476 min = 3501 ;
TickTock 48:d1ce92104a1f 477 //max = min + 95*2 ; // for tall values
TickTock 48:d1ce92104a1f 478 max = min + 95/4 ; // for small values
TickTock 48:d1ce92104a1f 479 avg = ( max + min ) / 2;
TickTock 48:d1ce92104a1f 480 iBarValMax = max - min ; // zero to N
TickTock 92:935adef49ea4 481 for(int i=0; i<96; i++) {
TickTock 48:d1ce92104a1f 482 //nBar[i] = i*2 + min ; // test tall values
TickTock 48:d1ce92104a1f 483 nBar[i] = i/4 + min ; // test small values
TickTock 48:d1ce92104a1f 484 }
TickTock 48:d1ce92104a1f 485 }
TickTock 48:d1ce92104a1f 486 //---------------
TickTock 48:d1ce92104a1f 487 float nBarScale = float(height) / iBarValMax ;
TickTock 48:d1ce92104a1f 488 if( nBarScale < 0.1 ) nBarScale = 0.1 ;
TickTock 48:d1ce92104a1f 489
TickTock 48:d1ce92104a1f 490 // do the Bar-height scaling
TickTock 92:935adef49ea4 491 for(int i=0; i<96; i++){
TickTock 48:d1ce92104a1f 492 nBar[i] -= min ; // now, 0 to N = iBinValMax
TickTock 48:d1ce92104a1f 493 nBar[i] *= nBarScale ; // scale, as needed
TickTock 48:d1ce92104a1f 494 }
TickTock 48:d1ce92104a1f 495
TickTock 48:d1ce92104a1f 496 // values, for now
garygid 87:46ac3f2519d6 497 // BatDataBaseG4 * 7 = 224
TickTock 48:d1ce92104a1f 498 tt.locate( 0, yWinMax+40 );
TickTock 48:d1ce92104a1f 499 printf(" MAX MIN AVG CVLI T1 T2 T3 T4\n %04d %04d %04d %04d %02dC %02dC %02dC %02dC\n\n",
garygid 87:46ac3f2519d6 500 max,min,avg,jv, battData[224+5],battData[224+8], battData[224+11],battData[224+14]);
TickTock 48:d1ce92104a1f 501
TickTock 48:d1ce92104a1f 502 // label the X axis (approximate)
TickTock 48:d1ce92104a1f 503 tt.locate( 2, yWinMax+5); printf("%04d", min );
TickTock 48:d1ce92104a1f 504 //tt.locate( 2, yWinMin-14 ); printf("%04d = %04d from %1.4f", max, int( height / nBarScale ) + min, nBarScale );
TickTock 48:d1ce92104a1f 505 tt.locate( 2, yWinMin-14 ); printf("%04d = (%d) mv range.", max , max - min );
TickTock 48:d1ce92104a1f 506
TickTock 48:d1ce92104a1f 507 //---------------
TickTock 48:d1ce92104a1f 508 // show the bars
TickTock 48:d1ce92104a1f 509 int nBarWidth = 2 ;
TickTock 48:d1ce92104a1f 510 int nBarSpace = 1 ; // 1 for testing
TickTock 48:d1ce92104a1f 511
TickTock 48:d1ce92104a1f 512 int xPos = xWinMin + 2 ; // start one from the left
TickTock 48:d1ce92104a1f 513
TickTock 92:935adef49ea4 514 for( int i=0; i<96; i++) {
TickTock 48:d1ce92104a1f 515 height = nBar[i] ;
TickTock 48:d1ce92104a1f 516 if( height > 100 ) height = 100 ; // clip tops
TickTock 48:d1ce92104a1f 517
TickTock 48:d1ce92104a1f 518 // draw the bar, is always inside x-window
TickTock 48:d1ce92104a1f 519 tt.fillrect( xPos,yWinMax-height, xPos+nBarWidth-1,yWinMax, Green);
TickTock 48:d1ce92104a1f 520
TickTock 48:d1ce92104a1f 521 // tic mark the y axis each 5
TickTock 48:d1ce92104a1f 522 if(i%5 == 4){
TickTock 48:d1ce92104a1f 523 tt.line( xPos,yWinMax+2, xPos,yWinMax+5, White); // a white tick mark
TickTock 48:d1ce92104a1f 524 tt.line( xPos+1,yWinMax+2, xPos+1,yWinMax+5, White); // a white tick mark, to widen
TickTock 48:d1ce92104a1f 525 //tt.rect( xPos,yWinMax+2, xPos+1,yWinMax+5, White); // a white 2-wide tick mark is SLOW
TickTock 48:d1ce92104a1f 526 }
TickTock 48:d1ce92104a1f 527 // label the y axis each 10
TickTock 48:d1ce92104a1f 528 if(i%10 == 9){
TickTock 48:d1ce92104a1f 529 tt.locate( xPos-6, yWinMax+8 );
TickTock 48:d1ce92104a1f 530 printf("%02d\n", i+1 );
TickTock 48:d1ce92104a1f 531 }
TickTock 48:d1ce92104a1f 532
TickTock 48:d1ce92104a1f 533 // step to the next bar position
TickTock 48:d1ce92104a1f 534 xPos += nBarWidth + nBarSpace ;
TickTock 48:d1ce92104a1f 535 }
TickTock 48:d1ce92104a1f 536
TickTock 48:d1ce92104a1f 537 showCP=false;
TickTock 48:d1ce92104a1f 538 }
TickTock 48:d1ce92104a1f 539
TickTock 48:d1ce92104a1f 540 // handle the button
TickTock 48:d1ce92104a1f 541 if(sMode==1&&showButtons){
TickTock 48:d1ce92104a1f 542 tt.foreground(Yellow);
TickTock 48:d1ce92104a1f 543 tt.background(DarkCyan);
TickTock 48:d1ce92104a1f 544 tt.set_font((unsigned char*) Arial12x12);
garygid 54:6ce808d0995e 545
garygid 54:6ce808d0995e 546 showButton(1,0,"Request","CP Data",4,4);
TickTock 48:d1ce92104a1f 547 }
TickTock 48:d1ce92104a1f 548 }
TickTock 48:d1ce92104a1f 549
TickTock 48:d1ce92104a1f 550 //----------------
TickTock 44:6262a9fd1e56 551 // gg - hist
TickTock 47:9cc7d876dd6d 552 void cpHistogram(bool force, bool showButtons){
TickTock 44:6262a9fd1e56 553 short unsigned max, min, jv, i, bd;
TickTock 44:6262a9fd1e56 554 unsigned avg;
TickTock 44:6262a9fd1e56 555 if(force){
TickTock 44:6262a9fd1e56 556 tt.foreground(White);
TickTock 44:6262a9fd1e56 557 tt.background(Navy);
TickTock 44:6262a9fd1e56 558 tt.set_font((unsigned char*) Arial12x12_prop); // select the font
TickTock 44:6262a9fd1e56 559 max=0;
TickTock 44:6262a9fd1e56 560 min=9999;
TickTock 44:6262a9fd1e56 561 avg=0;
TickTock 92:935adef49ea4 562 for(i=0; i<96; i++){
TickTock 44:6262a9fd1e56 563 bd=(battData[i*2+3]<<8)+battData[i*2+4];
TickTock 44:6262a9fd1e56 564 avg+=bd;
TickTock 44:6262a9fd1e56 565 if(bd>max) max=bd;
TickTock 44:6262a9fd1e56 566 if(bd<min) min=bd;
TickTock 44:6262a9fd1e56 567 }
TickTock 44:6262a9fd1e56 568 avg /= 96;
TickTock 44:6262a9fd1e56 569 if(min<3713) {
TickTock 44:6262a9fd1e56 570 jv=avg-(max-avg)*1.5;
TickTock 44:6262a9fd1e56 571 } else { // Only compute judgement value if min cellpair meets <= 3712mV requirement
TickTock 44:6262a9fd1e56 572 jv=0;
TickTock 44:6262a9fd1e56 573 }
TickTock 44:6262a9fd1e56 574
TickTock 44:6262a9fd1e56 575 //------------------
TickTock 44:6262a9fd1e56 576 tt.cls();
TickTock 44:6262a9fd1e56 577
TickTock 44:6262a9fd1e56 578 // show as histogram
TickTock 44:6262a9fd1e56 579 int xWinMin = 20;
TickTock 44:6262a9fd1e56 580 int xWinMax = 300;
TickTock 44:6262a9fd1e56 581 int yWinMin = 50;
TickTock 44:6262a9fd1e56 582 int yWinMax = 150;
TickTock 44:6262a9fd1e56 583 // draw the Histogram Frame, 2 pixels wide
TickTock 44:6262a9fd1e56 584 tt.rect( xWinMin-1,yWinMin-1, xWinMax+1,yWinMax+1,Red);
TickTock 44:6262a9fd1e56 585 tt.rect( xWinMin-2,yWinMin-2, xWinMax+2,yWinMax+2,Green);
TickTock 44:6262a9fd1e56 586
TickTock 44:6262a9fd1e56 587 // binning
TickTock 44:6262a9fd1e56 588 short nBin[301] ; // bins to count Min values in nBin[0], etc.
TickTock 44:6262a9fd1e56 589 int height ;
TickTock 44:6262a9fd1e56 590 int iBinIndxMax = 300 ;
TickTock 44:6262a9fd1e56 591 int iBinValMax = max - min ; // zero to N
TickTock 44:6262a9fd1e56 592 if( iBinValMax > iBinIndxMax ) iBinValMax = iBinIndxMax ;
TickTock 44:6262a9fd1e56 593
TickTock 44:6262a9fd1e56 594 // clean the bins
TickTock 92:935adef49ea4 595 for(int i=0; i<=iBinIndxMax; i++) {
TickTock 44:6262a9fd1e56 596 nBin[i] = 0;
TickTock 44:6262a9fd1e56 597 }
TickTock 44:6262a9fd1e56 598
TickTock 44:6262a9fd1e56 599 // do the bin counting
TickTock 92:935adef49ea4 600 for(int i=0; i<96; i++){
TickTock 44:6262a9fd1e56 601 bd=(battData[i*2+3]<<8)+battData[i*2+4] - min ;
TickTock 44:6262a9fd1e56 602 if( bd > iBinValMax ) bd = iBinValMax ;
TickTock 92:935adef49ea4 603 nBin[bd] ++ ;
TickTock 44:6262a9fd1e56 604 }
TickTock 44:6262a9fd1e56 605
TickTock 44:6262a9fd1e56 606 //----------------
TickTock 44:6262a9fd1e56 607 if( iBinValMax == 0 ) {
TickTock 44:6262a9fd1e56 608 // for testing
TickTock 44:6262a9fd1e56 609 min = 10 ;
TickTock 44:6262a9fd1e56 610 max = 50 ;
TickTock 44:6262a9fd1e56 611 avg = ( max + min ) / 2;
TickTock 44:6262a9fd1e56 612 iBinValMax = max - min ;
TickTock 92:935adef49ea4 613 for(int i=0; i<=(iBinValMax/2); i++) {
TickTock 44:6262a9fd1e56 614 nBin[i] = i ;
TickTock 44:6262a9fd1e56 615 nBin[iBinValMax-i] = i ;
TickTock 44:6262a9fd1e56 616 }
TickTock 44:6262a9fd1e56 617 }
TickTock 44:6262a9fd1e56 618
TickTock 48:d1ce92104a1f 619 // the values, for now
garygid 87:46ac3f2519d6 620 // BatDataBaseG4 * 7 = 224
TickTock 48:d1ce92104a1f 621 tt.locate( 0, yWinMax+40 );
garygid 87:46ac3f2519d6 622 printf(" MAX MIN AVG CVLI T1 T2 T3 T4\n %04d %04d %04d %04d %02dC %02dC %02dC %02dC\n\n",
garygid 87:46ac3f2519d6 623 max,min,avg,jv, battData[224+5],battData[224+8], battData[224+11],battData[224+14]);
TickTock 48:d1ce92104a1f 624
TickTock 44:6262a9fd1e56 625 //---------------
TickTock 44:6262a9fd1e56 626 // show the bars
TickTock 44:6262a9fd1e56 627 int nBarWidth = 3 ;
TickTock 44:6262a9fd1e56 628 int nBarSpace = 1 ; // 1 for testing
TickTock 44:6262a9fd1e56 629
TickTock 44:6262a9fd1e56 630 int xPos = (xWinMin + xWinMax) / 2 ;
TickTock 44:6262a9fd1e56 631 xPos -= (avg-min) * (nBarWidth + nBarSpace) ;
TickTock 44:6262a9fd1e56 632
TickTock 92:935adef49ea4 633 for( int i=0; i<=iBinValMax; i++) {
TickTock 44:6262a9fd1e56 634 height = 4 * nBin[i] ;
TickTock 44:6262a9fd1e56 635 if( height > 100 ) height = 100 ; // clip tops
TickTock 44:6262a9fd1e56 636
TickTock 44:6262a9fd1e56 637 // if inside the window, draw the bar
TickTock 44:6262a9fd1e56 638 if( ( xPos + nBarWidth < xWinMax ) && ( xPos > xWinMin ) )
TickTock 44:6262a9fd1e56 639 tt.fillrect( xPos,yWinMax-height, xPos+nBarWidth-1,yWinMax, Green);
TickTock 44:6262a9fd1e56 640
TickTock 44:6262a9fd1e56 641 // step to the next bar position
TickTock 44:6262a9fd1e56 642 xPos += nBarWidth + nBarSpace ;
TickTock 44:6262a9fd1e56 643 }
TickTock 44:6262a9fd1e56 644
TickTock 44:6262a9fd1e56 645 showCP=false;
TickTock 44:6262a9fd1e56 646 }
TickTock 44:6262a9fd1e56 647
TickTock 44:6262a9fd1e56 648 // handle the button
TickTock 47:9cc7d876dd6d 649 if(sMode==1&&showButtons){
TickTock 44:6262a9fd1e56 650 tt.foreground(Yellow);
TickTock 44:6262a9fd1e56 651 tt.background(DarkCyan);
TickTock 44:6262a9fd1e56 652 tt.set_font((unsigned char*) Arial12x12);
garygid 54:6ce808d0995e 653
garygid 54:6ce808d0995e 654 showButton(1,0,"Request","CP Data",4,4);
garygid 54:6ce808d0995e 655 }
TickTock 36:dbd39c315258 656 }
TickTock 36:dbd39c315258 657
TickTock 48:d1ce92104a1f 658 //---------------
leafman 98:9f8bab96edff 659 void config(bool force, bool showButtons){
TickTock 36:dbd39c315258 660 if (force) {
TickTock 36:dbd39c315258 661 tt.background(Black);
TickTock 36:dbd39c315258 662 tt.cls();
TickTock 36:dbd39c315258 663 }
TickTock 36:dbd39c315258 664 tt.foreground(Yellow);
TickTock 36:dbd39c315258 665 tt.background(DarkCyan);
TickTock 36:dbd39c315258 666 tt.set_font((unsigned char*) Arial12x12);
garygid 54:6ce808d0995e 667
garygid 65:821fc79cd7fe 668 //-------- top row --------
garygid 54:6ce808d0995e 669 showButton(0,0,"Calibrate"," Touch",4,4); // gg - 4x4
garygid 54:6ce808d0995e 670 showButton(1,0," Reset","",4,4);
garygid 65:821fc79cd7fe 671 showButton(2,0," Save"," Config",4,4);
garygid 65:821fc79cd7fe 672
garygid 65:821fc79cd7fe 673 // a button to step to the next skin
garygid 65:821fc79cd7fe 674 unsigned int nextSkin = skin + 1 ;
garygid 65:821fc79cd7fe 675 if( nextSkin > maxSkin ) nextSkin = 0 ;
garygid 54:6ce808d0995e 676
garygid 65:821fc79cd7fe 677 if( nextSkin == ttSkin ) sprintf(sTemp1,"Skin TT");
garygid 65:821fc79cd7fe 678 else if( nextSkin == ggSkin ) sprintf(sTemp1,"Skin GG");
garygid 65:821fc79cd7fe 679 else sprintf(sTemp1,"Skin %d",nextSkin);
garygid 65:821fc79cd7fe 680
garygid 65:821fc79cd7fe 681 showButton(3,0," Use",sTemp1,4,4);
TickTock 48:d1ce92104a1f 682
TickTock 48:d1ce92104a1f 683 //------- second row -----
TickTock 36:dbd39c315258 684 if (logEn) {
garygid 54:6ce808d0995e 685 sprintf(sTemp1,"Disable");
TickTock 36:dbd39c315258 686 } else {
garygid 54:6ce808d0995e 687 sprintf(sTemp1,"Enable");
TickTock 36:dbd39c315258 688 }
garygid 54:6ce808d0995e 689 showButton(0,1,sTemp1,"Logging",4,4);
TickTock 48:d1ce92104a1f 690
TickTock 36:dbd39c315258 691 if (repeatPoll) {
garygid 54:6ce808d0995e 692 sprintf(sTemp1,"Disable");
TickTock 36:dbd39c315258 693 } else {
garygid 54:6ce808d0995e 694 sprintf(sTemp1,"Enable");
TickTock 36:dbd39c315258 695 }
garygid 54:6ce808d0995e 696 showButton(1,1,sTemp1,"Auto CP",4,4);
TickTock 48:d1ce92104a1f 697
TickTock 48:d1ce92104a1f 698 // add Enable/Disable Batt Log gg - yesBattLog
TickTock 48:d1ce92104a1f 699 if (yesBattLog) {
garygid 54:6ce808d0995e 700 sprintf(sTemp1,"Disable");
TickTock 48:d1ce92104a1f 701 } else {
garygid 54:6ce808d0995e 702 sprintf(sTemp1,"Enable");
TickTock 48:d1ce92104a1f 703 }
garygid 54:6ce808d0995e 704 showButton(2,1,sTemp1,"Batt Log",4,4);
garygid 87:46ac3f2519d6 705
garygid 87:46ac3f2519d6 706 // add Enable/Disable Debug - debugMode
garygid 87:46ac3f2519d6 707 if (debugMode) {
garygid 87:46ac3f2519d6 708 sprintf(sTemp1,"Disable");
garygid 87:46ac3f2519d6 709 } else {
garygid 87:46ac3f2519d6 710 sprintf(sTemp1,"Enable");
garygid 87:46ac3f2519d6 711 }
garygid 87:46ac3f2519d6 712 showButton(3,1,sTemp1," Debug",4,4);
leafman 98:9f8bab96edff 713
leafman 98:9f8bab96edff 714 if(metric)
leafman 98:9f8bab96edff 715 showButton(0,2,"Imperial","",4,4);
leafman 98:9f8bab96edff 716 else
leafman 98:9f8bab96edff 717 showButton(0,2,"Metric","",4,4);
leafman 98:9f8bab96edff 718
leafman 98:9f8bab96edff 719 showButton(3,2,"Update","Firmware",4,4);
leafman 98:9f8bab96edff 720
TickTock 36:dbd39c315258 721 }
TickTock 36:dbd39c315258 722
TickTock 42:4533b13b297d 723 void pbScreen(bool force, bool showButtons){
TickTock 36:dbd39c315258 724 if (force) {
TickTock 36:dbd39c315258 725 tt.background(Black);
TickTock 36:dbd39c315258 726 tt.cls();
TickTock 36:dbd39c315258 727 }
TickTock 36:dbd39c315258 728 tt.foreground(Yellow);
TickTock 36:dbd39c315258 729 tt.background(DarkCyan);
TickTock 36:dbd39c315258 730 tt.set_font((unsigned char*) Arial12x12);
TickTock 36:dbd39c315258 731 if(playbackOpen){
garygid 54:6ce808d0995e 732 showButton(0,0,"Slower"," <--",4,4);
garygid 54:6ce808d0995e 733
TickTock 36:dbd39c315258 734 if(playbackEn){
garygid 54:6ce808d0995e 735 sprintf(sTemp1,"Pause");
TickTock 36:dbd39c315258 736 }else{
garygid 54:6ce808d0995e 737 sprintf(sTemp1," Run");
TickTock 36:dbd39c315258 738 }
garygid 54:6ce808d0995e 739 sprintf(sTemp2,"%4.3f ",playbackInt);
garygid 54:6ce808d0995e 740 showButton(1,0,sTemp1,sTemp2,4,4);
garygid 54:6ce808d0995e 741
garygid 54:6ce808d0995e 742 showButton(2,0,"Faster"," -->",4,4);
TickTock 36:dbd39c315258 743 }
TickTock 36:dbd39c315258 744 if(playbackOpen){
TickTock 36:dbd39c315258 745 sprintf(sTemp1," Stop");
TickTock 36:dbd39c315258 746 }else{
garygid 54:6ce808d0995e 747 sprintf(sTemp1,"Start");
TickTock 36:dbd39c315258 748 }
garygid 54:6ce808d0995e 749 showButton(1,1,sTemp1,"Playback",4,4);
TickTock 36:dbd39c315258 750 }
TickTock 36:dbd39c315258 751
TickTock 42:4533b13b297d 752 void showDateTime(bool force, bool showButtons){
TickTock 36:dbd39c315258 753 struct tm t; // pointer to a static tm structure
TickTock 36:dbd39c315258 754 time_t seconds ;
TickTock 36:dbd39c315258 755 tt.foreground(Yellow);
TickTock 44:6262a9fd1e56 756 tt.background(Black);
TickTock 36:dbd39c315258 757 if (force) {
TickTock 36:dbd39c315258 758 tt.cls();
TickTock 36:dbd39c315258 759 seconds = time(NULL);
TickTock 36:dbd39c315258 760 t = *localtime(&seconds) ;
TickTock 36:dbd39c315258 761
TickTock 36:dbd39c315258 762 tt.locate(10,10);
TickTock 43:e7f6f80590e3 763 tt.set_font((unsigned char*) Arial12x12);
TickTock 36:dbd39c315258 764 strftime(sTemp1, 32, "%a %m/%d/%Y %X \n", &t);
TickTock 36:dbd39c315258 765 printf("%s",sTemp1);
TickTock 42:4533b13b297d 766 if((sMode==1)&&showButtons){
TickTock 36:dbd39c315258 767 switch(dtMode){
TickTock 36:dbd39c315258 768 case 0:
TickTock 36:dbd39c315258 769 sprintf(sTemp1,"Year");
TickTock 36:dbd39c315258 770 break;
TickTock 36:dbd39c315258 771 case 1:
TickTock 36:dbd39c315258 772 sprintf(sTemp1,"Month");
TickTock 36:dbd39c315258 773 break;
TickTock 36:dbd39c315258 774 case 2:
TickTock 36:dbd39c315258 775 sprintf(sTemp1,"Day");
TickTock 36:dbd39c315258 776 break;
TickTock 36:dbd39c315258 777 case 3:
TickTock 36:dbd39c315258 778 sprintf(sTemp1,"Hour");
TickTock 36:dbd39c315258 779 break;
TickTock 36:dbd39c315258 780 case 4:
TickTock 36:dbd39c315258 781 sprintf(sTemp1,"Minute");
TickTock 36:dbd39c315258 782 break;
TickTock 36:dbd39c315258 783 case 5:
TickTock 36:dbd39c315258 784 sprintf(sTemp1,"Second");
TickTock 36:dbd39c315258 785 break;
TickTock 36:dbd39c315258 786 case 6:
TickTock 36:dbd39c315258 787 sprintf(sTemp1,"Select");
TickTock 36:dbd39c315258 788 break;
TickTock 36:dbd39c315258 789 default:
TickTock 36:dbd39c315258 790 break;
TickTock 36:dbd39c315258 791 }
TickTock 44:6262a9fd1e56 792 tt.background(DarkCyan);
TickTock 66:b7476ce7a59e 793 showButton(0,1,sTemp1,"",4,4);
garygid 54:6ce808d0995e 794 showButton(1,1," UP","",4,4);
garygid 54:6ce808d0995e 795 showButton(2,1," DOWN","",4,4);
TickTock 36:dbd39c315258 796 }
TickTock 36:dbd39c315258 797 }
TickTock 36:dbd39c315258 798 }
TickTock 36:dbd39c315258 799
TickTock 50:83d5864c64a0 800 void dteDisplay(bool force, bool showButtons, bool showMiles){
TickTock 66:b7476ce7a59e 801 unsigned short i,x,y,lx,ly,gids,radius,color,r,t;
TickTock 83:52b1f330a62d 802 unsigned char toVal;
TickTock 50:83d5864c64a0 803 static unsigned short lgids=0;
TickTock 50:83d5864c64a0 804 static unsigned char leff[39]={0};
TickTock 50:83d5864c64a0 805 CANMessage msg;
TickTock 66:b7476ce7a59e 806 unsigned long targetBraking, regenBraking, temp;
TickTock 73:62ee8eae3a84 807 static unsigned long maxTarget = 1000, maxRegen = 1000, tardivreg_x1000 = 1000;
TickTock 66:b7476ce7a59e 808 static unsigned char lr=0, lt=0;
TickTock 50:83d5864c64a0 809
TickTock 50:83d5864c64a0 810 msg = lastMsg[indexLastMsg[0x5bc]]; //Get gids
TickTock 50:83d5864c64a0 811 gids = (msg.data[0]<<2)+(msg.data[1]>>6);
TickTock 50:83d5864c64a0 812 if(gids==0){
TickTock 83:52b1f330a62d 813 gids=281; // Display new, fully charged capacity until real data obtained
TickTock 50:83d5864c64a0 814 }
TickTock 50:83d5864c64a0 815
TickTock 37:fea2c1d52c5f 816 tt.background(Navy);
TickTock 49:a3d2c5bb3cfa 817 tt.foreground(Yellow);
TickTock 52:d5385fbf4ea1 818 if(force){
TickTock 52:d5385fbf4ea1 819 tt.cls();
TickTock 83:52b1f330a62d 820 toVal=33;
TickTock 49:a3d2c5bb3cfa 821
TickTock 49:a3d2c5bb3cfa 822 x=50+0*6;
TickTock 52:d5385fbf4ea1 823 tt.locate(x-10,226);
TickTock 49:a3d2c5bb3cfa 824 printf("sec\n");
TickTock 50:83d5864c64a0 825 tt.line(x,10,x,220,DarkGrey);
TickTock 49:a3d2c5bb3cfa 826 x=50+9*6;
TickTock 52:d5385fbf4ea1 827 tt.locate(x-10,226);
TickTock 49:a3d2c5bb3cfa 828 printf("min\n");
TickTock 50:83d5864c64a0 829 tt.line(x,10,x,220,DarkGrey);
TickTock 49:a3d2c5bb3cfa 830 x=50+18*6;
TickTock 52:d5385fbf4ea1 831 tt.locate(x-10,226);
TickTock 49:a3d2c5bb3cfa 832 printf("hour\n");
TickTock 83:52b1f330a62d 833 tt.line(x,10,x,220,DarkGrey);
TickTock 49:a3d2c5bb3cfa 834 x=50+25*6;
TickTock 52:d5385fbf4ea1 835 tt.locate(x-10,226);
TickTock 49:a3d2c5bb3cfa 836 printf("day\n");
TickTock 50:83d5864c64a0 837 tt.line(x,10,x,220,DarkGrey);
TickTock 49:a3d2c5bb3cfa 838 x=50+32*6;
TickTock 52:d5385fbf4ea1 839 tt.locate(x-10,226);
TickTock 49:a3d2c5bb3cfa 840 printf("mon\n");
TickTock 50:83d5864c64a0 841 tt.line(x,10,x,220,DarkGrey);
TickTock 49:a3d2c5bb3cfa 842 x=50+38*6;
TickTock 66:b7476ce7a59e 843 //tt.locate(x-10,226);
TickTock 66:b7476ce7a59e 844 //printf("year\n");
TickTock 66:b7476ce7a59e 845 //tt.line(x,10,x,220,DarkGrey);
TickTock 83:52b1f330a62d 846 } else {
TickTock 83:52b1f330a62d 847 toVal=18;// no need to constantly update the long tc values
TickTock 50:83d5864c64a0 848 }
TickTock 83:52b1f330a62d 849 if(force||lgids!=gids){ // update Y axis when kWh changes
TickTock 83:52b1f330a62d 850 tt.set_font((unsigned char*) Arial12x12);
TickTock 92:935adef49ea4 851 for(i=0;i<10;i++){
TickTock 50:83d5864c64a0 852 y=200-i*20;
TickTock 83:52b1f330a62d 853 tt.locate(10,y-8);
leafman 98:9f8bab96edff 854 if (showMiles){
leafman 98:9f8bab96edff 855 printf("%3.0f\n",convertDistance(i*((float)(gids-5)*.075))); // LM - Added metric support
TickTock 83:52b1f330a62d 856 }else{
TickTock 83:52b1f330a62d 857 printf("%d.0\n",i);
TickTock 50:83d5864c64a0 858 }
TickTock 83:52b1f330a62d 859 tt.line(40,y,toVal*6+56,y,DarkGrey);
TickTock 83:52b1f330a62d 860 }
TickTock 83:52b1f330a62d 861 lgids=gids;
TickTock 83:52b1f330a62d 862 }
TickTock 84:fd21e5d32dab 863 if(updateDTE||force){
TickTock 92:935adef49ea4 864 for(i=0;i<10;i++){
TickTock 83:52b1f330a62d 865 y=200-i*20;
TickTock 83:52b1f330a62d 866 tt.line(40,y,158,y,DarkGrey);
TickTock 50:83d5864c64a0 867 }
TickTock 50:83d5864c64a0 868
TickTock 50:83d5864c64a0 869 x=50+0*6;
TickTock 50:83d5864c64a0 870 tt.line(x,10,x,220,DarkGrey);
TickTock 50:83d5864c64a0 871 x=50+9*6;
TickTock 50:83d5864c64a0 872 tt.line(x,10,x,220,DarkGrey);
TickTock 50:83d5864c64a0 873 x=50+18*6;
TickTock 50:83d5864c64a0 874 tt.line(x,10,x,220,DarkGrey);
TickTock 83:52b1f330a62d 875 //x=50+25*6;
TickTock 83:52b1f330a62d 876 //tt.line(x,60,x,220,DarkGrey);
TickTock 83:52b1f330a62d 877 //x=50+32*6;
TickTock 83:52b1f330a62d 878 //tt.line(x,60,x,220,DarkGrey);
TickTock 66:b7476ce7a59e 879 //x=50+38*6;
TickTock 66:b7476ce7a59e 880 //tt.line(x,60,x,220,DarkGrey);
TickTock 50:83d5864c64a0 881 tt.set_font((unsigned char*) SCProSB31x55);
TickTock 50:83d5864c64a0 882 tt.foreground(Green);
TickTock 50:83d5864c64a0 883 if (showMiles){
TickTock 93:c2402e8cd0e2 884 float miles = mpkWh[dtePeriod]*((float)(gids-5)*.075);
leafman 98:9f8bab96edff 885 miles = convertDistance(miles); // LM - Metric support
TickTock 93:c2402e8cd0e2 886 // Right justify
TickTock 94:c3a14b3975d6 887 if (miles>99.9){ //space=18; num=31; . = 23
TickTock 94:c3a14b3975d6 888 tt.locate(161,8);
TickTock 94:c3a14b3975d6 889 printf("%4.1f\n",miles);
TickTock 93:c2402e8cd0e2 890 } else if (miles>9.9){
TickTock 94:c3a14b3975d6 891 tt.locate(156,8);
TickTock 94:c3a14b3975d6 892 printf(" %3.1f\n",miles);
TickTock 93:c2402e8cd0e2 893 } else {
TickTock 94:c3a14b3975d6 894 tt.locate(151,8);
TickTock 94:c3a14b3975d6 895 printf(" %2.1f\n",miles);
TickTock 93:c2402e8cd0e2 896 }
TickTock 50:83d5864c64a0 897 } else {
TickTock 52:d5385fbf4ea1 898 tt.locate(180,10);
TickTock 66:b7476ce7a59e 899 printf("%3.1f \n",mpkWh[dtePeriod]);
TickTock 50:83d5864c64a0 900 }
TickTock 49:a3d2c5bb3cfa 901 lx=50;
TickTock 49:a3d2c5bb3cfa 902 ly=mpkWh[0]*20;
TickTock 49:a3d2c5bb3cfa 903 if(ly<200) {
TickTock 49:a3d2c5bb3cfa 904 ly=200-ly;
TickTock 49:a3d2c5bb3cfa 905 }else{
TickTock 49:a3d2c5bb3cfa 906 ly=0;
TickTock 49:a3d2c5bb3cfa 907 }
TickTock 50:83d5864c64a0 908 if(dtePeriod==0){
TickTock 52:d5385fbf4ea1 909 radius=6;
TickTock 83:52b1f330a62d 910 color=Yellow;
TickTock 50:83d5864c64a0 911 }else{
TickTock 50:83d5864c64a0 912 radius=2;
TickTock 50:83d5864c64a0 913 color=Green;
TickTock 50:83d5864c64a0 914 }
TickTock 50:83d5864c64a0 915 tt.fillcircle(lx,leff[0],radius,Navy);
TickTock 50:83d5864c64a0 916 tt.fillcircle(lx,ly,radius,color);
TickTock 49:a3d2c5bb3cfa 917
TickTock 92:935adef49ea4 918 for(i=1;i<toVal;i++){
TickTock 49:a3d2c5bb3cfa 919 x=50+i*6;
TickTock 49:a3d2c5bb3cfa 920 y=mpkWh[i]*20;
TickTock 49:a3d2c5bb3cfa 921 if(y<200) {
TickTock 49:a3d2c5bb3cfa 922 y=200-y;
TickTock 49:a3d2c5bb3cfa 923 }else{
TickTock 49:a3d2c5bb3cfa 924 y=0;
TickTock 49:a3d2c5bb3cfa 925 }
TickTock 50:83d5864c64a0 926 if(i==dtePeriod){
TickTock 83:52b1f330a62d 927 radius=6;
TickTock 83:52b1f330a62d 928 color=Yellow;
TickTock 50:83d5864c64a0 929 }else{
TickTock 50:83d5864c64a0 930 radius=2;
TickTock 50:83d5864c64a0 931 color=Green;
TickTock 50:83d5864c64a0 932 }
TickTock 50:83d5864c64a0 933 tt.fillcircle(x,leff[i],radius,Navy);
TickTock 50:83d5864c64a0 934 tt.line(x-6,leff[i-1],x,leff[i],Navy);
TickTock 50:83d5864c64a0 935 leff[i-1]=ly;
TickTock 52:d5385fbf4ea1 936 if(y>0){
TickTock 52:d5385fbf4ea1 937 tt.fillcircle(x,y,radius,color);
TickTock 52:d5385fbf4ea1 938 }
TickTock 49:a3d2c5bb3cfa 939 tt.line(lx,ly,x,y,White);
TickTock 49:a3d2c5bb3cfa 940 lx=x;
TickTock 49:a3d2c5bb3cfa 941 ly=y;
TickTock 49:a3d2c5bb3cfa 942 }
TickTock 50:83d5864c64a0 943 leff[i-1]=y;
TickTock 50:83d5864c64a0 944 updateDTE=false;
TickTock 37:fea2c1d52c5f 945 }
TickTock 66:b7476ce7a59e 946
TickTock 66:b7476ce7a59e 947 msg = lastMsg[indexLastMsg[0x1cb]]; //Get Target and Regen
TickTock 66:b7476ce7a59e 948 regenBraking = (msg.data[0]<<3)+(msg.data[1]>>5);
TickTock 66:b7476ce7a59e 949 targetBraking = (msg.data[2]<<3)+(msg.data[3]>>5);
TickTock 73:62ee8eae3a84 950
TickTock 73:62ee8eae3a84 951 if (targetBraking<2045){
TickTock 73:62ee8eae3a84 952 if ((targetBraking>50)&&(regenBraking>50)){
TickTock 73:62ee8eae3a84 953 temp = targetBraking;
TickTock 73:62ee8eae3a84 954 temp *= 1000;
TickTock 73:62ee8eae3a84 955 temp /= regenBraking;
TickTock 73:62ee8eae3a84 956 if (temp<tardivreg_x1000) tardivreg_x1000=temp;
TickTock 73:62ee8eae3a84 957 }
TickTock 73:62ee8eae3a84 958 if (targetBraking>maxTarget) maxTarget=targetBraking;
TickTock 73:62ee8eae3a84 959 if (regenBraking>maxRegen) maxRegen=regenBraking;
TickTock 73:62ee8eae3a84 960
TickTock 66:b7476ce7a59e 961 temp = targetBraking;
TickTock 73:62ee8eae3a84 962 temp *=200;
TickTock 73:62ee8eae3a84 963 temp /= maxTarget;
TickTock 73:62ee8eae3a84 964 t = (char) temp;
TickTock 73:62ee8eae3a84 965 if (t>175) t=175;
TickTock 73:62ee8eae3a84 966 temp = regenBraking;
TickTock 73:62ee8eae3a84 967 temp *= tardivreg_x1000;
TickTock 73:62ee8eae3a84 968 temp /= maxTarget;
TickTock 73:62ee8eae3a84 969 temp /= 5; // 1000/200=5
TickTock 73:62ee8eae3a84 970 r = (char) temp;
TickTock 73:62ee8eae3a84 971 if (r>175) r=175;
TickTock 73:62ee8eae3a84 972 if (r>t) t=r; //Should never happen
TickTock 73:62ee8eae3a84 973 if(lr!=r||lt!=t){
TickTock 73:62ee8eae3a84 974 tt.fillrect(264,64,310,239-t,Navy);
TickTock 73:62ee8eae3a84 975 tt.fillrect(264,239-t,310,239-r,Red);
TickTock 73:62ee8eae3a84 976 tt.fillrect(264,239-r,310,239,Green);
TickTock 73:62ee8eae3a84 977 }
TickTock 73:62ee8eae3a84 978 lt=t;
TickTock 73:62ee8eae3a84 979 lr=r;
TickTock 66:b7476ce7a59e 980 }
TickTock 37:fea2c1d52c5f 981 }
TickTock 37:fea2c1d52c5f 982
TickTock 36:dbd39c315258 983 void updateDisplay(char display){
TickTock 36:dbd39c315258 984 bool changed;
TickTock 36:dbd39c315258 985 changed = dMode[display]!=lastDMode[display];
TickTock 36:dbd39c315258 986 tt.set_display(display);
TickTock 36:dbd39c315258 987 switch (dMode[display]) {
TickTock 36:dbd39c315258 988 case logScreen:
TickTock 42:4533b13b297d 989 printLog(changed,(display==whichTouched));
TickTock 36:dbd39c315258 990 break;
TickTock 41:8d4609ea7259 991 case mainScreen:
TickTock 42:4533b13b297d 992 mainDisplay(changed,(display==whichTouched));
TickTock 36:dbd39c315258 993 break;
TickTock 36:dbd39c315258 994 case brakeScreen:
TickTock 42:4533b13b297d 995 braking(changed,(display==whichTouched));
TickTock 36:dbd39c315258 996 break;
TickTock 41:8d4609ea7259 997 case dteScreen:
TickTock 50:83d5864c64a0 998 dteDisplay(changed,(display==whichTouched),true);
TickTock 37:fea2c1d52c5f 999 break;
TickTock 50:83d5864c64a0 1000 case effScreen:
TickTock 50:83d5864c64a0 1001 dteDisplay(changed,(display==whichTouched),false);
TickTock 50:83d5864c64a0 1002 break;
TickTock 50:83d5864c64a0 1003 case monitorScreen:
TickTock 42:4533b13b297d 1004 printLast(changed,(display==whichTouched));
TickTock 36:dbd39c315258 1005 break;
TickTock 36:dbd39c315258 1006 case changedScreen:
TickTock 42:4533b13b297d 1007 printChanged(changed,(display==whichTouched));
TickTock 36:dbd39c315258 1008 break;
TickTock 36:dbd39c315258 1009 case cpScreen:
TickTock 42:4533b13b297d 1010 cpData(changed||showCP,(display==whichTouched));
TickTock 36:dbd39c315258 1011 break;
leafman 98:9f8bab96edff 1012 case configScreen:
leafman 98:9f8bab96edff 1013 config(changed,(display==whichTouched));
TickTock 36:dbd39c315258 1014 break;
TickTock 38:155ec32c5e91 1015 case playbackScreen:
TickTock 42:4533b13b297d 1016 pbScreen(changed,(display==whichTouched));
TickTock 36:dbd39c315258 1017 break;
TickTock 36:dbd39c315258 1018 case dateScreen:
TickTock 42:4533b13b297d 1019 showDateTime(changed,(display==whichTouched));
TickTock 36:dbd39c315258 1020 break;
TickTock 44:6262a9fd1e56 1021 case cpHistScreen: // gg - hist
TickTock 47:9cc7d876dd6d 1022 cpHistogram(changed||showCP,(display==whichTouched));
TickTock 44:6262a9fd1e56 1023 break;
TickTock 48:d1ce92104a1f 1024 case cpBarScreen: // gg - cpbars
TickTock 48:d1ce92104a1f 1025 cpBarPlot(changed||showCP,(display==whichTouched));
TickTock 48:d1ce92104a1f 1026 break;
garygid 67:2022fce701d0 1027 case indexScreen:
garygid 67:2022fce701d0 1028 showIndex(changed,(display==whichTouched));
garygid 67:2022fce701d0 1029 break;
TickTock 36:dbd39c315258 1030 default:
TickTock 43:e7f6f80590e3 1031 if (changed){
TickTock 43:e7f6f80590e3 1032 tt.background(Black);
TickTock 43:e7f6f80590e3 1033 tt.cls();
TickTock 43:e7f6f80590e3 1034 }
TickTock 36:dbd39c315258 1035 break;
TickTock 36:dbd39c315258 1036 }
TickTock 36:dbd39c315258 1037 lastDMode[display]=dMode[display];
TickTock 36:dbd39c315258 1038
TickTock 42:4533b13b297d 1039 if(display==whichTouched){
TickTock 42:4533b13b297d 1040 switch (sMode) {
TickTock 42:4533b13b297d 1041 case 1: // Select screens
TickTock 42:4533b13b297d 1042 tt.foreground(Yellow);
TickTock 42:4533b13b297d 1043 tt.background(DarkCyan);
garygid 54:6ce808d0995e 1044 tt.set_font((unsigned char*) Arial12x12);
garygid 54:6ce808d0995e 1045
garygid 54:6ce808d0995e 1046 showButton(0,tNavRow," <-Prev","",4,4); // gg - 4x4
garygid 67:2022fce701d0 1047 // col 1 see below
garygid 67:2022fce701d0 1048 showButton(2,tNavRow," Go To"," Index",4,4); // gg - index
garygid 54:6ce808d0995e 1049 showButton(3,tNavRow," Next->","",4,4); // gg - move next
garygid 54:6ce808d0995e 1050
garygid 67:2022fce701d0 1051 // col 1 in Nav row
TickTock 42:4533b13b297d 1052 switch (dMode[display]) {
TickTock 44:6262a9fd1e56 1053 case offScreen:
garygid 54:6ce808d0995e 1054 sprintf(sTemp2," Off");
TickTock 42:4533b13b297d 1055 break;
TickTock 44:6262a9fd1e56 1056 case logScreen:
garygid 54:6ce808d0995e 1057 sprintf(sTemp2," Log");
TickTock 42:4533b13b297d 1058 break;
TickTock 44:6262a9fd1e56 1059 case mainScreen:
garygid 54:6ce808d0995e 1060 sprintf(sTemp2," Main");
TickTock 42:4533b13b297d 1061 break;
TickTock 44:6262a9fd1e56 1062 case brakeScreen:
garygid 54:6ce808d0995e 1063 sprintf(sTemp2,"Braking");
TickTock 42:4533b13b297d 1064 break;
TickTock 44:6262a9fd1e56 1065 case dteScreen:
garygid 54:6ce808d0995e 1066 sprintf(sTemp2," DTE");
TickTock 42:4533b13b297d 1067 break;
TickTock 50:83d5864c64a0 1068 case effScreen:
garygid 54:6ce808d0995e 1069 sprintf(sTemp2," Eff");
TickTock 50:83d5864c64a0 1070 break;
TickTock 44:6262a9fd1e56 1071 case monitorScreen:
garygid 54:6ce808d0995e 1072 sprintf(sTemp2," Monitor");
TickTock 42:4533b13b297d 1073 break;
TickTock 44:6262a9fd1e56 1074 case changedScreen:
garygid 54:6ce808d0995e 1075 sprintf(sTemp2,"DeltaMon");
TickTock 42:4533b13b297d 1076 break;
TickTock 44:6262a9fd1e56 1077 case cpScreen:
garygid 67:2022fce701d0 1078 sprintf(sTemp2,"CP Data");
TickTock 42:4533b13b297d 1079 break;
leafman 98:9f8bab96edff 1080 case configScreen:
garygid 54:6ce808d0995e 1081 sprintf(sTemp2," Config");
leafman 98:9f8bab96edff 1082 break;
TickTock 44:6262a9fd1e56 1083 case playbackScreen:
garygid 54:6ce808d0995e 1084 sprintf(sTemp2,"Playback");
TickTock 42:4533b13b297d 1085 break;
TickTock 44:6262a9fd1e56 1086 case dateScreen:
garygid 54:6ce808d0995e 1087 sprintf(sTemp2,"Set Time");
TickTock 42:4533b13b297d 1088 break;
TickTock 44:6262a9fd1e56 1089 case cpHistScreen: // gg - hist
garygid 54:6ce808d0995e 1090 sprintf(sTemp2,"CP Hist");
TickTock 44:6262a9fd1e56 1091 break;
TickTock 48:d1ce92104a1f 1092 case cpBarScreen: // gg - cpbars
garygid 54:6ce808d0995e 1093 sprintf(sTemp2,"CP Bars");
TickTock 48:d1ce92104a1f 1094 break;
garygid 67:2022fce701d0 1095 case indexScreen: // gg - index
garygid 67:2022fce701d0 1096 sprintf(sTemp2," Index");
garygid 67:2022fce701d0 1097 break;
TickTock 42:4533b13b297d 1098 }
garygid 54:6ce808d0995e 1099 showButton(1,tNavRow," Select",sTemp2,4,4);
garygid 54:6ce808d0995e 1100
TickTock 42:4533b13b297d 1101 wait_ms(100); // pause a moment to reduce flicker
TickTock 42:4533b13b297d 1102 break;
garygid 54:6ce808d0995e 1103
TickTock 42:4533b13b297d 1104 case 2: // numpad
TickTock 42:4533b13b297d 1105 tt.foreground(Yellow);
TickTock 42:4533b13b297d 1106 tt.background(DarkCyan);
TickTock 42:4533b13b297d 1107 tt.set_font((unsigned char*) Arial24x23);
garygid 54:6ce808d0995e 1108
garygid 54:6ce808d0995e 1109 sprintf(sTemp2,"");
garygid 54:6ce808d0995e 1110 showButton(0,0," 1",sTemp2,4,4);
garygid 54:6ce808d0995e 1111 showButton(1,0," 2",sTemp2,4,4);
garygid 54:6ce808d0995e 1112 showButton(2,0," 3",sTemp2,4,4);
garygid 54:6ce808d0995e 1113 showButton(0,1," 4",sTemp2,4,4);
garygid 54:6ce808d0995e 1114 showButton(1,1," 5",sTemp2,4,4);
garygid 54:6ce808d0995e 1115 showButton(2,1," 6",sTemp2,4,4);
garygid 54:6ce808d0995e 1116 showButton(0,2," 7",sTemp2,4,4);
garygid 54:6ce808d0995e 1117 showButton(1,2," 8",sTemp2,4,4);
garygid 54:6ce808d0995e 1118 showButton(2,2," 9",sTemp2,4,4);
garygid 54:6ce808d0995e 1119 showButton(1,3," 0",sTemp2,4,4);
garygid 54:6ce808d0995e 1120
garygid 54:6ce808d0995e 1121 showButton(0,3,"<--",sTemp2,4,4);
garygid 54:6ce808d0995e 1122 showButton(2,3,"-->",sTemp2,4,4);
garygid 54:6ce808d0995e 1123 showButton(3,3,"return",sTemp2,4,4);
TickTock 42:4533b13b297d 1124 case 3:
TickTock 42:4533b13b297d 1125 break;
TickTock 42:4533b13b297d 1126 default:
TickTock 42:4533b13b297d 1127 break;
TickTock 42:4533b13b297d 1128 }
TickTock 36:dbd39c315258 1129 }
TickTock 36:dbd39c315258 1130 }
TickTock 36:dbd39c315258 1131
garygid 58:4d06288d75a2 1132 //---------------------
garygid 58:4d06288d75a2 1133 // gg - highlight
TickTock 62:ffd15edb5431 1134 void highlightButton(unsigned char column, unsigned char row, unsigned char tScn, unsigned char columns, unsigned char rows){
TickTock 62:ffd15edb5431 1135
garygid 58:4d06288d75a2 1136 unsigned short x1,x2,y1,y2;
garygid 58:4d06288d75a2 1137
garygid 58:4d06288d75a2 1138 x1=column*(320/columns)+btnGap/2;
garygid 58:4d06288d75a2 1139 x2=(column+1)*(320/columns)-btnGap/2;
garygid 58:4d06288d75a2 1140 y1=row*(240/rows)+btnGap/2;
garygid 58:4d06288d75a2 1141 y2=(row+1)*(240/rows)-btnGap/2;
garygid 65:821fc79cd7fe 1142
garygid 65:821fc79cd7fe 1143 tt.set_display(tScn);
garygid 65:821fc79cd7fe 1144
garygid 65:821fc79cd7fe 1145 if( skin == ggSkin ){
garygid 65:821fc79cd7fe 1146 // paint the whole button box, for a better visual effect
garygid 65:821fc79cd7fe 1147 // especially on a screen with a yellow background
garygid 65:821fc79cd7fe 1148 if( tScn == 0 )
garygid 65:821fc79cd7fe 1149 tt.fillrect(x1,y1,x2,y2,White); // DarkCyan);
garygid 65:821fc79cd7fe 1150 else
garygid 65:821fc79cd7fe 1151 tt.fillrect(x1,y1,x2,y2,Green); // DarkCyan);
TickTock 66:b7476ce7a59e 1152 } else {
TickTock 66:b7476ce7a59e 1153 tt.fillrect(x1,y1,x2,y2,Green); // DarkCyan);
garygid 65:821fc79cd7fe 1154 }
garygid 58:4d06288d75a2 1155
garygid 58:4d06288d75a2 1156 // paint the outer pixel as a yellow frame
garygid 58:4d06288d75a2 1157 tt.rect(x1,y1,x2,y2,Yellow) ; // DarkCyan);
garygid 58:4d06288d75a2 1158 }
garygid 58:4d06288d75a2 1159
garygid 58:4d06288d75a2 1160 //---------------------
TickTock 36:dbd39c315258 1161 void showButton(unsigned char column, unsigned char row, char * text1, char * text2, unsigned char columns, unsigned char rows){
TickTock 36:dbd39c315258 1162 unsigned short x1,x2,y1,y2;
garygid 54:6ce808d0995e 1163
TickTock 36:dbd39c315258 1164 x1=column*(320/columns)+btnGap/2;
TickTock 36:dbd39c315258 1165 x2=(column+1)*(320/columns)-btnGap/2;
TickTock 36:dbd39c315258 1166 y1=row*(240/rows)+btnGap/2;
TickTock 36:dbd39c315258 1167 y2=(row+1)*(240/rows)-btnGap/2;
TickTock 36:dbd39c315258 1168 tt.fillrect(x1,y1,x2,y2,DarkCyan);
garygid 54:6ce808d0995e 1169
garygid 54:6ce808d0995e 1170 // adapt formatting of text to the smaller 4x4 box
garygid 54:6ce808d0995e 1171 tt.locate(x1+btnGap/2,y1+btnGap); // gg - 4x4
TickTock 36:dbd39c315258 1172 printf("%s\n",text1);
garygid 54:6ce808d0995e 1173
garygid 54:6ce808d0995e 1174 tt.locate(x1+btnGap/2,y1+btnGap+20);
TickTock 36:dbd39c315258 1175 printf("%s\n",text2);
TickTock 36:dbd39c315258 1176 }
garygid 54:6ce808d0995e 1177
leafman 98:9f8bab96edff 1178
leafman 98:9f8bab96edff 1179 //The temps are stored as metric, distances as imperial... I'm assuming the input based on that - LM
leafman 98:9f8bab96edff 1180 float convertTemperature(float input)
leafman 98:9f8bab96edff 1181 {
leafman 98:9f8bab96edff 1182 if (!metric) {
leafman 98:9f8bab96edff 1183 //convert!
leafman 98:9f8bab96edff 1184 float output = input *1.8f;
leafman 98:9f8bab96edff 1185 output += 32.0f;
leafman 98:9f8bab96edff 1186 return output;
leafman 98:9f8bab96edff 1187 }
leafman 98:9f8bab96edff 1188 return input;
leafman 98:9f8bab96edff 1189 }
leafman 98:9f8bab96edff 1190 float convertDistance(float input)
leafman 98:9f8bab96edff 1191 {
leafman 98:9f8bab96edff 1192 if (metric) {
leafman 98:9f8bab96edff 1193 return input / 0.62137f;
leafman 98:9f8bab96edff 1194 }
leafman 98:9f8bab96edff 1195 return input;
leafman 98:9f8bab96edff 1196 }
leafman 98:9f8bab96edff 1197 char* distanceUnit()
leafman 98:9f8bab96edff 1198 {
leafman 98:9f8bab96edff 1199 if(metric)
leafman 98:9f8bab96edff 1200 return "km";
leafman 98:9f8bab96edff 1201 return "mi";
leafman 98:9f8bab96edff 1202 }
leafman 98:9f8bab96edff 1203 char* temperatureUnit()
leafman 98:9f8bab96edff 1204 {
leafman 98:9f8bab96edff 1205 if(metric)
leafman 98:9f8bab96edff 1206 return "C";
leafman 98:9f8bab96edff 1207 return "F";
leafman 98:9f8bab96edff 1208 }
leafman 98:9f8bab96edff 1209
garygid 54:6ce808d0995e 1210 //-------------
TickTock 41:8d4609ea7259 1211 // below is braking screen normalized to power rather than force
TickTock 41:8d4609ea7259 1212 // changed to force since power had too large a dynamic range
TickTock 42:4533b13b297d 1213 /*void braking (bool force, bool showButtons, bool prdata=false){
TickTock 23:cd03f9c3395e 1214 unsigned long targetBraking, regenBraking, speed;
TickTock 73:62ee8eae3a84 1215 static unsigned long maxTarget = 20000, maxRegen = 20000, tardivreg_x1000 = 1000;
TickTock 13:62e0f7f39ff5 1216 short rpm;
TickTock 13:62e0f7f39ff5 1217 unsigned long temp;
TickTock 13:62e0f7f39ff5 1218 static unsigned char lastPressure[4] = {200,200,200,200};
TickTock 13:62e0f7f39ff5 1219 unsigned char i,r,t;
TickTock 13:62e0f7f39ff5 1220 static unsigned char lr, lt;
TickTock 13:62e0f7f39ff5 1221 CANMessage msg;
TickTock 13:62e0f7f39ff5 1222
TickTock 13:62e0f7f39ff5 1223 msg = lastMsg[indexLastMsg[0x1cb]]; //Get Target and Regen
TickTock 13:62e0f7f39ff5 1224 regenBraking = (msg.data[0]<<3)+(msg.data[1]>>5);
TickTock 13:62e0f7f39ff5 1225 targetBraking = (msg.data[2]<<3)+(msg.data[3]>>5);
TickTock 13:62e0f7f39ff5 1226 msg = lastMsg[indexLastMsg[0x176]]; //Get rpms - not sure what this is but scales to mph with .0725
TickTock 13:62e0f7f39ff5 1227 rpm = ((short)msg.data[0]<<8)+msg.data[1];
TickTock 13:62e0f7f39ff5 1228 speed =rpm>0?rpm>>3:-rpm>>3; //Take absolute to get speed; div8
TickTock 23:cd03f9c3395e 1229 if ((targetBraking>2039)||(speed>200)) { //Filter weird messages
TickTock 23:cd03f9c3395e 1230 targetBraking = 0;
TickTock 23:cd03f9c3395e 1231 regenBraking = 0;
TickTock 23:cd03f9c3395e 1232 } else {
TickTock 23:cd03f9c3395e 1233 if ((targetBraking>50)&&(regenBraking>50)){
TickTock 23:cd03f9c3395e 1234 temp = targetBraking;
TickTock 23:cd03f9c3395e 1235 temp *= 1000;
TickTock 23:cd03f9c3395e 1236 temp /= regenBraking;
TickTock 73:62ee8eae3a84 1237 if (temp<tardivreg_x1000) tardivreg_x1000=temp;
TickTock 23:cd03f9c3395e 1238 }
TickTock 23:cd03f9c3395e 1239 targetBraking *= speed;
TickTock 23:cd03f9c3395e 1240 regenBraking *= speed;
TickTock 23:cd03f9c3395e 1241 if (targetBraking>maxTarget) maxTarget=targetBraking;
TickTock 23:cd03f9c3395e 1242 if (regenBraking>maxRegen) maxRegen=regenBraking;
TickTock 23:cd03f9c3395e 1243 }
TickTock 23:cd03f9c3395e 1244
TickTock 13:62e0f7f39ff5 1245 msg = lastMsg[indexLastMsg[0x1ca]]; //Get brake pressure
TickTock 13:62e0f7f39ff5 1246 tt.background(Navy);
TickTock 13:62e0f7f39ff5 1247 if (force) {
TickTock 13:62e0f7f39ff5 1248 tt.cls();
TickTock 13:62e0f7f39ff5 1249 tt.rect(0,111,170,239,White);
TickTock 13:62e0f7f39ff5 1250 tt.line(0,207,170,207,White);
TickTock 13:62e0f7f39ff5 1251 tt.line(0,175,170,175,White);
TickTock 13:62e0f7f39ff5 1252 tt.line(0,143,170,143,White);
TickTock 13:62e0f7f39ff5 1253 lastPressure[0] = 200;
TickTock 13:62e0f7f39ff5 1254 lastPressure[1] = 200;
TickTock 13:62e0f7f39ff5 1255 lastPressure[2] = 200;
TickTock 13:62e0f7f39ff5 1256 lastPressure[3] = 200;
TickTock 13:62e0f7f39ff5 1257 }
TickTock 13:62e0f7f39ff5 1258 // plot bar graph for each wheel pressure
TickTock 92:935adef49ea4 1259 for (i=0; i<4; i++){
TickTock 13:62e0f7f39ff5 1260 if (msg.data[i]<239) {
TickTock 13:62e0f7f39ff5 1261 if (msg.data[i]>lastPressure[i]){
TickTock 13:62e0f7f39ff5 1262 tt.fillrect(10+40*i,239-msg.data[i],40+40*i,239,Red);
TickTock 13:62e0f7f39ff5 1263 } else if (msg.data[i]<lastPressure[i]) {
TickTock 13:62e0f7f39ff5 1264 tt.fillrect(10+40*i,238-lastPressure[i],40+40*i,238-msg.data[i],Navy);
TickTock 13:62e0f7f39ff5 1265 }
TickTock 13:62e0f7f39ff5 1266 lastPressure[i]=msg.data[i];
TickTock 13:62e0f7f39ff5 1267 }
TickTock 13:62e0f7f39ff5 1268 }
TickTock 13:62e0f7f39ff5 1269
TickTock 27:6bd073c33977 1270 temp = targetBraking;
TickTock 27:6bd073c33977 1271 temp *=200;
TickTock 27:6bd073c33977 1272 temp /= maxTarget;
TickTock 27:6bd073c33977 1273 t = (char) temp;
TickTock 27:6bd073c33977 1274 if (t>200) t=200;
TickTock 27:6bd073c33977 1275 temp = regenBraking;
TickTock 73:62ee8eae3a84 1276 temp *= tardivreg_x1000;
TickTock 27:6bd073c33977 1277 temp /= maxTarget;
TickTock 27:6bd073c33977 1278 temp /= 5;
TickTock 27:6bd073c33977 1279 r = (char) temp;
TickTock 27:6bd073c33977 1280 if (r>200) r=200;
TickTock 27:6bd073c33977 1281 if(lr!=r&&prdata){
TickTock 27:6bd073c33977 1282 tt.foreground(Yellow);
TickTock 27:6bd073c33977 1283 tt.set_font((unsigned char*) Arial28x28);
TickTock 27:6bd073c33977 1284 tt.locate(100,40);
TickTock 27:6bd073c33977 1285 printf("%d %d \n",regenBraking,maxRegen);
TickTock 27:6bd073c33977 1286 tt.locate(100,70);
TickTock 73:62ee8eae3a84 1287 printf("%3.1f (%3.1f%s) \n",(float)tardivreg_x1000/10,(float)regenBraking*tardivreg_x1000/targetBraking/10,"%");
TickTock 27:6bd073c33977 1288 }
TickTock 27:6bd073c33977 1289 if(lt!=t&&prdata){
TickTock 27:6bd073c33977 1290 tt.foreground(Yellow);
TickTock 27:6bd073c33977 1291 tt.set_font((unsigned char*) Arial28x28);
TickTock 27:6bd073c33977 1292 tt.locate(100,10);
TickTock 27:6bd073c33977 1293 printf("%d %d \n",targetBraking,maxTarget);
TickTock 13:62e0f7f39ff5 1294 }
TickTock 27:6bd073c33977 1295 if (r>t) t=r; //Should never happen
TickTock 27:6bd073c33977 1296 if((lr!=r||lt!=t)&&!prdata){
TickTock 27:6bd073c33977 1297 tt.fillrect(200,10,300,239-t,Navy);
TickTock 27:6bd073c33977 1298 tt.fillrect(200,239-t,300,239-r,Red);
TickTock 27:6bd073c33977 1299 tt.fillrect(200,239-r,300,239,Green);
TickTock 27:6bd073c33977 1300 }
TickTock 27:6bd073c33977 1301 lt=t;
TickTock 27:6bd073c33977 1302 lr=r;
TickTock 36:dbd39c315258 1303 }*/