on board diagnostics - per-olovper-olov.se/onewebmedia/rapport-obd.pdf · 2015. 7. 15. ·...

LiTH-ITN-EX--03/010

On Board Diagnostics -på fordon

Examensarbete utfört i datorteknik

vid Linköpings Tekniska Högskola, Campus Norrköping

Andreas Magnusson & Andreas Örnberg

Handledare: Per-Olof Eriksson Examinator: Kent Axelsson

Examensarbete On Board Diagnostics-på fordon Instutitionen för teknik och naturvetenskap,ITN

Linköpings Universitet, Tekniska Högskolan

2 (37)

Abstract With the extensive fleet of vehicles in the Swedish defence it might be a good point using portable test equipment, which easily can be used for fast and accurate diagnosis on the vehicles. In fact most of the modern vehicles on the civilian market today do support such a diagnosis system, which goes under the name On Board Diagnostic II (OBD-II). As a part of a potential evolution in a mobile test system within the Swedish defence we have, among other things, studied the standards and the protocols that are being used in fault diagnosis on vehicles today. The thesis was performed at AerotechTelub in Linköping and the purpose was to broaden their knowledge about vehicle diagnosis and to develop a vehicle diagnosis software, which can be used on modern cars and serve as a introducing step for AerotechTelub to evolve a good diagnosis environment for the vehicles of the Swedish defence. In the thesis, one could read about standards regarding OBD-II, about the program that was developed for AerotechTelub and about the interface circuit, which is needed for communication between the software and a modern vehicle computer.



3 (37)

Sammanfattning I försvarets omfattande fordonspark skulle det vara bra att ha ett bärbart testsystem som enkelt kan anslutas för att göra en snabb feldiagnos på fordonen. De flesta av de moderna fordon som finns på den civila marknaden idag har stöd för ett sådant diagnostiksystem, som går under namnet On Board Diagnostics II. Som en del i en potentiell utveckling av ett mobilt testsystem inom försvaret har vi bla. studerat de standarder och protokoll som idag används inom feldiagnostik på fordon. Examensarbetet genomfördes på AerotechTelub i Linköping och syftet var att bredda deras kunskaper om fordonsdiagnostik, samt att utveckla en programvara för fordonsdiagnos, som kan användas på moderna bilar och fungera som ett inledande steg för AerotechTelub att ta fram en bra diagnosmiljö för försvarets fordon. I rapporten kan man bla läsa om de standarder som finns kring OBD-II, och om den fordonsdiagnosprogramvara som konstruerats åt AerotechTelub och den interfacekrets som behövs för att kommunikation skall kunna utbytas mellan programvaran och en modern fordonsdator.



4 (37)

Förord Detta är den skriftliga delen för det 10 poängs examensarbete som utförts i AerotechTelubs lokaler i Linköping under våren 2003. Examensarbetet ingår i en högskoleingenjörsexamen i Data och Elektroteknik på Linköpings universitet. Vi vill passa på att tacka vår handledare Per-Olof Eriksson på AerotechTelub, samt vår akademiska handledare Kent Axelsson för deras hjälp med bland annat information och praktiska detaljer under arbetets gång. Vi vill även passa på att tacka Joachim Booberg på AerotechTelub för hans support med programvaran och Morgan Uggla på Saab Automobile i Trollhättan.



5 (37)

Innehållsförteckning

INLEDNING.............................................................................................................................................................................8

ON BOARD DIAGNOSTIC II..............................................................................................................................................10

OBD-II KONTAKT J1962 ....................................................................................................................................................10 VART SITTER OBD-II KONTAKTEN I FORDONET?..................................................................................................................11

FELKODER ...........................................................................................................................................................................12 VAD ÄR EN FELKOD?.............................................................................................................................................................12 ANATOMIN FÖR FELKODERNA...............................................................................................................................................12 SERVICELAMPAN ..................................................................................................................................................................13 TVÅ TYPER AV FELKODER .....................................................................................................................................................14

SAE J1979 STANDARDEN FÖR DE 9 TESTMODERNA ...............................................................................................14 MODE 1.................................................................................................................................................................................15

PID 0 Vilka PID:s som stöds............................................................................................................................................15 PID 1 MIL-lampa, antal felkoder och tester ....................................................................................................................15 PID 3 Bränslesystem status (öppen/stängd loop).............................................................................................................16 PID 5 Kylartemperatur i grader Celsius..........................................................................................................................16 PID 6 Kortsiktig bränsletrim i procent, bank 1................................................................................................................16 PID 7 Långsiktig bränsletrim i procent, bank 1...............................................................................................................16 PID 8 Kortsiktig bränsletrim i procent, bank 2................................................................................................................16 PID 9 Långsiktig bränsletrim i procent, bank 2...............................................................................................................16 PID 12 Motorns varvtal i varv per min ............................................................................................................................17 PID 14 Antal grader cylinder ett är före..........................................................................................................................17 PID 15 Insug temperatur i grader Celsius .......................................................................................................................17 PID 17 Gasspjällsläge i procent ......................................................................................................................................17 PID 28 Fordonets OBD version.......................................................................................................................................18 PID 29 Alternativ lokalisering av syresensorerna ...........................................................................................................18 PID 30 Hjälpinmatningstatus...........................................................................................................................................19 PID 31 ..............................................................................................................................................................................19 PID 32 ..............................................................................................................................................................................19

MODE 2.................................................................................................................................................................................19 MODE 3.................................................................................................................................................................................19 MODE 4.................................................................................................................................................................................19 MODE 5.................................................................................................................................................................................20 MODE 6.................................................................................................................................................................................20 MODE 7.................................................................................................................................................................................20 MODE 8.................................................................................................................................................................................21 MODE 9.................................................................................................................................................................................21

ÖVERFÖRINGSPROTOKOLL ..........................................................................................................................................22 J1850 PWM..........................................................................................................................................................................22 J1850 VPW ..........................................................................................................................................................................22 ISO 15765 –CAN.................................................................................................................................................................22 ISO 9141/14230 ...................................................................................................................................................................22

Signalnivåer .....................................................................................................................................................................23 Meddelandets struktur......................................................................................................................................................23

INITIERING AV BUSSEN ENLIGT ISO 9141-2 ..........................................................................................................................25 EXEMPEL PÅ MEDDELANDE MED ISO 9141-2........................................................................................................................26

VIN-VEHICLE IDENTIFICATION NUMBER .................................................................................................................27 VIN-STRUKTUR OCH UPPBYGGNAD .....................................................................................................................................27 KONTROLLSIFFRAN...............................................................................................................................................................28

Exempel på kontrollsifferberäkning. ................................................................................................................................28



6 (37)

EXEMPEL PÅ ETT CHASSINUMMER FRÅN SAAB AUTOMOBILES AB. ....................................................................................29 OBD-II I DAGENS FORDON ..............................................................................................................................................29

PERSONBILAR .......................................................................................................................................................................30 LASTBILAR............................................................................................................................................................................30

UTVECKLINGEN AV OBD.................................................................................................................................................31

DIAGNOS FÖR MILITÄRA FORDON..............................................................................................................................32 LEOPARDEN, STRV 121 OCH STRV 122..............................................................................................................................32 STRIDSFORDON 90 ................................................................................................................................................................32 FRAMTIDSVISION ..................................................................................................................................................................32

TEMC – TEST EQUIPMENT AND MAINTENANCE COMPUTER.............................................................................33

RESULTAT PROGRAMVARA...........................................................................................................................................34

FÖRBÄTTRINGAR PÅ PROGRAMVARAN....................................................................................................................35

SLUTSATSER........................................................................................................................................................................36

REFERENSER.......................................................................................................................................................................37 INTERNET:.............................................................................................................................................................................37 KONTAKTPERSONER: ............................................................................................................................................................37 LITTERATUR: ........................................................................................................................................................................37 TIDSSKRIFT: ..........................................................................................................................................................................37 PROTOKOLL: .........................................................................................................................................................................37

BILAGOR

BILAGA A: INTERFACEKRETSEN BILAGA B: ANVÄNDARMANUAL FÖR PROGRAMVARAN BILAGA C: KRAVSPECFIKATION FÖR PROGRAMVARAN BILAGA D: KODBESKRIVNING BILAGA E: KÄLLKOD BILAGA F: SIMULATORN



7 (37)

Figurförteckning Figur 1 Fundamentala standarder inom OBD II.......................................................................................................................10 Figur 2 Kontakten .................................................................................................................................................................11 Figur 3 Standardkabel för OBD-II ...........................................................................................................................................11 Figur 4 Felkodsstruktur enligt SAE J2012 ...............................................................................................................................12 Figur 6 Servicelampor..............................................................................................................................................................13 Figur 7 Spänningsnivåer, sk "Worst case"-värden ...................................................................................................................23 Figur 8 De olika bitarna i formatbyten .....................................................................................................................................23 Figur 9 Fyra olika former av meddelande enligt ISO 14230\KWP 2000. ................................................................................24 Figur 10 Meddelandeblock enligt ISO 9141-2.........................................................................................................................25 Figur 11 Initieringsprocess enligt ISO 9141-2/ ISO 14230......................................................................................................26 Figur 12 Chassiplåt från Saab ..................................................................................................................................................29 Figur 13 Eu:s tidskrav på fordonstillverkarna. .........................................................................................................................30 Figur 14 TEMC - Underhållsdatorn .........................................................................................................................................33

Tabellförteckning Tabell 1 Stiftkonfiguration för kontakten.................................................................................................................................11 Tabell 2 Den andra byten, kontinuerliga test............................................................................................................................15 Tabell 3 Den tredje och fjärde byten, icke kontinuerlig testen.................................................................................................15 Tabell 4 De 4 olika meddelandehuvudena ...............................................................................................................................24 Tabell 5 Värden för tecknen i VIN...........................................................................................................................................28 Tabell 6 Viktning för positioner i VIN.....................................................................................................................................28 Tabell 7 Kontrollsifferberäkning..............................................................................................................................................28 Tabell 8 Avkodat chassinummer från Saab..............................................................................................................................29



8 (37)

Inledning Denna rapport är slutresultatet av ett tio poängs examensarbete på AerotechTelub i Linköping. Syftet med examensjobbet är att undersöka de befintliga standarderna för fordonsdiagnostik såväl inom den militära som inom den civila fordonsindustrin. Med hjälp av inhämtade kunskaper utveckla en programvara samt nödvändig hårdvara för att kunna kommunicera med fordonen. Examensarbetet inriktas på framtagning av programvaran, eftersom hårdvara finns att köpa ute på marknaden. Diagnostiksystem för fordon har uppkommit genom krav på att emissionen från fordonen måste minska för miljöns skull. I rapporten kommer först historiken och utvecklingen av On Board Diagnostics (OBD) att tas upp. Vidare kommer de standarder och protokoll som bygger upp OBD-II att beskrivas, samt vilken information som går att få ut från fordon som stöder detta. I en senare del av rapporten kan man läsa om hur långt fordonstillverkarna har kommit, civilt samt militärt, på denna front. Slutligen beskrivs den utvecklade diagnosutrustningen, och hur den används, samt hur den är uppbyggd.



9 (37)

Historik över utvecklingen Hela idén med att ha en process eller liknande som övervakar fordonet från att släppa ut avgaser föddes faktiskt i Amerika så tidigt som 1955. Det var då som ”Federal Pollution Control Act” infördes, för att kunna förse samhället med bättre insikt vad beträffar konsekvenser och effekter vid luftföroreningar. Kalifornien var under slutet av 50-talet Amerikas mest befolkade stat och hade ca 8 miljoner registrerade bilar på den tiden. Det ledde till att Kalifornien fick lov att göra något för att förhindra att miljön skulle bli radikalt försämrad. Under 60-talet instiftades därför en rad regler och stadgar som skulle reducera luftföroreningarna i staten. År 1967 grundades California Air Resolution Board(CARB), och 3 år senare grundades U.S. Environmental Protection Agency (EPA). Dessa organisationer upprättade en rad lagar som skulle reducera luftföroreningarna, var det tänkt, men faktum är att det inte var många fordonstillverkare som engagerade sig i dessa lagar. Man ansåg helt enkelt att det skulle kosta för mycket att följa lagarna, så många ignorerade dem helt eller gjorde precis det som behövdes för att komma inom lagens ramar. Inte blev det bättre av att regeringen i landet under den tiden inte gjorde något åt det uppenbara problemet. Det var först under slutet av 70-talet som man på allvar gjorde något åt saken, och den här gången fick fordonstillverkarna börja följa lagarna för att få sälja sina bilar. General Motors i USA hade första generationens On Board Diagnostics i början av 80-talet, trots att det inte fanns något egentligt krav för det då. Det egentliga genombrottet för OBD kom 1988 då det Amerikanska standardiseringsorganet SAE tog fram ett antal standarder som CARB utnyttjade för att kunna införa lagkrav på att alla bilar i Kalifornien måste ha OBD. Många tillverkare utvecklade sina egna testsystem vilket gav verkstäderna en djungel av tillverkarspecifika metoder för feldiagnostik. Detta gjorde att EPA tvingades träda fram och införa en rad standarder. Året var 1996 och med detta hade också den andra generationens OBD fötts, OBD-II. OBD-II måste därefter följas av samtliga fordonstillverkare i Amerika för att de ska kunna få sälja bilar. Canada var det land som följde efter genom att införa OBD-2 under 1998. Det var ett EU direktiv från 1998 som stod för introduktionen av OBD-II i Europa, och under januari 2000 blev det krav på alla bensindrivna bilar, men eftersom Europa aldrig haft någon första generations OBD känns det rätt att de införde den under benämningen European On Board Diagnostics, alias EOBD. I början av 2003 kom EOBD även att gälla samtliga nytillverkade dieseldrivna personbilar.



10 (37)

On Board Diagnostic II On Board Diagnostics II (OBD II), är alltså namnet på den samling standarder som gäller för samtliga personbilar på marknaden i dag. I figur 1. kan man se några av de största standarderna som bär upp OBD II.

Figur 1 Fundamentala standarder inom OBD II

Observera att Society of Automobile Engineers, SAE, har standardiserat de flesta utav de standarder som knyts till OBD II. Vad beträffar den Europeiska varianten, EOBD, så har den byggts kring ISO –15031-x, som är ekvivalent med de Amerikanska SAE dokumenten J1962, J2012, J1979 etc. Detta betyder sålunda att den Europeiska varianten är en kopia av den Amerikanska. Dessa fyra standarder kommer att tas upp mer ingående i rapporten och de överföringsprotokoll som utnyttjas kommer att studeras.

OBD-II Kontakt J1962 På J1962 kontakten, eller ”Diagnostic Link Connector” som den heter inom OBD-II är endast ett fåtal stift standardiserade. Det är stiften 2,4,5,6,7,10,14,15,16, som används för kommunikationen mellan tex. ECM1 och testutrustningen. Dock är det bara 4 eller 5 stift av dessa som utnyttjas av fordonstillverkaren, beroende på vilket protokoll fordonet använder. Nedan finns en samanställning över vilka stift de olika protokollen utnyttjar (matning och jord underförstått). Dessa protokoll finns beskrivna under rubriken överföringsprotokoll. Protokoll Stift J1850 VPW 2 J1850 PWM 2, 10 ISO 9141 / ISO 14230 7,15 ISO 15765 CAN 6,14

1 Står för Engine Control Module och är en enhet som bevakar insprutning och tändning etc.



11 (37)

På stift 16 på fordonets kontakt ligger en icke-regulerad spänning från fordonsbatteriets positiva pol. Vidare finns chassijorden på stift 4 och signaljord på stift 5 vilket medför att mätutrustningen enkelt kan ta sin matning från fordonets batteri. Kontakten som sitter på fordonet skall alltid vara av typen hona, och följaktligen skall testutrustningens kontakt vara av typen hane. Båda kontakterna skall, i analogi med standarden, vara ”D”-formade enligt figur 2. I regel brukar kontakten ha CAN interface på 2 av stiften, enligt stiftkonfigurationen nedan. Pin 2: J1850 Bus+ Pin 4: Chassi Jord Pin 5: Signal jord Pin 6: CAN Hög (J-2284) Pin 7: ISO 9141-2 K-signal Pin 10: J1850 Bus (PWM) Pin 14: CAN Låg (J-2284) Pin 15: ISO 9141-2 L-Signal Pin 16: Batteri

Figur 2 Kontakten

Tabell 1 Stiftkonfiguration för kontakten

Vart sitter OBD-II kontakten i fordonet? Kontakten måste finnas i närheten av förarsätet och standarden säger att det inte skall behövas några avancerade verktyg för att kunna ta fram kontakten. Kontakten får inte sitta på längre avstånd än 16 tum från ratten. Oftast sitter kontakten dold bakom en askkopp eller placerad under instrumentpanelen. I regel är kontakten skyddad med ett enkelt snäpplock, ofta märkt ”OBD”. I fig. kan man se en vanlig kabel som kan användas för att kunna ansluta till fordonsdatorn.

Figur 3 Standardkabel för OBD-II



12 (37)

Felkoder

Vad är en felkod? En felkod, ofta benämnd DTC (Diagnostic trouble code) i Amerikansk litteratur, är den kod som OBD-II standarden använder för att rapportera fel som uppstått i fordonet till fordonsteknikern. Enligt Standarden SAE J2012 skall felkoden bestå av en bokstav och fyra siffror. Det finns tillverkarspecifika felkoder och de av SAE specificerade felkoderna. Man kan enkelt se om det är en ”SAE-kod” eftersom andra tecknet i koden då alltid är en nolla. En fordonstillverkare behöver inte följa denna standard, men de flesta gör det ändå. Många stora företag har dock fler feldiagnosmöjligheter än de som specificerats i SAE J2012 och de har därför möjlighet att använda egendefinierade felkoder genom att då ha en 1a på 2a plats i felkoden.

Anatomin för felkoderna Felkoden är uppbyggt på ett logiskt sätt som gör att man enkelt kan se vilken del i fordonet som felkoden indikerar något om. Följande figur påvisar den något hierarkiska uppbyggnaden av den fem tecken långa felkoden.

Figur 4 Felkodsstruktur enligt SAE J2012 Anledningen till att felkoden är uppbyggd på detta sätt är att koden egentligen bara består av två bytes. Det första värdet i felkoden, bokstaven, är representerad av bit 7 och bit 6 i den första byten av de två. Eftersom bokstaven bara är representerad av 2 bitar kan den endast anta 4 lägen (B,C,P,U), såsom figur 4. Nästa tecken (den första siffran) är representerad av bit 5 och 4 i första byten. Den andra siffran



13 (37)

representeras av bitarna 3,2,1 och 0 i första byten, och kan således ha 16 kombinationer. Dock används naturligtvis endast 9 av dessa möjliga kombinationer då det decimala talsystemet används. De sista två siffrorna i felkoden representeras av de övre resp. de undre fyra bitarna i den andra (sista) byten. Låt oss ponera att fordonsdatorn returnerar de hexadecimala värdena 0x03, 0x02 vid förfrågan om lagrade felkoder. Detta skulle enligt fig. ge oss felkoden P0302. I och med att det står ett P som första tecken vet vi att det handlar om ett motorrelaterat fel. Vi vet även att det handlar om en felkod definierad av SAE J2012 eftersom det står en 0:a som andra tecken. Om vi sedan ser på figur 5. ger 3:an oss att det handlar om ett tändningsproblem. De sista 2 tecknen i felkoden ”02” ger oss informationen att det handlar om cylinder 2. Sätter vi detta samman inser man att det handlar om en misständning i cylinder 2.

Figur 5 Felkodens uppbyggnad på 2-bytesformat

Servicelampan Servicelampan eller Malfunction Indication Lamp (MIL) som den ofta benämns i utländsk litteratur är den indikator som alla moderna bilar har utrustats med. Servicelampan, som finns på instrumentpanelen, tänds då fordonet har upptäckt ett utsläppsrelaterat fel. Ofta förekommer lampsymboler som de som visas i figur 6. men det kan även bara vara en motorsilhuett som symbol.

Figur 6 Servicelampor

När servicelampan tänds i ett fordon är det alltså frågan om att fordonet har ett fel som förmodligen leder till att utsläppen ökar från fordonet. Det kan vara saker som att tanklocket inte är stängt eller att en tändhatt är trasig.När Servicelampan är tänd är det som regel minst en felkod lagrad i fordonsdatorn, som ger verkstaden närmare information om felet. Dock behöver det inte vara så att servicelampan tänds så fort ett fel uppkommit. Faktum är att fordonstillverkarna är något vaksamma över att servicelampan inte skall tändas på en stor mängd bilar, då detta, åtminstone i USA förmodligen skulle leda till att biltillverkaren fick lov att kalla tillbaka sålda bilar. Man tänder därför inte alltid servicelampan direkt när ett fel uppkommit utan då det legat kvar och uppkommit under flera



14 (37)

körcykler2. På en helt vanlig bil brukar servicelampan tändas om ett fel uppkommer och finns kvar under 3 på varandra följande körcykler. Skulle det å andra sidan vara så att felet inte uppkommer alls under 3 körcykler så kan servicelampan slockna. Detta betyder då inte att felkoden har försvunnit från fordonsdatorn, utan den ligger kvar tills man raderat felet med ett diagnosverktyg.

Två typer av felkoder Det finns 2 olika kategorier eller typer av felkoder som OBD-II använder sig av. Typ A och Typ B, där typ A är den mer allvarligare. TYP A. 1. Utsläppsrelaterade felkoder. 2. Tänder Servicelampan efter en felaktig körcykel. 3. Lagrar en sk “Freeze Frame”3 efter att en felaktig körcykel förekommit. TYP B 1. Utsläppsrelaterade felkoder. 2. Sätter en “väntande” felkod efter att en körcykel fallerat. 3. Nollställer en väntande felkod när några på varandra korrekta körcykeler genomgåtts. 4. Tänder servicelampan och lagrar en ”Freeze Frame” efter 2 eller 3 felaktiga körcykler i rad.

SAE J1979 Standarden för de 9 testmoderna OBD-II använder sig av olika modes för att strukturera upp de tjänster som ingår i standarden. De är nio stycken och numreras från 1 till 9. Se tabell nedan.

1. Levererar realtidsdata. 2. Levererar ”freeze frame” data, som är mätvärden som lagras när ett fel uppkommer. 3. Levererar felkoder. 4. Raderar felkoder och lagrade värden i fordonsdatorn. 5. Levererar resultatet av lambdaprobens självtest. 6. Levererar resultatet av självtest av system som inte kontinuerligt övervakas. 7. Levererar resultatet av självtest av system som kontinuerligt övervakas. 8. Dedikerat kontrollmode. 9. Levererar fordonsdata, mjukvaruversion och fordonets ID-nummer VIN (Vehicle

Identification Number) samma som chassinumret.

2 En typisk körcykel är när fordonet kallstartats och körs till normaltemperatur. Under denna process måste fordonets självtester bli klara. 3 En Freeze Frame är ett lagrat datablock med parametrar som var aktuella när ett fel uppstod.



15 (37)

Mode 1 Mode 1 ger realtidsdata från fordonet. För att dela upp mode 1 ytterligare, i hastighet, varvtal osv. så används PIDs4.

PID 0 Vilka PID:s som stöds PID 0 används för att få reda på vilka PID fordonet stödjer. Fordonsdatorn returnerar 4 bytes vid en förfrågan som deklarerar vilka PID av 1-32 som stöds. Den mest signifikanta siffran i första byten innehåller information om PID 1, nästa bit om PID 2 osv. Värdet ett på biten står för att parametern stöds och en nolla för att den inte stöds.

PID 1 MIL-lampa, antal felkoder och tester PID 01 används för att ta reda på antalet felkoder, statusen för MIL lampan och vilka test som fordonet stödjer. Fordonsdatorn returnerar 4 bytes, där första bytens bitar 0-6 innehåller antal felkoder och bit 7 är statusen för MIL lampan (0 = av, 1 = på). För de tre andra bytes se tabellen 2 och 3. Tabell 2 Den andra byten, kontinuerliga test

OBD Test Andra byten

Misständning Bit 0 = 1 innebär att testet stöds

Bränslesystem Bit 1 = 1 innebär att testet stöds

Komponenter Bit 2 = 1 innebär att testet stöds

Misständning Bit 4 = 0 innebär att testet är klart

Bränslesystem Bit 5 = 0 innebär att testet är klart

Komponenter Bit 6 = 0 innebär att testet är klart

Tabell 3 Den tredje och fjärde byten, icke kontinuerlig testen

OBD Test Tredje byten Fjärde byten

Katalysator Bit 0 = 1 innebär att testet stöds Bit 0 = 0 innebär att testet är klart

Upphettad katalysator Bit 1 = 1 innebär att testet stöds Bit 1 = 0 innebär att testet är klart

Avdunstningsystem Bit 2 = 1 innebär att testet stöds Bit 2 = 0 innebär att testet är klart

Sekundära luftsystem Bit 3 = 1 innebär att testet stöds Bit 3 = 0 innebär att testet är klart

A/C kylning Bit 4 = 1 innebär att testet stöds Bit 4 = 0 innebär att testet är klart

Syresensor Bit 5 = 1 innebär att testet stöds Bit 5 = 0 innebär att testet är klart

Syresensoruppvärmare Bit 6 = 1 innebär att testet stöds Bit 6 = 0 innebär att testet är klart

EGR system Bit 7 = 1 innebär att testet stöds Bit 7 = 0 innebär att testet är klart 4 PID är en akronym för parameter identification .



16 (37)

PID 3 Bränslesystem status (öppen/stängd loop) Denna PID returnerar två bytes. Första byten är för system 1 och andra för system 2. Man tolkar system ett och två på samma sätt. Bit 0 Öppen Loop, detta tillstånd är normaltillståndet under uppstart. Bit 1 Stängd Loop, Syresensorerna är återkopplade för att reglera bränsletillförseln. Normaltillstånd under körning. Bit 2 Öppen Loop, infaller under acceleration och deacceleration. Bit 3 Öppen Loop , infaller under systemfel. Bit 4 Stängd Loop, använder sig av återkoppling av syresensorerna, men alla används ej i återkopplingen pga. något fel. Bits 5-7 används ej och skall vara noll.

Bara en bit kan vara ettstäld. PID 4 Motorlast i procent Denna PID returnerar en byte. För att räkna fram motorlasten i procent används följande formel: Motorlast i procent =byten från fordonsdatorn * 100/255

PID 5 Kylartemperatur i grader Celsius Denna PID returnerar en byte. För att räkna fram kylartemperatur i grader Celsius används följande formel: Kylartemperatur i grader Celsius = byten från fordonsdatorn –40.

PID 6 Kortsiktig bränsletrim i procent, bank 1 Denna PID returnerar en byte. Bränsletrim är ett relativt värde ifrån -100 % till + 99,22 %. För att räkna fram bränsletrim används följande formel: Bränsletrim i procent = 0,7812 * (byten från fordonsdatorn -128)

PID 7 Långsiktig bränsletrim i procent, bank 1 Samma formel som PID 6

PID 8 Kortsiktig bränsletrim i procent, bank 2 Samma formel som PID 6

PID 9 Långsiktig bränsletrim i procent, bank 2 Samma formel som PID 6 PID 10 Bränsletryck i kPa Denna PID returnerar en byte. För att räkna fram bränsletryck i kPa används följande formel: Bränsletryck i kPa = 3 * byten från fordonsdatorn.



17 (37)

PID 11 Tryck insugningsgrenrör i kPa Denna PID returnerar en byte och trycket i insugningsgrenröret är värdet på den byte som returnerades.

PID 12 Motorns varvtal i varv per min Denna PID returnerar 2 bytes. För att räkna fram motorns varvtal används följande formel: Motorns varvtal i varv per min = 0,25 * (första byten från fordonsdatorn * 256 + andra byten). PID 13 Hastigheten i km/h Denna PID returnerar en byte och hastigheten är värdet på den byte som returnerades. Observera att hastigheten alltid är positiv, även om man backar.

PID 14 Antal grader cylinder ett är före Denna PID returnerar en byte. För att räkna fram hur många grader cylinder ett ligger före används följande formel: Grader före = (0,5 * byten från fordonsdatorn) – 64.

PID 15 Insug temperatur i grader Celsius Denna PID returnerar en byte. För att räkna fram insugstemperatur används följande formel: Insugstemperatur i grader Celsius = byten från fordonsdatorn – 40. PID 16 Luftflödet i MAF sensorn i gm/sec Denna PID returnerar två bytes. För att räkna fram luftflödet in till motorn används följande formel: Luftflödet i MAF sensorn i gm/s = 0,01 * ((256 * första byten) + andra byten).

PID 17 Gasspjällsläge i procent Denna PID returnerar en byte. För att räkna fram gasspjälläget används följande formel: Gasspjälläge i procent = 0,3922 * byten från fordonsdatorn. PID 18 Sekundära luftsystemstatus Sekundära luftsystem används till att värma katalysatorn. Denna PID returnerar en byte som bara en bit kan vara en etta. Byten tolkas på följande sätt: Bit 0 =1 -> En uppåtström i den första katalysatorn. Bit 1 =1 -> En nedåtström i den första katalysatorn. Bit 2 =1 -> Systemet avstängt. Bits 3-7 är reserverade (skall vara noll) PID 19 Syresensorerna lokalisering i bankerna Denna PID returnerar en byte som innehåller information om vilka sensorer som existerar och i vilka banker. Varje bit i byten står för en sensor. Om värdet är en etta så finns det en sensor i den aktuella positionen, och en nolla så finns det ingen sensor på aktuell plats. Bitarna tolkas på följande sätt: BIT 0 = Bank 1 - Sensor 1 BIT 1 = Bank 1- Sensor 2 BIT 2 = Bank 1- Sensor 3 BIT 3 = Bank 1- Sensor 4 BIT 4 = Bank 2- Sensor 1 BIT 5 = Bank 2- Sensor 2



18 (37)

BIT 6 = Bank 2- Sensor 3 BIT 7 = Bank 2- Sensor 4 PID 20 Spänning syresensor bank1 sensor1 Denna PID returnerar två bytes. Den första byten innehåller spänningen för syresensor 1 i bank 1. Den andra byten innehåller kortsiktigt bränsletrim som är associerat till syresensorerna, om värdet i byten är det hexadecimala värdet FF så används inte denna syresensor i uträkningarna av bränsletrimmet. Följande formler används: Spänning syresensor = 0,005 * första byten. Kortsiktigt bränsletrim i procent = 0,7812 * (andra byten -128). PID 21 Spänning syresensor bank1 sensor2 Samma metod som PID 20. PID 22 Spänning syresensor bank1 sensor3 Samma metod som PID 20. PID 23 Spänning syresensor bank1 sensor4 Samma metod som PID 20. PID 24 Spänning syresensor bank2 sensor1 Samma metod som PID 20. PID 25 Spänning syresensor bank2 sensor2 Samma metod som PID 20. PID 26 Spänning syresensor bank2 sensor3 Samma metod som PID 20. PID 27 Spänning syresensor bank2 sensor4 Samma metod som PID 20.

PID 28 Fordonets OBD version Denna PID returnerar en byte, som står för vilken OBD version fordonet stödjer. Byten avkodas enligt följande:

01 - OBD II (Kaliforniens ARB) 02 - OBD (EPA) 03 - OBD and OBD II 04 - OBD 1 05 – Ingen OBD version stöds. 06 - EOBD (Europe)

PID 29 Alternativ lokalisering av syresensorerna Denna PID är liknande PID 19 med skillnaden att bitarna står för andra positioner. Se nedan: BIT 0 - Bank 1- Sensor 1 BIT 1 - Bank 1- Sensor 2 BIT 2 - Bank 2- Sensor 1



19 (37)

BIT 3 - Bank 2- Sensor 2 BIT 4 - Bank 3- Sensor 1 BIT 5 - Bank 3- Sensor 2 BIT 6 - Bank 4- Sensor 1 BIT 7 - Bank 4- Sensor 2

PID 30 Hjälpinmatningstatus Returnerar en byte. Om bit 0 är en etta så är Power Take Off aktiv.

PID 31 Reserverad

PID 32 PID 20 fungerar på mottsvarande sätt för PID 33 – 64 som ingår i standard J2190.

Mode 2 Med mode 2 så hämtas frysta parametrar ”freeze frame” från fordonsdatorn. Dessa parametrar är tagna från fordonet då ett fel inträffade. Vilket fel det rör sig om får man fram genom att använda PID 2, fordonsdatorn returnerar då två bytes som är felkoden. Mode 2 är indelade med PIDs på samma sätt som mode 1. Det som skiljer är att PID 2 (vilken felkod som de frysta värden gäller för) bara finns i mode 2 och PID 1 (MIL-lampa, antal felkoder och tester) bara finns i mode 1.

Mode 3 Mode 3 användes för att leverera felkoder. Kontrollera först PID 1 i mode 1 för att se om det finns felkoder och hur många. Användning av mode 3 när felkoder ej finns kan leda till att svar från fordonsdatorn uteblir. Felkoder fås genom att anropa med mode 3 (detta mode är inte uppdelat i PID:s). Då levereras felkoder i paket om tre st (6 bytes) tills alla har överförts. Om antal felkoder inte är jämt delbart med 3 så fylls det sista paketet med felkoder, på med nollor.

Mode 4 Mode 4 används för att nollställa MIL lampan, radera frysta parametrar, felkoder och nollställa de olika testerna. Detta mode är som mode 3 inte uppdelat i PIDs. För att nollställa och radera så anropas bara mode 4.



20 (37)

Mode 5 I detta mode fås resultatet från syresensorernas självtest. Syresensorer är på fordon monterade framför och bakom katalysatorn. De har en viktig roll för att optimera förbränningen i motorn. Vid en perfekt förbränning så blir restprodukterna bara koldioxid och vatten. Vid en dålig förbränning blir det kolväten, koloxid, syre, koldioxid, vatten och kväveoxid kvar. En förbränning är svårt att få perfekt, men syresensorerna hjälper till att återkoppla information om förbränningens kvalité så att förbränningen kan effektiviseras. Information om hur man läser ut syresensorerna/lambaprobens självtestresultat är svår att få tag på. Skulle dock någon syresensor inte fungera korrekt så kommer en felkod att generas.

Mode 6 Levererar resultatet av självtest av system som inte kontinuerligt övervakas. Använd mode 1 PID 1 för att kontrollera vilka test som stöds av fordonet och att de är klara. Katalysatortest kontrollerar katalysatorns effektivitet genom att jämföra syresensorn före katalysatorn med syresensorn efter. Om syresensorn efter katalysatorn ger lika eller nästa lika mycket utslag som sensorn innan katalysatorn kommer testet att misslyckas, eftersom katalysatorn inte har lyckats att rena avgaserna tillräckligt mycket till koldioxid och vatten. Upphettadkatalysatortest kontrollerar hur effektivt katalysatorn blir uppvärmd. Avdunstningssystemtest kontrollerar bränsleavdunstningsystemet i bränsletanken. Så att inga bränsleångor kommer ut i luften i onödan. Sekundära luftsystemtest kontrollerar luftpumpen och dess komponenter som används till att värma upp katalysatorn snabbare. A/C kylningstestet är inte så vanligt att det är implementerat i fordonsdatorn. Testet kontrollerar motorns vridmoment när kompressorn kopplas in. Syresensortest kontrollerar hur väl syresensorerna fungerar. Detta är ett viktigt test eftersom syresensorna styr genom återkoppling hur mycket bränsle som skall förbrännas. Syresensor uppvärmningstest kontrollerar uppvärmningen av syresensorna. EGR (Exhasust Gas Recirculation) systemtest kontrollerar ventilen och flödet är ok. EGR är ett system där man försöker att bränna om ej förbränt bränsle. Ett av de vanligaste problem är att sot sätter igen systemet. Information om att läsa ut mode 6 har tyvärr ej kunnat hittas. Eftersom dessa test rör emissionen så kommer en felkod att leverans ifall något inte fungerar som det ska.

Mode 7 Levererar resultatet av självtest av system som kontinuerligt övervakas. Använd mode 1 PID 1 för att kontrollera vilka test som stöds av fordonet och att de är klara.



21 (37)

Misständningtestet kontrollerar att ingen misständning sker. Det är vevaxelgivaren som kontrollerar tändningarna. Om misständning detekteras så sätts en felkod P03XX där XX står för vilken cylinder som misstände. Bränslesystemtestets uppgift är att se till att bränsleförbrukningen blir optimerad för fordonet. Detta sker med hjälp av kortsiktig och långsiktig bränsletrim parameterar. Det fungerar som så att syresensorer mäter av hur bra förbränningen gick, och sätter värdet på kortsiktig bränsletrim som innebär om det behövs mer eller mindre bränsle. Långsiktig bränsletrim tar då och då stickprov av kortsiktiga och ändrar sitt värde för att få kortsiktigt bränsletrim att närma sig värdet noll. Om kortsiktigt eller långsiktigt bränsletrim ändrar för drastiskt så genereras en felkod. Komponentertestet testar olika komponenter i fordonet som påverkar motordrift. Ex på komponenter är hastighetsgivare och kylvätsketemperaturgivare. Information om att läsa ut mode 7 har tyvärr ej kunnat hittas. Eftersom dessa test rör emissionen så kommer en felkod att levereras ifall något inte fungerar som det ska.

Mode 8 Mode 8 är till för att testa fordonets diagnostiksystem med extern testutrustning, och enskilda komponenter. Information om hur man använder mode 8 har tyvärr inte kunnat hittas.

Mode 9 Mode 9 innehåller fordonsinformationen så som chassinumret (VIN nummer), version på mjukvaran, och lite annat. Fordonet chassinummer får genom att använda PID 2. VIN numret returneras ifrån fordonsdatorn i fem paket med vardera 5 bytes. Den första byten står för vilket paket det är. De övriga fyra bytes innehåll beror på vilket paket det är: I första paketet är sista byten (femte), första bokstaven i VIN numret i ascii format. I andra paketet är de fyra sista byten (två till fem), andra till femte tecknet i VIN numret. I tredje paketet är de fyra sista byten, sjätte till nionde tecknet i VIN numret. I fjärde paketet är de fyra sista byten, tionde till trettonde tecknet i VIN numret. I femte paketet är de fyra sista byten, fjortonde till sjuttonde tecknet i VIN numret.



22 (37)

Överföringsprotokoll För att det skall kunna gå att kommunicera med fordonsdatorn behövs ett protokoll. OBD har 5 stycken protokoll som används av olika fordonstillverkare runt om i världen. Två av dessa protokoll är standardiserade av SAE och går under standardbenämningen J1850. De två protokollen heter VPW och PWM och finns i stora delar implementerade i Amerikanska fordon. För Europa och Asien heter protokollen IS0 9141 och ISO 14230. På senare år har standarden ISO 15765 vedertagits som nu mer är ett av överföringsprotokollen inom EOBD och detta kommer förmodligen att ersätta de övriga protokollen inom en nära framtid.

J1850 PWM PWM-protokollet är uppbyggd på tekniken pulsbreddsmodulering (Pulse width Modulation). Hastigheten ligger på 41.6Kb/s och använder stiften 2 och 10 på den standardiserade kontakten. PWM används av biltillverkare som Ford, Jaguar och Mazda.

J1850 VPW Den andra av de två SAE-standarderna är VPW som är ett något långsammare protokoll. Det utnyttjar en överföringshastighet på 10.4Kb/s och är ett variabelt pulsbreddsmodulerat protokoll. För detta protokoll utnyttjas bara stift 2 på kontaktdonet för dubbelriktad kommunikation. Protokollet används på General Motors fordon men Chrysler har också till en viss del utnyttjat det i sina fordon.

ISO 15765 –CAN ISO 15765-4 eller ”Diagnostics on CAN-Requirements for emission related systems” som standarden benäms har blivit godkänt som ett ytterligare överföringsprotokoll för EOBD i EU direktivet 1999/102 från januari 2000. I Amerika blev standarden vedertagen som ett överföringsprotokoll något senare men standarden gäller från fordonsmodeller gjorda under 2003 och efter. Med detta måste man undertrycka att eftersom CAN-bussen jobbar med hastigheter som är ca 100 ggr snabbare än ISO 9141 så kommer den att ta över som överföringsprotokoll inom EOBD/OBD-II med all säkerhet. Struktur, uppbyggnad, meddelandeformat och övrigt som berör CAN som överföringsmedium finns standardiserat i ISO 11898.

ISO 9141/14230 Detta är den standard som Europa har etablerat för kommunikation med fordonsdatorer och därför också den standard som vi kommer att studera mer ingående än de övriga. Speciellt ISO 14230 eller ”Keyword Protocol 2000” som standarden också benämns, eftersom det är den som Samarbetsgruppen för svensk fordonsdiagnos har beslutat att använda. Samarbetsgruppen för svensk fordonsdiagnos består av fordonstillverkare som Volvo, Saab och Scania. De har därför ett stort inflytande över hur standarden utformas i Sverige och har bla. skapat dokumenten SSF 14230-X som beskriver den svenska tillämpningen av EOBD.



23 (37)

Signalnivåer För att kommunikationen skall kunna tolkas korrekt måste de logiska tillstånden bestämmas med avseende på en viss spänningsnivå. Spänningsnivåerna tolkas till de två logiska tillstånden enligt figur 7. En logisk 0:a är max 20% av spänningen på sändarsidan och max 30% av spänningen på mottagarsidan. Vidare är en logisk 1:a minst 80% av spänningen på sändarsidan och minst 70% på mottagarsidan. I figuren är VB fordonets batterispänning.

Figur 7 Spänningsnivåer, sk "Worst case"-värden

Meddelandets struktur Ett datameddelande som skickas mellan fordonsdatorn och ett testinstrument består enligt ISO14230 av ett meddelandehuvud, data och slutligen en checksumma5. Meddelandehuvudet består av max 4 bytes. En formatbyte, en måladress, en källadress och slutligen en sista byte, längdbyten, som talar om hur stort datapaketet är. I meddelandehuvudet är det bara formatbyten som måste vara med vid ett meddelande, dvs de andra tre är valbara. Formatbyten består av 6 bitar som ger meddelandets längd och 2 bitar som utnyttjas för att indikera vilken typ av meddelandehuvud som används. Formatbytens uppbyggnad kan ses i figuren nedan där Ax är adressbit och Lx är längdbit.

Figur 8 De olika bitarna i formatbyten

Beroende på A1 och A0:s värde i formatbyten så finns det 4 olika typer av meddelandehuvud som ett meddelande kan ha.

5 En checksumma är en beräkningsalgoritm som utförs för att kontrollera om informationen har överförts korrekt.



24 (37)

Dessa fyra former finns i tabell 4 nedan.

Tabell 4 De 4 olika meddelandehuvudena

A1 A0 Typ av meddelandehuvud 0 0 Ingen adressinformation 0 1 CARB/ 9141 Mode 1 0 Fysisk adressering 1 1 Funktionell adressering Om L0 till L5 är noll, dvs. om längden är noll på ett meddelande betyder det att längdbyten är inkluderad i meddelandehuvudet. Längdbyten talar då istället om hur många byte datameddelandet innehåller. Eftersom längdbyten har 8 bitar till förfogande och formatbyten enbart har 6 längdbitar innebär det att man kan utöka meddelandelängden från 63 bytes till 255 genom att införa en längdbyte i meddelandehuvudet. Enligt ISO 14230 kan ett meddelande alltså ha adressering eller icke adressering, dvs måladressbyte och källadressbyte medtagen i huvudet eller ej. Vidare kan ett meddelande ha med en längdbyte eller ej. Detta ger standarden 4 olika meddelandeformat som kan ses nedan.

Figur 9 Fyra olika former av meddelande enligt ISO 14230\KWP 2000.

Det första meddelandet innehåller varken adresser eller längdbyte. Meddelandet är då ett Node-to-Node6 meddelande och har en största datastorlek på 63 bytes eftersom det saknar längdbyte. Meddelande 2 används vid Multimode-bus7 topologier då man måste kunna adressera en specifik ECU8 för att kunna kommunicera med den. Meddelande 3 är likt det första meddelandet med skillnaden att det kan ta 255 databytes. Slutligen klarar sista meddelandeformatet av att adressera en specifik ECU och leverera upp till 255 databytes. Om vi ser till de olika meddelandehuvuden som finns ska vi speciellt gå in på den typ av meddelandehuvud som heter CARB /9141 Mode enligt standard och tabell 4. Detta meddelandeformat

6 Med Node-to-Node menas att det bara förekommer en ECU på K-linan som man kommunicerar med. 7 Med Multimode-bus menas att det förekommer flera ECU:er i serie på K-linan som man kan kommunicera med. 8 ECU, kommer från engelskans Electronic Control Unit och är en enhet som övervakar insprutning, bromsar etc.



25 (37)

är nämligen det meddelandeformat som interfacekretsen stöder som vi konstruerat och det är något annorlunda de övriga formaten. Enligt ISO 9141-2 består ett meddelande av två bytes meddelandehuvud, en källadress, data och slutligen checksumman. Varje byte inleds med en startbit och slutförs med en stoppbit vid överföringen. Data kan variera mellan 1 och 7 bytes till skillnad från ISO-14230 som hade stöd för hela 255 bytes. En Figur på hur meddelandeblocket ser ut kan ses i figur 10.

Figur 10 Meddelandeblock enligt ISO 9141-2

Checksumman finns som vanligt med sist i meddelandet. Den finns för att ha någon form av kontroll på att meddelandet överförts korrekt. Definitionen för checksumman är citerad och översatt från ISO 9141-2 och är enligt standarden på följande sätt:

.1och256mod}{somdefinieratär)2(där

:ärsåt,meddelandeii''nrbytepåvärdetnumeriskadetär)1(där,...321

:ärmeddelandeettOm

1

1

>=<><><+><=><=><>>=<<

≤≤><><><>><><<

−

CSiCSCSNtilliCSCSCS

NiiCSN

iiiN

På vanlig svenska skulle detta innebära följande enkla sats: Addera samtliga bytes i meddelandet. Modulo 256 på den summan ger oss Checksumman.

Initiering av bussen enligt ISO 9141-2 För att man skall kunna hämta information från en ECU behöver bussen initieras. Figur 11 visar informationsflödet vid en initiering av bussen. Vid ’1’ skickar diagnosinstrumentet det hexadecimala talet 33 som är en adress, med en hastighet av 5 bitar/sek. Fordonsdatorn kommer då att svara med ett synkmönster som består av alternerande 0 och 1, dvs 55 hexadecimalt. Vidare kommer fordonsdatorn att skicka två stycken Key Word 9följt på varandra med ett visst tidsintervall. I detta fallet sänds hexvärdet 08 två ggr. Diagnosinstrumentet svarar genom att sända det senast mottagna Keywordet 9 Key Word används av fordonsdatorn för att tala om för diagnosinstrumentet vilka meddelandetyper som stöds och hur hårdvaran är uppbyggd med avseende på L och K-Linan.



26 (37)

inverterat, dvs F7. Som en sista etapp i bussinitieringen kommer fordonsdatorn att skicka tillbaka den adress som testinstrumentet angav, inverterat. Efter detta är bussen initierad och redo för ordinär kommunikation.

Figur 11 Initieringsprocess enligt ISO 9141-2/ ISO 14230

Exempel på meddelande med ISO 9141-2 När bussen initierats bör man skicka ett meddelande som kontrollerar vilka PIDS som stöds enligt SAE J1979. Det gör man genom att skicka ett ”Mode 1-PID 0”-meddelande. Det är en förfrågan som ger svar på hur många PID:s som stöds från alla CARB-relaterade ECU:er för mode 1. Den interfacekrets som vi har för att kommunicera med fordonsdatorn hanterar meddelandehuvuden och checksummor intern i assemblerkoden. Därför behöver man enbart skicka, som i detta fallet 0100. Dvs Mode 1 PID 0. Följande rader är förfrågan till en fordonsdator och svar från den: >0100 48 6B 11 41 00 BE 3F B8 10 CA Svaret består av två stycken meddelandehuvuden.48 och 6B. Det är svaret på att interfacekretsen skickat meddelandehuvuden med värdena 68 och 6A enligt SAE J1979. Vidare fås värdet 11 vilket är en adress. 41 00 är svaret på att vi skickat 0100. Fyran läggs till för att påvisa att det är ett svar enligt



27 (37)

standarden, eller rättare sagt bit 6 ettställs i den första av de två byten. BE 3F B8 10 är våra fyra databytes som i detta fallet talar om för oss vilka PID:s som stöds. Varje bit av dessa 32 bitar (4 bytes) är nämligen en PID-status, och är en bit ettställd stöds den specifika PID:en. Standarden stöder med andra ord 32 PID:s per Mode. Enligt figuren nedan, där en ettställd bit markerats grå, stöds PID nr 1,3,4,5,6,7,11,12,13,14,15,16,17,19,20,21 och slutligen 28.

Den sista byten i svaret är Checksumman. Eftersom vi nu vet vilka PID som fordonsdatorn stöder i Mode 1är det bara att testa dessa parametrar. Som exempel är PID 13 enligt standarden fordonshastigheten som vi ser stöds i detta fall.

VIN-Vehicle identification number VIN, Vehicle Identification Number, är det Amerikanska namnet på den 17 tecken långa serien av siffror och bokstäver som de allra flesta fordon har erhållit vid tillverkningen. VIN, eller chassinummer som det heter i Sverige, blev definierat i ISO-standarden 3779 i februari 1977 och standarden har inte blivit förändrad sedan 1983. Anledningen till att man instiftade denna standard var att man enkelt skulle kunna identifiera bl.a. ursprung på en rad olika typer av motorfordon. Det finns nu stora databaser, bl.a. på Internet, som samlat in information om varje enskilt fordon, genom trafikregister osv. Till dessa databaser kan man söka sig till om man vill göra en kontroll på om ett specifikt fordon har varit med i någon krock eller liknande. En sådan kontroll kan vara mycket bra att göra vid t.ex. köp av begagnade bilar. Under mitten av 80-talet instiftade Amerikanarna en norm som skulle göra det svårare att stjäla bilar. Normen gick ut på att alla stöldbegärliga bilmodeller fick lov att märka ca 12-14 av de större bildelarna med VIN. Under senare år gäller detta alla bilar. Ett korrekt VIN, eller chassinummer, skall enbart innehålla stora bokstäver A-Z och siffrorna 1-9. Det får inte vara några andra tecken eller mellanslag med i ett VIN. För att det inte skall kunna bli några missförstånd används inte bokstäverna I,O,Q.

VIN-Struktur och Uppbyggnad VIN består utav tre delar, som vart och ett ger information om fordonet. De tre delarna är: WMI- World Manufacturer Identifier är den internationellt vedertagna benämningen på de tre första positionerna i VIN. WMI tillhandahåller information om i vilket land fordonet tillverkats och vilken tillverkare som tillverkat fordonet. Undantaget då en tillverkare konstruerar mindre än 500 bilar/år ges den 3:e positionen i VIN en 9:a. VDS – Vehicle Descriptor Section. Den här delen av VIN ger information om vad det är för sorts fordon. Information som ”4 dörrars Sedan” och liknande, mer specifikare information, går att få reda på genom VDS. VDS tar upp 6 positioner i VIN och dessa är tecken 4-9.



28 (37)

VIS – Vehicle Identifier Section är den sista delen i VIN och består av resterande 8 tecken. Standarden säger att denna del skall identifiera ett specifikt fordon. De två första tecknen är produktionsort och årsmodell. De 6 sista tecknen av dessa är det specifika produktionsnumret.

Kontrollsiffran Det 9:e tecknet i chassinumret är en kontrollsiffra/kontrollbokstav som verifierar att det är ett korrekt VIN. Kontrollsiffran beräknas genom att multiplicera de övriga 16 tecknen med en specifik viktning för varje enskilt tecken. Summan av dessa produkter skall sedan divideras med 11, och resten av denna heltalskvot är kontrollsiffran. Är resten 10 blir kontrollsiffran istället en kontrollbokstav, ”X”. Varje bokstav tilldelas ett bestämt numeriskt värde för att det skall gå att göra beräkningen. Observera att bokstäverna I, O, Q lämnats i tabell 5 nedan, enligt standarden.

A=1 J=1 T=3 B=2 K=2 U=4 C=3 L=3 V=5 D=4 M=4 W=6 E=5 N=5 X=7 F=6 P=7 Y=8 G=7 R=9 Z=9 H=8 S=2

Tabell 5 Värden för tecknen i VIN

Den specifika viktningen som man tilldelar samtliga tecken i VIN, förutom kontrollsiffran, är enligt tabell 6 nedan:

1=*8 10=*9 2=*7 11=*8 3=*6 12=*7 4=*5 13=*6 5=*4 14=*5 6=*3 15=*4 7=*2 16=*3

8=*10 17=*2

Tabell 6 Viktning för positioner i VIN

Exempel på kontrollsifferberäkning. VIN: 1 F A F P 5 3 U - X G 1 6 7 5 9 7 Siffervärde: 1 6 1 6 7 5 3 4 - 7 7 1 6 7 5 9 7 Viktning: 8 7 6 5 4 3 2 10 - 9 8 7 6 5 4 3 2 Produkten: 8 42 6 30 28 15 6 40 - 63 56 7 36 35 20 27 14 Tabell 7 Kontrollsifferberäkning Summan av produkterna är 433. 433 modulo 11 ger en heltalsrest på 4. Följaktligen skall 9:e position ges en 4:a i VIN.



29 (37)

Exempel på ett chassinummer från SAAB Automobiles AB. Figur 12 är en bild av den chassiplåt som alltid skall finnas instansad i chassit på fordonet. SAAB brukar ofta ha chassiplåten belägen under motorhuven, i hörnet närmast föraren eller någonstans på dörren vid föraren.

Figur 12 Chassiplåt från Saab Chassinumret innehåller i detta fallet följande information:

Tabell 8 Avkodat chassinummer från Saab

Position Definition Aktuellt chassinummer 1(Y) Geografisk område: Nordeuropa. 2(S) Land: Sverige. 3(3) Biltillverkare: SAAB Automobiles AB. 4(D) Produktlinje: 9-3. 5(F) Modellserie: 9-3 SE med förar- och

passagerarairbag. 6(5) Karossutförande: 5-dörrars. 7(8) Växellåda: Automatisk 4-växlad. 8(N) Motorvariant: 2,0 T B204L. 9(2) Kontrollsiffra: 2 10(V) Årsmodell: 1997 11(2) Produktionsort: Trollhättan. 12 Produktionsnummer: 027251

OBD-II i dagens fordon



30 (37)

I Europa är det EU, som med sina direktiv, pressar på fordonstillverkarna att implementera fordons diagnostik. För personbilar så finns OBD idag redan implementerat, medan för lastbilar blir det ett krav först år 2005. Se fig.

Figur 13 Eu:s tidskrav på fordonstillverkarna.

Personbilar OBD-II började gälla för vanliga bensindrivna bilar vid år 2000. Personbilarna som använder diesel som drivmedel gäller OBD-II från år 2003. Volvo och Saab har OBD-II implementerat i sina bilar redan idag. Båda biltillverkarna har mera diagnos än bara emissionsrelaterad diagnos implementerad, alltså mer än bara det som är lagkrav. Saab har över tusen stycken felkoder som rör motorn och växellådan på deras 9-3:a. Av dessa hör 150 stycken till standarden J2012 (P0 koder). Det finns även andra typer av felkoder implementerat i Saab 9-3 t.ex. C, U, och B felkoder. Problemet med dessa tillverkarspecifika felkoder är att definitionerna av dessa felkoder inte är tillgängliga för allmänheten. Saab har ett testinstrument som heter Tech2, en version av detta instrument klarar av att avkoda samtliga felkoder. Den versionen säljs bara till märkesverkstäder. Enligt Saab så har USA nu ökat pressen på fordonstillverkare att släppa mera information om deras diagnostiksystem. Den nya Saab 9-3 använder inget ISO 9141/ISO 14230 protokoll vid kommunikationen med diagnostik verktyget, utan använder sig helt och hållet av CAN. Även Volvo talar om att de kommer att gå över till CAN. Volvo använder sig av CARB:s OBD vilket innebär att de har lagkrav att ha krav K-linan på sina fordon tom år 2005. Saab använder sig av EOBD.

Lastbilar För tunga lastbilar börjar OBD-II att gälla från och med september år 2005. Vid år 2008 kommer kraven för diagnostiken att öka. Idag finns det inget krav på OBD på lastbilar, men Scania har redan implementerat KWP2000/ISO 14230 och kommer att samköras det med ISO 15031 (diagnostics on CAN) ett tag framöver. Scania använder dock ej ISO 9141/ISO 14230 (k-line bussen) i överföringen mellan diagnostikverktyget och fordonet utan enbart CAN. Kontakten för diagnostikinstrumentet i Scanias lastbil är ej den standardiserade med 16 stift (J1962), utan en egen variant. Scania har ett program, Scania diagnos 2,



31 (37)

där felkoder utläses och tolkas från fordonet. Detta får vem som helst köpa och prislappen är runt 80000 kr.

Utvecklingen av OBD Utvecklingen av OBD kommer med all säkerhet att fortsätta. USA som leder utvecklingen på OBD har pressat på biltillverkarna, med att de måste släppa på mera detaljer angående bilarnas elsystem. Fordonspecifik information kan nog bli tillgängligt inom snar framtid. När det gäller överföringsprotokoll så kommer CAN att ersätta K-line bussen när den inte längre blir obligatorisk i CARB standarden. CAN finns redan idag både i Saab, Volvo och Scanias bilar. För lastbilar kommer OBD att bli ett krav först år 2005. Vid år 2008 kommer kraven att öka för lastbilarna. Det kan tänkas att även emissionskraven för personbilar också kommer att ökas framåt i tiden. Vilket troligtvis kommer leda till mera elektronik för att få ner emissionen. Idag har Mercedes ett system som heter TeleAid som larmar larmcentralen ifall en bil råkar ut för en kollision. Det larmar via mobiltelesystemet som finns i bilen och med hjälp av GPS så lokaliseras fordonet. Det finns en del inom TeleAid som kallas för Telediagnos. Telediagnos är ett system där föraren av fordonet kan kontakta Mercedes ifall fel på fordonet har inträffat. Föraren trycker på en knapp på fordonets mobiltelefon och automatiskt skickas information om fordonet och vart fordonet befinner sig till ett assistanscenter. Sedan ringer servicepersonal upp och försöker lösa problemet på bästa sätt. Man kan tänka sig att system som Telediagnos kommer framöver att finnas hos flera biltillverkare. En vision är att man skall kunna kommunicera med fordonet och ställa om parametrar, kanske beroende väderlek och trafikförhållanden.



32 (37)

Diagnos för militära fordon I dagens stridsvagnar inom det svenska försvaret så verkar det som att OBD-II inte existerar, än så länge. Eftersom det sitter Scania motorer i Hägglunds stridsvagn 90, så kan man tänka sig att det bara är en tidsfråga innan OBD-II finns implementerat. I övrigt har det varit väldigt svårt att hitta relevant information om de militära fordonens eventuella diagnossystem.

Leoparden, STRV 121 och STRV 122 I Leoparden används idag ett tyskt diagnostikverktyg som heter RPP+. Detta verktyg ansluts till stridsvagnen via ett diagnostikuttag. Det finns två olika modeller av RPP+. Det första som det tekniska befälet använder sig av, och det andra som besättningen av stridsvagnen kan handha. RPP+ utför diagnos mestadels på tornet. Ett annat verktyg som används är underhållsdatorn TEMC som utför ett antal tester ex brandsläckningssystem, vinkelgivare osv. Se avsnittet om TEMC.

Stridsfordon 90 För stridsfordon 90 som används inom det svenska försvaret, finns idag inget avancerat diagnossystem för felsökning.

Framtidsvision En framtidsvision över diagnostiken på militära fordon är att ha inbyggda diagnossystem som under körning utför diagnos över fordonet. Hägglunds har idag ett system som heter VIS (Vehicle Information System) som skall kunna presentera samma data som en vanlig instrumentpanel samt fler funktioner som t.ex. instruktionsbok, fel-log och statusrapporter via bildskärmar till användarna av fordonet. I VIS systemet används CAN-bussen som överföringsmedium mellan alla olika enheter. En annan vision är att ha ett externt diagnostestsystem, t ex TEMC, som kan anslutas till fordonet via ett diagnostiktuttag. Det diagnostestsystemet borde klara av lite olika typer av fordon i förvarets fordonspark, så som stridsvagnar, lastbilar osv. Observera att den ena visionen inte utesluter den andra.



33 (37)

TEMC – Test Equipment and Maintenance Computer TEMC är den dator som programvaran är byggd för. Fördelar med att ha ett bestämt datasystem att programmera mot är att man vet vilka resurser man har, som exempel så är programvaran i examensarbetet anpassad efter TEMC:s skärmupplösning 1024 x 768. TEMC är beställd av försvarets Materielverk från Krauss-Maffei Wegmann GmbH där AerotechTelub är underleverantör. TEMC är ett stödsystem för fältmässig funktionstest och felsökning inom stridsfältsnivån för Stridsvagn Leopard 2. En del av syftet med examensjobbet är att öka TEMC funktionalitet för att gälla mer än bara för stridsvagnar i försvarets fordonspark.

Figur 14 TEMC - Underhållsdatorn



34 (37)

Resultat programvara Programvaran har testats på SAABs modeller 9-3, 9-5 med önskat resultat. Fordonen levererade samtliga parametrar utom bränsletrycket som fordonen ej stöder. Vid testkörning med SAAB-bilarna stämde hastighet och varvtal etc. överens med de värden som instrumentpanelen visade. Vi har vid ett flertal tillfällen försökt få fordonen att tända servicelampan och lämna felkoder genom att dra säkringar och ta bort givare. Eftersom de nya fordonen har ett sofistikerat bränsleavdunstningssystem som registrerar mindre läckor av bränsle, så ska det gå att ha tanklocket avtaget under en tid för att tända servicelampan. Det har dock varit lite problem med att få bilen att tända servicelampan, vilket i och för sig är bra, men vi lyckades vid ett tillfälle få fordonsdatorn att tända den och leverera en felkod. Programvaran registrerade detta och en felkod sparades ner enligt planerna. Dock hade vi räknat med att en Freeze Frame skulle sparas för felkoden, vilket inte gjordes. Detta beror förmodligen på att felet inte var allvarligt nog. Därför har vi inte testat ”Frysta värden”-fliken mer än med det fordonssimulatorprogram som vi gjort för att kunna utveckla programvaran. Vi har även testat diagnossystemet på en Volvo 850 från -96 med satisfierat resultat. Intressant här var att Volvo hade implementerat OBD-II flera år innan det var lagkrav. Vi har även testat Programvaran mot en Volkswagen, årsmodell 2002 som gick på diesel. Detta var även här intressant att se att Volkswagen låg före lagstiftningen som säger att dieselfordon måste ha OBD-II implementerat under 2003. Mycket utav den information som kan läsas ut från programvaran, såsom syresensorvärden och katalysatortester är sådant som inte finns på ett dieselfordon, så följaktligen fanns det inte mycket att läsa ut från den fordonsdatorn förutom standardparametrar. Vi har även testat programvaran mot två Audimodeller från mitten av 90-talet, men där kunde vi snabbt konstatera att det inte skulle fungera när inte ens den standardiserade OBD-II kontakten passade. Slutligen kan det påpekas att chassinumret inte gick att få från fordonsdatorn på vissa modeller. SAAB verkade dock ha fullt stöd för detta, och förmodligen är det fullt stöd på alla tillverkarmodeller som tillverkas idag.



35 (37)

Förbättringar på programvaran För tillfället är alla feldefinitioner på engelska och med tillverkarspecifika felkoder från ett okänt fordon. En bra förbättring skulle vara att ha svenska feldefinitioner med tillverkarspecifika felkoder. De tillverkarspecifika felkoderna kan då knytas till rätt fordon eftersom programvaran kan hämta hem Chassinumret och därmed också kan ta reda på vad det är för tillverkare och fordonsmodell etc. Man kopplar felkoderna mot rätt fordon helt enkelt. I dagsläget håller LAConsole.exe kvar porten öppen om man avslutar OBD-programet när man fortfarande är uppkopplad mot fordonsdatorn. Detta gör att serieporten är upptagen om man startar om OBD-programvaran. Detta kan lösas med funktionen preparetoclose() som finns färdig i programvaran. Utnyttja funktionen för att tvinga användaren att koppla ned med stoppknappen innan det går att stänga programvaran. Klassen COBDCommunication är för tillfället enbart uppbyggd för att kommunicera via serieporten med den interfacekrets som man kan läsa om i rapporten. Denna klass skulle kunna byggas ut eller bytas ut för att stödja ett CAN-interface. Programvaran utnyttjar för tillfället ej den information som kan utläsas i mode 5,6,7 och 8 enligt SAE J1979. Det har varit svårt att hitta information om dessa modes på nätet. Dock skulle man kunna köpa standarden SAE J1979 som beskriver detta. Dessa parametrar skulle man kunna lägga till som ytterliggare flikar exempelvis. Vissa fordon som tillverkades i ett tidigt skede i EOBD:s utveckling kan ibland inte stödja mode 9 som ger programvaran chassinumret. Detta leder till att ingen textfil med tidigare servicetillfällen kan lagras för den bilen. Man skulle här kunna ha en dialogruta eller likande som ber användaren att knappa in chassinumret så att felkoder kan lagras. En annan intressant aspekt vore att kunna nollställa den andra servicelampan eller ”10.000 milaservice”-lampan som den benämns ibland och som finns på de flesta bilar. Detta kan tyvärr ej göras med det interface som för tillfället används. Dock borde möjligheten finnas om man kan adressera andra ECU:er via tex CAN. Slutligen finns det någon enstaka parameter lämnad som skulle kunna presenteras med programvaran men som inte känns aktuell eller av annan anledning blivit utelämnad.



36 (37)

Slutsatser Fordonsdiagnosen på våra fordon har utvecklats under många år och kommer att fortsätta att utvecklas. Amerika har under många år drivit utvecklingen framåt och på senare år har Europa börjat följa detta med standarder som den Europeiska varianten av OBD-II som går under namnet EOBD. Ska man som företag utveckla ett testsystem för fordon är det ingen tvekan om att det är CAN som man skall satsa på som överföringsprotokoll, då detta är upp till 100 gånger snabbare än ISO 9141. De flesta fordonstillverkare kommer nämligen med all säkerhet att lämna de övriga protokollen för CAN. Som exempel har Saab lämnat K-linan och enbart utnyttjat CAN som överföringsprotokoll. En annan fördel med CAN är att man kan adressera mer enheter i fordonet och på så sätt få ut information som inte bara berör exempelvis emissionen. Den processor som införskaffades för interfacekretsen stödjer tyvärr ingen adressering av andra ECU:er än de som berör emission. I princip skulle man dock kunna skriva om assemblerkoden i processorn så att den initierar fler ECU:er än de som berör utsläpp. För att man skall kunna bygga en bra diagnosprogramvara som stödjer avläsning och programmering av exempelvis ABS, airbags och centrallås så måste man ha tillgång till den tillverkarspecifika informationen för det fordonet. Det finns nämligen mycket tillverkarspecifika tillämpningar även om standarden 15765-x vid namn ”Diagnostics on CAN” standardiserat en del kring detta. Framöver kommer det, åtminstone i USA att bli lättare att inhämta fordonsspecifik information om buss och elsystem i fordon. Detta kan vara en del i ett försök att reducera det överläge som märkesverkstäderna har gentemot övriga verkstäder vad beträffar just den avancerade elektroniken som finns i dagens fordon.



37 (37)

Referenser

Internet: [I1] http://www.scantool.com [I2] http://www.obddiagnostics.com/obdinfo/info.html acc 2003-06-17 [I3] http://www.scantool.net/forum/index.php acc 2003-06-17 [I4] http://www.aerotechtelub.se/Upload/temc%20004.pdf [I5] http://www.mercedes-benz.com/e/innovation/fmobil/webcar_5.htm [I6] http://www.mercedes-benz.com/e/innovation/rd/teleaid.htm [I7] http://clubs.hemmings.com/clubsites/chevylist/tech/vin/decode_modern_vin.htm [I8] http://www.autoinsurancetips.com/vin_number.htm [I9] http://www.obdii.com/connector.html

Kontaktpersoner: [K1] Mattias Nyberg, Scania Södertälje [K3] Morgan Uggla, SAAB Automobile, Trollhättan [K2] Peter Servin, FMV Skövde

Litteratur: [L1] Peter David (2000),OBDII Diagnostics, Kotzig Publishing,Slovakien ISBN 0-9715411-4-0

Tidsskrift: [T1] Allt om elektronik nr 9/2002, Electronic Press AB, Stenugnsund [T2] Allt om elektronik nr 10-11/2002, Electronic Press AB, Stenugnsund

Protokoll: [P1] ISO 14230-1 Road Vehicles – Diagnostics systems. Keyword Protocol 2000 – Physical layer. [P2] ISO 14230-2 Road Vehicles – Diagnostics systems. Keyword Protocol 2000 –Datalink layer. [P3] ISO 9141-1 Road Vehicles – Diagnostics systems- Requirements for interchange of digital information. [P4] ISO 9141-2 Road Vehicles – Diagnostics systems- CARB requirements for interchange of digital information.

http://www.scantool.com/

http://www.aerotechtelub.se/Upload/temc 004.pdf

http://www.mercedes-benz.com/e/innovation/fmobil/webcar_5.htm

http://www.mercedes-benz.com/e/innovation/rd/teleaid.htm

http://clubs.hemmings.com/clubsites/chevylist/tech/vin/decode_modern_vin.htm

http://www.autoinsurancetips.com/vin_number.htm

http://www.obdii.com/connector.html

Bilaga A: Interfacekretsen. För att programvaran som vi programmerat skall kunna kommunicera med fordonsdatorn behövs en gränssnittsomvandlare som konverterar spänningsnivåer etc. Eftersom vi använder RS232 på datorsidan och ISO 14230/KWP2000 på fordonssidan. Interfacekretsen som kan ses på fig. nedan hanterar spänningsomvandlingen med hjälp av transistorer som bottnar och stryps. Kretsen får matning från fordonets batteri via stift 16 enligt standard. PIC-processorn som sitter på kortet är en pic16c54 från Microchip och den är av ELM Electronics försedd med ett assemblerprogram som sköter protokolltolkningen. Med interfacekretsen kan man kommunicera med en fordonsdator genom exempelvis hyperterminalen, som ingår i Windows, om man vet vilka kommandon som skall sändas. Checksumman och de meddelandehuvuden som ingår i ISO-protokollet hanteras helt av kretsen och behövs därför inte hanteras i någon annan programvara.

Benkonfiguration Kretsen har försetts med 7 stift som vart och ett skall kopplas in för att interfacet skall kunna fungera. I figur 1 illustreras vilka ben som är vilka på interfacet.

Figur 1 Interfacekretsens 7 stift

OBD 1 L-Line 2 Batteri 3 K-Line 4 Signaljord RS232 5 Rx, Ta emot data 6 Tx, Sänd data 7 Signaljord

Tabell 1 Interfacekretsens stiftkonfiguration

Kopplingsschema för interfacekretsen.

Figur 2 Kopplingsschema

Komponentlista

Beteckning Komponent Spänningsreg. REG LM340MP-5,0 Spänningsreg. Kondensatorer C1,C3 X7R 0603 0,1uF C2 X7R 0603 10nF C4,C5 NPO 0603 27pF Dioder D1,D2 BAS32L Switchdiod SOD 80 Transistorer Q1,Q2 BSR18A PNP SOT23 Q3,Q4 BCX70J (AJ) SOT23 Kristall XTAL 3.579545 MHz Resistorer R1,R6 0805 , 10Kohm R2,R5 0805 , 510 ohm R3,R4 0805 , 2,2 Kohm R7,R10 0805, 4,7 Kohm R8 0805, 47 Kohm R9 0805, 100Kohm Processor ELM_323 ELM 323 PIC

Tabell 2 Komponentlista

Komponentplacering

Figur 3 Komponentplacering

Mönsterkortslayout på interfacekretsen. Kortet nedan är designat i Eagle som är en programvara från CADsoft och den översta layouten är topplagret som till synes också har försetts med ett jordplan för bättre EMC-prestanda. Originalstorlek är 53* 34 (mm) så kortet i figur 19 är förstorad ett antal gånger.

Figur 4 Mönsterkortslayout

Bilaga B: Användarmanual för programvaran Programvaran är framtagen för att man på ett enkelt sätt skall kunna kommunicera med fordonsdatorn i ett fordon. Kommunikationen sker mellan serieporten på datorn och via en interfacekrets som omvandlar ordinär seriekommunikation till de standardiserade protokollen ISO 9141/14230. När programvaran startas ser programmet ut enligt nedanstående bild. Programmet har 4 stycken ramar. I ramen ”Inställningar” ställer användaren in sina parametrar. Dessa värden är kopplade mot en databas. Ramen ”Instruktion” ger handledaren kortare instruktioner om vad som för tillfället bör göras. I ramen ”Kommentar” kan användaren själv skriva in meddelanden och kommentarer. Resultat-ramen är den ram där kommunikationen med fordonsdatorn sker. Resultat innehåller förutom 6 st flikar som kommer att tas upp specifikt, även 6 st rutor med diverse information som hämtats från fordonsdatorn.

Figur 1 Bild på Programvaran

De 6 rutorna, belägna i högra delen av programvaran, beskrivs enligt följande: Protokoll ger användaren information om vilket protokoll som för närvarnade används för att kommunicera med fordonsdatorn. Fordonets ID förser användaren med testobjektets standardiserade 17 tecken långa chassinummer. Antal Felkoder rapporterar antalet felkoder som testobjektet lagrar i fordonsdatorn.

Typ av OBD levererar information till användaren om vilken variant av OBD som används. OBD1, OBD2 etc. Kommunikation Status ger användaren information om länken mot fordonsdatorn samt ev. uppkopplingstid. Status Servicelampa indikerar med en röd blinkande motorsymbol om servicelampan slagits på i testobjektet. Finns inga felkoder lagrade i fordonsdatorn kommer symbolen att lysa grönt.

Fliken Realtid.

Figur 2 Realtidsfliken

Fliken realtid är den flik som användaren ser vid uppstarten. När kommunikationen är upprättad med fordonsdatorn kommer dessa parametrar att uppdateras kontinuerligt utifrån fordonsdatorns värden. Realtidsvärdena är indelade i de två grupperna Generella parametrar och Bränslesystem. Från start är samtliga checkrutor markerade vilket innebär att alla värden skall hämtas. Avbockas en ruta hämtar programvaran ej det värdet. Detta gör att uppdateringsförloppet kan ökas markant om man väljer att exempelvis titta enbart på hastighetsvärdet. En förloppsindikator vid namn Uppdateringsförlopp ger information om uppdateringshastigheten för parametrarna.

Parameter Beskrivning

Hastighet Aktuellt värde på testobjektets hastighet i km/h Varvtal Aktuellt värde på testobjektets motorvarvtal i vpm. Motorlast Den last i procent som belastar motorn. Temp Kylare Aktuell temperatur på kylaren i grader C. Temp Insug Denna parameter ger insugningstemperaturen I grader

Celsius. Gaspedalsläge Ger information om gaspedalens läge till motorns styrenhet.

Denna information används för att vrida gasspjället. Tryck Insugningsrör

Aktuellt tryck i insugningsgrenröret

Bränsletryck Denna Parameter ger det aktuella värdet på bränsletrycket in till motorn.

Status System 1 Öppet eller återkopplat (stängd loop) bränslesystem. Där ett återkopplat system ger bättre bränsleblandning genom att fordonet utnyttjat syresensorer.

Status System 2 Öppet eller återkopplat (stängd loop) bränslesystem. Där ett återkopplat system ger bättre bränsleblandning genom att fordonet utnyttjat syresensorer.

Kortsiktig Bränsletrim

Med hjälp av syresensorer kan bränsleblandningen optimeras gentemot den optimala blandningen luft/bränsle som är 14.7:1 Parametern ger info om denna optimeringsprocess. Värdet ligger mellan –10% - 10 %

Långsiktig Bränsletrim

Denna parameter tar ”stickprov” på det kortsiktiga bränsletrimvärdet och om det kortsiktiga skulle ligga förskjutet så förskjuts detta värde så att Kortsiktig bränsletrim kommer mot 0.

Tabell 1 Beskrivning av realtidsparametrar

Fliken Felkoder

Figur 3 Fliken Felkoder

Fliken Felkoder rapporterar de eventuella felkoder som testobjektet kan tänkas ha. De felkoder som bilen eventuellt har lagrat, och som programvaran senare hämtar hem, kommer att finnas i rutan Befintliga Felkoder. Där kan användaren klicka på en felkod från fordonet och få upp specifik information om felkoden i rutan Felkodens Definition. När användaren väljer att radera felkoderna som ligger i fordonsdatorn, genom att trycka på knappen RADERA, kommer de befintliga felkoderna att försvinna, och istället kommer listen Tidigare Service nu att uppdateras med datumet samt klockslaget på den samling felkoder som var aktuell vid raderingen. Listen tidigare service sparar således samtliga tidigare servicetillfällen som det specifika fordonet har genomfört. Detta är kopplat med chassinumret som primnyckel och sker automatiskt. I listen Tidigare Service kan man därför välja ett datum för feldiagnostik och när detta är gjort kommer rutan Befintliga Felkoder för Tidigare Service att innehålla de fel som fanns vid det specifika servicetillfället. Detta för att man enkelt skall kunna jämföra om det finns återkommande fel i testobjektet. Definitionerna för samtliga felkoder som programvaran hanterar finns att tillgå i textfilen ”Felkoder.txt” och det är den som programvaran utnyttjar för att hitta korrekt definition för felkoden. För närvararande är felkoderna på engelska , men kan alltså skrivas om till svenska genom att ändra i textfilen.

Fliken Frysta värden.

Figur 4 Fliken Frysta värden

Fliken Frysta värden är endast aktiv då Servicelampan lyser på testobjektet och det finns felkoder lagrade i fordonsdatorn. Felet som genererade de frysta värdena är den ruta som innehåller information om vilket fel det var som orsakade en frysning av de realtidsvärden som var aktuella då servicelampan tändes. På så sätt kan man se om någon parameter var onormal då felkoden utlöstes vilket underlättar felsökandet. Parametrarna är i övrigt de samma som finns under fliken realtid. RADERA-knappen har samma funktion som den som finns i fliken Felkoder och när den trycks blir hela fliken Frysta värden tömd på parametrar och avaktiverad.

Fliken Fordonsinfo

Figur 5 Fliken fordonsinfo

Fliken fordonsinfo ger användaren specifik information om testobjektet. Här kan man få information om biltillverkare, årsmodell och produktionsort etc. Denna information finns inte lagrad i fordonsdatorn i ordinär bemärkelse, den är istället hämtad från det chassinummer som dock finns lagrat i fordonsdatorn. Informationen som går att utläsa från chassinumret är standardiserad men informationen varierar naturligtvis beroende på fordonstillverkaren. Eftersom det finns mängder med fordonstillverkare och modeller har vi valt att ha denna information lagrad i textfiler. Fördelen med detta är att man enkelt kan implementera ytterliggare information om fordon allteftersom de släpps på marknaden eller om man vill förändra något om någon specifik tillverkare. Man kan även enkelt skriva om koden för att anpassa detta till en databas. För att lägga till en fordonstillverkares chassinummerinformation får man skapa en textfil som har de 4 första bokstäverna i chassinummret som namn. Detta för att det är dessa 4 bokstäver som identifierar en fordonstillverkares specifika modell, enligt standarden. Ett exempel på hur ett inlagt textdokument kan se ut är denna fil, som innehåller specificeringar hämtad från en specifik SAAB-modells instruktionsbok:

Figur 6 Struktur på textdokument för chassinummeravkodning

När ett chassinummer hämtas från fordonsdatorn och de första 4 bokstäverna stämmer med något av namnen på de textfiler som finns lagrade, kan programvaran således finna ytterliggare information i textfilen. Textfilen måste byggas upp på detta sätt för att programmet skall kunna hämta informationen. Ett @ skall ligga framför varje ny position i chassinumret och efter det skall de olika varianterna ligga på rad med definitionen efter ”=”-tecknet. Som exempel på detta innebär Chassinumret ”YS3EG45CX13456783” alltså att programvaran kommer att visa följande information under fliken Fordonsinfo: Geografiskt område Nordeuropa Land Sverige Biltillverkare SAAB Automobile AB Produktlinje 9-5 Karossutförande Saab 9-5 Aero med förarairbag Modellserie 4-dörrars Växellåda Manuell 5-växlad Motorvariant 2,0 t, B205E Kontrollsiffra X Årsmodell 2001 Produktionsort Trollhättan Tillverkningsnummer 456783

Tabell 2 Exempel på chassinummeravkodning

Fliken fordonets Självtest

Figur 7 Fordonets självtest

Denna flik ger användaren information om fordonets självtester. Fordonet gör självtester och mätningar för att kalibrera inställningar för bränsleförbrukning och misständningar etc. Det finns, i analogi med figuren ovan, kontinuerliga tester och de tester som bara utförs en gång. För att ett test skall rapporteras som klart från fordonsdatorn skall ibland vissa körmönster ha uppfyllts. Dessa kan tex vara att åka i 30km/h och accelerera kraftigt etc. Programvaran ger beskedet ”Stöds ej” om fordonstillverkaren inte har implementerat ett självtest på ett visst specifikt område. Vid radering av felkoder kommer även fordonsdatorns insamlade värden från dessa tester att raderas vilket innebär att dessa tester kommer att vara i läget ”Ej Klart”. Det innebär att vissa fordon kan komma att gå förmodligen försumbart sämre, under en liten stund tills dessa självtester är utförda och klara. Fordonet utnyttjar de fabriksdefinierade värdena under den tid då självkalibreringen ej är klar.

Fliken Syresensorer

Figur 8 Fliken syresensorer Fliken ger information om de syresensorer som finns implementerade i fordonet för att optimera bränslesystemet. Standarden stödjer 4 sensorer i respektive bank. Dock är det ofta som fordonen har mindre än 8 sensorer och då syns ”--” i rutorna, som ovan. Varje sensor ger ett spänningsvärde samt ett bränsletrimvärde som är associerat med sensorn. Dessa parametrar hämtas en gång varje gång du väljer fliken. Vill man hämta dessa parametrar ytterliggare en gång från fordonsdatorn är det bara att trycka på knappen uppdatera för att få de senaste värdena.

Filen Settings.ini Programvaran öppnar den kommunikationsport som står angiven i filen Settings.ini Filen är en två raders textfil och ska innehålla följande text för att tex. öppna serieport 1: ------------- [kommunikationsinställningar] Commport=COM1 -------------

Bilaga C: Kravspecifikation för programvaran OBD-programvaran skall användas i TEMC för att kunna ge en snabb och effektiv diagnos på försvarets fordon. OBD-programmet kommer via en serieport (RS232) att kommunicera (ta emot och skicka) med ett interface som i sin tur sköter kontakten till fordonsdatorn. Programmet kommer att programmeras med Microsoft Visual C++ version 6.0. Rutorna Inställningar, Instruktion och Kommentar lämnar vi som dom är i första versionen av programvaran. Resultat-rutan består av tre flikar: Realtid, Felkoder och Frysta värden. Samt de fasta objekten som alltid skall synas Protokoll, Fordonets ID, Antal Felkoder och Status Servicelampa, oberoende vald flik. Protokoll, Fordonets ID och Antal Felkoder skall kunna presentera en variabel textsträng, användaren av programmet skall ej få tillgång att ändra i dessa. Status Servicelampa skall kunna växlas mellan två lägen. Symbolen är grön och texten under är ”Servicelampan släckt”. Symbolen blinkar rött och texten under är ”Servicelampan tänd”. Slutsats: Vi vill kunna växla bilder i rutan status servicelampa. Realtid fliken skall alltid gå att få upp, samt att den även är den flik som skall vara aktuell vid start av programmet. Textrutorna skall kunna presentera en variabel textsträng, och även här får användaren inte möjlighet att ändra i dessa. Felkoder fliken skall kunna gå att öppna om det finns några felkoder, annars skall den vara skuggad. Befintliga Felkoder är en lista där användaren skall kunna markera en felkod (En felkod består av fem tecken). Felkodens Definition skall presentera en avkodning av användarens valda felkod. Det skall alltså gå att presentera en textsträng. Här får användaren inte möjlighet att ändra på något i textsträngen. Rensa Felkoder och Frysta Värden är en enkel knapp som användaren skall kunna radera alla felkoder och frysta data med mera i fordonsdatorn. Samma knapp som RENSA knappen under fliken Frysta värden. Tidigare Service är en list som ger användaren möjlighet att se resultaten av tidigare fordonskontroller. Vid val av att se en tidigare kontroll, så skall de nedre Befintliga Felkoder och Felkodens Definition fungera på samma sätt som de övre, dock så visas värden från en tidigare service. Om ingen Tidigare Service är vald så ska de nedre Befintliga Felkoder och Felkodens Definition vara skuggande.

Formatet på listen Tidigare Service är datum och klockslag: 2003-04-11:11.00, så bredden på listen borde vara godtycklig. Frysta värden fliken är väldigt lik realtid fliken men med de två undantagen knappen RENSA och textrutan Felet som generade de frysta värdena. Knappen RENSA som är samma som den på fliken Felkoder och fungerar på samma sätt. Felet som generade de frysta värdena är bara en informationsruta där en variabel textsträng skall kunna presenteras, utan att användaren kan ändra i denna.

Bilaga D: Kodbeskrivning OBD programmet är programmerat i Visual C++. Programmets ”workspace” består av två projekt AtOdbGui och AtSysCommon som tillsammans innehåller ca 70 st klasser. När examensarbetet började togs ett skelett fram från ett gammalt program för att minimera programmeringstiden. AtSysCommon delen i programmet har lämnats orörd, allt arbete har koncentrats till AtOdbGui delen. AtOdbGui består av 12 st klasser, där två av klasserna COdbMenu och CAtOdbGuiApp lämnats orörda. Det är de resterande 10 klasserna som har programmerats i examensarbetet, och det är de klasserna som denna kodbeskrivning skall försöka förklara lite närmare. Vissa av klasserna är helt nyskapade till programmet och vissa är vidareutvecklade från skelett, och där kommer bara den delen av vidareutvecklingen att tas upp i beskrivningen. Klasserna går att dela upp i två grupper: Klasser som hanterar logiken i programvara. Det är de klasser som är till vänster om COdbLogic i figuren nedan, och även COdbLogic själv. Klasser som hanterar det grafiska användargränssnittet. Det är de klasser som är till höger om COdbLogic i figuren nedan. Observera att resource.h inte är en klass utan en h-fil.

Figur 1 Programvarutopologi

De logiska klasserna De logiska klasserna består av fem klasser COBDCommunication, CTroubleCode, COBDVehicleInfo och CEarlierServices och COdbLogic. COdbLogic fanns med i programskelettet medan de övriga klasserna har lagts till efterhand. Andledningen till att logiken är uppdelad i fem klasser är dels att det är smidigt sätt att programmera, men också att det skall kunna gå att uppdatera programmet genom att byta ut vissa klasser.

COdbLogics konstruktor skapar ett objekt för var och en av de övriga logikklasserna. Uppgiften för COdbLogic är att utnyttja funktionerna från varje logikklass för att uppnå önskat resultat. Klassen COdbLogic kommer också att fungera som en bro mellan de logiska och grafiska programkodsdelarna. COBDCommunication sköter om kommunikationen med interfacet i programvaran. Kommunikationen sker idag via en seriellport, vilken port bestäms av filen settings.ini, om filen saknas så används COM1. Ifall man byter ut interfacet i framtiden, så är det COBDCommunication som kommer att behövas uppdateras eller skrivas om. CTroubleCode är den klass som används för att hämta definitionerna av felkoderna. Alla definitionerna ligger idag lagrade i en textfil, men kan i framtiden bytas ut mot en databaskoppling. Det är bara CTroubleCode som hämtar information från textfilen, så det är bara denna klassen som berörs av ett byte till en databas. COBDVehicleInfo hämtar information från textfil för att tolka VIN numret. För varje bilmodell så skall det finnas en textfil, se användarmanualen till programmet, idag finns två modeller inlagda Saab 95 och 93. Ifall databas koppling önskas istället för textfil är det bara att ändra i COBDVehicleInfo klassen. CEarlierServices hämtar och lagrar information om tidigare felkoder på fordonet, med hjälp av VIN numret så används rätt textfil. Som de andra klasserna så är det bara att ändra i denna klass om databas koppling önskas istället.

De grafiska användargränssnittsklasserna Ett program med grafiskt användargränssnitt är händelsestyrt. För att hantera detta finns det ett antal klasser med olika funktionalitet. När användaren trycker på någon knapp, eller väljer en flik, skapas en händelse. Denna händelse fångas upp i klassen COdbGui som anropar lämplig funktion i COdbGuiHandler. Det är bara ibland som COdbGui fixar händelsen själv och avstår ifrån att anropa COdbGuiHandler. COdbGuiHandler funktioner anropas av regel från COdbGui. COdbGuiHandler hämtar då nya data ifrån logikdelen via COdbLogic, ritar om programfönstet om så behövs med hjälp av COdbDefultGraphic, tillsist placerar ut informationen i tex en textruta med hjälp av resource.h. Om hela denna process skulle ta lång tid så anropar COdbGuiHandler klassen CInitDlg som skriver ut en ruta med information till användaren, så att inte användaren tror programmet har låst sig. Filen resource.h är den fil som innehåller alla grafiska objekt så som textrutor, ikoner, bilder, konstanta textsträngar, ramar (frames), flikar (tabs) osv. Varje objekt har ett namn. Inom de olika flikarna i programmet så återanvänds många textrutor, för att hålla ner mängden. Eftersom en hel del grafiska objekt återanvänds i olika flikarna, så måste någon klass hantera hur programfönstret skall se ut just då, det är COdbDefultGraphic uppgift. COdbDefultGraphic har olika funktioner för varje flik och även för grafiken runt om fliken

också. Funktionerna innehåller information om vart alla textrutor och andra objekt skall befinna sig i programmet, och flyttar runt dessa när användaren förflyttar sig i programmet. Klassbeskrivning

Klassen COBDCommunication Klassen COBDCommunication sköter den seriella kommunikationen med OBD-interfacet. Klassen får in data i hexformat, tex 0101 (mode 1 PID 1) kommer som två bytes 0x01 0x01, och kodar över till ascii-tecken för att interfacet skall kunna tolkat rätt. Klassen utför även en tillbakakonvertering av mottagna tecken till hexformatet.

Publika funktioner • COBDCommunication

Funktionen COBDCommunication är klassen konstruktor som främst ställer in boolen CommunicationStatus till false, vilket innebär att kommunikationen ej är i drift.

• InitCOBDCommunication

InitCOBDCommunication initierar serieporten och interfacet. Via filen Settings.ini så bestäms vilken serieport som skall användas, och saknas filen så används COM1 som standardvärde. Funktionen skickar ut ett meddelande till användaren om att initieringen av serieporten eller interfacet har misslyckats. I funktionen så ställs även timeouts in till serieporten, dessa är väl tilltagna och kan minskas om så önskas.

CloseCommunication Funktionen CloseCommunication nollställer interfacet och stänger sedan serieporten. Den sätter communicationstatus till falsk för att markera att kommunikationen har stängts ner. transive Denna funktions uppgift är att sända ett obdkommando till fordonsdatorn och sedan ta emot svaret. Det kommandot som funktionen sänder till interfacet är det som skickas in som inparametrar till funktionen, och är av typen unsigned char vektor. Om kommunikationen gick bra så returneras en pekare till den unsigned char vektorn där svaret finns lagrat. Vid en bruten eller ogiltigt svar så är vektorn tom, och ett meddelande till användaren har gått ut och communicationssatus har blivit falsk. GetCommunicationStatus Denna funktion returnerar communicationstatus. getCommunicationProtocol Denna funktion returnerar vilket protokoll som används. Konkret sker detta genom att returnera pekaren till den CString som innehåller namnet på protokollet. getAndUpdateTimeConnected Denna funktion returnerar en pekare till en CString som innehåller fakta om kopplingen till fordonsdatorn. Vid fungarande kommunikation så innehåller strängen texten uppkopplad och

aktuell uppkopplad tid. Tiden uppdateras varje gång funktionen anropas genom att ökas en sekund. Anropet till denna funktion sker genom en timer på en sekund.

Privata funktioner: converter Denna funktion konverterar en unsigned char till två char. Tex 0xA3 blir uppdelat till A och 3 i ascii värde. Denna funktion returnerar inga parametrar utan använder sig av de två sista inparametrarna som är referensparametrar för att returnera de två char tecknen. Translater Denna funktion returnar hexadecimala värdet (en unsigned char) av de två tecken som är inparameterar. Tex F och 4 blir 0xF4.

Datamedlemmar hComm hComm är serieportens objekt. CommunicationStatus CommunicationStatus är en bool som är sann om kommunikationen fungerar och falsk om kommunikationen är bruten. Dcb Dcb är objeket där serieportens egenskaper sätts.

• Recive Är en vector med unsigned char som innehåller svaret vid en förfrågan av fordonsdatorn.

• NumberOfBytes

NumberOfBytes är ett object av typen LPDWORD och används för att bestämma hur många bytes som skall sändas och tas imot på en gång.

• NrOne

NrOne är en unsigned long som I konstruktion sätts till 1. NumberOfBytes sätts sedan att peka på NrOne, så attt bara en byte skickas eller tagsimot itaget.

Timeouts Timeouts är ett objekt av COMMTIMEOUTS. Detta objekt används för att ställa in de olika timeout för seriekommunikationen. CommunicationProtocol CommunicationProtocol är en CString som innehåller vilket protokol som används. I denna programversion används bara 14230 så textsträngen sätts i konstruktion. ConnectedTime ConnectedTime är en CString som innehåller kommunikationstatusen och om kommunikationen är igång även textsträng med uppkopplad tid.

TimeConnected TimeConnected är en int som innehåller antal sekunder som kommunikationen har varit upprättad. TimeConnected nollställs (sätts till värdet -1) i funktionen InitCOBDCommunication och räknas upp i getAndUpdateTimeConnected.

Klassen CTroubleCode Klassens primära uppgift är att avkoda 2 bytes-data för att skapa den 5 tecken långa standardiserade felkod som varje par av bytes representerar. Vidare kommer samtliga felkoder som skapas att läggas i en CString-vector. Klassen kommer även att jämföra varje felkod med en fil som innehåller felkoder och dess definitioner. När den hittat rätt kod lagras även felkodens definition ned i en Cstring-vector.

Publika funktioner • MakeTroubleCodes

Denna funktion har en pekare av typen “unsigned char-vektor” som inparameter. Funktionen tar denna vektor och skapar två vektorer innehållande felkoder resp. definitioner för vart och ett av elementen i invektorn. Funktionen utnyttjar InsertTroubleCode för att utföra konverteringen från felkoden med 2 tecken till felkoden med 5 tecken.

• GetTroubleCodes

Denna funktion returnerar vektorn med de standardiserade felkoderna som skapats med MakeTroubleCodes.

• GetTroubleCodeDefinitions

Denna funktion returnerar vektorn med definitionerna för felkoderna som skapats med MakeTroubleCodes

Privata funktioner • InsertTroubleCode

Funktionen har 2 st unsigned char som inparameter. Dessa två bytes konverteras till en 5 tecken lång CString som läggs in i slutet på datamedlemmen TroubleCodes. Även definitionen för felkoden läggs in den privata datamedlemmen TroubleCodesDefinition.

Datamedlemmar vector <CString> TroubleCodes vector<CString> TroubleCodeDefinitions CString TroubleCodeDefinition

Klass COBDVehicleInfo Klassen COBDVehicleInfos uppgift är att med hjälp av VIN numret ta fram fordonets data, som används i fliken fordonsdata. För varje bilmodell så finns det en textfil som innehåller information om hur VIN numret skall avkodas.

Publika medlemsfunktioner • setVehicleInfo

Funktionen setVehicleInfo har pekaren till textsträngen med VIN numret som inparameter. Med hjälp av de fyra första tecknet i VIN numret så hämtas rätt textfil in, som innehåller information för att koda av hela VIN numret. All fordonsdata från textfilen lagras i vektorn VehicleInfo.

• getVehicleInfo

Funktionen getVehicleInfos uppgift är att returnera pekaren till VehicleInfo.

Datamedlemmar • VehicleInfo

VehicleInfo är en vektor bestående av CStrings, som innehåller fordonsdata efter funktionen setVehicleInfo har anropas.

Klassen CEarlierServices Klassens uppgift är att hålla information om de tidigare servicetillfällena som ett specifikt fordon eventuellt har haft.

Publika funktioner • CEarlierServicesMake

Funktionen har som inparameter en CString och det är fordonets chassinummer som skall vara i CStringen. Funktionen skapar in textfil med samma namn som chassinumret. Om en sådan fil redan finns skapas ingen. Slutligen anropas funktionen UpdateServices i samma klass.

• UpdateServices

Då funktionen anropas kommer filen med det aktuella chassinumret att öppnas varpå alla tidigare servicetilfällen som finns i lagrade i filen läggs i den privata datamedlemmen av typen vektor-CString vid namn Servicedates.

• GetServiceDates

Returnerar pekaren till datamedlemmen Servicedates.

• GetTroubleCodeFromService Till denna funktion skall inparametern vara av typen int. Funktionen returnerar de felkoder som finns på det specifika indexet, via datamedlemmen TroubleCodes.

• SaveService

Funktionen sparar samtliga de felkoder som ligger lagrade i inparametern, som är en pekare av typen vector CString. Funktionen utnyttjar även getDateandTime för att göra en tidsstämpel på när sparandet ägde rum.

Privata medlemsfunktioner • getDateAndTime

Funktionen modifierar en string så att aktuellt datum och aktuell tid hamnar i den. Datumet och aktuell tid blir på följande format : ”2000-00-00 00:00”

Datamedlemmar vector <unsigned char> TroubleCodes; vector<CString> ServiceDates; char filename[22];

Klassen COdbLogic Klassens primära uppgift är att med hjälp av de fyra underklasserna och deras funktioner utföra de operationer som krävs för att kunna hämta in data från fordonsdatorn. COdbLogic är motorn i programvaran som levererar textsträngar färdiga för presentation till Grafikklassen.

Publika Funktioner • GetVIN

Denna funktion hämtar det 17 tecken långa chassinumret från fordonsdatorn och returnerar det som en CString-pekare. Funktionen utför även anrop på funktionerna CEarlierServicesMake och setVehicleInfo.

• GetEarlierServices

Funktionen anropar funktionen GetServiceDates i klassen EarlierServices och returnerar vad den returnerat. Returen är en pekare av typen vektor-CString.

• GetTroubleCodesFromService

Funktionen har som inparameter en int som indexerar vilken rad i en rullgardinslist som användaren valt. Utifrån det indexet returnerar funktionen de felkoder som är associerade med raden.

• GetTroubleCodeDefinitionFromService

Inparam int index return m_poTroubleCodes_earlier->GetTroubleCodeDefinitions(index);

• GetServiceStatusAndNrOfTroubleCodes

Funktionen hämtar Servicelampans status och antalet felkoder som finns lagrade i fordonsdatorn. Denna funktion hämtar även information om de självkontroller som fordonet gör.

• GetTroubleCodeCausedFreeze

Funktionen hämtar den felkod som genererade en sk FreezeFrame från fordonsdatorn. Resultatet läggs i den privata CString datamedlemmen FreezeTroubleCode på formen ”FELKOD : DEFINITION”

• AlreadyRetrivedFreezeFrame

Funktionen returnerar RetrivedFreezeFrame som är av typen bool. True betyder att en FreezeFrame redan hämtats från fordonsdatorn.

• GetFreezeParameters

Detta är en stor funktion som hämtar en rad olika parametrar från fordonsdatorn och som lagrats vid ett fel i motorn. Dessa parametrar lagras i CString-vektorn FreezeParameters.

• GetOBDRequirements

Denna funktion hämtar vilken typ av OBD det är som fordonet stödjer.

CARBs (Kalifornien) OBD har tex. mycket hårdare miljökrav än EOBD (Europa).

• InitCommunication Funktionen anropar funktionen InitCOBDCommunication() i klassen COBDCommunication som initierar serieporten.

• CloseCommunication

Funktionen anropar funktionen CloseCommunication() i klassen COBDCommunication som stänger serieporten.

• GetCommunicationStatus

Funktionen anropar funktionen GetCommunicationStatus() i klassen COBDCommunication som returnerar true då kommununikationen mellan fordonsdatorn och programvaran är aktiv. False då kommunikationen är nere.

• GetCommunicationProtocol

Funktionen anropar funktionen getCommunicationProtocol() i klassen COBDCommunication som returnerar en textsträng med information om vilket protokoll som för närvarande utnyttjas för kommunikation med fordonsdatorn.

• GetSupportedRealTimePIDs

För att inte programvaran skall kunna hämta info från fordonsdatorn som inte stöds görs först en kontroll på vilka parametrar som stöds av fordonet. Resultatet lagras i variabler vid namn SupportedRealTimePIDsA (B,C,D) och varje enskild funktion som skall hämta parametervärden från fordonsdatorn gör först en kontroll på om parametern stöds innan den läser av värdet genom att bit-testa korrekt variabel. Stöds parametern ej av fordonet hämtas den följaktligen inte.

• GetRPM

Funktionen returnerar fordonets varvtal.

• GetSpeed Funktionen returnerar fordonets hastighet i km/h.

• GetCoolerTemp

Funktionen returnerar fordonets kylartemperatur.

• GetEngineLoad Funktionen returnerar fordonets motorlast.

• GetFuelPressure

Funktionen returnerar fordonets bränsletryck.

• GetIntakeMan Funktionen returnerar trycket på fordonets insugningsgrenrör i kilo pascal.

• GetThrottlePos

Funktionen returnerar gasspällsläget på fordonet i procent.

• GetIntakeTemp Funktionen returnerar fordonets insugstemperatur i grader Celcius.

• GetMafAirFlow

Funktionen returnerar luftflödet in till motorn.

• GetTimingAdv Funktionen returnerar ett värde på hur mycket första cylinderns tändning ligger före de övriga cylindrarna.

• GetShortTrimBank1 Funktionen returnerar fordonets bränsleoptimering i procent.

• GetLongTrimBank1

Funktionen returnerar fordonets långtidsoptimering i procent. Denna faktor justeras så att den kortsiktiga bränsleoptimeringen ligger runt 0.

• GetFuelSystemStatus

Funktionen returnerar statusen på fordonets bränslesystem. Funktionen returnerar svaret ”Stängd loop” eller ”Öppen loop” beroende på om bränslesystemet utnyttjar syresensorer för bränslereglering eller fabriksinställda börvärden.

• GetOxygenSensorVoltages

Funktionen returnerar spänningen och bränsletrimvärden på de syresensorer som finns implementerade i motorn hos testobjektet för att optimera bränsleblandning och förbränning.

• GetMonitoringTestsCompleted

Funktionen returnerar statusen på de självtest som fordonet utfört för att kunna självkalibrera.

• GetMilLampStatus Funktionen returnerar MilLamp som är en privat datamedlem av typen bool och där true betyder att servicelampan är tänd.

• GetTroubleCodes

Om felkoder ej har hämtats tidigare och om det finns felkoder kommer funktionen att hämta in ”packade felkoder” i tvåbytesformat i grupper om 3 enligt standarden SAE J1979. Dessa bytes kommer att göras om till standardfelkoder på 5 tecken och returneras som en pekare av typen vektor CString.

• GetNrOfTroubleCode Returnerar medlemmen NrOfTroubleCode som innehåller antalet fel som fordonet har.

• EraseTroubleCodes Funktionen raderar fordonsdatorn på felkoder, kalibreringsinställningar,FreezeFrames och släcker eventuell servicelampa. Enligt standarden SAE J1978 för Diagnosverkyg så visas även en varningsruta som ger användaren information om att denne håller på att radera felkoder etc. innan nollställningen kan utföras. Vidare sparas aktuella

felkoder i en fil för senare observation om så önskas. Klassobjektet m_poTroubleCodes återskapas och vektorer nollställs på deras innehåll.

• GetTroubleCodeDefinition

Anropar funktionen GetTroubleCodeDefinitions() i klassen CtroubleCode. Funktionernas inparameter är en int.

• GetVehicleInfo

Anropar funktionen getVehicleInfo i klassen COBDVehicleInfo och returnerar dess retur.

• GetTimeConnected Funktionen anropar getAndUpdateTimeConnected() i klassen COBDCommunication.

• GetMorePidsStatus

Enligt standarden SAE J1979 finns möjlighet för utökade PIDs. Denna funktion kontrollerar om fordonet har stöd för ytterliggare parametrar och returnerar true om så är fallet.

Privata medlemsfunktioner: • SetPIDForSend

Funktionen används av i stort sett samtliga parameterinhämtningsfunktioner för att adressera de olika modernas PID:s.

• ConvertToString

Funktionen tar antingen en int som inparameter eller så tar den en double och antal decimaler som inparameter. Funktionen konverterar invärdet till en CString så att det kan presenteras på ett bra sätt.

Datamedlemmar CAtTemcError *m_pError; COdbDb *m_poDb; CAtLabels *m_poLabels; CObList *m_poUutInfo; CUutInfo m_oUut; CTroubleCode *m_poTroubleCodes; CTroubleCode *m_poTroubleCodes_earlier; CEarlierServices *m_poEarlierServices; COBDCommunication *m_poOBDCommunication; COBDVehicleInfo *m_poVehicleInfo; CString NrTroubleCodes; int NrOfTroubleCode; bool RetrivedTroubleCodes; vector<unsigned char> Faults; bool MilLamp; CString VINnr; CString OBDRequirements;

CString FreezeTroubleCode; bool RetrivedFreezeTroubleCode; bool RetrivedFreezeFrame; vector<CString> FreezeParameters; //-RealTimeMembers-- bool RealTimePIDsChecked; CString RPM; CString Speed; CString CoolerTemp; CString EngineLoad; CString IntakeManifold; CString IntakeTemp; CString ThrottlePos; CString FuelPressure; CString TimingAdv; CString MafAirFlow; CString ShortTrimBank1; CString LongTrimBank1; vector<CString> FuelSystemStatus; vector<CString> OxygenSensorVoltages; vector<unsigned char> MonitoringTests; unsigned char OxygenSensors; unsigned char SupportedRealTimePIDsA; unsigned char SupportedRealTimePIDsB; unsigned char SupportedRealTimePIDsC; unsigned char SupportedRealTimePIDsD;

Klassen COdbGui Ett Windows program är händelsestyrt, vilket innebär att det är användaren som påverkar vad som skall hända i programmet, via att t ex klicka på något. I klassen COdbGui finns kod skriven för att fånga upp händelser, samt de funktioner som körs vid en händelse.

Händelser och medlemsfunktioner • COdbGui

Funktionen COdbGui är klassens konstruktor. Det som har lagts till är den sista raden där toggleStatusLamp som sätts till startvärde falskt. ToggleStatusLamp används i onTimer nedan för att få servicelampa att blinka.

• OnTimer

Denna funktion OnTimer anropas av en hanterare som utlöses när en timer har gått färdigt. Det går att ha godtyckligt antal hanterare och i programvaran har vi lagt till 4 st. Den första nr 6 används till att få uppdateringen i realtid fliken till att fungera bra. Den andra nr 7 används till att hålla reda på uppkopplingen till fordonsdatorn, varje sekund utlöses denna timer så länge uppkopplingen är fungerande, och på så viss så uppdateras uppkopplad tid. Den tredje nr 8 används bara en gång och detta sker 30 ms efter programmet har startas. Det som sker då är att storleken på fönstret för programmet ställs in till den optimerade storlek. Den fjärde och sista är till för att få servicelampan att blinka.

• OnSelchangeList_dtc

Denna funktion anropas när användaren har tryckt på någon felkod i den aktuella felkodslistan. Denna funktion anropar OnSelchangeList_dtc i COdbGuiHandler som får skriva ut definitionen för vald felkod.

• OnSelchangeList_old_dtc

Samma som OnSelchangeList_dtc förutom att det gäller för tidigare service.

• OnSelchangeCombo_earl_service Denna funktion anropas när användaren har valt något tidigare servicetillfälle i rullisten i fliken felkoder. Funktionen anropar COdbGuiHandlers OnSelchangeCombo_earl_service som får hantera alla utskrifter av felkoder från valt servicetillfälle.

• OnClickedButton_erase

Denna funktion anropas när användaren har klickat på radera-knappen i någon av flikarna felkoder eller frysta värden. Funktionen anropar OnClickedButton_erase från COdbGuiHandler för att sköta raderingen.

• OnClickedButton_start

Denna funktion anropas när användaren har klickat på start-knappen. Funktionen anropar OnClickedButton_start från COdbGuiHandler för att starta upp kommunikationen.

• OnClickedButton_stop

Denna funktion anropas när användaren har klickat på stopp-knappen. Funktionen anropar OnClickedButton_stop från COdbGuiHandler för att koppla ner kommunikationen.

• OnClickedButton_update

Denna funktion anropas när användaren har klickat på uppdatera-knappen i flikarna syresensorer och fordonets självtest. Funktionen anropar OnClickedButton_update från COdbGuiHandler för att uppdatera data.

• OnClickedButton_ok

Denna funktion anropas när användaren har klickat på ok-knappen. Funktionen anropar OnClickedButton_ok från COdbGuiHandler för att gå vidare i startprocessen.

Datamedlemmar COdbLogic *m_poLogic; HWND m_hwndGuiWnd; CAtTemcError *m_poError; COdbDefaultGraphic *m_poGraphic; COdbMenu *m_poMenu; COdbGuiHandler *m_poHandler; CAtLabels *m_poLabels; BOOL m_bClose; Bool toggleStatusLamp;

Klass COdbGuiHandler Klassen COdbGuiHandlers huvuduppgift är att hämta de olika textsträngarna från klassen COdbLogic som behövs i det aktuella programfönstret och placera strängarna i rätt textrutor. Man kan säga att COdbGuiHandler knyter ihop det grafiska användargränssnittet och logiken i programmet.

Publika medlemsfunktioner • COdbGuiHandler

Konstruktion COdbGuiHandler ger variabel RealtimeUpdateCounter sitt startvärde.

• SelchangeTabDb Denna funktion får som inparameter in vilken flik som har blivit vald av användaren. Den flik som är vald hämtas data till från CodbLogic, antagligen direkt eller via en funktion, och placeras ut i tillhörande textrutor i det grafiska användargränsnitt. Realtidsfilken är lite speciell där setts en timer som sedan anropar funktionen UpdateRealTime som kontunerligt uppdaterar fliken.

• InitObdComboBox

Denna funktion matar in de textsträngar som skall vara i rullisten tidigare servicetillfällen i fliken felkoder.

• InitObdListBox

Denna funktion hämtar felkoder från CodbLogic och matar in felkoderna i textboxen för felkoderna.

• SetServiceStatusAndNrOfTroubleCodes Denna funktion hämtar information från klassen CodbLogic. Dvs antal felkoder och servicelampans status. Strängen med antal felkoder matas in i dess textruta och statusen för servicelampan visas både med text och bild. Är servicelampan tänd så sätts en timer som sköter blinkandet av bilden.

• SetMonitoringTestsStatus

Denna funktion hämtar in information från CodbLogic om vilka av fordonets självtest som fordonet stödjer och vilka som är klara. SetMonitoringTestsStatus kodar av informationen och matar in resultatet i rätt textrutor i fliken fordonets självtest.

• SetOxygenSensorVoltages

Denna funktion hämtar textstängar om syresensorna från CodbLogic och matar in dem i textrutorna i fliken syresensorer.

• UpdateRealTime

Denna funktion anropas genom att en timer löses ut, och har som uppgift att kontinuerligt uppdatera textrutorna i fliken realtid. Eftersom kommunikationen med fordonet är långsam så uppdateras en textruta i taget, med hjälp av räknaren RealtimeUpdateCounter så vet funktionen vilken textruta som skall uppdateras i anropet. I slutet av funktionen sätt timer till 5 ms, vilket görs för att programmet skall

hinna skriva ut mätvärdet i textrutan innan nästa tidsavbrott kommer. UpdateRealTime använder sig av CodbLogic för att hämta in data.

• UpdateTimeConnected

När kommunikationen upprättas till fordonet så sätts en timer som inställs på att utlösas en gång i sekunden, denna timer anropar UpdateTimeConnected. UpdateTimeConnected anropar GetTimeConnected i CodbLogic som i sin tur anropar getAndUpdateTimeConnected i COBDCommunication som med hjälp av anropet räknar upp tiden och skickar tillbaks pekaren till textsträngen där aktuell uppkopplad tid finns. UpdateTimeConnected ser till att textsträngen läggs ut i textrutan kommunikationsstatus.

• OnSize

Funktionen OnSize bestämmer när programfönstret skall sluta ritas om, när användaren ändar på fönsterstorleken. Denna funktion används inte mycket eftersom fönstret får en given storlek i programstarten.

• OnClickedButton_erase

Denna funktion anropar funktion i CodbLogic som raderar felkoder, frysta värden och självtest resultaten. Innan raderingen sker får användaren svara på en förfrågan om användaren verkligen vill radera. Vid positivt svar så raderas data och textrutorna nollställs.

• OnClickedButton_stop

Denna funktion kommer att köras när användaren har tryckt på stoppknappen. Funktionen anropar CloseCommunication från COdbLogic så att kommunikationen kopplas ner, samt tar fram startknappen, avaktiverar stopknappen och nollställer alla textrutor.

• OnClickedButton_start

Denna funktion anropas när användaren har tryckt på startknappen, och anropar funktioner från COdbLogic som startar kommunikationen, hämtar VIN nr, kommunikationsprotokoll och typ av OBD. Eftersom det är många tidskrävande funktioner som anropas, så visas en dialogruta så inte användaren tror att programmet har låst sig. Funktionen aktiverar stoppknappen och avaktiverar startknappen, samt sätter timern för kommunikationsstatusen och timern för realtidsuppdateringen ifall realtidsfliken är vald. Tillsist aktiverar funktionen alla textrutor i fliken.

• OnClickedButton_update Denna funktion anropas när användaren har tryckt på uppdatera knappen i fliken syresensorer eller fordonets självtest. Beroende vilken flik användaren är inne i, så anropas funktionen SetMonitoringTestsStatus eller SetOxygenSensorVoltages som kommer att uppdatera mätvärdena.

• OnClickedButton_ok Denna funktion anropas när användaren har tryckt på ok-knappen. Funktionen byter ut texten i instruktionsrutan, och avaktiverar ok-knappen och tar fram startknappen.

• OnSelchangeList_dtc

Denna funktion anropas när användaren har valt någon felkod ur felkodslistan i fliken felkoder. Funktionen kontrollerar vilken felkod som valdes och hämtar in förklaringen av felkoden från COdbLogic, och presenterar den i definitionsrutan.

• OnSelchangeList_old_dtc

Samma som OnSelchangeList_dtc fast för tidigare service.

• OnSelchangeCombo_earl_service Den funktion anropas när användaren har valt ett tidigare servicetillfälle i fliken felkoder. Funktionen läser av vilket tillfälle, och rensar tidigare services felkodslista och textrutan med definitionerna. OnSelchangeCombo_earl_service hämtar sedan in de nya felkoderna för valt servicetillfälle från COdbLogic och presenterar dem i felkodslistan.

Datamedlemmar BOOL m_bTimer; SHORT m_nTest; SHORT m_nCategory; SHORT m_nMode; BOOL m_bHideUnselected; CAtTemcError *m_poError; COdbLogic *m_poLogic; COdbDefaultGraphic *m_poGraphic; HWND m_hwndGuiWnd; SHORT m_nSignalCount; COdbMenu *m_poMenu; CAtLabels *m_poLabels; CUutInfo m_oUut; CObList *m_poPlaylists; SHORT m_nSequence; IOleInPlaceFrame *m_poInPlaceFrame; SHORT m_nTab; CObList *m_poSegmentReports; CObList *m_poMatchedReports; //Added by Andreas² CComboBox *ServiceBox; CListBox *TroubleCodeBox; int RealtimeUpdateCounter;

Klass COdbDefaultGraphic COdbDefaultGraphic är den klass som sätter ut alla grafiska objekt (textträngar, rullistor osv) på rätt plats. Denna klass har ett publikt arv till klassen CAtGraphic.

Publika medlemsfunktioner • Draw

Draw är den funktion som ritar om hela fönstret för programmet. Med anropet av funktionen DrawSettings så ritas allt förutom flikarna i resultat ut. Med hjälp av variabeln m_nMode så anropas rätt ritfunktion för den aktuella fliken i resultat.

• OnSelDlgRealtime Till denna funktion finns det en inparameter som är av typen bool, sant eller falskt. Vid sant så kommer denna funktion att rita om programfönstret och med variabeln m_nMode ser funktionen till att realtidsfliken kommer att ritas ut. Funktionen kommer även att ta fram alla grafikobjekt(textrutor osv) som skall användas inom realtidsfliken och sätter ut de konstanta textsträngarna för fliken. Vid falskt i inparametern så döljer funktionen alla grafikobjekt inom fliken.

• OnSelDlgTroubleCode Fungerar på samma sätt som OnSelDlgRealtime fast för felkods fliken.

• OnSelDlgFreeze Fungerar på samma sätt som OnSelDlgRealtime fast för frysta värden fliken.

• OnSelDlgVehicle Fungerar på samma sätt som OnSelDlgRealtime fast för fordonsinfo fliken.

• OnSelDlgMonitor Fungerar på samma sätt som OnSelDlgRealtime fast för fordonets självtest fliken.

• OnSelDlgOxygenSensors Fungerar på samma sätt som OnSelDlgRealtime fast för syresensor fliken.

Privata medlemsfunktioner • DrawSettings

Denna funktion ritar ut allting förutom flikarna i resultatrutan.

• DrawTabRealtime Ritar ut vart alla grafikobjekt i realtidsfliken skall vara.

• DrawTabMonitor

Ritar ut vart alla grafikobjekt i fordonets självtestfliken skall vara.

• DrawTabTroubleCode Ritar ut vart alla grafikobjekt i felkodsfliken skall vara.

• DrawTabFreeze

Ritar ut vart alla grafikobjekt i frysta värden fliken skall vara.

• DrawTabVehicle Ritar ut vart alla grafikobjekt i fordonsinfo fliken skall vara.

• DrawTabOxygenSensors Ritar ut vart alla grafikobjekt i syresensor fliken skall vara.

Datamedlemmar CTabCtrl *m_poTabDb; CListCtrl *pmyListCtrl; CDialog *m_poDialog; IUnknown *m_poUnk; short m_nMode;

Klass CInitDlg Denna klass har ett publikt arv från klassen CAtStatusDlg. Det som klassen CInitDlg uträttar är att presentara en förloppsindikator i en dialogruta. Klassen CAtStatusDlg sköter dialogfönstret och byter ut pekaren till ett timglas.

Publika medlemsfunktioner • InitProcessBar

Funktionen InitProcessBar initierar förloppindikatorn med värdet noll, i dialogrutan.

• UppdateProcessBar Funktionen UppdateProcessBar har en int som inparameter, som skall innehålla hur mycket förloppstapeln skall visa i dialogrutan. Värdet på int:en kan vara mellan 0-100.

• HideProgressBar Funktionen HideProgressBar tar bort förloppsindikatorn i dialogrutan.

Bilaga E: Källkod Ordningsföljd: OBDCommunication.h OBDCommunication.cpp EarlierService.h EarlierService.cpp OBDVehicleInfo.h OBDVehicleInfo.cpp TroubleCodes.h TroubleCodes.cpp ODBLogic.h ODBLogic.cpp ODBGui.h ODBGui.cpp ODBGuihandler.h ODBGuihandler.cpp ODBDefaultGraphics.h ODBDefaultGraphics.cpp InitDlg.h InitDlg.cpp

// OBDCommunication.h: interface for the COBDCommunication class.////////////////////////////////////////////////////////////////////////

#include <vector>using namespace std;

#if !defined(AFX_OBDCOMMUNICATION_H__F03BD1DC_337F_4A2F_9242_91CE2CC00BA7__INCLUDED_)#define AFX_OBDCOMMUNICATION_H__F03BD1DC_337F_4A2F_9242_91CE2CC00BA7__INCLUDED_

#if _MSC_VER > 1000#pragma once#endif // _MSC_VER > 1000

class COBDCommunication {public: COBDCommunication(); void InitCOBDCommunication(); void CloseCommunication();

vector<unsigned char> *transive(vector<unsigned char> *send);

bool GetCommunicationStatus(); CString *getCommunicationProtocol(); CString *getAndUpdateTimeConnected();

virtual ~COBDCommunication();

private: void converter(unsigned char data, char &data1, char &data2); unsigned char translater(char data1, char data2); HANDLE hComm; bool CommunicationStatus; DCB dcb;

vector<unsigned char> recive;

LPDWORD NumberOfBytes; unsigned long NrOne;

COMMTIMEOUTS Timeouts;

CString CommunicationProtocol; CString ConnectedTime; //Skapad 2003-05-19 int TimeConnected;

};

#endif // !defined(AFX_OBDCOMMUNICATION_H__F03BD1DC_337F_4A2F_9242_91CE2CC00BA7__INCLUDED_)

1

// OBDCommunication.cpp: implementation of the COBDCommunication class.////////////////////////////////////////////////////////////////////////#include <iostream>#include "stdafx.h"#include "OBDCommunication.h"#include <vector>#include <fstream>

using namespace std;

//////////////////////////////////////////////////////////////////////// Construction/Destruction//////////////////////////////////////////////////////////////////////

COBDCommunication::COBDCommunication(){

NrOne = 1; NumberOfBytes=&NrOne; CommunicationProtocol.Insert(0, "14230"); CommunicationStatus=false;

}

COBDCommunication::~COBDCommunication(){

}

void COBDCommunication::InitCOBDCommunication()

{ ifstream file; file.open("settings.ini", ios::in); char buffert[400]; char CommPort[400]; int i=0;

if(!file) { CommPort[0] = 'C'; CommPort[1] = 'O'; CommPort[2] = 'M'; CommPort[3] = '1'; CommPort[4] = '\0'; } else { file.getline(buffert, 399); file.getline(buffert, 399); while(i<400 && buffert[i] != '=') i++; i++; //Går förbi = tecknet

int r; for(r=0; i<400 && buffert[i] != '\0'; r++, i++) CommPort[r]=buffert[i]; CommPort[r]='\0';

}

file.close();

char *pcCommPort = CommPort; bool fSuccess; hComm = CreateFile( pcCommPort, GENERIC_READ | GENERIC_WRITE, 0, // must be opened with exclusive-access NULL, // no security attributes OPEN_EXISTING, // must use OPEN_EXISTING 0, // not overlapped I/O

1

NULL // hTemplate must be NULL for comm devices );

if (hComm == INVALID_HANDLE_VALUE) { // Handle the error.// printf ("CreateFile failed with error %d.\n", GetLastError()); MessageBox(0, "Initiering av kommunikationen avbröts!", "Kommunikationsproblem", MB_OK); CommunicationStatus =false; return; }

// Build on the current configuration, and skip setting the size // of the input and output buffers with SetupComm.

fSuccess = GetCommState(hComm, &dcb);

if (!fSuccess) { // Handle the error.// printf ("GetCommState failed with error %d.\n", GetLastError());

MessageBox(0, "Initiering av kommunikationen avbröts!", "Kommunikationsproblem", MB_OK); CommunicationStatus =false; return;// return (2); }

// Fill in DCB: 9600 bps, 8 data bits, no parity, and 1 stop bit.

dcb.BaudRate = CBR_9600; // set the baud rate dcb.ByteSize = 8; // data size, xmit, and rcv dcb.Parity = NOPARITY; // no parity bit dcb.StopBits = ONESTOPBIT; // one stop bit

fSuccess = SetCommState(hComm, &dcb);

if (!fSuccess) { // Handle the error.// printf ("SetCommState failed with error %d.\n", GetLastError()); MessageBox(0, "Initiering av kommunikationen avbröts!", "Kommunikationsproblem", MB_OK); CommunicationStatus =false; return; }

// printf ("Serial port %s successfully reconfigured.\n", pcCommPort); CommunicationStatus =true;

//------------------TIMEOUT-------------------------------

Timeouts.ReadIntervalTimeout=5000; Timeouts.ReadTotalTimeoutConstant=5000; Timeouts.ReadTotalTimeoutMultiplier=5000; Timeouts.WriteTotalTimeoutConstant=50; Timeouts.WriteTotalTimeoutMultiplier=50; SetCommTimeouts(hComm, &Timeouts);

//INIT ELM char temp = 'a';

char atz[4]="ATZ"; atz[3]=13;

WriteFile(hComm, &atz, 4, NumberOfBytes, NULL);

2

char indata[500]; temp = 'j';//something else but '>'

ReadFile(hComm, &temp, 1, NumberOfBytes, NULL); if(temp != 'A' && temp != 'E' ) { MessageBox(0, "OBD interface svarar inte", "Kommunikationsproblem", MB_OK); CommunicationStatus =false; return; }

for(i=0; temp != '>'; i++) { ReadFile(hComm, &temp, 1, NumberOfBytes, NULL); indata[i]=temp; }

char businit[5]="0101"; businit[4]=13;

vector<char> bustest;

WriteFile(hComm, &businit, 5, NumberOfBytes, NULL);

temp = 'a';//something else but '>' while (temp != '>') { ReadFile(hComm, &temp, 1, NumberOfBytes, NULL); bustest.push_back(temp); }

for(i=0; i<bustest.size();i++) { if(bustest.at(i) == 'B') break; }

if(bustest.size() > (i+9) && bustest.at(i) == 'B' && bustest.at(i+1) == 'U' && bustest.at(i+2) == 'S' && bustest.at(i+3) == ' ' && bustest.at(i+4) == 'I' && bustest.at(i+5) == 'N' && bustest.at(i+6) == 'I' && bustest.at(i+7) == 'T' ) { for(i=i+8; i<bustest.size();i++) { if(bustest.at(i) == 'O') break; } if(bustest.size() > (i+1) && bustest.at(i) == 'O' && bustest.at(i+1) == 'K') CommunicationStatus =true; else { CommunicationStatus =false; MessageBox(0, "Fordonsdatorn svarar inte", "Kommunikationsproblem", MB_OK); return; }

} else { CommunicationStatus =false; MessageBox(0, "Fordonsdatorn svarar inte", "Kommunikationsproblem", MB_OK); return; }

char ate[5]="ATE0"; ate[4]=13;

WriteFile(hComm, &ate, 5, NumberOfBytes, NULL);

3

indata[500]; temp = 'a';//something else but '>' for(i=0; temp != '>'; i++) { ReadFile(hComm, &temp, 1, NumberOfBytes, NULL); indata[i]=temp; }

//////////////////////////////////////////////////////////////////////////////// char atfi[5]="ATL0"; //2003-05-16 atfi[4]=13;

WriteFile(hComm, &atfi, 5, NumberOfBytes, NULL);

temp = 'a';//something else but '>' for(i=0; temp != '>'; i++) { ReadFile(hComm, &temp, 1, NumberOfBytes, NULL); indata[i]=temp; }/////////////////////////////////////////////////////////////////////////////////////

TimeConnected=-1;

}

void COBDCommunication::CloseCommunication(){ char atz[4]="ATZ"; atz[3]=13;

WriteFile(hComm, &atz, 4, NumberOfBytes, NULL);

CommunicationStatus =false; CloseHandle(hComm); }

CString *COBDCommunication::getAndUpdateTimeConnected(){ TimeConnected++; ConnectedTime.Empty(); char temp; int temp2=TimeConnected; if(CommunicationStatus == false) { ConnectedTime.Insert(0, "Nedkopplad"); return &ConnectedTime; }

ConnectedTime.Insert(0, "Uppkopplad "); if(TimeConnected > 599) { temp=(TimeConnected/600)+48; ConnectedTime.Insert(ConnectedTime.GetLength(), temp); temp2=temp2 - (temp-48) * 600; }

if(temp2 > 59) { temp=(temp2/60)+48; ConnectedTime.Insert(ConnectedTime.GetLength(), temp); temp2=temp2 - (temp-48) * 60; } else ConnectedTime.Insert(ConnectedTime.GetLength(), '0');

ConnectedTime.Insert(ConnectedTime.GetLength(), ':');

temp=(temp2/10)+48; ConnectedTime.Insert(ConnectedTime.GetLength(), temp);

4

temp=(temp2%10)+48; ConnectedTime.Insert(ConnectedTime.GetLength(), temp);

return &ConnectedTime;}

vector<unsigned char> *COBDCommunication::transive(vector<unsigned char> *send){ unsigned char temp=0x01; char tempData1; char tempData2; char sendData[50]; int i=0; recive.clear();

if(CommunicationStatus==false) return &recive;

//Send data on COM1 for(int r=0; r < (send->size()) ; r++) { temp=send->at(r); converter(temp, tempData1, tempData2); sendData[i]=tempData1; i++; sendData[i]=tempData2; i++; }

sendData[i]=13; WriteFile(hComm, &sendData, (i+1), NumberOfBytes, NULL);

//READ DATA FROM COM1

int c=0; tempData2='q'; bool error = false;

while((send->size()*2) > c) { tempData2='q'; ReadFile(hComm, &tempData2, 1, NumberOfBytes, NULL); if(tempData2=='q') { CommunicationStatus=false; MessageBox(0, "Kommunikationen har brytits", "Kommunikationsproblem", MB_OK); return &recive; }

if(c == 0 && tempData2 !='4' && tempData2!=' ' && tempData2!=13 && tempData1!=10) error=true;

if(tempData2!=' ' && tempData2!=13 && tempData1!=10) c++; if(error==true) break; }

if(error==true) { while(tempData1 != '>') ReadFile(hComm, &tempData1, 1, NumberOfBytes, NULL); return &recive;

5

}

recive.clear(); tempData1='q'; tempData2='q'; while(tempData1 != '>' && tempData2 != '>') { tempData1='q'; ReadFile(hComm, &tempData1, 1, NumberOfBytes, NULL); if(tempData1=='q') { CommunicationStatus=false; MessageBox(0, "Kommunikationen har brytits", "Kommunikationsproblem", MB_OK); recive.clear(); return &recive; } while(tempData1==' ' || tempData1==13 || tempData1==10) { ReadFile(hComm, &tempData1, 1, NumberOfBytes, NULL); if(tempData1=='q') { CommunicationStatus=false; MessageBox(0, "Kommunikationen har brytits", "Kommunikationsproblem", MB_OK); recive.clear(); return &recive; } }

if(tempData1=='>') break;

tempData2='q'; ReadFile(hComm, &tempData2, 1, NumberOfBytes, NULL); if(tempData2=='q') { CommunicationStatus=false; MessageBox(0, "Kommunikationen har brytits", "Kommunikationsproblem", MB_OK); recive.clear(); return &recive; } while(tempData2==' '|| tempData2==13 || tempData2==10) { ReadFile(hComm, &tempData2, 1, NumberOfBytes, NULL); if(tempData1=='q') { CommunicationStatus=false; MessageBox(0, "Kommunikationen har brytits", "Kommunikationsproblem", MB_OK); recive.clear(); return &recive; } }

temp = translater(tempData1, tempData2); recive.push_back(temp); } if(tempData2=='>') recive.pop_back();

CommunicationStatus=true; return &recive;}

6

bool COBDCommunication::GetCommunicationStatus(){ return CommunicationStatus;}

void COBDCommunication::converter(unsigned char data, char &data1, char &data2){

if(data & 0x80) { if(data & 0x40) { if(data & 0x20) { if(data & 0x10) data1='F'; else data1='E'; } else { if(data & 0x10) data1='D'; else data1='C'; } } else { if(data & 0x20) { if(data & 0x10) data1='B'; else data1='A'; } else { if(data & 0x10) data1='9'; else data1='8'; } } } else { if(data & 0x40) { if(data & 0x20) { if(data & 0x10) data1='7'; else data1='6'; } else { if(data & 0x10) data1='5'; else data1='4'; } } else { if(data & 0x20) { if(data & 0x10) data1='3'; else data1='2'; } else { if(data & 0x10) data1='1'; else

7

data1='0'; } } }

if(data & 0x08) { if(data & 0x04) { if(data & 0x02) { if(data & 0x01) data2='F'; else data2='E'; } else { if(data & 0x01) data2='D'; else data2='C'; } } else { if(data & 0x02) { if(data & 0x01) data2='B'; else data2='A'; } else { if(data & 0x01) data2='9'; else data2='8'; } } } else { if(data & 0x04) { if(data & 0x02) { if(data & 0x01) data2='7'; else data2='6'; } else { if(data & 0x01) data2='5'; else data2='4'; } } else { if(data & 0x02) { if(data & 0x01) data2='3'; else data2='2'; } else { if(data & 0x01) data2='1'; else data2='0'; } } }

}

8

unsigned char COBDCommunication::translater(char data1, char data2){ unsigned char temp=0;

if(data1 == '0') temp += 0;

if(data1 == '1') temp += 1*16;

if(data1 == '2') temp += 2*16;

if(data1 == '3') temp += 3*16; if(data1 == '4') temp += 4*16;

if(data1 == '5') temp += 5*16;

if(data1 == '6') temp += 6*16; if(data1 == '7') temp += 7*16; if(data1 == '8') temp += 8*16;

if(data1 == '9') temp += 9*16;

if(data1 == 'A') temp += 10*16;

if(data1 == 'B') temp += 11*16; if(data1 == 'C') temp += 12*16;

if(data1 == 'D') temp += 13*16;

if(data1 == 'E') temp += 14*16; if(data1 == 'F') temp += 15*16;

if(data2 == '0') temp += 0;

if(data2 == '1') temp += 1;

if(data2 == '2') temp += 2;

if(data2 == '3') temp += 3; if(data2 == '4') temp += 4;

if(data2 == '5') temp += 5;

if(data2 == '6') temp += 6; if(data2 == '7') temp += 7; if(data2 == '8')

9

temp += 8;

if(data2 == '9') temp += 9;

if(data2 == 'A') temp += 10;

if(data2 == 'B') temp += 11; if(data2 == 'C') temp += 12;

if(data2 == 'D') temp += 13;

if(data2 == 'E') temp += 14; if(data2 == 'F') temp += 15;

return temp; }

CString *COBDCommunication::getCommunicationProtocol(){ return &CommunicationProtocol;}

10

// EarlierServices.h: interface for the CEarlierServices class.////////////////////////////////////////////////////////////////////////

#if !defined(AFX_EARLIERSERVICES_H__3D0501E3_DA9B_43C3_82AF_3DC62366CAE9__INCLUDED_)#define AFX_EARLIERSERVICES_H__3D0501E3_DA9B_43C3_82AF_3DC62366CAE9__INCLUDED_

#include <string>#include <vector>#include <fstream>using namespace std;


class CEarlierServices {public:

CEarlierServices(); CEarlierServicesMake(CString VIN); void UpdateServices(); vector<CString> *GetServiceDates(); vector<unsigned char> *GetTroubleCodeFromService(int ServiceNr); void SaveService(vector<unsigned char> *PresentTroubleCode); virtual ~CEarlierServices();

private: vector <unsigned char> TroubleCodes; vector<CString> ServiceDates; char filename[22];

void getDateAndTime(string &dateTime);

};

#endif // !defined(AFX_EARLIERSERVICES_H__3D0501E3_DA9B_43C3_82AF_3DC62366CAE9__INCLUDED_)

1

// EarlierServices.cpp: implementation of the CEarlierServices class.////////////////////////////////////////////////////////////////////////

#include "stdafx.h"#include "EarlierServices.h"#include <iostream>#include <string>#include <vector>#include <fstream>#include <ctime>


//////////////////////////////////////////////////////////////////////// Construction/Destruction//////////////////////////////////////////////////////////////////////CEarlierServices::CEarlierServices(){

}

CEarlierServices::CEarlierServicesMake(CString VIN){ VIN.Insert(VIN.GetLength(), ".txt"); //Skapar filnamnet

for(int i=0; i<22 && i<VIN.GetLength(); i++) filename[i]=VIN[i];

if(VIN.GetLength() <= 22) //Ser till att det inte blir något konstrikt minnesfel filename[VIN.GetLength()]='\0'; else filename[21]='\0';

ofstream file; //Skapar en textfil om sådan ej finns file.open(filename, ios::app); file.close();

UpdateServices();

}

void CEarlierServices::UpdateServices(){ ifstream infile(filename); //Skapar en inström char buffert[400]; //Tidpunkterna för tidigare service läses in. CString ServiceTime; ServiceDates.clear(); while(infile.getline(buffert, 399)) { for(int j=0; j<17; j++) ServiceTime.Insert(j, buffert[j]); ServiceDates.push_back(ServiceTime); ServiceTime.Empty(); } infile.close();}

CEarlierServices::~CEarlierServices(){

}

vector<CString> *CEarlierServices::GetServiceDates(){ return &ServiceDates;}

vector<unsigned char> *CEarlierServices::GetTroubleCodeFromService(int ServiceNr) {

1

TroubleCodes.clear(); ifstream infile(filename); //Skapar en inström string text_from_file; for(int i=0; i<ServiceNr; i++) //Kör fram till rätt rad getline(infile, text_from_file);

unsigned char error_byte=0x54; //ej 0x0A som är koden för ny rad. infile >> text_from_file; infile >> text_from_file; infile >> ws;

while (error_byte != 0x0A) { infile >> hex >> noskipws>> error_byte; if(error_byte != 0x0A) TroubleCodes.push_back(error_byte); } infile.close();

return &TroubleCodes;}

void CEarlierServices::SaveService(vector<unsigned char> *PresentTroubleCode) //skall kodas{

ofstream file; //Skapar en textfil om sådan ej finns file.open(filename, ios::app);

string dateAndTime; getDateAndTime(dateAndTime);

file << dateAndTime;

for(int i=0; i<PresentTroubleCode->size(); i++) file << hex << PresentTroubleCode->at(i); file <<endl; file.close();

}

void CEarlierServices::getDateAndTime(string &dateTime){ dateTime="2000-00-00 00:00 ";

struct tm *now; time_t long_time; time( &long_time ); now = localtime( &long_time ); int year = now->tm_year - 100; int month = now->tm_mon + 1; int day = now->tm_mday; int hour = now->tm_hour; int min = now->tm_min;

if (year > 9 ) { dateTime[2]=(year/10)+48; dateTime[3]=(year%10)+48; } else { dateTime[3]=year+48; }

2

if (month > 9 ) { dateTime[5]='1'; dateTime[6]=month-10+48; } else dateTime[6]=month+48;

if (day > 9 ) { dateTime[8]=(day/10)+48; dateTime[9]=(day%10)+48; } else { dateTime[9]=day+48; }

if (hour > 9) { dateTime[11]=(hour/10)+48; dateTime[12]=(hour%10)+48; } else { dateTime[11]=48; dateTime[12]=hour+48; }

if (min > 9) { dateTime[14]=(min/10)+48; dateTime[15]=(min%10)+48; } else { dateTime[14]=48; dateTime[15]=min+48; } }

3

// OBDVehicleInfo.h: interface for the COBDVehicleInfo class.////////////////////////////////////////////////////////////////////////

#if !defined(AFX_OBDVEHICLEINFO_H__A0B54AA1_D22E_464A_A96F_49B4E3F66035__INCLUDED_)#define AFX_OBDVEHICLEINFO_H__A0B54AA1_D22E_464A_A96F_49B4E3F66035__INCLUDED_


#include <vector>using namespace std;

class COBDVehicleInfo {public: COBDVehicleInfo(); virtual ~COBDVehicleInfo();

void setVehicleInfo(CString *VIN);

vector<CString> *getVehicleInfo();

private: vector<CString> VehicleInfo;

};

#endif // !defined(AFX_OBDVEHICLEINFO_H__A0B54AA1_D22E_464A_A96F_49B4E3F66035__INCLUDED_)

1

// OBDVehicleInfo.cpp: implementation of the COBDVehicleInfo class.////////////////////////////////////////////////////////////////////////

#include "stdafx.h"#include "OBDVehicleInfo.h"#include <vector>#include <fstream>



COBDVehicleInfo::COBDVehicleInfo(){

}

COBDVehicleInfo::~COBDVehicleInfo(){

}

void COBDVehicleInfo::setVehicleInfo(CString *VIN){

char filename[9]=" .txt"; //Skapar filnamnet

for(int i=0; i<4; i++) filename[i]=VIN->GetAt(i);

ifstream file; file.open(filename, ios::in); if(!file) { CString temp; temp.Insert(0, "--"); for(int r=0; r<12; r++) VehicleInfo.push_back(temp); } else { char buffert[400]; //Tidpunkterna för tidigare service läses in. int element=-1;

while(file.getline(buffert, 399)) { if(buffert[0]=='@') { element++; if(element != VehicleInfo.size()) { CString temp; temp.Insert(0, "--"); VehicleInfo.push_back(temp); } if(buffert[1]=='1' && buffert[2]=='0') { CString temp; temp.Insert(0, VIN->GetAt(8)); VehicleInfo.push_back(temp); element=9; }

} else { if(buffert[0] == VIN->GetAt(element)) { CString temp; for(int y=2; buffert[y]!='\0'; y++) temp.Insert(temp.GetLength(), buffert[y]); VehicleInfo.push_back(temp);

1

} } }

CString temp; for(int u=11; u<17; u++) temp.Insert(temp.GetLength(), VIN->GetAt(u)); VehicleInfo.push_back(temp); } file.close();

}

vector<CString> *COBDVehicleInfo::getVehicleInfo(){ return &VehicleInfo;}

2

// TroubleCode.h: interface for the CTroubleCode class.////////////////////////////////////////////////////////////////////////#include <vector>using namespace std;

#if !defined(AFX_TROUBLECODE_H__064209FD_D1DD_495B_B606_2ACF297776D6__INCLUDED_)#define AFX_TROUBLECODE_H__064209FD_D1DD_495B_B606_2ACF297776D6__INCLUDED_


class CTroubleCode {public: CTroubleCode(); MakeTroubleCodes(vector<unsigned char> *Faults); vector <CString> *GetTroubleCodes(); CString *GetTroubleCodeDefinitions(int index); virtual ~CTroubleCode();

private://functionsInsertTroubleCode(unsigned char A ,unsigned char B);

//membersvector <CString> TroubleCodes;vector<CString> TroubleCodeDefinitions;CString TroubleCodeDefinition;

};

#endif // !defined(AFX_TROUBLECODE_H__064209FD_D1DD_495B_B606_2ACF297776D6__INCLUDED_)

1

// TroubleCode.cpp: implementation of the CTroubleCode class.////////////////////////////////////////////////////////////////////////

#include "stdafx.h"#include "TroubleCode.h"#include <CString>#include <string>#include <iostream>#include <fstream>#include <vector>



CTroubleCode::CTroubleCode(){}

CTroubleCode::MakeTroubleCodes(vector<unsigned char> *Faults){ TroubleCodes.clear(); TroubleCodeDefinitions.clear();

unsigned char A,B; for(int i=0; i<Faults->size() ;i++) { A=Faults->at(i); i++; B=Faults->at(i);

InsertTroubleCode(A,B); }}

CTroubleCode::InsertTroubleCode(unsigned char A ,unsigned char B){CString TroubleCode;CString TroubleCodeDefinition; if(A & 0x80) //Bittest för att erhålla första tecknet i DTC. { if(A & 0x40) TroubleCode.Insert(0,'U'); else TroubleCode.Insert(0,'B'); } else { if(A & 0x40) TroubleCode.Insert(0,'C'); else TroubleCode.Insert(0,'P'); }

if( A & 0x20) //Bittest för att erhålla andra tecknet i DTC. { if(A & 0x10) TroubleCode.Insert(1,'3'); else TroubleCode.Insert(1,'2'); } else { if(A & 0x10) TroubleCode.Insert(1, '1'); else TroubleCode.Insert(1, '0'); }

1

if( A & 0x08) //Bittest för att erhålla tredje tecknet i DTC. {

if(A & 0x01) TroubleCode.Insert(2,'9'); else TroubleCode.Insert(2,'8'); }

else { if(A & 0x04) { if(A & 0x02) { if(A & 0x01) TroubleCode.Insert(2, '7'); else TroubleCode.Insert(2, '6'); } else { if(A & 0x01) TroubleCode.Insert(2, '5'); else TroubleCode.Insert(2, '4'); } } else { if(A & 0x02) { if(A & 0x01) TroubleCode.Insert(2, '3'); else TroubleCode.Insert(2, '2'); } else { if(A & 0x01) TroubleCode.Insert(2, '1'); else TroubleCode.Insert(2, '0'); } } }

if( B & 0x80) //Bittest för att erhålla fjärde tecknet i DTC. {

if(B & 0x10) TroubleCode.Insert(3, '9'); else TroubleCode.Insert(3, '8'); }

else { if(B & 0x40) { if(B & 0x20) { if(B & 0x10) TroubleCode.Insert(3, '7'); else TroubleCode.Insert(3, '6'); } else { if(B & 0x10) TroubleCode.Insert(3, '5'); else TroubleCode.Insert(3, '4'); } }

2

else { if(B & 0x20) { if(B & 0x10) TroubleCode.Insert(3, '3'); else TroubleCode.Insert(3, '2'); } else { if(B & 0x10) TroubleCode.Insert(3, '1'); else TroubleCode.Insert(3, '0'); } } }

if( B & 0x08) //Bittest för att erhålla femte tecknet i DTC. {

if(B & 0x01) TroubleCode.Insert(4, '9'); else TroubleCode.Insert(4, '8'); }

else { if(B & 0x04) { if(B & 0x02) { if(B & 0x01) TroubleCode.Insert(4, '7'); else TroubleCode.Insert(4, '6'); } else { if(B & 0x01) TroubleCode.Insert(4, '5'); else TroubleCode.Insert(4, '4'); } } else { if(B & 0x02) { if(B & 0x01) TroubleCode.Insert(4, '3'); else TroubleCode.Insert(4, '2'); } else { if(B & 0x01) TroubleCode.Insert(4, '1'); else TroubleCode.Insert(4, '0'); } } }

ifstream infil ("felkoder.txt"); string TroubleCodeTEMP;

while(getline(infil,TroubleCodeTEMP)) { if(TroubleCode.GetAt(0)==TroubleCodeTEMP[0] && TroubleCode.GetAt(1)==TroubleCodeTEMP[1] && TroubleCode.GetAt(2)==TroubleCodeTEMP[2] && TroubleCode.GetAt(3)==TroubleCodeTEMP[3] && T

3

roubleCode.GetAt(4)==TroubleCodeTEMP[4]) { for(int i=0; i<TroubleCodeTEMP.size(); i++) TroubleCodeDefinition.Insert(i,TroubleCodeTEMP[i]);

TroubleCodeDefinition.Delete(0, 6); break; } }

infil.close();

TroubleCodeDefinitions.push_back(TroubleCodeDefinition); TroubleCodes.push_back(TroubleCode);

}

vector<CString> *CTroubleCode::GetTroubleCodes(){ return &TroubleCodes;}

CString *CTroubleCode::GetTroubleCodeDefinitions(int index){ if(index < TroubleCodeDefinitions.size()) TroubleCodeDefinition=TroubleCodeDefinitions.at(index); else TroubleCodeDefinition.Empty(); return &TroubleCodeDefinition;}

CTroubleCode::~CTroubleCode(){

}

4

// OdbLogic.h: interface for the COdbLogic class.////////////////////////////////////////////////////////////////////////

#if !defined(AFX_ODBLOGIC_H__4B5E3F6A_DE33_4046_8E27_460E624B1A0D__INCLUDED_)#define AFX_ODBLOGIC_H__4B5E3F6A_DE33_4046_8E27_460E624B1A0D__INCLUDED_


#include "..\..\SYS\AtSysCommon\AtTemcError.h"#include "..\..\SYS\AtSysCommon\AtLabels.h"#include "OdbDb.h"#include "TroubleCode.h"#include "EarlierServices.h"#include "OBDCommunication.h"#include "OBDVehicleInfo.h"#include <vector>


#import "..\..\MCH\AtMchDB\AtMchDbLib.tlb" raw_interfaces_only, raw_native_types, no_namespace, named_guids

class COdbLogic {public: COdbLogic();

CString *GetVIN();

vector<CString> *GetEarlierServices();

vector<CString> *GetTroubleCodesFromService(int index); CString *GetTroubleCodeDefinitionFromService(int index);

CString *GetServiceStatusAndNrOfTroubleCodes(bool &MilStatus); CString *GetTroubleCodeCausedFreeze();

bool AlreadyRetrivedFreezeFrame(); vector<CString> *GetFreezeParameters(); CString *GetOBDRequirements(); //PID 1C

//Init..ELM323....OK void InitCommunication(); void CloseCommunication(); bool GetCommunicationStatus();

CString *getCommunicationProtocol();

//Realtimefunctions

void GetSupportedRealTimePIDs(); void GetOxygenSensorsPresent();

CString *GetRPM(); CString *GetSpeed(); CString *GetCoolerTemp(); CString *GetEngineLoad(); CString *GetFuelPressure(); CString *GetIntakeMan(); CString *GetThrottlePos(); CString *GetIntakeTemp(); CString *GetMafAirFlow(); CString *GetTimingAdv(); CString *GetShortTrimBank1(); CString *GetLongTrimBank1();

vector<CString> *GetFuelSystemStatus(); vector<CString> *GetOxygenSensorVoltages(); vector<unsigned char> *GetMonitoringTestsCompleted(); bool GetMilLampStatus();

1

vector <CString> *GetTroubleCodes(); int GetNrOfTroubleCode(); void EraseTroubleCodes(); CString *GetTroubleCodeDefinition(int index);

vector<CString> *GetVehicleInfo(); //2003-05-13 CString *GetTimeConnected(); //2003-05-19

bool GetMorePidsStatus();

virtual ~COdbLogic();

// IMchPrintLogicpublic: STDMETHOD(InitLogic)(/*[in]*/ VARIANT *pvaClientSite, /*[in]*/ VARIANT *pvaErrorObject); STDMETHOD(GetLabels)(/*[out]*/ VARIANT *pvaLabels, /*[out]*/ VARIANT *pvaLabelId);

private://functions void DeleteUutInfo(); HRESULT GetSearchData(CString sSql, SAFEARRAY **ppsaData); vector <unsigned char> *SetPIDForSend(unsigned char A, unsigned char B); CString ConvertToString(int value); CString ConvertToString(double value,int PRECISION);

private://members CAtTemcError *m_pError; COdbDb *m_poDb; CAtLabels *m_poLabels; CObList *m_poUutInfo; CUutInfo m_oUut; CTroubleCode *m_poTroubleCodes; CTroubleCode *m_poTroubleCodes_earlier; CEarlierServices *m_poEarlierServices; COBDCommunication *m_poOBDCommunication; COBDVehicleInfo *m_poVehicleInfo; //2003-05-13 tillagd

CString NrTroubleCodes; int NrOfTroubleCode; bool RetrivedTroubleCodes; vector<unsigned char> Faults; bool MilLamp; //true = tänd

CString VINnr; CString OBDRequirements; CString FreezeTroubleCode; bool RetrivedFreezeTroubleCode;

2

bool RetrivedFreezeFrame; vector<CString> FreezeParameters;

//-RealTimeMembers-- bool RealTimePIDsChecked; CString RPM; CString Speed; CString CoolerTemp; CString EngineLoad; CString IntakeManifold; CString IntakeTemp; CString ThrottlePos; CString FuelPressure; CString TimingAdv; CString MafAirFlow; CString ShortTrimBank1; CString LongTrimBank1; vector<CString> FuelSystemStatus; vector<CString> OxygenSensorVoltages; vector<unsigned char> MonitoringTests; unsigned char OxygenSensors;

unsigned char SupportedRealTimePIDsA; unsigned char SupportedRealTimePIDsB; unsigned char SupportedRealTimePIDsC; unsigned char SupportedRealTimePIDsD;

};

#endif // !defined(AFX_ODBLOGIC_H__4B5E3F6A_DE33_4046_8E27_460E624B1A0D__INCLUDED_)

3

// System includes -------

// Project includes -------#include "stdafx.h"//#include "resource.h"

// Local includes -------#include "OdbLogic.h"#include "string.h"#include "TroubleCode.h"#include "EarlierServices.h"#include "OBDCommunication.h"#include "InitDlg.h"#include "OBDVehicleInfo.h"

#include <vector>


// Internal defines -------#define LOG_DATA

#ifdef _DEBUG#undef THIS_FILEstatic char THIS_FILE[]=__FILE__;#define new DEBUG_NEW#endif

// -------------------------- LIFECYCLE --------------------------//------------------------------------------------------------------------------//! Constructor//------------------------------------------------------------------------------COdbLogic::COdbLogic() { m_poDb = new COdbDb(); m_poUutInfo = new CObList(); m_poTroubleCodes= new CTroubleCode(); m_poTroubleCodes_earlier= new CTroubleCode(); m_poEarlierServices = new CEarlierServices(); m_poOBDCommunication = new COBDCommunication(); m_poVehicleInfo =new COBDVehicleInfo();

VINnr = "----------------"; MilLamp=false; RetrivedFreezeFrame=false; RetrivedFreezeTroubleCode=false; RealTimePIDsChecked=false;

RetrivedTroubleCodes=false;

SupportedRealTimePIDsA=0x00; SupportedRealTimePIDsB=0x00; SupportedRealTimePIDsC=0x00; SupportedRealTimePIDsD=0x00;

}//Constructor

//------------------------------------------------------------------------------//! Destructor//------------------------------------------------------------------------------COdbLogic::~COdbLogic() { delete m_poLabels; delete m_pError; delete m_poDb; delete m_poUutInfo;

delete m_poTroubleCodes; delete m_poTroubleCodes_earlier; delete m_poEarlierServices; delete m_poOBDCommunication;

1

delete m_poVehicleInfo; }//Destructor

//-----------------------------------------------------------------------------//// STDMETHODIMP COdbLogic::InitLogic//// -////------------------------------------------------------------------------------STDMETHODIMP COdbLogic::InitLogic(VARIANT *pvaClientSite,VARIANT *pvaErrorObject){ HRESULT hRes;

IOleClientSite *poClientSite = (IOleClientSite*) V_UNKNOWN(pvaClientSite); m_pError = new CAtTemcError("Print Logic"); m_pError->Create(poClientSite, V_UNKNOWN(pvaErrorObject)); m_poLabels = new CAtLabels(); hRes = m_poDb->CreateSession(); if (FAILED(hRes)) { CString strErrMsg; _com_error e1( hRes ); strErrMsg.Format("CreateSession: %s", e1.ErrorMessage() ); m_pError->Error(ERROR_MCE+4, 1, strErrMsg); return E_FAIL; } hRes = m_poDb->OpenDb(SEGMENT_ID_MCH_PRINT); if (FAILED(hRes)) { CString strErrMsg; _com_error e1( hRes ); strErrMsg.Format("OpenDb: %s", e1.ErrorMessage() ); m_pError->Error(ERROR_MCE+4, 1, strErrMsg); return E_FAIL; } VARIANT vaLabels; VARIANT vaLabelId; hRes = GetLabels(&vaLabels, &vaLabelId); if (FAILED(hRes)) { CString strErrMsg; _com_error e1( hRes ); strErrMsg.Format("GetLabels: %s", e1.ErrorMessage() ); m_pError->Error(ERROR_MCE+4, 1, strErrMsg); return E_FAIL; }

hRes = m_poLabels->StoreLogicLabels(&vaLabels, &vaLabelId);

//hRes = m_poCrystal.CoCreateInstance(CRAXDRT::CLSID_Application);

return S_OK;}//InitLogic

//-----------------------------------------------------------------------------//// STDMETHODIMP COdbLogic::GetLabels//// -////------------------------------------------------------------------------------STDMETHODIMP COdbLogic::GetLabels(VARIANT *pvaLabels, VARIANT *pvaLabelId){ AFX_MANAGE_STATE(AfxGetStaticModuleState())

return m_poDb->GetLabels(pvaLabels, pvaLabelId);}//GetLabels

//-----------------------------------------------------------------------------//// void COdbLogic::DeleteUutInfo//// -////------------------------------------------------------------------------------void COdbLogic::DeleteUutInfo(){ POSITION pos;

2

CUutInfo *pSignal;

pos = m_poUutInfo->GetHeadPosition(); while(pos) { pSignal = (CUutInfo*) m_poUutInfo->GetNext(pos); delete pSignal; } m_poUutInfo->RemoveAll();

return;}//DeleteUutInfo

/////////////////////////////////////////////////////////////////////////////CString *COdbLogic::GetVIN(){

VINnr.Empty(); vector<unsigned char> *Resived=SetPIDForSend(0x09,0x02); if(Resived->size() >32 ) { VINnr.Insert(VINnr.GetLength(),Resived->at(4)); VINnr.Insert(VINnr.GetLength(),Resived->at(8)); VINnr.Insert(VINnr.GetLength(),Resived->at(9)); VINnr.Insert(VINnr.GetLength(),Resived->at(10)); VINnr.Insert(VINnr.GetLength(),Resived->at(11)); VINnr.Insert(VINnr.GetLength(),Resived->at(15)); VINnr.Insert(VINnr.GetLength(),Resived->at(16)); VINnr.Insert(VINnr.GetLength(),Resived->at(17)); VINnr.Insert(VINnr.GetLength(),Resived->at(18)); VINnr.Insert(VINnr.GetLength(),Resived->at(22)); VINnr.Insert(VINnr.GetLength(),Resived->at(23)); VINnr.Insert(VINnr.GetLength(),Resived->at(24)); VINnr.Insert(VINnr.GetLength(),Resived->at(25)); VINnr.Insert(VINnr.GetLength(),Resived->at(29)); VINnr.Insert(VINnr.GetLength(),Resived->at(30)); VINnr.Insert(VINnr.GetLength(),Resived->at(31)); VINnr.Insert(VINnr.GetLength(),Resived->at(32));

m_poEarlierServices->CEarlierServicesMake(VINnr); m_poVehicleInfo->setVehicleInfo(&VINnr);

} else VINnr.Insert(0, "EJ IDENTIFIERAT");

return &VINnr;////////////////////////////////////////////////////////////////////////////}

bool COdbLogic::GetMilLampStatus(){return MilLamp;}

vector<CString> *COdbLogic::GetEarlierServices(){ return m_poEarlierServices->GetServiceDates();}

vector<CString> *COdbLogic::GetTroubleCodesFromService(int index){ m_poTroubleCodes_earlier->MakeTroubleCodes(m_poEarlierServices->GetTroubleCodeFromService(index)); return m_poTroubleCodes_earlier->GetTroubleCodes();}

CString *COdbLogic::GetTroubleCodeDefinitionFromService(int index){ return m_poTroubleCodes_earlier->GetTroubleCodeDefinitions(index);}

vector<unsigned char> *COdbLogic::GetMonitoringTestsCompleted(){ bool Temp;

3

GetServiceStatusAndNrOfTroubleCodes(Temp); return &MonitoringTests;}

CString *COdbLogic::GetServiceStatusAndNrOfTroubleCodes(bool &MilStatus){ NrOfTroubleCode=0; MilStatus =false;

vector<unsigned char> send; vector<unsigned char> *resive; MonitoringTests.clear(); unsigned char Temp=0x01; send.push_back(Temp); send.push_back(Temp);

resive = m_poOBDCommunication->transive(&send);

if(resive->size() > 3) { Temp=resive->at(0); MonitoringTests.push_back(resive->at(1)); //various Monitoringtests completed? MonitoringTests.push_back(resive->at(2)); MonitoringTests.push_back(resive->at(3));

if(Temp & 0x80) { MilStatus = true; NrOfTroubleCode=Temp - 0x80; } else { MilStatus = false; NrOfTroubleCode=Temp; } } else { Temp=0x00; MonitoringTests.push_back(Temp); MonitoringTests.push_back(Temp); MonitoringTests.push_back(Temp); }

NrTroubleCodes = ConvertToString(NrOfTroubleCode); MilLamp=MilStatus; return &NrTroubleCodes;}

CString *COdbLogic::GetTroubleCodeCausedFreeze(){//mode 2 PID 02 This PID returns 2 bytes representing the DTC.

if(MilLamp && RetrivedFreezeTroubleCode) return &FreezeTroubleCode;

FreezeTroubleCode.Empty();

if((RetrivedFreezeTroubleCode == false) && MilLamp && (m_poOBDCommunication->GetCommunicationStatus())) { vector<unsigned char> Send; unsigned char temp=0x02;

Send.push_back(temp); Send.push_back(temp);

vector<unsigned char> *read = m_poOBDCommunication->transive(&Send);

if(read->size()>1) m_poTroubleCodes_earlier->MakeTroubleCodes(read); else { FreezeTroubleCode.Insert(0, "Inga frysta parametrar finns lagrade i fordonsdatorn.");

4

RetrivedFreezeFrame=true; RetrivedFreezeTroubleCode=true; return &FreezeTroubleCode; }

if(m_poTroubleCodes_earlier->GetTroubleCodes()->size() > 0) FreezeTroubleCode.Insert(0,(*m_poTroubleCodes_earlier->GetTroubleCodes()).at(0)); FreezeTroubleCode.Insert(FreezeTroubleCode.GetLength()," : "); FreezeTroubleCode.Insert(FreezeTroubleCode.GetLength(),*m_poTroubleCodes_earlier->GetTroubleCodeDefinitions(0)); RetrivedFreezeTroubleCode=true; } else FreezeTroubleCode.Insert(0, "Inga frysta parametrar finns lagrade i fordonsdatorn.");

return &FreezeTroubleCode;

}

bool COdbLogic::AlreadyRetrivedFreezeFrame(){ return RetrivedFreezeFrame;}

CString COdbLogic::ConvertToString(int value){ CString temp; char temp2;

if(value <0) { temp.Insert(temp.GetLength(), '-'); value=value* -1; }

int zero=value/1000; value = value - (1000 * zero); int first=value/100; value = value - (100 * first); int secound=value/10; int three=value%10;

if(zero != 0) { temp2=zero+48; temp.Insert(temp.GetLength(), temp2); temp2=first+48; temp.Insert(temp.GetLength(), temp2); temp2=secound+48; temp.Insert(temp.GetLength(), temp2); temp2=three+48; temp.Insert(temp.GetLength(), temp2); } else if(first != 0) { temp2=first+48; temp.Insert(temp.GetLength(), temp2); temp2=secound+48; temp.Insert(temp.GetLength(), temp2); temp2=three+48; temp.Insert(temp.GetLength(), temp2); } else if(secound !=0) { temp2=secound+48; temp.Insert(temp.GetLength(), temp2); temp2=three+48; temp.Insert(temp.GetLength(), temp2); }

else { temp2=three+48;

5

temp.Insert(temp.GetLength(), temp2); }

return temp;}

CString COdbLogic::ConvertToString(double value, int PRECISION){

CString Converted; Converted.Empty();

char *buffer, *temp ;

int decimal_spot, sign, count, current_location = 0 ;

temp = fcvt (value, PRECISION, &decimal_spot, &sign) ;

if (strlen (temp) > PRECISION) buffer = (char *) malloc (strlen (temp) + 3) ; else buffer = (char *) malloc (PRECISION + 3) ;

if (buffer == NULL) { Converted="NaN"; return (Converted); }

/* Add negative sign if required. */

if (sign) buffer [current_location++] = '-' ;

/* Place decimal point in the correct location. */

if (decimal_spot > 0) { strncpy (&buffer [current_location], temp, decimal_spot) ; buffer [decimal_spot + current_location] = '.' ; strcpy (&buffer [decimal_spot + current_location + 1], &temp [decimal_spot]) ; } else { buffer [current_location] = '.' ; for(count = current_location; count<abs(decimal_spot)+current_location; count++) buffer [count + 1] = '0' ; strcpy (&buffer [count + 1], temp) ; } int i=0; while(buffer [i] !='\0') { Converted.Insert(i,buffer [i]); i++; } if(value<1 && value > -1) Converted.Insert(0,"0"); return Converted;}

vector <unsigned char> *COdbLogic::SetPIDForSend(unsigned char A, unsigned char B)

6

{ vector<unsigned char> Send; Send.push_back(A); Send.push_back(B); return m_poOBDCommunication->transive(&Send); }

////////////////////////////////////////////////////////////////////////////////////FREEZE/////////////////////////////////////////////////////////////////////////////////////////////vector<CString> *COdbLogic::GetFreezeParameters(){ if(RetrivedFreezeFrame) return &FreezeParameters; CString PIDData;

if(!MilLamp) { PIDData.Insert(0, "--"); for(int i=0; i<12; i++) FreezeParameters.push_back(PIDData); return &FreezeParameters; }

FreezeParameters.clear();

vector<unsigned char> *Resived; unsigned char SupportedFreezePIDsA, SupportedFreezePIDsB,SupportedFreezePIDsC, SupportedFreezePIDsD; Resived=SetPIDForSend(0x02,0x00);

if(Resived->size() >3) { SupportedFreezePIDsA = Resived->at(0); SupportedFreezePIDsB = Resived->at(1); SupportedFreezePIDsC = Resived->at(2); SupportedFreezePIDsD = Resived->at(3); } else { SupportedFreezePIDsA = 0x00; SupportedFreezePIDsB = 0x00; SupportedFreezePIDsC = 0x00; SupportedFreezePIDsD = 0x00; }

PIDData.Empty(); if( SupportedFreezePIDsB & 0x08) //Speed. PID 0D {

Resived=SetPIDForSend(0x02,0x0D); if(Resived->size() > 0) { unsigned char temp=Resived->at(0); int conv=temp; PIDData.Insert(0,ConvertToString(conv)); }

} else PIDData.Insert(0, "--");

FreezeParameters.push_back(PIDData);

7

PIDData.Empty(); if( SupportedFreezePIDsB & 0x10) //RPM PID 0C {

Resived=SetPIDForSend(0x02,0x0C); if(Resived->size() > 1) { unsigned char temp=Resived->at(0); int conv=temp*256; temp=Resived->at(1); conv =(conv+temp)/4;

PIDData.Insert(0,ConvertToString(conv)); }



PIDData.Empty(); if( SupportedFreezePIDsA & 0x10) //Engine load PID 04 {

Resived=SetPIDForSend(0x02,0x04); if(Resived->size() > 0) { unsigned char temp=Resived->at(0); double conv=temp*100/255; //Conversion according to standard. PIDData.Insert(0,ConvertToString(conv, 1)); }



PIDData.Empty(); if( SupportedFreezePIDsA & 0x08) //Coolant Temperature PID 05 {

Resived=SetPIDForSend(0x02,0x05); if(Resived->size() > 0) { unsigned char temp=Resived->at(0); int conv =temp - 40; PIDData.Insert(0,ConvertToString(conv)); }



PIDData.Empty(); if( SupportedFreezePIDsB & 0x40) //Fuel Pressure Kpa. PID 0A {

Resived=SetPIDForSend(0x02,0x0A); if(Resived->size() > 0) { unsigned char temp=Resived->at(0); int conv=temp*3; PIDData.Insert(0,ConvertToString(conv)); }

8



PIDData.Empty(); if( SupportedFreezePIDsC & 0x80) //Throttle pos PID 11 {

Resived=SetPIDForSend(0x02,0x11); if(Resived->size() > 0) { unsigned char temp=Resived->at(0); double conv=temp*0.3922; PIDData.Insert(0,ConvertToString(conv, 1)); }



PIDData.Empty(); if( SupportedFreezePIDsB & 0x20) //Intake man press PID 0B {

Resived=SetPIDForSend(0x02,0x0B); if(Resived->size() > 0) { unsigned char temp=Resived->at(0); int conv=temp; PIDData.Insert(0,ConvertToString(conv)); } } else PIDData.Insert(0, "--");


PIDData.Empty(); if( SupportedFreezePIDsB & 0x02) //Intake Air Temp PID 0F {

Resived=SetPIDForSend(0x02,0x0F); if(Resived->size() > 0) { unsigned char temp=Resived->at(0); int conv=temp-40; PIDData.Insert(0,ConvertToString(conv)); }



PIDData.Empty(); if( SupportedFreezePIDsA & 0x20) //Fuel System Status PID 03 {

Resived=SetPIDForSend(0x02,0x03); if(Resived->size() > 1) {

9

if(Resived->at(0) & (0x02 || 0x10)) PIDData.Insert(0,"Stängd Loop"); else PIDData.Insert(0,"Öppen Loop"); FreezeParameters.push_back(PIDData); PIDData.Empty();

if(Resived->at(1) & (0x02 || 0x10)) PIDData.Insert(0,"Stängd Loop"); else PIDData.Insert(0,"Öppen Loop"); FreezeParameters.push_back(PIDData); } } else { PIDData.Insert(0,"--"); FreezeParameters.push_back(PIDData); FreezeParameters.push_back(PIDData); }

PIDData.Empty(); if( SupportedFreezePIDsA & 0x04) //Short term fuel PID 06 {

Resived=SetPIDForSend(0x02,0x06); if(Resived->size() > 0) { unsigned char temp=Resived->at(0); double conv=(temp-128)*0.7812; PIDData.Insert(0,ConvertToString(conv, 1)); }



PIDData.Empty(); if( SupportedFreezePIDsA & 0x02) // Long term trim PID 07 {

Resived=SetPIDForSend(0x02,0x07); if(Resived->size() > 0) { unsigned char temp=Resived->at(0); double conv=(temp-128)*0.7812; PIDData.Insert(0,ConvertToString(conv, 1)); } } else PIDData.Insert(0, "--");


//*******************************//PIDS IMPLEMENTED FOR FREEZEFRAME//*******************************//Fuel System Status PID 03//Engine load PID 04//Coolant Temperature PID 05//Fuel Pressure Kpa. PID 0A//RPM PID 0C//Speed. PID 0D//Throttle Pos PID 11//Intake Air temp PID 0F//Intake man press PID 0B//Timing Adv.deg PID 0E//******************************

10

RetrivedFreezeFrame=true; return &FreezeParameters;

}

//********************************//!!!!!!!!!REALTIMEFUNCTIONS!!!!!!//********************************void COdbLogic::GetSupportedRealTimePIDs(){ if(!RealTimePIDsChecked) { vector<unsigned char> *Resived=SetPIDForSend(0x01,0x00); if(Resived->size() > 3) { SupportedRealTimePIDsA=Resived->at(0); SupportedRealTimePIDsB=Resived->at(1); SupportedRealTimePIDsC=Resived->at(2); SupportedRealTimePIDsD=Resived->at(3); } RealTimePIDsChecked=true; } }

//**

CString *COdbLogic::GetIntakeMan(){ IntakeManifold.Empty(); if( SupportedRealTimePIDsB & 0x20) //Intake Manifold PID 0B {

vector<unsigned char> *Resived=SetPIDForSend(0x01,0x0B); if(Resived->size() > 0) { unsigned char temp=Resived->at(0); int conv=temp; IntakeManifold.Insert(0,ConvertToString(conv)); }

} else IntakeManifold.Insert(0, "--");

return &IntakeManifold;

}

//**CString *COdbLogic::GetThrottlePos(){ ThrottlePos.Empty(); if( SupportedRealTimePIDsC & 0x80) //Throttle Pos. PID 11 {

vector<unsigned char> *Resived=SetPIDForSend(0x01,0x11); if(Resived->size() > 0) { unsigned char temp=Resived->at(0); double conv=temp*0.3922; ThrottlePos.Insert(0,ConvertToString(conv, 1)); }

} else ThrottlePos.Insert(0, "--");

return &ThrottlePos;

}

11

/*///////////////////////////BEHÖVS DENNA???/////void COdbLogic::GetOxygenSensorsPresent(){ if( SupportedRealTimePIDsC & 0x20) { vector<unsigned char> *Resived=SetPIDForSend(0x01,0x13); if(Resived->size() > 0) OxygenSensors=Resived->at(0); return; } OxygenSensors=0x00; return;

}*////////////////////////////////////////////vector<CString> *COdbLogic::GetOxygenSensorVoltages(){ OxygenSensorVoltages.clear(); CString SensorVoltage; int PRECISION=2;

if(SupportedRealTimePIDsC & 0x10) { vector<unsigned char> *Resived=SetPIDForSend(0x01,0x14); if(Resived->size() > 1) { unsigned char temp=Resived->at(0); //Oxygen sensor voltage int conv=temp; double DoubleValue=conv * 0.005; OxygenSensorVoltages.push_back(ConvertToString(DoubleValue,PRECISION)); temp=Resived->at(1); //Short term fuel trim associated with sensor conv=temp; DoubleValue=0.7812*(conv-128); OxygenSensorVoltages.push_back(ConvertToString(DoubleValue,PRECISION)); } else { OxygenSensorVoltages.push_back("--"); OxygenSensorVoltages.push_back("--"); } } else { OxygenSensorVoltages.push_back("--"); OxygenSensorVoltages.push_back("--"); }


12



if(SupportedRealTimePIDsC & 0x01) { vector<unsigned char> *Resived=SetPIDForSend(0x01,0x18); if(Resived->size() > 1) { unsigned char temp=Resived->at(0); //Oxygen sensor voltage int conv=temp; double DoubleValue=conv * 0.005; OxygenSensorVoltages.push_back(ConvertToString(DoubleValue,PRECISION)); temp=Resived->at(1); //Short term fuel trim associated with sensor conv=temp; DoubleValue=0.7812*(conv-128); OxygenSensorVoltages.push_back(ConvertToString(DoubleValue,PRECISION)); } else { OxygenSensorVoltages.push_back("--"); OxygenSensorVoltages.push_back("--"); } } else {

13

OxygenSensorVoltages.push_back("--"); OxygenSensorVoltages.push_back("--"); }

if(SupportedRealTimePIDsD & 0x80) { vector<unsigned char> *Resived=SetPIDForSend(0x01,0x19); if(Resived->size() > 1) { unsigned char temp=Resived->at(0); //Oxygen sensor voltage int conv=temp; double DoubleValue=conv * 0.005; OxygenSensorVoltages.push_back(ConvertToString(DoubleValue,PRECISION)); temp=Resived->at(1); //Short term fuel trim associated with sensor conv=temp; DoubleValue=0.7812*(conv-128); OxygenSensorVoltages.push_back(ConvertToString(DoubleValue,PRECISION)); } else { OxygenSensorVoltages.push_back("--"); OxygenSensorVoltages.push_back("--"); } } else { OxygenSensorVoltages.push_back("--"); OxygenSensorVoltages.push_back("--"); }

if(SupportedRealTimePIDsD & 0x40) { vector<unsigned char> *Resived=SetPIDForSend(0x01,0x1A); if(Resived->size() > 1) { unsigned char temp=Resived->at(0); //Oxygen sensor voltage int conv=temp; double DoubleValue=conv * 0.005; OxygenSensorVoltages.push_back(ConvertToString(DoubleValue,PRECISION)); temp=Resived->at(1); //Short term fuel trim associated with sensor conv=temp; DoubleValue=0.7812*(conv-128); OxygenSensorVoltages.push_back(ConvertToString(DoubleValue,PRECISION));

} else { OxygenSensorVoltages.push_back("--"); OxygenSensorVoltages.push_back("--"); } } else { OxygenSensorVoltages.push_back("--"); OxygenSensorVoltages.push_back("--"); }

if(SupportedRealTimePIDsD & 0x20) { vector<unsigned char> *Resived=SetPIDForSend(0x01,0x1B); if(Resived->size() > 1) { unsigned char temp=Resived->at(0); //Oxygen sensor voltage int conv=temp; double DoubleValue=conv * 0.005; OxygenSensorVoltages.push_back(ConvertToString(DoubleValue,PRECISION)); temp=Resived->at(1); //Short term fuel trim associated with sensor conv=temp; DoubleValue=0.7812*(conv-128); OxygenSensorVoltages.push_back(ConvertToString(DoubleValue,PRECISION));

} else { OxygenSensorVoltages.push_back("--");

14

OxygenSensorVoltages.push_back("--"); } } else { OxygenSensorVoltages.push_back("--"); OxygenSensorVoltages.push_back("--"); }

return &OxygenSensorVoltages;

}

CString *COdbLogic::GetIntakeTemp(){ IntakeTemp.Empty(); if( SupportedRealTimePIDsB & 0x02) //Intake Temp. PID 0F. {

vector<unsigned char> *Resived=SetPIDForSend(0x01,0x0F); if(Resived->size() > 0) { unsigned char temp=Resived->at(0); int conv=temp-40; IntakeTemp.Insert(0,ConvertToString(conv)); }

} else IntakeTemp.Insert(0, "--");

return &IntakeTemp;

}

CString *COdbLogic::GetRPM(){ RPM.Empty(); if( SupportedRealTimePIDsB & 0x10) //RPM PID 0C {

vector<unsigned char> *Resived=SetPIDForSend(0x01,0x0C); if(Resived->size() > 1) { unsigned char temp=Resived->at(0); int conv=temp*256; temp=Resived->at(1); conv =(conv+temp)/4;

RPM.Insert(0,ConvertToString(conv)); }

} else RPM.Insert(0, "--");

return &RPM;

}

15

CString *COdbLogic::GetSpeed(){ Speed.Empty(); if( SupportedRealTimePIDsB & 0x08) //SPEED PID 0D {

vector<unsigned char> *Resived=SetPIDForSend(0x01,0x0D); if(Resived->size() > 0) { unsigned char temp=Resived->at(0); int conv=temp; Speed.Insert(0,ConvertToString(conv)); }

} else Speed.Insert(0, "--");

return &Speed;

}

CString *COdbLogic::GetCoolerTemp(){ CoolerTemp.Empty(); if( SupportedRealTimePIDsA & 0x08) //CoolerTemp PID 05 {

vector<unsigned char> *Resived=SetPIDForSend(0x01,0x05); if(Resived->size() > 0) { unsigned char temp=Resived->at(0); int conv=temp-40; CoolerTemp.Insert(0,ConvertToString(conv)); }

} else CoolerTemp.Insert(0, "--");

return &CoolerTemp;

}

CString *COdbLogic::GetShortTrimBank1(){ ShortTrimBank1.Empty(); if( SupportedRealTimePIDsA & 0x04) //Short term fuel PID 06 {

vector<unsigned char> *Resived=SetPIDForSend(0x01,0x06); if(Resived->size() > 0) { unsigned char temp=Resived->at(0); double conv=(temp-128)*0.7812; ShortTrimBank1.Insert(0,ConvertToString(conv, 1)); }

} else ShortTrimBank1.Insert(0, "--");

return &ShortTrimBank1;

}

CString *COdbLogic::GetLongTrimBank1(){

16

LongTrimBank1.Empty(); if( SupportedRealTimePIDsA & 0x02) // Long term trim PID 07 {

vector<unsigned char> *Resived=SetPIDForSend(0x01,0x07); if(Resived->size() > 0) { unsigned char temp=Resived->at(0); double conv=(temp-128)*0.7812; LongTrimBank1.Insert(0,ConvertToString(conv, 1)); } } else LongTrimBank1.Insert(0, "--");

return &LongTrimBank1;}

CString *COdbLogic::GetFuelPressure(){

FuelPressure.Empty(); if( SupportedRealTimePIDsB & 0x40) //Fuel press kpa PID 0A {

vector<unsigned char> *Resived=SetPIDForSend(0x01,0x0A); if(Resived->size() > 0) { unsigned char temp=Resived->at(0); int conv=temp*3; FuelPressure.Insert(0,ConvertToString(conv)); }

} else FuelPressure.Insert(0, "--");

return &FuelPressure;

}

vector<CString> *COdbLogic::GetFuelSystemStatus(){ FuelSystemStatus.clear(); CString Temp; if( SupportedRealTimePIDsA & 0x20) //Fuel System Status PID 03 { vector<unsigned char> *Resived=SetPIDForSend(0x01,0x03); if(Resived->size() > 1) { if(Resived->at(0) & 0x02 ) Temp.Insert(0,"Stängd Loop"); else if(Resived->at(0) & 0x10) Temp.Insert(0,"Stängd Loop");

else Temp.Insert(0,"Öppen Loop");

FuelSystemStatus.push_back(Temp); Temp.Empty();

if(Resived->at(1) & 0x02) Temp.Insert(0,"Stängd Loop"); else if(Resived->at(1) & 0x10) Temp.Insert(0,"Stängd Loop"); else Temp.Insert(0,"Öppen Loop");

FuelSystemStatus.push_back(Temp); } else

17

{ Temp.Insert(0,"--"); FuelSystemStatus.push_back(Temp); FuelSystemStatus.push_back(Temp); } } else { Temp.Insert(0,"--"); FuelSystemStatus.push_back(Temp); FuelSystemStatus.push_back(Temp); }

return &FuelSystemStatus;

}

CString *COdbLogic::GetMafAirFlow(){

MafAirFlow.Empty(); if( SupportedRealTimePIDsB & 0x01) //MAF Air Flow PID 10 {

vector<unsigned char> *Resived=SetPIDForSend(0x01,0x10); if(Resived->size() > 1) { unsigned char temp=Resived->at(0); int conv=temp*256; temp=Resived->at(1); conv=(conv+temp)*0.01; MafAirFlow.Insert(0,ConvertToString(conv)); }

} else MafAirFlow.Insert(0, "--");

return &MafAirFlow;

}

CString *COdbLogic::GetTimingAdv(){

TimingAdv.Empty(); if( SupportedRealTimePIDsB & 0x04) //Timing adv. PID 0E {

vector<unsigned char> *Resived=SetPIDForSend(0x01,0x0E); if(Resived->size() > 0) { unsigned char temp=Resived->at(0); int conv=(temp*0.5)-64; TimingAdv.Insert(0,ConvertToString(conv)); } } else TimingAdv.Insert(0, "--");

return &TimingAdv;

}

CString *COdbLogic::GetEngineLoad(){

18

EngineLoad.Empty(); if( SupportedRealTimePIDsA & 0x10) //Engine Load(%) PID 04 {

vector<unsigned char> *Resived=SetPIDForSend(0x01,0x04); if(Resived->size() > 0) { unsigned char temp=Resived->at(0); double conv=temp*100/255; EngineLoad.Insert(0,ConvertToString(conv, 1)); }

} else EngineLoad.Insert(0, "--");

return &EngineLoad;

}////////////Communications/////////////void COdbLogic::InitCommunication(){ RetrivedFreezeFrame = false; RetrivedFreezeTroubleCode = false; RealTimePIDsChecked = false; RetrivedTroubleCodes = false;

m_poOBDCommunication->InitCOBDCommunication();}

bool COdbLogic::GetCommunicationStatus(){ return m_poOBDCommunication->GetCommunicationStatus();}

void COdbLogic::CloseCommunication(){ m_poOBDCommunication->CloseCommunication(); }////////////////////////////////////////

CString *COdbLogic::GetOBDRequirements(){ OBDRequirements.Empty(); if( SupportedRealTimePIDsD & 0x10) //Design OBD Requirements PID 1C {

vector<unsigned char> *Resived=SetPIDForSend(0x01,0x1C); if(Resived->size() > 0) { unsigned char temp=Resived->at(0); int conv=temp; switch(conv) { case 1: OBDRequirements.Insert(0,"OBD II (ARB)"); break; case 2: OBDRequirements.Insert(0,"OBD (EPA)"); break; case 3: OBDRequirements.Insert(0,"OBD/OBD II"); break; case 4: OBDRequirements.Insert(0,"OBD I"); break; default: OBDRequirements.Insert(0,"Inga OBD-krav"); break; case 6: OBDRequirements.Insert(0,"EOBD (Europa)"); break; }//switch

19

}//if }//if else OBDRequirements.Insert(0, "--");

return &OBDRequirements;

}

////////////Aktuella felkoder//////////////////////////////////////////vector <CString> *COdbLogic::GetTroubleCodes() //Skapad 2003-05-12{ if(RetrivedTroubleCodes==false && NrOfTroubleCode > 0) { vector<unsigned char> send; send.push_back(0x03); vector<unsigned char> *codes =m_poOBDCommunication->transive(&send);

int r = 0; for(int i=0; i<codes->size(); i++) { if((i+1)%7 != 0) Faults.push_back(codes->at(i)); }

while(Faults.size()/2 > NrOfTroubleCode) { Faults.pop_back(); Faults.pop_back(); }

m_poTroubleCodes->MakeTroubleCodes(&Faults); RetrivedTroubleCodes=true;

} return m_poTroubleCodes->GetTroubleCodes();}

int COdbLogic::GetNrOfTroubleCode(){ return NrOfTroubleCode;}

CString *COdbLogic::GetTroubleCodeDefinition(int index){ return m_poTroubleCodes->GetTroubleCodeDefinitions(index);}

vector<CString> *COdbLogic::GetVehicleInfo(){ return m_poVehicleInfo->getVehicleInfo();}

CString *COdbLogic::getCommunicationProtocol(){ return m_poOBDCommunication->getCommunicationProtocol();}

CString *COdbLogic::GetTimeConnected(){ return m_poOBDCommunication->getAndUpdateTimeConnected();}

void COdbLogic::EraseTroubleCodes(){ vector<unsigned char> send; send.push_back(0x04); m_poOBDCommunication->transive(&send); RetrivedTroubleCodes=false; m_poEarlierServices->SaveService(&Faults); m_poEarlierServices->UpdateServices(); Faults.clear(); NrOfTroubleCode=0;

20

NrTroubleCodes.Empty(); delete m_poTroubleCodes; m_poTroubleCodes=new CTroubleCode();

}

bool COdbLogic::GetMorePidsStatus(){ if(SupportedRealTimePIDsD & 0x01) return true; else return false;}

21

// OdbGui.h : Declaration of the COdbGui

#ifndef __ODBGUI_H_#define __ODBGUI_H_

#import "..\..\SYS\AtSysCommon\LACSnapIn_i.tlb" raw_interfaces_only, \raw_native_types, no_namespace, named_guids

#import "..\..\SYS\AtSysCommon\LAConsole.tlb" no_namespace, \raw_interfaces_only, raw_native_types, named_guids

#include "..\..\SYS\AtSysCommon\AtTemcError.h"#include "resource.h" // main symbols#include <atlctl.h>#include <afxpriv.h>#include "..\..\SYS\AtSysCommon\AtLabels.h"#include "..\..\SYS\AtSysCommon\IAtLacImpl.h"

#include "OdbDefaultGraphic.h"#include "OdbMenu.h"#include "OdbGuiHandler.h"#include "OdbLogic.h"

// Macros and defines ( nyttja static const i st. f. defines för det som inte är makron!)

// Structure declarations

// Forward declarations

// External functions

//------------------------------------------------------------------------------// Class declaration.//! This class handles ...tbd <short comment on class>/*! <Long blockcomment on class CMchPrintGui> *///------------------------------------------------------------------------------class ATL_NO_VTABLE COdbGui : public CComObjectRootEx<CComSingleThreadModel>, public IDispatchImpl<IOdbGui, &IID_IOdbGui, &LIBID_ATODBGUILib>, public CComCompositeControl<COdbGui>, public IPersistStreamInitImpl<COdbGui>, public IOleControlImpl<COdbGui>, public IOleObjectImpl<COdbGui>, public IOleInPlaceActiveObjectImpl<COdbGui>, public IViewObjectExImpl<COdbGui>, public IOleInPlaceObjectWindowlessImpl<COdbGui>, public IPersistStorageImpl<COdbGui>, public ISpecifyPropertyPagesImpl<COdbGui>, public IQuickActivateImpl<COdbGui>, public IDataObjectImpl<COdbGui>, public IProvideClassInfo2Impl<&CLSID_OdbGui, NULL, &LIBID_ATODBGUILib>, public CComCoClass<COdbGui, &CLSID_OdbGui>, public IAtLacImpl<IOdbGui>{public: COdbGui(); virtual ~COdbGui();

DECLARE_REGISTRY_RESOURCEID(IDR_ODBGUI)

DECLARE_PROTECT_FINAL_CONSTRUCT()

BEGIN_COM_MAP(COdbGui) COM_INTERFACE_ENTRY(IOdbGui) COM_INTERFACE_ENTRY(IViewObjectEx) COM_INTERFACE_ENTRY(IViewObject2) COM_INTERFACE_ENTRY(IViewObject) COM_INTERFACE_ENTRY(IOleInPlaceObjectWindowless) COM_INTERFACE_ENTRY(IOleInPlaceObject) COM_INTERFACE_ENTRY2(IOleWindow, IOleInPlaceObjectWindowless) COM_INTERFACE_ENTRY(IOleInPlaceActiveObject) COM_INTERFACE_ENTRY(IOleControl) COM_INTERFACE_ENTRY(IOleObject) COM_INTERFACE_ENTRY(IPersistStreamInit) COM_INTERFACE_ENTRY2(IPersist, IPersistStreamInit)

1

COM_INTERFACE_ENTRY(ISpecifyPropertyPages) COM_INTERFACE_ENTRY(IQuickActivate) COM_INTERFACE_ENTRY(IPersistStorage) COM_INTERFACE_ENTRY(IDataObject) COM_INTERFACE_ENTRY(IProvideClassInfo) COM_INTERFACE_ENTRY(IProvideClassInfo2) COM_INTERFACE_ENTRY2(IDispatch, IOdbGui) COM_INTERFACE_ENTRY(ILACSnapIn) COM_INTERFACE_ENTRY(ILACSnapInExclusiveGroup)END_COM_MAP()

BEGIN_PROP_MAP(COdbGui) PROP_DATA_ENTRY("_cx", m_sizeExtent.cx, VT_UI4) PROP_DATA_ENTRY("_cy", m_sizeExtent.cy, VT_UI4) // Example entries // PROP_ENTRY("Property Description", dispid, clsid) // PROP_PAGE(CLSID_StockColorPage)END_PROP_MAP()

BEGIN_MSG_MAP(COdbGui) MESSAGE_HANDLER(WM_CTLCOLORDLG, OnColorDlg) MESSAGE_HANDLER(WM_CTLCOLORSTATIC, OnColorDlg) CHAIN_MSG_MAP(CComCompositeControl<COdbGui>) MESSAGE_HANDLER(WM_MENUSELECT, OnMenuSelect) MESSAGE_HANDLER(WM_INITMENU, OnInitMenu) MESSAGE_HANDLER(WM_INITMENUPOPUP, OnInitMenuPopup) MESSAGE_HANDLER(WM_SIZE, OnSize) MESSAGE_HANDLER(WM_HELPHITTEST, OnHelpHitTest) MESSAGE_HANDLER(WM_COMMANDHELP, OnCommandHelp) MESSAGE_HANDLER(WM_TIMER, OnTimer) //MESSAGE_HANDLER(WM_NOTIFY, OnCommand)

//Controls

NOTIFY_HANDLER(IDC_TAB_DB, TCN_SELCHANGE, OnSelchangeTabDb) NOTIFY_HANDLER(IDC_TREE_FILES, NM_RCLICK, OnRclickTreeFiles) NOTIFY_HANDLER(IDC_LIST_REPORTS, NM_RCLICK, OnRclickListReports) NOTIFY_HANDLER(IDC_LIST_SERIES, NM_RCLICK, OnRclickListSeries) NOTIFY_HANDLER(IDC_TREE_FILES, NM_DBLCLK, OnDblclkTreeFiles) COMMAND_HANDLER(IDC_COMBO_DATE_END, CBN_SELCHANGE, OnSelchangeComboDateEnd) COMMAND_HANDLER(IDC_COMBO_DATE_START, CBN_SELCHANGE, OnSelchangeComboDateStart) COMMAND_HANDLER(IDC_COMBO_MBT, CBN_SELCHANGE, OnSelchangeComboMbt) COMMAND_HANDLER(IDC_COMBO_OPERATOR, CBN_SELCHANGE, OnSelchangeComboOperator) COMMAND_HANDLER(IDC_COMBO_REG_NO, CBN_SELCHANGE, OnSelchangeComboRegNo) COMMAND_HANDLER(IDC_COMBO_REPORT, CBN_SELCHANGE, OnSelchangeComboReport) COMMAND_HANDLER(IDC_COMBO_UNIT, CBN_SELCHANGE, OnSelchangeComboUnit) COMMAND_HANDLER(IDC_COMBO_UNIT_NO, CBN_SELCHANGE, OnSelchangeComboUnitNo) NOTIFY_HANDLER(IDC_LIST_REPORTS, HDN_ITEMDBLCLICK, OnItemdblclickListReports) NOTIFY_HANDLER(IDC_TREE_FILES, NM_CLICK, OnClickTreeFiles) NOTIFY_HANDLER(IDC_TREE_FILES, TVN_SELCHANGED, OnSelchangedTreeFiles) COMMAND_HANDLER(IDC_LIST1, LBN_SELCHANGE, OnSelchangeList1) COMMAND_HANDLER(IDC_BUTTON_ERASE, BN_CLICKED, OnClickedButton_erase) COMMAND_HANDLER(IDC_LIST_DTC, LBN_SELCHANGE, OnSelchangeList_dtc) COMMAND_HANDLER(IDC_COMBO_EARL_SERVICE, CBN_SELCHANGE, OnSelchangeCombo_earl_service) COMMAND_HANDLER(IDC_LIST_OLD_DTC, LBN_SELCHANGE, OnSelchangeList_old_dtc) COMMAND_HANDLER(IDC_BUTTON_START, BN_CLICKED, OnClickedButton_start) COMMAND_HANDLER(IDC_BUTTON_STOP, BN_CLICKED, OnClickedButton_stop) COMMAND_HANDLER(IDC_BUTTON_UPDATE, BN_CLICKED, OnClickedButton_update) COMMAND_HANDLER(IDC_BUTTON_OK, BN_CLICKED, OnClickedButton_ok) COMMAND_HANDLER(IDC_BUTTON_QUIT, BN_CLICKED, OnClickedButton_quit)END_MSG_MAP()// Handler prototypes:// LRESULT MessageHandler(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled);// LRESULT CommandHandler(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled);// LRESULT NotifyHandler(int idCtrl, LPNMHDR pnmh, BOOL& bHandled);

BEGIN_SINK_MAP(COdbGui) //Make sure the Event Handlers have __stdcall calling conventionEND_SINK_MAP()

// IViewObjectEx DECLARE_VIEW_STATUS(0)

// IOdbGuipublic:

enum { IDD = IDD_ODBGUI };

// Common

2

STDMETHOD(ContextSensitiveHelp(BOOL fEnterMode)); LRESULT OnHelpHitTest(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled); LRESULT OnCommandHelp(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled); STDMETHOD(OnDocWindowActivate)(BOOL fActivate); STDMETHOD(OnAmbientPropertyChange)(DISPID dispid); LRESULT OnColorDlg(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled); HRESULT NextInTabOrder( BOOL bPrevious ); STDMETHOD(TranslateAccelerator)(MSG *pMsg); LRESULT OnMenuSelect(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled); LRESULT OnInitMenu(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled); LRESULT OnInitMenuPopup(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled); LRESULT OnSize(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled); HWND Create( HWND hWndParent, RECT& rcPos, LPARAM dwInitParam = NULL); LRESULT OnTimer(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled); LRESULT OnCommand(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled);

// Controls LRESULT OnSelchangeTabDb(int idCtrl, LPNMHDR pnmh, BOOL& bHandled); LRESULT OnButtonShow(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled); LRESULT OnButtonShowSeries(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled); LRESULT OnButtonPrint(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled); LRESULT OnButtonSearch(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled); LRESULT OnRclickTreeFiles(int idCtrl, LPNMHDR pnmh, BOOL& bHandled); LRESULT OnRclickListReports(int idCtrl, LPNMHDR pnmh, BOOL& bHandled); LRESULT OnRclickListSeries(int idCtrl, LPNMHDR pnmh, BOOL& bHandled); LRESULT OnDblclkTreeFiles(int idCtrl, LPNMHDR pnmh, BOOL& bHandled); LRESULT OnClickTreeFiles(int idCtrl, LPNMHDR pnmh, BOOL& bHandled); LRESULT OnSelchangedTreeFiles(int idCtrl, LPNMHDR pnmh, BOOL& bHandled); LRESULT OnSelchangeComboDateEnd(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled); LRESULT OnSelchangeComboDateStart(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled); LRESULT OnSelchangeComboMbt(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled); LRESULT OnSelchangeComboOperator(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled); LRESULT OnSelchangeComboRegNo(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled); LRESULT OnSelchangeComboReport(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled); LRESULT OnSelchangeComboUnit(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled); LRESULT OnSelchangeComboUnitNo(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled); LRESULT OnItemdblclickListReports(int idCtrl, LPNMHDR pnmh, BOOL& bHandled); LRESULT OnSelchangeList1(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled); LRESULT OnClickedButton_erase(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled); LRESULT OnSelchangeList_dtc(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled); LRESULT OnSelchangeCombo_earl_service(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled); LRESULT OnSelchangeList_old_dtc(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled); LRESULT OnClickedButton_start(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled); LRESULT OnClickedButton_stop(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled); LRESULT OnClickedButton_update(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled); LRESULT OnClickedButton_ok(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled); LRESULT OnClickedButton_quit(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled);

// ILACSnapIn STDMETHOD(PrepareToClose)(LONG * pbCancel);

// Private methodsprivate: BOOL End();

// Private attributesprivate: COdbLogic *m_poLogic; HWND m_hwndGuiWnd; CAtTemcError *m_poError; COdbDefaultGraphic *m_poGraphic; COdbMenu *m_poMenu; COdbGuiHandler *m_poHandler; //CMchPrintHelp *m_poHelp; CAtLabels *m_poLabels; BOOL m_bClose;

bool toggleStatusLamp; //Tillagt 2003-05-21

3

};

#endif //__ODBGUI_H_

4


// Project includes -------#include "stdafx.h"#include "AtOdbGui.h"

// Local includes -------#include "OdbGui.h"

// Internal defines -------

// -------------------------- LIFECYCLE --------------------------//------------------------------------------------------------------------------//! Constructor//------------------------------------------------------------------------------COdbGui::COdbGui(){ m_bWindowOnly = TRUE; CalcExtent(m_sizeExtent); m_poError = NULL; m_poHandler = NULL; m_poMenu = NULL; m_poGraphic = NULL; m_poLabels = NULL; m_bClose = true; SnapInInit("MCH", "On Board Diagnostics", "1.0.0");

toggleStatusLamp=false; //2003-05-21

}

//------------------------------------------------------------------------------//! Destructor//------------------------------------------------------------------------------COdbGui::~COdbGui(){}

// -------------------------- OPERATORS --------------------------

// -------------------------- OPERATIONS --------------------------

// -------------------------- ACCESS METHODS --------------------------

//-----------------------------------------------------------------------------//// LRESULT COdbGui::PrepareToClose//// -////------------------------------------------------------------------------------STDMETHODIMP COdbGui::PrepareToClose(LONG * pbCancel){ if (pbCancel == NULL) return E_POINTER; if (m_poError) { *pbCancel = m_poError->ErrorSet(); } else { *pbCancel = false; } if (*pbCancel) { SetTimer(5, 500); return S_OK; } *pbCancel = !End(); if (!*pbCancel) { delete m_poError;

1

m_poError = NULL; } return S_OK;}//PrepareToClose

//-----------------------------------------------------------------------------//// COdbGui::Create/*!// \param hWndParent Handle to parent window // \param rcPos Size and position of parent window// \param dwInitParam // \return Handle to main window*///------------------------------------------------------------------------------HWND COdbGui::Create(HWND hWndParent, RECT& rcPos, LPARAM dwInitParam){ HRESULT hRes; VARIANT vaClientSite; VARIANT vaErrorObject; SHORT nMbtType; CString sMbtType; CString sOperator; CString sRegNo;

//AfxInitRichEdit(); m_hwndGuiWnd = CComCompositeControl<COdbGui>::Create(hWndParent, rcPos, dwInitParam);

if ( m_hwndGuiWnd == NULL ) { MessageBox("Kunde inte skapa GUI", "Kritiskt fel"); return NULL; }

hRes = LacInit(m_spClientSite, &sMbtType, &sOperator, &sRegNo); if (FAILED(hRes)) { CString strErrMsg; _com_error e1( hRes ); strErrMsg.Format("LacInit: %s", e1.ErrorMessage() ); MessageBox(strErrMsg, "Kritiskt fel"); return m_hwndGuiWnd; }

m_bClose = false;

m_poError = new CAtTemcError("OBD"); m_poError->Create(m_spClientSite); m_poLabels = new CAtLabels();

//m_poError->Error(ERROR_MCE+1, 1, "Test"); /* hRes = m_poLogic.CoCreateInstance(CLSID_MchPrintLogic); if (FAILED(hRes)) { m_poError->Error(0, 2, "Kunde ansluta till PRINT logik"); return m_hwndGuiWnd; } */ m_poLogic = new COdbLogic(); V_VT(&vaClientSite) = VT_UNKNOWN; V_UNKNOWN(&vaClientSite) = m_spClientSite; V_VT(&vaErrorObject) = VT_UNKNOWN; V_UNKNOWN(&vaErrorObject) = m_poError->GetErrorObject(); if (FAILED(m_poLogic->InitLogic(&vaClientSite, &vaErrorObject))) { return m_hwndGuiWnd; }

VARIANT vaLabels; VARIANT vaLabelId; if (SUCCEEDED(m_poLogic->GetLabels(&vaLabels, &vaLabelId))) { m_poLabels->StoreLabels(&vaLabels, &vaLabelId); }

// Get the entered MBT type /* if (!sMbtType.Compare(m_poLabels->FindGeneralLabel(30))) {

2

nMbtType = MBT_TYPE_121; } else if (!sMbtType.Compare(m_poLabels->FindGeneralLabel(31))) { nMbtType = MBT_TYPE_122; } else if (!sMbtType.Compare(m_poLabels->FindGeneralLabel(32))) { nMbtType = MBT_TYPE_BGV120; } else */ { nMbtType = MBT_TYPE_NONE; } //m_pError->Error(20, 0, "Guifel");

m_poGraphic = new COdbDefaultGraphic(m_hwndGuiWnd); m_poGraphic->SetLabels(m_poLabels); if (!m_poGraphic->InitGraphic(nMbtType, &sOperator, &sRegNo)) { m_poError->Error(ERROR_MCE + 2, EVENT_ERROR, m_poLabels->FindErrorLabel(5)); return m_hwndGuiWnd; }

m_poMenu = new COdbMenu(m_poInPlaceFrame, m_hwndGuiWnd); m_poMenu->m_poLabels = m_poLabels; if ( !m_poMenu->CreateInPlaceMenu() ) { m_poError->Error(1, 2, "Kunde inte skapa meny"); return m_hwndGuiWnd; } COdbGuiHandler::TYPEHANDLERDATA oHandlerData; oHandlerData.hwndGuiWnd = m_hwndGuiWnd; oHandlerData.poGraphic = m_poGraphic; oHandlerData.poLogic = m_poLogic; oHandlerData.poMenu = m_poMenu; oHandlerData.poLabels = m_poLabels; oHandlerData.poError = m_poError; oHandlerData.poInPlaceFrame = m_poInPlaceFrame; m_poHandler = new COdbGuiHandler(&oHandlerData); if ( !m_poHandler ) { m_poError->Error(3, 2, "Kunde inte skapa GUI hanterare"); return m_hwndGuiWnd; } /* m_poHelp = new COdbHelp(m_hwndGuiWnd, m_poGraphic); if ( !m_poHelp ) { m_poError->Error(3, 2, "Kunde inte skapa hjälp hanterare"); return m_hwndGuiWnd; } */

m_poHandler->SelchangeTabDb(TAB_REALTIME);

//BOOL bHandled; //OnSelchangeComboMbt(0, 0, NULL, bHandled); return m_hwndGuiWnd;}//Create

//-----------------------------------------------------------------------------//// LRESULT COdbGui::OnDocWindowActivate//// -////------------------------------------------------------------------------------STDMETHODIMP COdbGui::OnDocWindowActivate(BOOL fActivate){ if ( fActivate && m_bUIActive && m_poMenu ) m_poMenu->SetMenu();

return IOleInPlaceActiveObjectImpl<COdbGui>::OnDocWindowActivate(fActivate);}//OnDocWindowActivate

//-----------------------------------------------------------------------------//

3

// LRESULT COdbGui::OnAmbientPropertyChange//// -////------------------------------------------------------------------------------STDMETHODIMP COdbGui::OnAmbientPropertyChange(DISPID dispid){ if (dispid == DISPID_AMBIENT_BACKCOLOR) { SetBackgroundColorFromAmbient(); FireViewChange(); } return IOleControlImpl<COdbGui>::OnAmbientPropertyChange(dispid);}//OnAmbientPropertyChange

//-----------------------------------------------------------------------------//// LRESULT COdbGui::OnColorDlg//// -////------------------------------------------------------------------------------LRESULT COdbGui::OnColorDlg(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled){ return DefWindowProc(); //Ignore ambient back color and pass to system.}//OnColorDlg

//-----------------------------------------------------------------------------//// LRESULT COdbGui::NextInTabOrder//// -////------------------------------------------------------------------------------HRESULT COdbGui::NextInTabOrder( BOOL bPrevious ){ CWnd* pWndNext = CWnd::FromHandle(GetNextDlgTabItem(GetFocus(), bPrevious)); if (pWndNext) { /* if (pWndNext->m_hWnd == ::GetDlgItem(m_hwndGuiWnd, IDC_TAB_INSTRUCTION)) { ::SetFocus(::GetDlgItem(m_hwndGuiWnd, IDC_INSTRUCTIONS)); } else if (pWndNext->m_hWnd == ::GetDlgItem(m_hwndGuiWnd, IDC_TAB_RESULT)) { ::SetFocus(::GetDlgItem(m_hwndGuiWnd, IDC_SPREAD)); } else */ { pWndNext->SetFocus(); } return S_OK; } return S_FALSE;}//NextInTabOrder

//-----------------------------------------------------------------------------//// LRESULT COdbGui::TranslateAccelerator//// -////------------------------------------------------------------------------------STDMETHODIMP COdbGui::TranslateAccelerator(MSG *pMsg){ static BOOL bShifted = false; if ( ((pMsg->message >= WM_KEYFIRST) && (pMsg->message <= WM_KEYLAST)) ) { CComQIPtr<IOleControlSite,&IID_IOleControlSite> spCtrlSite(m_spClientSite); if(spCtrlSite) { switch( pMsg->wParam ) { case VK_TAB: if ( pMsg->message == WM_KEYUP ) { return NextInTabOrder( bShifted ); }

4

else if (pMsg->message == WM_KEYDOWN) { /* if (::GetFocus() == ::GetDlgItem(m_hwndGuiWnd, IDC_INSTRUCTIONS)) { ::SetFocus(::GetDlgItem(m_hwndGuiWnd, IDC_TAB_INSTRUCTION)); } else if (::GetFocus() == ::GetDlgItem(m_hwndGuiWnd, IDC_SPREAD)) { ::SetFocus(::GetDlgItem(m_hwndGuiWnd, IDC_TAB_RESULT)); } */ } break; case VK_RETURN: return spCtrlSite->TranslateAccelerator (pMsg,0); break; case VK_SHIFT: bShifted = pMsg->message == WM_KEYDOWN; return spCtrlSite->TranslateAccelerator (pMsg,0); break; default: return spCtrlSite->TranslateAccelerator (pMsg,0); break; } return S_OK; } } return S_FALSE;}//TranslateAccelerator

//-----------------------------------------------------------------------------//// LRESULT COdbGui::OnMenuSelect//// -////------------------------------------------------------------------------------LRESULT COdbGui::OnMenuSelect(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled){ static DWORD dwLast = 0; DWORD dwIndex = LOWORD(wParam); DWORD dwFlags = HIWORD(wParam); CString csFilePath;

if (dwFlags == 0xFFFF) { switch(dwLast) { case IDM_FILE_SAVE: // m_poHandler->OnButtonSave(); break; case IDM_FILE_QUIT: ::PostMessage(::GetParent(GetParent()), WM_SYSCOMMAND, SC_CLOSE, -1); break; case IDM_EDIT_COPY: //sString += "Copy"; break; case IDM_EDIT_PASTE: //sString += "Paste"; break; case IDM_EDIT_CUT: //sString += "Cut"; break; case IDM_TOOLS_CALIBRATE: //sString += "Kalibrera"; break; case IDM_TOOLS_SELFTEST_COMPONENTS: /* m_poSelftest = new CMceSelftest();

m_poSelftest->Create( _Module.GetResourceInstance(), MAKEINTRESOURCE(IDD_MCESELFTEST), CWnd::FromHandle(m_hwndGuiWnd), m_poLogic, m_poLabels);

m_poSelftest->DoModal(); delete m_poSelftest; */

5

break; case IDM_TOOLS_SELFTEST_CABLES: //sString += "Självtest kabel"; break; case IDM_TOOLS_SELFTEST_ADAPTERS: //sString += "Självtest adapter"; break; case IDM_TOOLS_SELFTEST_RELAYCARDS: //sString += "Självtest reläkort"; break; case IDM_HELP_CONTENT: //m_poHelp->CommandHelp(IDM_HELP_CONTENT); //sString += "Innehåll"; break; case IDM_HELP_INDEX: //m_poHelp->CommandHelp(IDM_HELP_INDEX); //sString += "Index"; break; case IDM_HELP_ABOUT: //m_poHelp->CommandHelp(IDM_HELP_ABOUT); //sString += "Om MCE"; break; default: return false; break; } dwLast = 0; return true; } else { dwLast = dwIndex; } return 0;}//OnMenuSelect

//-----------------------------------------------------------------------------//// LRESULT COdbGui::OnInitMenu//// -////------------------------------------------------------------------------------LRESULT COdbGui::OnInitMenu(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled){ m_poMenu->OnInitMenu(CMenu::FromHandle( (HMENU) wParam )); return 0;}//OnInitMenu

//-----------------------------------------------------------------------------//// LRESULT COdbGui::OnInitMenuPopup//// -////------------------------------------------------------------------------------LRESULT COdbGui::OnInitMenuPopup(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled){ m_poMenu->OnInitMenuPopup(CMenu::FromHandle( (HMENU) wParam ));

return 1;}//OnInitMenuPopup

//-----------------------------------------------------------------------------//// LRESULT COdbGui::OnSize//// -////------------------------------------------------------------------------------LRESULT COdbGui::OnSize(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled){ if (m_poHandler) { return m_poHandler->OnSize(); } return 0;}//OnSize

//-----------------------------------------------------------------------------//// LRESULT COdbGui::ContextSensitiveHelp//

6

// -////------------------------------------------------------------------------------STDMETHODIMP COdbGui::ContextSensitiveHelp(BOOL fEnterMode){ //return m_poHelp->ContextSensitiveHelp( fEnterMode ); return S_OK;}//ContextSensitiveHelp

//-----------------------------------------------------------------------------//// LRESULT COdbGui::OnHelpHitTest//// Parameters:// WPARAM wParam: usually = 0 in message WM_HELPHITTEST, see MSDN// LPARAM lParam: contains device coordinates where the mouse was clicked // relative to the client area of the window. // LOWORD(lParam)=X-axis, HIWORD(lParam)=Y-axis//// Return:// LRESULT should return a DWORD Help ID for use by WinHelp//-----------------------------------------------------------------------------LRESULT COdbGui::OnHelpHitTest(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)

{ CPoint cpMouseCursorPoint(LOWORD(lParam), HIWORD(lParam));

//return m_poHelp->HelpHitTest(cpMouseCursorPoint); return S_OK;}//OnHelpHitTest

//-----------------------------------------------------------------------------//// LRESULT COdbGui::OnCommandHelp//// Purpose: handles WM_COMMANDHELP which is an MFC private Windows message that// is received by the active window when Help is requested, see MSDN//// Parameters:// WPARAM wParam: usually = 0 in message WM_COMMANDHELP, see MSDN// LPARAM lParam: currently available Help context.// = 0 if no Help context has been determined yet.// Context ID in lParam may be used to determine a "better" context or// may just be passed.//// Return:// LRESULT should return TRUE if the OnCommandHelp function calls Help.// Returning TRUE stops the routing of this command to other classes// (base classes) and to other windows.//-----------------------------------------------------------------------------LRESULT COdbGui::OnCommandHelp(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled){ //return m_poHelp->CommandHelp(lParam); return S_OK;}//OnCommandHelp

//-----------------------------------------------------------------------------//// LRESULT COdbGui::OnCommand//// -////------------------------------------------------------------------------------LRESULT COdbGui::OnCommand(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled){ bHandled = false; if (HIWORD(wParam) == NM_RCLICK) { //m_poHandler->OnTopRowChangeSpread(LOWORD(wParam)); return 0; } return 0;}//OnCommand

//-----------------------------------------------------------------------------//// LRESULT COdbGui::OnTimer//// -////------------------------------------------------------------------------------

7

LRESULT COdbGui::OnTimer(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled){ switch (wParam) { case 5: KillTimer(5); m_bClose = true; ::PostMessage(::GetParent(GetParent()), WM_SYSCOMMAND, SC_CLOSE, -1); break;

case 6: //Realtid timer 2003-05-12 //KillTimer(6); m_poHandler->UpdateRealTime(); //SetTimer(6, 5000); break;

case 7: if(!m_poLogic->GetCommunicationStatus()) { KillTimer(7); m_poGraphic->GetDlgItem(IDC_BUTTON_ERASE)->EnableWindow(false); m_poLogic->CloseCommunication(); m_poGraphic->GetDlgItem(IDC_BUTTON_START)->EnableWindow(true); m_poGraphic->GetDlgItem(IDC_BUTTON_STOP)->EnableWindow(false); m_poGraphic->GetDlgItem(IDC_BUTTON_UPDATE)->EnableWindow(false); m_poGraphic->GetDlgItem(IDC_EDIT_INSTRUCTIONS)->SetWindowText("1.Kontrollera anslutningen mellan TEMC och fordonet.\r\n2.Tryck på Starta för att återansluta."); } m_poHandler->UpdateTimeConnected();

break;

case 8: // Set the default window-size KillTimer(8); if (!::IsZoomed(::GetParent(GetParent()))) { ::MoveWindow(::GetParent(GetParent()), 0,0, 1020, 610, true); //::MoveWindow(::GetParent(GetParent()), 0,0, 1060, 610, true); } // endif m_poGraphic->OnSelDlgRealtime(true); break;

case 9: //Tillagt 2003-05-21 För att få Mil iconen att blinka. if(toggleStatusLamp) toggleStatusLamp=false; else toggleStatusLamp=true;

m_poGraphic->GetDlgItem(IDC_ICON_MIL_RED)->ShowWindow(toggleStatusLamp);

break;

default: return m_poHandler->OnTimer(wParam); }

return 0;}//OnTimer

//-----------------------------------------------------------------------------//// LRESULT COdbGui::End//// -////------------------------------------------------------------------------------BOOL COdbGui::End(){ /* if (m_poHandler) { if (m_poHandler->m_nStage > 0)

8

{ m_poError->Error(ERROR_MCE+1, EVENT_WARNING, m_poLabels->FindErrorLabel(0)); return false; } } */ delete m_poHandler; m_poHandler = NULL; delete m_poMenu; m_poMenu = NULL; delete m_poGraphic; m_poGraphic = NULL;

if (m_poLogic) { delete m_poLogic; m_poLogic = NULL; } delete m_poLabels; m_poLabels = NULL;

return true;}//End //-----------------------------------------------------------------------------//// LRESULT COdbGui::OnSelchangeTabDb//// -////------------------------------------------------------------------------------LRESULT COdbGui::OnSelchangeTabDb(int idCtrl, LPNMHDR pnmh, BOOL& bHandled){ bHandled = false; int iSel = TabCtrl_GetCurSel(pnmh->hwndFrom); if (iSel > -1) { m_poHandler->SelchangeTabDb(iSel); }

return 0;}//OnSelchangeTabDb

//-----------------------------------------------------------------------------//// LRESULT COdbGui::OnButtonShow//// -////------------------------------------------------------------------------------LRESULT COdbGui::OnButtonShow(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled){ m_poHandler->OnButtonShow();

return 0;}//OnButtonShow

//-----------------------------------------------------------------------------//// LRESULT COdbGui::OnButtonShowSeries//// -////------------------------------------------------------------------------------LRESULT COdbGui::OnButtonShowSeries(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled){ m_poHandler->OnButtonShowSeries();

return 0;}//OnButtonShowSeries

//-----------------------------------------------------------------------------//// LRESULT COdbGui::OnButtonPrint//// -////------------------------------------------------------------------------------LRESULT COdbGui::OnButtonPrint(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled){

9

m_poHandler->OnButtonPrint();

return 0;}//OnButtonPrint

//-----------------------------------------------------------------------------//// LRESULT COdbGui::OnButtonSearch//// -////------------------------------------------------------------------------------LRESULT COdbGui::OnButtonSearch(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled){ m_poHandler->OnButtonSearch();

return 0;}//OnButtonSearch

//-----------------------------------------------------------------------------//// LRESULT COdbGui::OnRclickTreeFiles//// -////------------------------------------------------------------------------------LRESULT COdbGui::OnRclickTreeFiles(int idCtrl, LPNMHDR pnmh, BOOL& bHandled){ CTreeCtrl *poTree = (CTreeCtrl*) m_poGraphic->GetDlgItem(IDC_TREE_FILES);

HTREEITEM hItem = poTree->GetSelectedItem();

// Check if the item is a leaf. if(poTree->ItemHasChildren(hItem) == 0) { bHandled = true; m_poHandler->OnRclickTreeFiles(); } else return -1;

return 0;}//OnRclickTreeFiles

//-----------------------------------------------------------------------------//// LRESULT COdbGui::OnDblclkTreeFiles//// -////------------------------------------------------------------------------------LRESULT COdbGui::OnDblclkTreeFiles(int idCtrl, LPNMHDR pnmh, BOOL& bHandled){ // TODO : Add Code for control notification handler. bHandled = true; m_poHandler->OnDblclkTreeFiles(); return 0;}//OnDblclkTreeFiles

//-----------------------------------------------------------------------------//// LRESULT COdbGui::OnClickTreeFiles//// -////------------------------------------------------------------------------------LRESULT COdbGui::OnClickTreeFiles(int idCtrl, LPNMHDR pnmh, BOOL& bHandled){ bHandled = true; m_poHandler->OnClickTreeFiles(); return 0;}//OnClickTreeFiles

//-----------------------------------------------------------------------------//// LRESULT COdbGui::OnSelchangedTreeFiles//// -////------------------------------------------------------------------------------LRESULT COdbGui::OnSelchangedTreeFiles(int idCtrl, LPNMHDR pnmh, BOOL& bHandled){

10

bHandled = true; m_poHandler->OnSelchangedTreeFiles(); return 0;}//OnSelchangedTreeFiles

//-----------------------------------------------------------------------------//// LRESULT COdbGui::OnRclickListReports//// -////------------------------------------------------------------------------------LRESULT COdbGui::OnRclickListReports(int idCtrl, LPNMHDR pnmh, BOOL& bHandled){ bHandled = true; m_poHandler->OnRclickListReports(); return 0;}//OnRclickListReports

//-----------------------------------------------------------------------------//// LRESULT COdbGui::OnRclickListSeries//// -////------------------------------------------------------------------------------LRESULT COdbGui::OnRclickListSeries(int idCtrl, LPNMHDR pnmh, BOOL& bHandled){ bHandled = true; m_poHandler->OnRclickListSeries(); return 0;

}//OnRclickListReports

//-----------------------------------------------------------------------------//// LRESULT COdbGui::OnSelchangeComboDateEnd//// -////------------------------------------------------------------------------------LRESULT COdbGui::OnSelchangeComboDateEnd(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled){ // TODO : Add Code for control notification handler. //m_poHandler->SelchangeTabDb(TAB_SEARCH); return 0;}//OnSelchangeComboDateEnd

//-----------------------------------------------------------------------------//// LRESULT COdbGui::OnSelchangeComboDateStart//// -////------------------------------------------------------------------------------LRESULT COdbGui::OnSelchangeComboDateStart(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled){ // TODO : Add Code for control notification handler. //m_poHandler->SelchangeTabDb(TAB_SEARCH); return 0;}//OnSelchangeComboDateStart

//-----------------------------------------------------------------------------//// LRESULT COdbGui::OnSelchangeComboMbt//// -////------------------------------------------------------------------------------LRESULT COdbGui::OnSelchangeComboMbt(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled){ // TODO : Add Code for control notification handler. //m_poHandler->SelchangeTabDb(TAB_SEARCH); return 0;}//OnSelchangeComboMbt

//-----------------------------------------------------------------------------

11

//// LRESULT COdbGui::OnSelchangeComboOperator//// -////------------------------------------------------------------------------------LRESULT COdbGui::OnSelchangeComboOperator(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled){ // TODO : Add Code for control notification handler. //m_poHandler->SelchangeTabDb(TAB_SEARCH); return 0;}//OnSelchangeComboOperator

//-----------------------------------------------------------------------------//// LRESULT COdbGui::OnSelchangeComboRegNo//// -////------------------------------------------------------------------------------LRESULT COdbGui::OnSelchangeComboRegNo(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled){ // TODO : Add Code for control notification handler. //m_poHandler->SelchangeTabDb(TAB_SEARCH); return 0;}//OnSelchangeComboRegNo

//-----------------------------------------------------------------------------//// LRESULT COdbGui::OnSelchangeComboReport//// -////------------------------------------------------------------------------------LRESULT COdbGui::OnSelchangeComboReport(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled){ // TODO : Add Code for control notification handler. //m_poHandler->SelchangeTabDb(TAB_SEARCH); return 0;}//OnSelchangeComboReport

//-----------------------------------------------------------------------------//// LRESULT COdbGui::OnSelchangeComboUnit//// -////------------------------------------------------------------------------------LRESULT COdbGui::OnSelchangeComboUnit(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled){ // TODO : Add Code for control notification handler. //m_poHandler->SelchangeTabDb(TAB_SEARCH); return 0;}//OnSelchangeComboUnit

//-----------------------------------------------------------------------------//// LRESULT COdbGui::OnSelchangeComboUnitNo//// -////------------------------------------------------------------------------------LRESULT COdbGui::OnSelchangeComboUnitNo(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled){ // TODO : Add Code for control notification handler. //m_poHandler->SelchangeTabDb(TAB_SEARCH); return 0;}//OnSelchangeComboUnitNo

//-----------------------------------------------------------------------------//// LRESULT COdbGui::OnItemdblclickListReports//// -////------------------------------------------------------------------------------LRESULT COdbGui::OnItemdblclickListReports(int idCtrl, LPNMHDR pnmh, BOOL& bHandled)

12

{ // TODO : Add Code for control notification handler. m_poHandler->OnItemdblclickListReports(); return 0;}//OnItemdblclickListReports

LRESULT COdbGui::OnSelchangeList1(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled){ // TODO : Add Code for control notification handler. return 0;}

LRESULT COdbGui::OnClickedButton_erase(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled){ // TODO : Add Code for control notification handler. m_poHandler->OnClickedButton_erase(); return 0;}

LRESULT COdbGui::OnClickedButton_start(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled) { m_poHandler->OnClickedButton_start(); return 0; }

LRESULT COdbGui::OnClickedButton_stop(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled) { m_poHandler->OnClickedButton_stop(); return 0; }

LRESULT COdbGui::OnClickedButton_update(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled) { m_poHandler->OnClickedButton_update(); return 0; }LRESULT COdbGui::OnClickedButton_ok(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled)

{ m_poHandler->OnClickedButton_ok(); return 0; }

LRESULT COdbGui::OnClickedButton_quit(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled) { m_poHandler->OnClickedButton_quit(); return 0; }

LRESULT COdbGui::OnSelchangeList_dtc(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled){

m_poHandler->OnSelchangeList_dtc(); return 0;}

LRESULT COdbGui::OnSelchangeList_old_dtc(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled){ m_poHandler->OnSelchangeList_old_dtc(); return 0;}

13

LRESULT COdbGui::OnSelchangeCombo_earl_service(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled) { m_poHandler->OnSelchangeCombo_earl_service(); return 0; }

14

// OdbGuiHandler.h: interface for the COdbGuiHandler class.////////////////////////////////////////////////////////////////////////

#if !defined(AFX_ODBGUIHANDLER_H__7B0361C6_026B_4583_9EC4_2F620975FB1A__INCLUDED_)#define AFX_ODBGUIHANDLER_H__7B0361C6_026B_4583_9EC4_2F620975FB1A__INCLUDED_


#include "OdbLogic.h"#include "EarlierServices.h"#include <vector>

#include "..\..\SYS\AtSysCommon\AtTemcError.h"#include "OdbDefaultGraphic.h"#include "OdbMenu.h"

class COdbGuiHandler { // Public structurespublic: typedef struct typeHandlerData { COdbLogic *poLogic; CAtGraphic *poGraphic; HWND hwndGuiWnd; COdbMenu *poMenu; CAtLabels *poLabels; CAtTemcError *poError; IOleInPlaceFrame *poInPlaceFrame; } TYPEHANDLERDATA;

public: LRESULT OnSelchangedTreeFiles(); LRESULT OnClickTreeFiles(); void ChangeSearchData(); COdbGuiHandler(TYPEHANDLERDATA *poData); virtual ~COdbGuiHandler();

void OnButtonSearch(); void OnButtonPrint(); void OnButtonShow(); void OnButtonShowSeries(); void SelchangeTabDb(int iSel); void OnRclickTreeFiles(); void OnDblclkTreeFiles(); void OnRclickListReports(); void OnRclickListSeries(); void OnItemdblclickListReports(); void InitObdComboBox(); void InitObdListBox(); void SetServiceStatusAndNrOfTroubleCodes(); void SetMonitoringTestsStatus(); void SetOxygenSensorVoltages();

void UpdateRealTime(); //Skapad 2003-05-12

void UpdateTimeConnected(); //Skapad 2003-05-19

// OPERATIONS ---------- LRESULT OnSize(); LRESULT OnTimer(DWORD dwTimerId);

LRESULT OnClickedButton_erase(); LRESULT OnClickedButton_stop(); LRESULT OnClickedButton_start(); LRESULT OnClickedButton_update(); LRESULT OnClickedButton_ok(); LRESULT OnSelchangeList_dtc(); LRESULT OnSelchangeList_old_dtc(); LRESULT OnSelchangeCombo_earl_service(); LRESULT OnClickedButton_quit();

1

// OdbGuiHandler.cpp: implementation of the COdbGuiHandler class.////////////////////////////////////////////////////////////////////////

#include "stdafx.h"#include "resource.h"#include "OdbGuiHandler.h"#include "TroubleCode.h"#include "EarlierServices.h"#include <vector>#include "InitDlg.h"


//////////////////////////////////////////////////////////////////////// Construction/Destruction//////////////////////////////////////////////////////////////////////COdbGuiHandler::COdbGuiHandler(COdbGuiHandler::typeHandlerData *poData){ m_poLogic = poData->poLogic; m_poGraphic = (COdbDefaultGraphic*) poData->poGraphic; m_hwndGuiWnd = poData->hwndGuiWnd; m_poMenu = poData->poMenu; m_poInPlaceFrame = poData->poInPlaceFrame; m_bHideUnselected = false; m_nTest = 0; m_poLabels = poData->poLabels; m_poPlaylists = NULL; m_nTab = TAB_REALTIME; m_poSegmentReports = NULL; m_poMatchedReports = NULL; RealtimeUpdateCounter=0; //Tillagd 2003-05-15 }

COdbGuiHandler::~COdbGuiHandler(){}

LRESULT COdbGuiHandler::OnSize(){ CRect rect; CRect rectGraphic;// CDC *pDC;

GetClientRect(m_hwndGuiWnd, rect);

if (rect.Width() > 200 && rect.Height() > 660) { //rectGraphic = rect; //pDC = CDC::FromHandle(GetDC(m_hwndGuiWnd)); m_poGraphic->Draw(rect); //ReleaseDC(m_hwndGuiWnd, pDC->m_hDC); }

return 0;}

LRESULT COdbGuiHandler::OnTimer(DWORD dwTimerId){ //double dValue; struct tm *newtime; time_t long_time; CString sDate; static clock_t start, finish; //double duration; static long timer = 9; CWnd *poWnd;

1

USES_CONVERSION; // for T2COLE in SetStatusText switch ( dwTimerId ) { case 1001: time( &long_time ); /* Get time as long integer. */ newtime = localtime( &long_time ); /* Convert to local time. */ sDate.Format( "%02d-%02d-%02d %02d:%02d", newtime->tm_year + 1900, newtime->tm_mon+1, newtime->tm_mday, newtime->tm_hour, newtime->tm_min ); if(poWnd = m_poGraphic->GetDlgItem(IDC_EDIT_COMMENT)) //IDC_EDIT_DATE { poWnd->SetWindowText( sDate ); } break;

case 1: // UpdateMeasuredValues(); break;

case 2: // UpdateCcrData(); break;

}

return 0;}

void COdbGuiHandler::SelchangeTabDb(int iSel){ m_nTab = iSel; KillTimer(m_hwndGuiWnd, 6);

m_poGraphic->GetDlgItem(IDC_EDIT_1)->SetWindowText(NULL); m_poGraphic->GetDlgItem(IDC_EDIT_2)->SetWindowText(NULL); m_poGraphic->GetDlgItem(IDC_EDIT_3)->SetWindowText(NULL); m_poGraphic->GetDlgItem(IDC_EDIT_4)->SetWindowText(NULL); m_poGraphic->GetDlgItem(IDC_EDIT_5)->SetWindowText(NULL); m_poGraphic->GetDlgItem(IDC_EDIT_6)->SetWindowText(NULL); m_poGraphic->GetDlgItem(IDC_EDIT_7)->SetWindowText(NULL); m_poGraphic->GetDlgItem(IDC_EDIT_8)->SetWindowText(NULL); m_poGraphic->GetDlgItem(IDC_EDIT_9)->SetWindowText(NULL); m_poGraphic->GetDlgItem(IDC_EDIT_10)->SetWindowText(NULL); m_poGraphic->GetDlgItem(IDC_EDIT_11)->SetWindowText(NULL); m_poGraphic->GetDlgItem(IDC_EDIT_12)->SetWindowText(NULL); m_poGraphic->GetDlgItem(IDC_EDIT_13)->SetWindowText(NULL); m_poGraphic->GetDlgItem(IDC_EDIT_14)->SetWindowText(NULL); m_poGraphic->GetDlgItem(IDC_EDIT_15)->SetWindowText(NULL); m_poGraphic->GetDlgItem(IDC_EDIT_16)->SetWindowText(NULL); if(m_poLogic->GetCommunicationStatus()) { m_poGraphic->GetDlgItem(IDC_EDIT_FAULTCODE)->EnableWindow(true); m_poGraphic->GetDlgItem(IDC_EDIT_1)->EnableWindow(true); m_poGraphic->GetDlgItem(IDC_EDIT_2)->EnableWindow(true); m_poGraphic->GetDlgItem(IDC_EDIT_3)->EnableWindow(true); m_poGraphic->GetDlgItem(IDC_EDIT_4)->EnableWindow(true); m_poGraphic->GetDlgItem(IDC_EDIT_5)->EnableWindow(true); m_poGraphic->GetDlgItem(IDC_EDIT_6)->EnableWindow(true); m_poGraphic->GetDlgItem(IDC_EDIT_7)->EnableWindow(true); m_poGraphic->GetDlgItem(IDC_EDIT_8)->EnableWindow(true); m_poGraphic->GetDlgItem(IDC_EDIT_9)->EnableWindow(true); m_poGraphic->GetDlgItem(IDC_EDIT_10)->EnableWindow(true); m_poGraphic->GetDlgItem(IDC_EDIT_11)->EnableWindow(true); m_poGraphic->GetDlgItem(IDC_EDIT_12)->EnableWindow(true); }

CInitDlg StatusDlg; //Tilllagt 2003-05-27 HWND TEMP = StatusDlg.Create(m_hwndGuiWnd); StatusDlg.HideProgressBar();

switch (iSel)

2

{ case TAB_REALTIME: if(m_poLogic->GetMorePidsStatus()) m_poGraphic->GetDlgItem(IDC_STATIC_MORE_PIDS)->SetWindowText("Testobjektet stödjer ytterligare realtidsparametrar enligt SAE 2190."); else m_poGraphic->GetDlgItem(IDC_STATIC_MORE_PIDS)->SetWindowText(NULL);

m_poGraphic->OnSelDlgRealtime(true);

SetTimer(m_hwndGuiWnd, 6, 50, NULL); //Försök att uppdatera realtidsvärderna 2003-05-12

break;

case TAB_VEHICLE: if(m_poLogic->GetVehicleInfo()->size()>11) { m_poGraphic->GetDlgItem(IDC_EDIT_1)->SetWindowText(m_poLogic->GetVehicleInfo()->at(0)); m_poGraphic->GetDlgItem(IDC_EDIT_2)->SetWindowText(m_poLogic->GetVehicleInfo()->at(1)); m_poGraphic->GetDlgItem(IDC_EDIT_3)->SetWindowText(m_poLogic->GetVehicleInfo()->at(2)); m_poGraphic->GetDlgItem(IDC_EDIT_4)->SetWindowText(m_poLogic->GetVehicleInfo()->at(3)); m_poGraphic->GetDlgItem(IDC_EDIT_5)->SetWindowText(m_poLogic->GetVehicleInfo()->at(4)); m_poGraphic->GetDlgItem(IDC_EDIT_6)->SetWindowText(m_poLogic->GetVehicleInfo()->at(5)); m_poGraphic->GetDlgItem(IDC_EDIT_7)->SetWindowText(m_poLogic->GetVehicleInfo()->at(6)); m_poGraphic->GetDlgItem(IDC_EDIT_8)->SetWindowText(m_poLogic->GetVehicleInfo()->at(7)); m_poGraphic->GetDlgItem(IDC_EDIT_9)->SetWindowText(m_poLogic->GetVehicleInfo()->at(8)); m_poGraphic->GetDlgItem(IDC_EDIT_10)->SetWindowText(m_poLogic->GetVehicleInfo()->at(9)); m_poGraphic->GetDlgItem(IDC_EDIT_11)->SetWindowText(m_poLogic->GetVehicleInfo()->at(10)); m_poGraphic->GetDlgItem(IDC_EDIT_12)->SetWindowText(m_poLogic->GetVehicleInfo()->at(11)); }

m_poGraphic->OnSelDlgVehicle(true); break;

case TAB_TROUBLECODE: StatusDlg.Status("Hämtar felkoder..."); InitObdListBox(); //Låg tidigare i konstruktor, flyttad 2003-05-12 // Display the data InitObdComboBox();

//Tillagt 2003-05-26 TroubleCodeBox = (CListBox*) m_poGraphic->GetDlgItem(IDC_LIST_OLD_DTC); TroubleCodeBox->ResetContent(); m_poGraphic->GetDlgItem(IDC_EDIT_OLD_DEF)->SetWindowText(NULL); m_poGraphic->GetDlgItem(IDC_EDIT_DEF)->SetWindowText(NULL);

StatusDlg.Status(NULL); m_poGraphic->OnSelDlgTroubleCode(true); break;

case TAB_FREEZE: StatusDlg.Status("Hämtar frysta parametrar...");

m_poGraphic->GetDlgItem(IDC_EDIT_FAULTCODE)->SetWindowText(*m_poLogic->GetTroubleCodeCausedFreeze()); if(m_poLogic->GetFreezeParameters()->size() > 11)

3

{ if(m_poLogic->GetMilLampStatus()) { m_poGraphic->GetDlgItem(IDC_EDIT_1)->SetWindowText(m_poLogic->GetFreezeParameters()->at(0)); m_poGraphic->GetDlgItem(IDC_EDIT_2)->SetWindowText(m_poLogic->GetFreezeParameters()->at(1)); m_poGraphic->GetDlgItem(IDC_EDIT_3)->SetWindowText(m_poLogic->GetFreezeParameters()->at(2)); m_poGraphic->GetDlgItem(IDC_EDIT_4)->SetWindowText(m_poLogic->GetFreezeParameters()->at(3)); m_poGraphic->GetDlgItem(IDC_EDIT_5)->SetWindowText(m_poLogic->GetFreezeParameters()->at(4)); m_poGraphic->GetDlgItem(IDC_EDIT_6)->SetWindowText(m_poLogic->GetFreezeParameters()->at(5)); m_poGraphic->GetDlgItem(IDC_EDIT_7)->SetWindowText(m_poLogic->GetFreezeParameters()->at(6)); m_poGraphic->GetDlgItem(IDC_EDIT_8)->SetWindowText(m_poLogic->GetFreezeParameters()->at(7)); m_poGraphic->GetDlgItem(IDC_EDIT_9)->SetWindowText(m_poLogic->GetFreezeParameters()->at(8)); m_poGraphic->GetDlgItem(IDC_EDIT_10)->SetWindowText(m_poLogic->GetFreezeParameters()->at(9)); m_poGraphic->GetDlgItem(IDC_EDIT_11)->SetWindowText(m_poLogic->GetFreezeParameters()->at(10)); m_poGraphic->GetDlgItem(IDC_EDIT_12)->SetWindowText(m_poLogic->GetFreezeParameters()->at(11)); } else { m_poGraphic->GetDlgItem(IDC_EDIT_FAULTCODE)->EnableWindow(false); m_poGraphic->GetDlgItem(IDC_EDIT_1)->EnableWindow(false); m_poGraphic->GetDlgItem(IDC_EDIT_2)->EnableWindow(false); m_poGraphic->GetDlgItem(IDC_EDIT_3)->EnableWindow(false); m_poGraphic->GetDlgItem(IDC_EDIT_4)->EnableWindow(false); m_poGraphic->GetDlgItem(IDC_EDIT_5)->EnableWindow(false); m_poGraphic->GetDlgItem(IDC_EDIT_6)->EnableWindow(false); m_poGraphic->GetDlgItem(IDC_EDIT_7)->EnableWindow(false); m_poGraphic->GetDlgItem(IDC_EDIT_8)->EnableWindow(false); m_poGraphic->GetDlgItem(IDC_EDIT_9)->EnableWindow(false); m_poGraphic->GetDlgItem(IDC_EDIT_10)->EnableWindow(false); m_poGraphic->GetDlgItem(IDC_EDIT_11)->EnableWindow(false); m_poGraphic->GetDlgItem(IDC_EDIT_12)->EnableWindow(false); } }

StatusDlg.Status(NULL); m_poGraphic->OnSelDlgFreeze(true); break;

case TAB_MONITORING:

StatusDlg.Status("Hämtar testresultat..."); SetMonitoringTestsStatus(); m_poGraphic->OnSelDlgMonitor(true); StatusDlg.Status(NULL); break;

case TAB_OXYGENSENSORS:

StatusDlg.Status("Hämtar sensorvärden..."); SetOxygenSensorVoltages(); m_poGraphic->OnSelDlgOxygenSensors(true); StatusDlg.Status(NULL); break;

}

return;}

void COdbGuiHandler::OnButtonShow(){

4

switch (m_nTab) { case TAB_REALTIME: OnDblclkTreeFiles(); break;

case TAB_TROUBLECODE: break; } // endswitch return;}

void COdbGuiHandler::OnButtonShowSeries(){ CListCtrl *poListCtrl; int iSelected;

switch (m_nTab) { case TAB_REALTIME: OnDblclkTreeFiles(); break;

case TAB_TROUBLECODE: poListCtrl = (CListCtrl*) m_poGraphic->GetDlgItem(IDC_LIST_REPORTS); iSelected = poListCtrl->GetSelectionMark(); if (iSelected != -1) { short nSegment = static_cast<short>(poListCtrl->GetItemData(iSelected)); CString sDate = poListCtrl->GetItemText(iSelected, 2); } break; } // endswitch return;}

void COdbGuiHandler::OnButtonPrint(){

return;}

void COdbGuiHandler::OnButtonSearch(){ return;}

void COdbGuiHandler::OnRclickTreeFiles(){ // Print the report CTreeCtrl *poTree = (CTreeCtrl*) m_poGraphic->GetDlgItem(IDC_TREE_FILES); HTREEITEM hItem = poTree->GetSelectedItem(); DWORD dwItemData = poTree->GetItemData(hItem); CString sText = poTree->GetItemText(hItem); CString sDate = sText.Right(19);

return;}

void COdbGuiHandler::OnDblclkTreeFiles(){ //HRESULT hrRes; // Get the selected report and its date CTreeCtrl *poTree = (CTreeCtrl*) m_poGraphic->GetDlgItem(IDC_TREE_FILES); HTREEITEM hItem = poTree->GetSelectedItem();

5

HTREEITEM hTempItem = hItem;

// Get hold of the MbtRegNr in the tree view. CString sTemp = "XXX"; int nSteps2Root = 0; while(poTree->GetItemText(hTempItem) != "") { hTempItem = poTree->GetParentItem(hTempItem); nSteps2Root++; } HTREEITEM hRegNrItem = hItem; for(int nSteps = 0; nSteps < (nSteps2Root-2); nSteps++) hRegNrItem = poTree->GetParentItem(hRegNrItem);

SHORT nItemData = (SHORT) poTree->GetItemData(hItem); CString sText = poTree->GetItemText(hItem); int nLength = sText.GetLength(); CString sDate = sText.Right(19); CString sTestType = sText.Mid(0,nLength-20); //IUnknown *poActiveReport;

_bstr_t bstrTestType = sTestType; _bstr_t bstrDate = sDate; _bstr_t bstrRegNr = poTree->GetItemText(hRegNrItem);

return;}

void COdbGuiHandler::OnRclickListReports(){ // Print the report // Get the selected report and its date CListCtrl *poListCtrl = (CListCtrl*) m_poGraphic->GetDlgItem(IDC_LIST_REPORTS); int iItem = poListCtrl->GetSelectionMark(); SHORT nItemData = (SHORT) poListCtrl->GetItemData(iItem); CString sText = poListCtrl->GetItemText(iItem,2); CString sDate = sText.Right(19);

return;}

void COdbGuiHandler::OnRclickListSeries(){ CListCtrl *poListSeries = (CListCtrl*) m_poGraphic->GetDlgItem(IDC_LIST_SERIES); int iItem = poListSeries->GetSelectionMark();

poListSeries->DeleteItem(iItem);

return;}//OnRclickListSeries

void COdbGuiHandler::OnItemdblclickListReports(){ // Get the selected report and its date CListCtrl *poListCtrl = (CListCtrl*) m_poGraphic->GetDlgItem(IDC_LIST_REPORTS); int iItem = poListCtrl->GetSelectionMark(); SHORT nItemData = (SHORT) poListCtrl->GetItemData(iItem); CString sText = poListCtrl->GetItemText(iItem,2); CString sDate = sText.Right(19);

return;}

void COdbGuiHandler::ChangeSearchData(){

}

6

LRESULT COdbGuiHandler::OnClickTreeFiles(){

return 0;}

LRESULT COdbGuiHandler::OnSelchangedTreeFiles(){

return 0;}

void COdbGuiHandler::InitObdComboBox(){ ServiceBox = (CComboBox*) m_poGraphic->GetDlgItem(IDC_COMBO_EARL_SERVICE); ServiceBox->ResetContent();

int Row; vector<CString> *ServiceDates=m_poLogic->GetEarlierServices();

Row=ServiceBox->AddString("Välj ett tidigare servicetillfälle");

for(int i=0; i<ServiceDates->size() ;i++) Row=ServiceBox->AddString(ServiceDates->at(i));

Row=ServiceBox->SelectString(0, "Välj ett tidigare servicetillfälle");

}

void COdbGuiHandler::InitObdListBox(){ TroubleCodeBox = (CListBox*) m_poGraphic->GetDlgItem(IDC_LIST_DTC); TroubleCodeBox->ResetContent();

vector<CString> *TroubleCodes = m_poLogic->GetTroubleCodes(); int NrOfTroublCodes=m_poLogic->GetNrOfTroubleCode();

for(int i=0; i<TroubleCodes->size() && i < NrOfTroublCodes ;i++) TroubleCodeBox->InsertString(-1, TroubleCodes->at(i));

}

void COdbGuiHandler::SetOxygenSensorVoltages(){ vector<CString> *SensorVoltages; SensorVoltages = m_poLogic->GetOxygenSensorVoltages();

if(SensorVoltages->size()>15) { m_poGraphic->GetDlgItem(IDC_EDIT_1)->SetWindowText(SensorVoltages->at(0)); m_poGraphic->GetDlgItem(IDC_EDIT_2)->SetWindowText(SensorVoltages->at(1)); m_poGraphic->GetDlgItem(IDC_EDIT_3)->SetWindowText(SensorVoltages->at(2)); m_poGraphic->GetDlgItem(IDC_EDIT_4)->SetWindowText(SensorVoltages->at(3)); m_poGraphic->GetDlgItem(IDC_EDIT_5)->SetWindowText(SensorVoltages->at(4)); m_poGraphic->GetDlgItem(IDC_EDIT_6)->SetWindowText(SensorVoltages->at(5)); m_poGraphic->GetDlgItem(IDC_EDIT_7)->SetWindowText(SensorVoltages->at(6)); m_poGraphic->GetDlgItem(IDC_EDIT_8)->SetWindowText(SensorVoltages->at(7)); m_poGraphic->GetDlgItem(IDC_EDIT_9)->SetWindowText(SensorVoltages->at(8)); m_poGraphic->GetDlgItem(IDC_EDIT_10)->SetWindowText(SensorVoltages->at(9)); m_poGraphic->GetDlgItem(IDC_EDIT_11)->SetWindowText(SensorVoltages->at(10)); m_poGraphic->GetDlgItem(IDC_EDIT_12)->SetWindowText(SensorVoltages->at(11)); m_poGraphic->GetDlgItem(IDC_EDIT_13)->SetWindowText(SensorVoltages->at(12)); m_poGraphic->GetDlgItem(IDC_EDIT_14)->SetWindowText(SensorVoltages->at(13)); m_poGraphic->GetDlgItem(IDC_EDIT_15)->SetWindowText(SensorVoltages->at(14)); m_poGraphic->GetDlgItem(IDC_EDIT_16)->SetWindowText(SensorVoltages->at(15)); }

}

7

void COdbGuiHandler::SetMonitoringTestsStatus(){ unsigned char MonitoringTests=0x00; unsigned char NonContinuousTestSupported=0x00; unsigned char NonContinuousTestCompleted=0x00;

if (m_poLogic->GetMonitoringTestsCompleted()->size() > 2) { MonitoringTests=(m_poLogic->GetMonitoringTestsCompleted()->at(0)); NonContinuousTestSupported=(m_poLogic->GetMonitoringTestsCompleted()->at(1)); NonContinuousTestCompleted=(m_poLogic->GetMonitoringTestsCompleted()->at(2)); }

//Continuous//Misfire if(MonitoringTests & 0x01) { if(MonitoringTests & 0x10) m_poGraphic->GetDlgItem(IDC_EDIT_1)->SetWindowText("Ej klart"); else m_poGraphic->GetDlgItem(IDC_EDIT_1)->SetWindowText("Klart"); } else m_poGraphic->GetDlgItem(IDC_EDIT_1)->SetWindowText("Stöds ej");

//FuelSystem if(MonitoringTests & 0x02) { if(MonitoringTests & 0x20) m_poGraphic->GetDlgItem(IDC_EDIT_2)->SetWindowText("Ej klart"); else m_poGraphic->GetDlgItem(IDC_EDIT_2)->SetWindowText("Klart"); } else m_poGraphic->GetDlgItem(IDC_EDIT_2)->SetWindowText("Stöds ej");

//Components if(MonitoringTests & 0x04) { if(MonitoringTests & 0x40) m_poGraphic->GetDlgItem(IDC_EDIT_3)->SetWindowText("Ej klart"); else m_poGraphic->GetDlgItem(IDC_EDIT_3)->SetWindowText("Klart"); } else m_poGraphic->GetDlgItem(IDC_EDIT_3)->SetWindowText("Stöds ej");

//Non ContinuousTests.

//Catalyst if(NonContinuousTestSupported & 0x01) { if(NonContinuousTestCompleted & 0x01) m_poGraphic->GetDlgItem(IDC_EDIT_4)->SetWindowText("Ej klart"); else m_poGraphic->GetDlgItem(IDC_EDIT_4)->SetWindowText("Klart"); } else m_poGraphic->GetDlgItem(IDC_EDIT_4)->SetWindowText("Stöds ej");

//Heated Catalyst if(NonContinuousTestSupported & 0x02) { if(NonContinuousTestCompleted & 0x02) m_poGraphic->GetDlgItem(IDC_EDIT_5)->SetWindowText("Ej klart"); else m_poGraphic->GetDlgItem(IDC_EDIT_5)->SetWindowText("Klart"); } else m_poGraphic->GetDlgItem(IDC_EDIT_5)->SetWindowText("Stöds ej");

//Evaporative System if(NonContinuousTestSupported & 0x04) { if(NonContinuousTestCompleted & 0x04) m_poGraphic->GetDlgItem(IDC_EDIT_6)->SetWindowText("Ej klart"); else m_poGraphic->GetDlgItem(IDC_EDIT_6)->SetWindowText("Klart"); }

8

else m_poGraphic->GetDlgItem(IDC_EDIT_6)->SetWindowText("Stöds ej");

//Secondary Air system if(NonContinuousTestSupported & 0x08) { if(NonContinuousTestCompleted & 0x08) m_poGraphic->GetDlgItem(IDC_EDIT_7)->SetWindowText("Ej klart"); else m_poGraphic->GetDlgItem(IDC_EDIT_7)->SetWindowText("Klart"); } else m_poGraphic->GetDlgItem(IDC_EDIT_7)->SetWindowText("Stöds ej");

//AC if(NonContinuousTestSupported & 0x10) { if(NonContinuousTestCompleted & 0x10) m_poGraphic->GetDlgItem(IDC_EDIT_8)->SetWindowText("Ej klart"); else m_poGraphic->GetDlgItem(IDC_EDIT_8)->SetWindowText("Klart"); } else m_poGraphic->GetDlgItem(IDC_EDIT_8)->SetWindowText("Stöds ej");//Oxygen Sensor if(NonContinuousTestSupported & 0x20) { if(NonContinuousTestCompleted & 0x20) m_poGraphic->GetDlgItem(IDC_EDIT_9)->SetWindowText("Ej klart"); else m_poGraphic->GetDlgItem(IDC_EDIT_9)->SetWindowText("Klart"); } else m_poGraphic->GetDlgItem(IDC_EDIT_9)->SetWindowText("Stöds ej");//Oxygen Sensor Heater if(NonContinuousTestSupported & 0x40) { if(NonContinuousTestCompleted & 0x40) m_poGraphic->GetDlgItem(IDC_EDIT_10)->SetWindowText("Ej klart"); else m_poGraphic->GetDlgItem(IDC_EDIT_10)->SetWindowText("Klart"); } else m_poGraphic->GetDlgItem(IDC_EDIT_10)->SetWindowText("Stöds ej");}

void COdbGuiHandler::SetServiceStatusAndNrOfTroubleCodes(){ bool MilStatus; CString *NrTroubleCodes;

NrTroubleCodes = m_poLogic->GetServiceStatusAndNrOfTroubleCodes(MilStatus); if(MilStatus) { m_poGraphic->GetDlgItem(IDC_TEXT_STATUS)->SetWindowText("Servicelampan tänd"); m_poGraphic->GetDlgItem(IDC_ICON_MIL_GREEN)->ShowWindow(false); m_poGraphic->GetDlgItem(IDC_ICON_MIL_RED)->ShowWindow(true); SetTimer(m_hwndGuiWnd, 9, 500, NULL); } else { m_poGraphic->GetDlgItem(IDC_TEXT_STATUS)->SetWindowText("Servicelampan släckt"); m_poGraphic->GetDlgItem(IDC_ICON_MIL_GREEN)->ShowWindow(true); m_poGraphic->GetDlgItem(IDC_ICON_MIL_RED)->ShowWindow(false); KillTimer(m_hwndGuiWnd, 9); }

m_poGraphic->GetDlgItem(IDC_TEXT_STATUS)->ShowWindow(true);

m_poGraphic->GetDlgItem(IDC_EDIT_ERRORS)->SetWindowText(*NrTroubleCodes);

if(m_poLogic->GetNrOfTroubleCode()>0) { m_poGraphic->GetDlgItem(IDC_BUTTON_ERASE)->EnableWindow(true); } else {

9

m_poGraphic->GetDlgItem(IDC_BUTTON_ERASE)->EnableWindow(false); }

}

LRESULT COdbGuiHandler::OnClickedButton_quit() //Skapad 2003-05-14{ return 0;}

LRESULT COdbGuiHandler::OnClickedButton_erase() //Skapad 2003-04-25{ if(IDYES==MessageBox(0, "Vill du verkligen radera alla felkoder, frysta värden och nollställa servicelampan?", "Rensa alla data?", MB_YESNO)) { m_poLogic->EraseTroubleCodes(); m_poGraphic->GetDlgItem(IDC_EDIT_DEF)->SetWindowText(NULL); ((CListBox*) m_poGraphic->GetDlgItem(IDC_LIST_DTC))->ResetContent(); SetServiceStatusAndNrOfTroubleCodes(); InitObdComboBox(); m_poGraphic->GetDlgItem(IDC_EDIT_FAULTCODE)->SetWindowText(NULL); m_poGraphic->GetDlgItem(IDC_EDIT_1)->SetWindowText(NULL); m_poGraphic->GetDlgItem(IDC_EDIT_2)->SetWindowText(NULL); m_poGraphic->GetDlgItem(IDC_EDIT_3)->SetWindowText(NULL); m_poGraphic->GetDlgItem(IDC_EDIT_4)->SetWindowText(NULL); m_poGraphic->GetDlgItem(IDC_EDIT_5)->SetWindowText(NULL); m_poGraphic->GetDlgItem(IDC_EDIT_6)->SetWindowText(NULL); m_poGraphic->GetDlgItem(IDC_EDIT_7)->SetWindowText(NULL); m_poGraphic->GetDlgItem(IDC_EDIT_8)->SetWindowText(NULL); m_poGraphic->GetDlgItem(IDC_EDIT_9)->SetWindowText(NULL); m_poGraphic->GetDlgItem(IDC_EDIT_10)->SetWindowText(NULL); m_poGraphic->GetDlgItem(IDC_EDIT_11)->SetWindowText(NULL); m_poGraphic->GetDlgItem(IDC_EDIT_12)->SetWindowText(NULL); m_poGraphic->GetDlgItem(IDC_EDIT_13)->SetWindowText(NULL);

m_poGraphic->GetDlgItem(IDC_EDIT_FAULTCODE)->EnableWindow(false); m_poGraphic->GetDlgItem(IDC_EDIT_1)->EnableWindow(false); m_poGraphic->GetDlgItem(IDC_EDIT_2)->EnableWindow(false); m_poGraphic->GetDlgItem(IDC_EDIT_3)->EnableWindow(false); m_poGraphic->GetDlgItem(IDC_EDIT_4)->EnableWindow(false); m_poGraphic->GetDlgItem(IDC_EDIT_5)->EnableWindow(false); m_poGraphic->GetDlgItem(IDC_EDIT_6)->EnableWindow(false); m_poGraphic->GetDlgItem(IDC_EDIT_7)->EnableWindow(false); m_poGraphic->GetDlgItem(IDC_EDIT_8)->EnableWindow(false); m_poGraphic->GetDlgItem(IDC_EDIT_9)->EnableWindow(false); m_poGraphic->GetDlgItem(IDC_EDIT_10)->EnableWindow(false); m_poGraphic->GetDlgItem(IDC_EDIT_11)->EnableWindow(false); m_poGraphic->GetDlgItem(IDC_EDIT_12)->EnableWindow(false); } return 0;}

LRESULT COdbGuiHandler::OnClickedButton_stop() //skapad 2003-05-09{ m_poLogic->CloseCommunication(); //Stänger Serieport m_poGraphic->GetDlgItem(IDC_BUTTON_START)->EnableWindow(true); m_poGraphic->GetDlgItem(IDC_BUTTON_STOP)->EnableWindow(false); m_poGraphic->GetDlgItem(IDC_PROGRESS_REALTIME)->ShowWindow(false); m_poGraphic->GetDlgItem(IDC_STATIC_PROGRESS_REALTIME)->ShowWindow(false); KillTimer(m_hwndGuiWnd, 7); m_poGraphic->GetDlgItem(IDC_EDIT_COMM_STATUS)->SetWindowText("Nedkopplad"); m_poGraphic->GetDlgItem(IDC_BUTTON_ERASE)->EnableWindow(false); m_poGraphic->GetDlgItem(IDC_BUTTON_UPDATE)->EnableWindow(false);

m_poGraphic->GetDlgItem(IDC_EDIT_INSTRUCTIONS)->SetWindowText("1.Slå av tändningen.\r\n2.Koppla ur interfacet mellan fordonet och TEMC.");

10

//Släcker fönster m_poGraphic->GetDlgItem(IDC_EDIT_1)->EnableWindow(false); m_poGraphic->GetDlgItem(IDC_EDIT_2)->EnableWindow(false); m_poGraphic->GetDlgItem(IDC_EDIT_3)->EnableWindow(false); m_poGraphic->GetDlgItem(IDC_EDIT_4)->EnableWindow(false); m_poGraphic->GetDlgItem(IDC_EDIT_5)->EnableWindow(false); m_poGraphic->GetDlgItem(IDC_EDIT_6)->EnableWindow(false); m_poGraphic->GetDlgItem(IDC_EDIT_7)->EnableWindow(false); m_poGraphic->GetDlgItem(IDC_EDIT_8)->EnableWindow(false); m_poGraphic->GetDlgItem(IDC_EDIT_9)->EnableWindow(false); m_poGraphic->GetDlgItem(IDC_EDIT_10)->EnableWindow(false); m_poGraphic->GetDlgItem(IDC_EDIT_11)->EnableWindow(false); m_poGraphic->GetDlgItem(IDC_EDIT_12)->EnableWindow(false); m_poGraphic->GetDlgItem(IDC_EDIT_13)->EnableWindow(false); m_poGraphic->GetDlgItem(IDC_EDIT_14)->EnableWindow(false); m_poGraphic->GetDlgItem(IDC_EDIT_15)->EnableWindow(false); m_poGraphic->GetDlgItem(IDC_EDIT_16)->EnableWindow(false); return 0; }

LRESULT COdbGuiHandler::OnClickedButton_start() //Skapad 2003-05-08{

CInitDlg StatusDlg; HWND TEMP = StatusDlg.Create(m_hwndGuiWnd); StatusDlg.Status("Initierar hårdvaran...");

StatusDlg.InitProcessBar();

StatusDlg.UppdateProcessBar(10); m_poLogic->InitCommunication();

SetTimer(m_hwndGuiWnd, 7, 1000, NULL); UpdateTimeConnected();

StatusDlg.UppdateProcessBar(40); StatusDlg.Status("Hämtar parametrar...");

m_poGraphic->GetDlgItem(IDC_EDIT_VEHICLE_ID)->SetWindowText(*m_poLogic->GetVIN()); StatusDlg.UppdateProcessBar(80);

m_poGraphic->GetDlgItem(IDC_EDIT_PROTOCOL)->SetWindowText(*m_poLogic->getCommunicationProtocol());

SetServiceStatusAndNrOfTroubleCodes();

StatusDlg.UppdateProcessBar(95);

m_poLogic->GetSupportedRealTimePIDs();

StatusDlg.UppdateProcessBar(98);

//Design OBD Requirements PID 1C m_poGraphic->GetDlgItem(IDC_EDIT_OBD_TYPE)->SetWindowText(*m_poLogic->GetOBDRequirements());

if(m_poLogic->GetCommunicationStatus()) { if(m_nTab==TAB_REALTIME) { m_poGraphic->GetDlgItem(IDC_PROGRESS_REALTIME)->ShowWindow(true); m_poGraphic->GetDlgItem(IDC_STATIC_PROGRESS_REALTIME)->ShowWindow(true); SetTimer(m_hwndGuiWnd, 6, 50, NULL);

11

if(m_poLogic->GetMorePidsStatus()) m_poGraphic->GetDlgItem(IDC_STATIC_MORE_PIDS)->SetWindowText("Testobjektet stödjer ytterligare realtidsparametrar enligt SAE 2190."); else m_poGraphic->GetDlgItem(IDC_STATIC_MORE_PIDS)->SetWindowText(NULL); } m_poGraphic->GetDlgItem(IDC_BUTTON_START)->EnableWindow(false); m_poGraphic->GetDlgItem(IDC_BUTTON_STOP)->EnableWindow(true); m_poGraphic->GetDlgItem(IDC_EDIT_INSTRUCTIONS)->SetWindowText("1.För att avsluta fordonskontrollen tryck på Stoppa."); m_poGraphic->GetDlgItem(IDC_EDIT_1)->EnableWindow(true); m_poGraphic->GetDlgItem(IDC_EDIT_2)->EnableWindow(true); m_poGraphic->GetDlgItem(IDC_EDIT_3)->EnableWindow(true); m_poGraphic->GetDlgItem(IDC_EDIT_4)->EnableWindow(true); m_poGraphic->GetDlgItem(IDC_EDIT_5)->EnableWindow(true); m_poGraphic->GetDlgItem(IDC_EDIT_6)->EnableWindow(true); m_poGraphic->GetDlgItem(IDC_EDIT_7)->EnableWindow(true); m_poGraphic->GetDlgItem(IDC_EDIT_8)->EnableWindow(true); m_poGraphic->GetDlgItem(IDC_EDIT_9)->EnableWindow(true); m_poGraphic->GetDlgItem(IDC_EDIT_10)->EnableWindow(true); m_poGraphic->GetDlgItem(IDC_EDIT_11)->EnableWindow(true); m_poGraphic->GetDlgItem(IDC_EDIT_12)->EnableWindow(true); m_poGraphic->GetDlgItem(IDC_EDIT_13)->EnableWindow(true); m_poGraphic->GetDlgItem(IDC_EDIT_14)->EnableWindow(true); m_poGraphic->GetDlgItem(IDC_EDIT_15)->EnableWindow(true); m_poGraphic->GetDlgItem(IDC_EDIT_16)->EnableWindow(true); }

StatusDlg.Status(NULL); //Closing statusdlg. m_poGraphic->GetDlgItem(IDC_BUTTON_UPDATE)->EnableWindow(true); return 0;}

LRESULT COdbGuiHandler::OnClickedButton_update(){ m_poGraphic->GetDlgItem(IDC_BUTTON_UPDATE)->EnableWindow(false); CInitDlg StatusDlg; HWND TEMP = StatusDlg.Create(m_hwndGuiWnd); StatusDlg.HideProgressBar(); if(m_nTab==TAB_MONITORING) { StatusDlg.Status("Hämtar testresultat..."); SetMonitoringTestsStatus(); } else { StatusDlg.Status("Hämtar Sensorvärden..."); SetOxygenSensorVoltages(); }

StatusDlg.Status(NULL); //Closing statusdlg m_poGraphic->GetDlgItem(IDC_BUTTON_UPDATE)->EnableWindow(true); return 0;}

LRESULT COdbGuiHandler::OnClickedButton_ok(){

m_poGraphic->GetDlgItem(IDC_EDIT_INSTRUCTIONS)->SetWindowText("1.Tryck Start för att upprätta kommunikation med fordonsdatorn."); m_poGraphic->GetDlgItem(IDC_BUTTON_START)->EnableWindow(true); m_poGraphic->GetDlgItem(IDC_BUTTON_OK)->EnableWindow(false);

return 0;}

12

LRESULT COdbGuiHandler::OnSelchangeList_dtc() //Skapad 2003-04-29{

TroubleCodeBox = (CListBox*) m_poGraphic->GetDlgItem(IDC_LIST_DTC); int index = TroubleCodeBox->GetCurSel();

CString *TroubleCodeDef=m_poLogic->GetTroubleCodeDefinition(index); m_poGraphic->GetDlgItem(IDC_EDIT_DEF)->SetWindowText(*TroubleCodeDef);

return 0;}

LRESULT::COdbGuiHandler::OnSelchangeList_old_dtc(){

TroubleCodeBox = (CListBox*) m_poGraphic->GetDlgItem(IDC_LIST_OLD_DTC);

int index = TroubleCodeBox->GetCurSel(); CString *TroubleCodeDef=m_poLogic->GetTroubleCodeDefinitionFromService(index);

m_poGraphic->GetDlgItem(IDC_EDIT_OLD_DEF)->SetWindowText(*TroubleCodeDef);

return 0;

}

LRESULT COdbGuiHandler::OnSelchangeCombo_earl_service() //Skapad 2003-05-05{ int index = ServiceBox->GetCurSel(); TroubleCodeBox = (CListBox*) m_poGraphic->GetDlgItem(IDC_LIST_OLD_DTC); TroubleCodeBox->ResetContent();

m_poGraphic->GetDlgItem(IDC_EDIT_OLD_DEF)->SetWindowText(NULL);

if(index==0) { return 0; }

index--;

vector <CString> *TroubleCodesEarlier = m_poLogic->GetTroubleCodesFromService(index);

if(TroubleCodesEarlier->size() != 0) { for(int i= 0; i<TroubleCodesEarlier->size(); i++) TroubleCodeBox->InsertString(-1, TroubleCodesEarlier->at(i)); } return 0;

}

void COdbGuiHandler::UpdateRealTime() { KillTimer(m_hwndGuiWnd, 6);

if(m_poLogic->GetCommunicationStatus()) { CProgressCtrl* pProg = (CProgressCtrl*) m_poGraphic->GetDlgItem(IDC_PROGRESS_REALTIME); pProg->SetRange(0,100); //init progressbar. vector<CString> *FuelSystem;

13

switch (RealtimeUpdateCounter) { case 0: pProg->SetPos(0); if(((CButton*)m_poGraphic->GetDlgItem(IDC_CHECK1))->GetCheck()) m_poGraphic->GetDlgItem(IDC_EDIT_1)->SetWindowText(*m_poLogic->GetSpeed()); else m_poGraphic->GetDlgItem(IDC_EDIT_1)->SetWindowText("--");

pProg->SetPos(8); break;

case 1: if(((CButton*)m_poGraphic->GetDlgItem(IDC_CHECK2))->GetCheck()) m_poGraphic->GetDlgItem(IDC_EDIT_2)->SetWindowText(*m_poLogic->GetRPM()); else m_poGraphic->GetDlgItem(IDC_EDIT_2)->SetWindowText("--"); pProg->SetPos(16); break;

case 2: if(((CButton*)m_poGraphic->GetDlgItem(IDC_CHECK3))->GetCheck()) m_poGraphic->GetDlgItem(IDC_EDIT_3)->SetWindowText(*m_poLogic->GetEngineLoad()); else m_poGraphic->GetDlgItem(IDC_EDIT_3)->SetWindowText("--"); pProg->SetPos(24); break;

case 3: if(((CButton*)m_poGraphic->GetDlgItem(IDC_CHECK4))->GetCheck()) m_poGraphic->GetDlgItem(IDC_EDIT_4)->SetWindowText(*m_poLogic->GetCoolerTemp()); else m_poGraphic->GetDlgItem(IDC_EDIT_4)->SetWindowText("--");


case 4: if(((CButton*)m_poGraphic->GetDlgItem(IDC_CHECK5))->GetCheck()) m_poGraphic->GetDlgItem(IDC_EDIT_5)->SetWindowText(*m_poLogic->GetIntakeTemp()); else m_poGraphic->GetDlgItem(IDC_EDIT_5)->SetWindowText("--");


case 5: if(((CButton*)m_poGraphic->GetDlgItem(IDC_CHECK6))->GetCheck()) m_poGraphic->GetDlgItem(IDC_EDIT_6)->SetWindowText(*m_poLogic->GetThrottlePos()); else m_poGraphic->GetDlgItem(IDC_EDIT_6)->SetWindowText("--");


case 6: if(((CButton*)m_poGraphic->GetDlgItem(IDC_CHECK7))->GetCheck()) m_poGraphic->GetDlgItem(IDC_EDIT_7)->SetWindowText(*m_poLogic->GetIntakeMan()); else m_poGraphic->GetDlgItem(IDC_EDIT_7)->SetWindowText("--");


case 7: if(((CButton*)m_poGraphic->GetDlgItem(IDC_CHECK8))->GetCheck()) m_poGraphic->GetDlgItem(IDC_EDIT_8)->SetWindowText(*m_poLogic->GetFuelPressure()); else m_poGraphic->GetDlgItem(IDC_EDIT_8)->SetWindowText("--");

pProg->SetPos(72);

14

break;

case 8: if(((CButton*)m_poGraphic->GetDlgItem(IDC_CHECK9))->GetCheck() || ((CButton*)m_poGraphic->GetDlgItem(IDC_CHECK10))->GetCheck()) FuelSystem=m_poLogic->GetFuelSystemStatus(); if(((CButton*)m_poGraphic->GetDlgItem(IDC_CHECK9))->GetCheck()) { m_poGraphic->GetDlgItem(IDC_EDIT_9)->SetWindowText(FuelSystem->at(0)); } else m_poGraphic->GetDlgItem(IDC_EDIT_9)->SetWindowText("--");

if(((CButton*)m_poGraphic->GetDlgItem(IDC_CHECK10))->GetCheck()) { m_poGraphic->GetDlgItem(IDC_EDIT_10)->SetWindowText(FuelSystem->at(1)); } else m_poGraphic->GetDlgItem(IDC_EDIT_10)->SetWindowText("--");


case 9: if(((CButton*)m_poGraphic->GetDlgItem(IDC_CHECK11))->GetCheck()) m_poGraphic->GetDlgItem(IDC_EDIT_11)->SetWindowText(*m_poLogic->GetShortTrimBank1()); else m_poGraphic->GetDlgItem(IDC_EDIT_11)->SetWindowText("--");


case 10: if(((CButton*)m_poGraphic->GetDlgItem(IDC_CHECK12))->GetCheck()) m_poGraphic->GetDlgItem(IDC_EDIT_12)->SetWindowText(*m_poLogic->GetLongTrimBank1()); else m_poGraphic->GetDlgItem(IDC_EDIT_12)->SetWindowText("--");

pProg->SetPos(100); RealtimeUpdateCounter=-1; break; }

RealtimeUpdateCounter++; SetTimer(m_hwndGuiWnd, 6, 5, NULL); }}

void COdbGuiHandler::UpdateTimeConnected(){ m_poGraphic->GetDlgItem(IDC_EDIT_COMM_STATUS)->SetWindowText(*m_poLogic->GetTimeConnected());

}

15

// Private attributesprivate: BOOL m_bTimer; SHORT m_nTest; SHORT m_nCategory; SHORT m_nMode; BOOL m_bHideUnselected; CAtTemcError *m_poError; COdbLogic *m_poLogic; COdbDefaultGraphic *m_poGraphic; HWND m_hwndGuiWnd; SHORT m_nSignalCount; COdbMenu *m_poMenu; CAtLabels *m_poLabels; CUutInfo m_oUut; CObList *m_poPlaylists; SHORT m_nSequence; IOleInPlaceFrame *m_poInPlaceFrame; SHORT m_nTab; CObList *m_poSegmentReports; CObList *m_poMatchedReports; //Added by Andreas² CComboBox *ServiceBox; CListBox *TroubleCodeBox;

int RealtimeUpdateCounter;

};

#endif // !defined(AFX_ODBGUIHANDLER_H__7B0361C6_026B_4583_9EC4_2F620975FB1A__INCLUDED_)

2

// OdbDefaultGraphic.h: interface for the COdbDefaultGraphic class.////////////////////////////////////////////////////////////////////////

#if !defined(AFX_ODBDEFAULTGRAPHIC_H__D8A80D27_F1ED_4C15_B045_B920F31F88F5__INCLUDED_)#define AFX_ODBDEFAULTGRAPHIC_H__D8A80D27_F1ED_4C15_B045_B920F31F88F5__INCLUDED_


#include <afxcmn.h>#include "..\..\SYS\AtSysCommon\AtGraphic.h"

// Macros and defines ( nyttja static const i st. f. defines för det som inte är makron!)static const SHORT TAB_REALTIME = 0;static const SHORT TAB_TROUBLECODE = 1;static const SHORT TAB_FREEZE = 2;static const SHORT TAB_VEHICLE = 3;static const SHORT TAB_MONITORING = 4;static const SHORT TAB_OXYGENSENSORS = 5;

//------------------------------------------------------------------------------// Class declaration.//// This class handles //////------------------------------------------------------------------------------class COdbDefaultGraphic : public CAtGraphic{ // Public methodspublic: // LIFECYCLE ------------------------ // Constructor COdbDefaultGraphic(HWND hGuiWnd); // Destructor virtual ~COdbDefaultGraphic(); // OPERATORS ------------------------ // OPERATIONS ------------------------ // Performs required changes to the GUI when a test is initiated void Apply();

// Performs required changes to the GUI after a test has been stopped. void StopTest();

// Performs required changes to the GUI after a test has been aborted. void AbortTest();

// Performs required changes to the GUI after a test has started void StartTest();

// Initializes the graphic with default values BOOL InitGraphic(SHORT nMbtType, CString *psOperator, CString *psRegNo);

// Updates all common graphics. void Draw(CRect rect);

// Updates the UUT combo with new data BOOL InitUut();

HRESULT OnSelDlgRealtime(BOOL bTabEnable=true); HRESULT OnSelDlgTroubleCode(BOOL bTabEnable=true); HRESULT OnSelDlgFreeze(BOOL bTabEnable=true); HRESULT OnSelDlgVehicle(BOOL bTabEnable=true); HRESULT OnSelDlgMonitor(BOOL bTabEnable=true); HRESULT OnSelDlgOxygenSensors(BOOL bTabEnable=true);

// ACCESS METHODS ------------------------

1

// Public attributespublic:

// Protected methodsprotected: // Protected attributesprotected: // Private methodsprivate: // OPERATIONS ------------------------ // Updates size and position for the common controls void DrawSettings(CRect rect);

void DrawSettings(CRect rect, CRect *pRectTab); void DrawTabRealtime(CRect rect); void DrawTabMonitor(CRect rect); void DrawTabTroubleCode(CRect rect); void DrawTabFreeze(CRect rect); void DrawTabVehicle(CRect rect); void DrawTabOxygenSensors(CRect rect);

void SetComboContent(UINT uiCombo, CStringList *poList); CString GetComboSelText(UINT uiCombo); // Private attributesprivate: CTabCtrl *m_poTabDb; CListCtrl *pmyListCtrl; CDialog *m_poDialog; IUnknown *m_poUnk; short m_nMode;

}; // COdbDefaultGraphic

#endif // !defined(AFX_ODBDEFAULTGRAPHIC_H__D8A80D27_F1ED_4C15_B045_B920F31F88F5__INCLUDED_)

2


// Project includes -------#include "stdafx.h"#include "resource.h"

#include "TroubleCode.h"


// Local includes -------#include "OdbDefaultGraphic.h"

// Internal defines -------#ifdef _DEBUG#undef THIS_FILEstatic char THIS_FILE[]=__FILE__;#define new DEBUG_NEW#endif

// Global variables -------

// Function declarations -------

// -------------------------- LIFECYCLE --------------------------//------------------------------------------------------------------------------// Constructor//------------------------------------------------------------------------------COdbDefaultGraphic::COdbDefaultGraphic(HWND hGuiWnd){ m_hGuiWnd = hGuiWnd;} // Constructor

//------------------------------------------------------------------------------// Destructor//------------------------------------------------------------------------------COdbDefaultGraphic::~COdbDefaultGraphic(){

} // Destructor

// -------------------------- OPERATORS --------------------------

// -------------------------- OPERATIONS --------------------------//-----------------------------------------------------------------------------//// void COdbDefaultGraphic::DrawSettings(CRect rect)//// Updates size and position for the common controls in the main window using // rect for size and position of the main window. // //------------------------------------------------------------------------------void COdbDefaultGraphic::DrawSettings(CRect rect){ int iX = rect.left + 20; int iY = rect.top + 30; int iWidth = rect.Width(); int iHeight = rect.Height(); int iOffset; int iLeft;

iLeft = 370; // Settings frame GetDlgItem(IDC_FRAME_SETTINGS)->MoveWindow(iX-15, iY-25, iLeft, 135, TRUE);

GetDlgItem(IDC_STATIC_MBT)->MoveWindow(iX, iY+2, 60, 15, TRUE ); GetDlgItem(IDC_STATIC_REG_NO)->MoveWindow(iX, iY+27, 60, 20, TRUE ); GetDlgItem(IDC_STATIC_UNIT_NO)->MoveWindow(iX, iY+52, 60, 20, TRUE ); GetDlgItem(IDC_STATIC_UNIT)->MoveWindow(iX, iY+77, 60, 20, TRUE ); GetDlgItem(IDC_COMBO_MBT)->MoveWindow(iX+65, iY, 70, 20, false ); ((CComboBox*)GetDlgItem(IDC_COMBO_MBT))->SetEditSel(-1,0);

1

GetDlgItem(IDC_EDIT_REG_NO)->MoveWindow(iX+65, iY+25, 70, 20, true ); GetDlgItem(IDC_EDIT_UNIT_NO)->MoveWindow(iX+65, iY+50, 70, 20, true ); GetDlgItem(IDC_COMBO_UNIT)->MoveWindow(iX+65, iY+75, 200, 12, false ); ((CComboBox*)GetDlgItem(IDC_COMBO_UNIT))->SetEditSel(-1,0); GetDlgItem(IDC_STATIC_OPERATOR)->MoveWindow(iX+150, iY, 50, 20, TRUE ); GetDlgItem(IDC_EDIT_OPERATOR)->MoveWindow(iX+205, iY, 140, 20, TRUE ); GetDlgItem(IDC_EDIT_DATE)->MoveWindow(iX+205, iY+25, 140, 20, TRUE ); GetDlgItem(IDC_BUTTON_APPLY)->MoveWindow(iX+275, iY+75, 70, 24, TRUE ); // Signallist frame iX = 385; GetDlgItem(IDC_FRAME_RESULT)->MoveWindow(iX, iY-25, iWidth-5-iX, iHeight-40, TRUE ); iX = 20; iY = 154; iOffset = ( iHeight - iY - 34 ) / 2; // Instruction frame GetDlgItem(IDC_FRAME_INSTRUCTION)->MoveWindow(iX-15, iY, iLeft, iOffset-6,TRUE ); GetDlgItem(IDC_EDIT_INSTRUCTIONS)->MoveWindow(iX, iY+30, iLeft-35,iOffset-50, TRUE ); // Comment frame GetDlgItem(IDC_FRAME_COMMENT)->MoveWindow(iX-15, iY+iOffset+5, iLeft,iOffset-6, TRUE ); GetDlgItem(IDC_EDIT_COMMENTS)->MoveWindow(iX, iY+iOffset+35, iLeft-35,iOffset-50, TRUE ); // Buttons iY = iHeight - 28; GetDlgItem(IDC_BUTTON_OK)->MoveWindow(iWidth-375, iY, 70, 24, TRUE ); GetDlgItem(IDC_BUTTON_ABORT)->MoveWindow(iWidth-300, iY, 70, 24, TRUE ); GetDlgItem(IDC_BUTTON_NO)->MoveWindow(iWidth-225, iY, 70, 24, TRUE ); GetDlgItem(IDC_BUTTON_START)->MoveWindow(iWidth-300, iY, 70, 24, TRUE ); GetDlgItem(IDC_BUTTON_STOP)->MoveWindow(iWidth-225, iY, 70, 24, TRUE ); GetDlgItem(IDC_BUTTON_SAVE)->MoveWindow(iWidth-150, iY, 70, 24, TRUE ); GetDlgItem(IDC_BUTTON_HELP)->MoveWindow(iWidth-75, iY, 70, 24, TRUE ); GetDlgItem(IDC_BUTTON_QUIT)->MoveWindow(iWidth-75, iY, 70, 24, TRUE );

GetDlgItem(IDC_BUTTON_BACK)->MoveWindow(iWidth-500, iY-60, 70, 24, TRUE ); GetDlgItem(IDC_BUTTON_UPDATE)->MoveWindow(iWidth-425, iY-60, 70, 24, TRUE );

GetDlgItem(IDC_STATIC_ERASE)->MoveWindow(iWidth-378, iY-100, 180, 60,TRUE); GetDlgItem(IDC_BUTTON_ERASE)->MoveWindow(iWidth-340, iY-80, 100, 30,TRUE);

// Dummy static for the tabbing functionality GetDlgItem(IDC_TAB_INSTRUCTION)->MoveWindow(iX, iY, 10, 10, TRUE ); GetDlgItem(IDC_TAB_RESULT)->MoveWindow(iX+40, iY, 10, 10, TRUE );

// Resultat iLeft = 370; iX = 385; iY = rect.top + 30; GetDlgItem(IDC_FRAME_RESULT)->SetWindowPos(CWnd::FromHandle(HWND_BOTTOM), iX, iY-25, iWidth-5-iX, iHeight-40, TRUE); GetDlgItem(IDC_TAB_DB)->MoveWindow(iX+15, iY-0, 1043-215-iX, iHeight - 75, TRUE); //GetDlgItem(IDC_TAB_DB)->MoveWindow(iX+15, iY-0, iWidth-180-iX, iHeight - 75, TRUE);

iX = iWidth - 150; iY += 15; GetDlgItem(IDC_FRAME_PROTOCOL)->MoveWindow(iX, iY-0, 135, 50, TRUE); GetDlgItem(IDC_EDIT_PROTOCOL)->MoveWindow(iX+10, iY+20, 115, 20, TRUE); iY += 70; GetDlgItem(IDC_FRAME_VEHICLE_ID)->MoveWindow(iX, iY-0, 135, 50, TRUE); //GetDlgItem(IDC_FRAME_VEHICLE_ID)->MoveWindow(iX, iY-0, 130, 50, TRUE); GetDlgItem(IDC_EDIT_VEHICLE_ID)->MoveWindow(iX+10, iY+20, 115, 20, TRUE); //GetDlgItem(IDC_EDIT_VEHICLE_ID)->MoveWindow(iX+10, iY+20, 110, 20, TRUE);

iY += 70; GetDlgItem(IDC_FRAME_ERRORS)->MoveWindow(iX, iY-0, 135, 50, TRUE); GetDlgItem(IDC_EDIT_ERRORS)->MoveWindow(iX+10, iY+20, 115, 20, TRUE);

iY += 70; GetDlgItem(IDC_STATIC_OBD_TYPE)->MoveWindow(iX, iY-0, 135, 50, TRUE); GetDlgItem(IDC_EDIT_OBD_TYPE)->MoveWindow(iX+10, iY+20, 115, 20, TRUE);

iY += 70; //Tillagd 2003-05-15 GetDlgItem(IDC_STATIC_COMM_STATUS)->MoveWindow(iX, iY-0, 135, 50, TRUE);

2

GetDlgItem(IDC_EDIT_COMM_STATUS)->MoveWindow(iX+10, iY+20, 115, 20, TRUE);

iY = iHeight-145; GetDlgItem(IDC_FRAME_STATUS)->MoveWindow(iX, iY-0, 135, 100, TRUE); GetDlgItem(IDC_TEXT_STATUS)->MoveWindow(iX+10, iY+80, 115, 15, TRUE); GetDlgItem(IDC_ICON_MIL_GREEN)->MoveWindow(iX+42, iY+30, 52, 32, TRUE); GetDlgItem(IDC_ICON_MIL_RED)->MoveWindow(iX+42, iY+30, 52, 32, TRUE);

return;} // DrawSettings

//-----------------------------------------------------------------------------//// void COdbDefaultGraphic::Draw(CRect rect)//// Updates all common graphics.// //------------------------------------------------------------------------------void COdbDefaultGraphic::Draw(CRect rect){ DrawSettings(rect); switch (m_nMode) { case 0: DrawTabRealtime(rect); break;

case 1: DrawTabTroubleCode(rect); break;

case 2: DrawTabFreeze(rect); break; case 3: DrawTabVehicle(rect); break; case 4: DrawTabMonitor(rect); break;

case 5: DrawTabOxygenSensors(rect); break;

}

return;} // Draw

//-----------------------------------------------------------------------------//// BOOL COdbDefaultGraphic::InitGraphic(SHORT nMbtType, CString *psOperator, // CString *psRegNo)//// Initializes the graphic with default values using nMbtType as MBT type, // psOperator as the operator, psRegNo as serial number and returns true.// //------------------------------------------------------------------------------BOOL COdbDefaultGraphic::InitGraphic(SHORT nMbtType, CString *psOperator, CString *psRegNo){ int iRow; int ii; CComboBox *poCombo; CString sLabel; CAtGraphic::InitGraphic();

// Set MBT types

3

poCombo = (CComboBox*) GetDlgItem(IDC_COMBO_MBT); poCombo->ResetContent(); for ( ii=0; ii<3; ii++) { iRow = poCombo->AddString(m_poLabels->FindGeneralLabel(30+ii)); switch (ii) { case 0: poCombo->SetItemData(iRow, MBT_TYPE_121); break; case 1: poCombo->SetItemData(iRow, MBT_TYPE_122); break; case 2: poCombo->SetItemData(iRow, MBT_TYPE_BGV120); break;

} // endswitch } // endfor // Set the default value for (ii=0; ii<poCombo->GetCount(); ii++) { if ((SHORT) poCombo->GetItemData(ii) == nMbtType) { poCombo->SetCurSel(ii); } // endif } // endfor

GetDlgItem(IDC_EDIT_OPERATOR)->SetWindowText(*psOperator); GetDlgItem(IDC_EDIT_REG_NO)->SetWindowText(*psRegNo); GetDlgItem(IDC_BUTTON_NO)->EnableWindow(false); GetDlgItem(IDC_BUTTON_OK)->EnableWindow(true); GetDlgItem(IDC_BUTTON_START)->EnableWindow(false); GetDlgItem(IDC_BUTTON_STOP)->EnableWindow(false); GetDlgItem(IDC_BUTTON_SAVE)->EnableWindow(false); GetDlgItem(IDC_BUTTON_QUIT)->ShowWindow(false); GetDlgItem(IDC_BUTTON_HELP)->ShowWindow(true); GetDlgItem(IDC_BUTTON_ABORT)->EnableWindow(false); GetDlgItem(IDC_BUTTON_ERASE)->EnableWindow(false); GetDlgItem(IDC_BUTTON_UPDATE)->EnableWindow(false);

GetDlgItem(IDC_ICON_MIL_RED)->ShowWindow(false); GetDlgItem(IDC_ICON_MIL_GREEN)->ShowWindow(false); GetDlgItem(IDC_BUTTON_SAVE)->ShowWindow(false); GetDlgItem(IDC_BUTTON_BACK)->ShowWindow(false); GetDlgItem(IDC_BUTTON_ABORT)->ShowWindow(false); GetDlgItem(IDC_PROGRESS_REALTIME)->ShowWindow(false); GetDlgItem(IDC_STATIC_PROGRESS_REALTIME)->ShowWindow(false);

TCITEM tie; m_poTabDb = (CTabCtrl*) GetDlgItem(IDC_TAB_DB);

// Add a tab for each of the three child dialog boxes. tie.mask = TCIF_TEXT | TCIF_IMAGE; tie.iImage = -1; tie.pszText = "Realtid"; m_poTabDb->InsertItem( 0, &tie ); tie.pszText = "Felkoder"; m_poTabDb->InsertItem( 1, &tie ); tie.pszText = "Frysta värden"; m_poTabDb->InsertItem( 2, &tie ); tie.pszText = "Fordonsinfo"; m_poTabDb->InsertItem( 3, &tie ); tie.pszText = "Fordonets Självtest"; m_poTabDb->InsertItem( 4, &tie ); tie.pszText = "Syresensorer"; m_poTabDb->InsertItem( 5, &tie ); SetTimer(m_hGuiWnd, 8, 30, NULL); GetDlgItem(IDC_EDIT_COMM_STATUS)->SetWindowText("Ej ansluten"); // Simulate selection of the first item. OnSelDlgRealtime();

GetDlgItem(IDC_EDIT_1)->EnableWindow(false); GetDlgItem(IDC_EDIT_2)->EnableWindow(false); GetDlgItem(IDC_EDIT_3)->EnableWindow(false); GetDlgItem(IDC_EDIT_4)->EnableWindow(false); GetDlgItem(IDC_EDIT_5)->EnableWindow(false); GetDlgItem(IDC_EDIT_6)->EnableWindow(false); GetDlgItem(IDC_EDIT_7)->EnableWindow(false); GetDlgItem(IDC_EDIT_8)->EnableWindow(false); GetDlgItem(IDC_EDIT_9)->EnableWindow(false);

4

GetDlgItem(IDC_EDIT_10)->EnableWindow(false); GetDlgItem(IDC_EDIT_11)->EnableWindow(false); GetDlgItem(IDC_EDIT_12)->EnableWindow(false); GetDlgItem(IDC_EDIT_13)->EnableWindow(false); GetDlgItem(IDC_EDIT_14)->EnableWindow(false); GetDlgItem(IDC_EDIT_15)->EnableWindow(false); GetDlgItem(IDC_EDIT_16)->EnableWindow(false);

//Set Checkboxes ((CButton*) GetDlgItem(IDC_CHECK1))->SetCheck(1); ((CButton*) GetDlgItem(IDC_CHECK2))->SetCheck(1); ((CButton*) GetDlgItem(IDC_CHECK3))->SetCheck(1); ((CButton*) GetDlgItem(IDC_CHECK4))->SetCheck(1); ((CButton*) GetDlgItem(IDC_CHECK5))->SetCheck(1); ((CButton*) GetDlgItem(IDC_CHECK6))->SetCheck(1); ((CButton*) GetDlgItem(IDC_CHECK7))->SetCheck(1); ((CButton*) GetDlgItem(IDC_CHECK8))->SetCheck(1); ((CButton*) GetDlgItem(IDC_CHECK9))->SetCheck(1); ((CButton*) GetDlgItem(IDC_CHECK10))->SetCheck(1); ((CButton*) GetDlgItem(IDC_CHECK11))->SetCheck(1); ((CButton*) GetDlgItem(IDC_CHECK12))->SetCheck(1);

//Instructions for the user. GetDlgItem(IDC_EDIT_INSTRUCTIONS)->SetWindowText("1.Anslut kontaktdon till fordonets OBD-interface\r\n2.Slå på tändningen.\r\n3.Tryck på OK när ovanstående är gjort.");

return true;

} // InitGraphic

//-----------------------------------------------------------------------------//// void COdbDefaultGraphic::StartTest()//// Performs required changes to the GUI after a test has started.// //------------------------------------------------------------------------------void COdbDefaultGraphic::StartTest(){ GetDlgItem(IDC_BUTTON_NO)->EnableWindow(true); GetDlgItem(IDC_BUTTON_OK)->EnableWindow(false); GetDlgItem(IDC_BUTTON_START)->EnableWindow(false); GetDlgItem(IDC_BUTTON_STOP)->EnableWindow(true); GetDlgItem(IDC_BUTTON_SAVE)->EnableWindow(false); GetDlgItem(IDC_COMBO_MODE)->EnableWindow(false); GetDlgItem(IDC_EDIT_COMMENT)->SetWindowText("Användarens kommentarer");} // StartTest

//-----------------------------------------------------------------------------//// void COdbDefaultGraphic::AbortTest()//// Performs required changes to the GUI after a test has been aborted.// //------------------------------------------------------------------------------void COdbDefaultGraphic::AbortTest(){ GetDlgItem(IDC_BUTTON_NO)->EnableWindow(false); GetDlgItem(IDC_BUTTON_OK)->EnableWindow(false); GetDlgItem(IDC_BUTTON_START)->EnableWindow(false); GetDlgItem(IDC_BUTTON_STOP)->EnableWindow(false); GetDlgItem(IDC_BUTTON_SAVE)->EnableWindow(false); GetDlgItem(IDC_BUTTON_ABORT)->EnableWindow(false); GetDlgItem(IDC_COMBO_MBT)->EnableWindow(true); GetDlgItem(IDC_EDIT_OPERATOR)->EnableWindow(true); GetDlgItem(IDC_EDIT_REG_NO)->EnableWindow(true); GetDlgItem(IDC_COMBO_UNIT)->EnableWindow(true); GetDlgItem(IDC_BUTTON_APPLY)->EnableWindow(true); } // AbortTest

//-----------------------------------------------------------------------------//

5

// void COdbDefaultGraphic::StopTest()//// Performs required changes to the GUI after a test has been stopped.// //------------------------------------------------------------------------------void COdbDefaultGraphic::StopTest(){ GetDlgItem(IDC_BUTTON_NO)->EnableWindow(false); GetDlgItem(IDC_BUTTON_OK)->EnableWindow(true); GetDlgItem(IDC_BUTTON_START)->EnableWindow(true); GetDlgItem(IDC_BUTTON_STOP)->EnableWindow(false); GetDlgItem(IDC_BUTTON_SAVE)->EnableWindow(true); GetDlgItem(IDC_COMBO_MODE)->EnableWindow(true);} // StopTest

//-----------------------------------------------------------------------------//// void COdbDefaultGraphic::Apply()//// Performs required changes to the GUI when a test is initiated.// //------------------------------------------------------------------------------void COdbDefaultGraphic::Apply(){ GetDlgItem(IDC_BUTTON_NO)->EnableWindow(false); GetDlgItem(IDC_BUTTON_OK)->EnableWindow(false); GetDlgItem(IDC_BUTTON_START)->EnableWindow(false); GetDlgItem(IDC_BUTTON_STOP)->EnableWindow(false); GetDlgItem(IDC_BUTTON_APPLY)->EnableWindow(false); GetDlgItem(IDC_BUTTON_ABORT)->EnableWindow(true); GetDlgItem(IDC_COMBO_MBT)->EnableWindow(false); GetDlgItem(IDC_EDIT_OPERATOR)->EnableWindow(false); GetDlgItem(IDC_EDIT_REG_NO)->EnableWindow(false); GetDlgItem(IDC_COMBO_UNIT)->EnableWindow(false); } // Apply

//-----------------------------------------------------------------------------//// void COdbDefaultGraphic::InitUut()//// Updates the UUT combo with new data and returns true.// //------------------------------------------------------------------------------BOOL COdbDefaultGraphic::InitUut(){ int iRow; CComboBox *poCombo; CString sLabel; CString sFNum; CString sFName; LONG lLabelId;

poCombo = (CComboBox*) GetDlgItem(IDC_COMBO_UNIT); poCombo->ResetContent(); m_poLabels->ResetUutPosition(); while (m_poLabels->GetNextUutLabel(&sFNum, &sFName, &lLabelId)) { sLabel.Format("%s %s", sFName, sFNum); iRow = poCombo->AddString(sLabel); poCombo->SetItemData(iRow, lLabelId); } // endwhile poCombo->SetWindowText(m_poLabels->FindGeneralLabel(190));

return true;} // InitUut

void COdbDefaultGraphic::DrawTabTroubleCode(CRect rect){ int iX = rect.left + 10; int iY = rect.top + 30; int iWidth = rect.Width()-20; int iHeight = rect.Height()-35; int iOffset; int iLength;

iOffset = iX + 60; iLength = iWidth-iOffset+10;

6

GetDlgItem(IDC_STATIC_ERASE)->MoveWindow(iX+629, iY+425, 180, 60,TRUE); GetDlgItem(IDC_BUTTON_ERASE)->MoveWindow(iX+669, iY+445, 100, 30,TRUE);

return;}

void COdbDefaultGraphic::DrawTabRealtime(CRect rect){ int iX = 400; int iY = rect.top + 100; int iWidth = rect.Width()-20-iX; int iHeight = rect.Height()-40;

// Report list GetDlgItem(IDC_FRAME_1)->MoveWindow(iX+30, iY-10, 180, 300, true); GetDlgItem(IDC_FRAME_2)->MoveWindow(iX+230, iY-10, 180, 300, true); //Edit boxes column 1 GetDlgItem(IDC_EDIT_1)->SetWindowPos(NULL, iX+140, iY+35-3, 30,20 , SWP_DRAWFRAME); GetDlgItem(IDC_EDIT_2)->SetWindowPos(NULL, iX+140, iY+35*2-3, 30,20 , SWP_DRAWFRAME); GetDlgItem(IDC_EDIT_3)->SetWindowPos(NULL, iX+140, iY+35*3-3, 30,20 , SWP_DRAWFRAME); GetDlgItem(IDC_EDIT_4)->SetWindowPos(NULL, iX+140, iY+35*4-3, 30,20 , SWP_DRAWFRAME); GetDlgItem(IDC_EDIT_5)->SetWindowPos(NULL, iX+140, iY+35*5-3, 30,20 , SWP_DRAWFRAME); GetDlgItem(IDC_EDIT_6)->SetWindowPos(NULL, iX+140, iY+35*6-3, 30,20 , SWP_DRAWFRAME); GetDlgItem(IDC_EDIT_7)->SetWindowPos(NULL, iX+140, iY+35*7, 30,20 , SWP_DRAWFRAME);

GetDlgItem(IDC_STATIC_UNIT_1)->SetWindowPos(NULL, iX+175, iY+35, 30,30 , SWP_DRAWFRAME); GetDlgItem(IDC_STATIC_UNIT_2)->SetWindowPos(NULL, iX+175, iY+35*2, 20,30 , SWP_NOSIZE); GetDlgItem(IDC_STATIC_UNIT_3)->SetWindowPos(NULL, iX+175, iY+35*3, 20,30 , SWP_NOSIZE); GetDlgItem(IDC_STATIC_UNIT_4)->SetWindowPos(NULL, iX+175, iY+35*4, 20,30 , SWP_NOSIZE); GetDlgItem(IDC_STATIC_UNIT_5)->SetWindowPos(NULL, iX+175, iY+35*5, 30,20 , SWP_NOSIZE); GetDlgItem(IDC_STATIC_UNIT_6)->SetWindowPos(NULL, iX+175, iY+35*6, 30,20 , SWP_NOSIZE); GetDlgItem(IDC_STATIC_UNIT_7)->SetWindowPos(NULL, iX+175, iY+35*7+3, 30,20 , SWP_NOSIZE);

//Statics column 1 GetDlgItem(IDC_STATIC_1)->SetWindowPos(NULL, iX+50, iY+35, 80,30 , SWP_DRAWFRAME); GetDlgItem(IDC_STATIC_2)->SetWindowPos(NULL, iX+50, iY+35*2, 80,30 , SWP_DRAWFRAME); GetDlgItem(IDC_STATIC_3)->SetWindowPos(NULL, iX+50, iY+35*3, 80,30 , SWP_DRAWFRAME); GetDlgItem(IDC_STATIC_4)->SetWindowPos(NULL, iX+50, iY+35*4, 80,30 , SWP_DRAWFRAME); GetDlgItem(IDC_STATIC_5)->SetWindowPos(NULL, iX+50, iY+35*5, 80,30 , SWP_DRAWFRAME); GetDlgItem(IDC_STATIC_6)->SetWindowPos(NULL, iX+50, iY+35*6, 80,30 , SWP_DRAWFRAME); GetDlgItem(IDC_STATIC_7)->SetWindowPos(NULL, iX+50, iY+35*7, 80,30 , SWP_DRAWFRAME);

//Check Boxes column 1 GetDlgItem(IDC_CHECK1)->SetWindowPos(NULL, iX+35, iY+35+2, 20,30 , SWP_NOSIZE); GetDlgItem(IDC_CHECK2)->SetWindowPos(NULL, iX+35, iY+35*2+2, 20,30 , SWP_NOSIZE); GetDlgItem(IDC_CHECK3)->SetWindowPos(NULL, iX+35, iY+35*3+2, 20,30 , SWP_NOSIZE); GetDlgItem(IDC_CHECK4)->SetWindowPos(NULL, iX+35, iY+35*4+2, 20,30 , SWP_NOSIZE); GetDlgItem(IDC_CHECK5)->SetWindowPos(NULL, iX+35, iY+35*5+2, 30,20 , SWP_NOSIZE); GetDlgItem(IDC_CHECK6)->SetWindowPos(NULL, iX+35, iY+35*6+2, 30,20 , SWP_NOSIZE); GetDlgItem(IDC_CHECK7)->SetWindowPos(NULL, iX+35, iY+35*7+2, 30,20 , SWP_NOSIZE);

//New Column

//Edit boxes column 2

GetDlgItem(IDC_EDIT_8)->SetWindowPos(NULL, iX+330, iY+35-3, 30,20 , SWP_DRAWFRAME); GetDlgItem(IDC_EDIT_9)->SetWindowPos(NULL, iX+330, iY+35*2+10, 70,20 , SWP_DRAWFRAME); //GetDlgItem(IDC_EDIT_9)->SetWindowPos(NULL, iX+330, iY+45*2, 30,20 , SWP_DRAWFRAME); GetDlgItem(IDC_EDIT_10)->SetWindowPos(NULL, iX+330, iY+45*3, 30,20 , SWP_DRAWFRAME); GetDlgItem(IDC_EDIT_10)->SetWindowPos(NULL, iX+330, iY+35*3+20, 70,20 , SWP_DRAWFRAME); //2003-05-21 försök att snygga till programmet GetDlgItem(IDC_EDIT_11)->SetWindowPos(NULL, iX+330, iY+35*4+30, 30,20 , SWP_DRAWFRAME); GetDlgItem(IDC_EDIT_12)->SetWindowPos(NULL, iX+330, iY+35*5+40, 30,20 , SWP_DRAWFRAME);

7

GetDlgItem(IDC_STATIC_UNIT_8)->SetWindowPos(NULL, iX+365, iY+35, 20,30 , SWP_NOSIZE); GetDlgItem(IDC_STATIC_UNIT_9)->SetWindowPos(NULL, iX+365, iY+35*2+10, 20,30 , SWP_NOSIZE); GetDlgItem(IDC_STATIC_UNIT_10)->SetWindowPos(NULL, iX+365, iY+35*3+20, 20,30 , SWP_NOSIZE); GetDlgItem(IDC_STATIC_UNIT_11)->SetWindowPos(NULL, iX+365, iY+35*4+30+3, 20,30 , SWP_NOSIZE); GetDlgItem(IDC_STATIC_UNIT_12)->SetWindowPos(NULL, iX+365, iY+35*5+40+3, 30,20 , SWP_NOSIZE);

//Statics column 2 GetDlgItem(IDC_STATIC_8)->SetWindowPos(NULL, iX+300-40, iY+35, 80,30 , SWP_DRAWFRAME); GetDlgItem(IDC_STATIC_9)->SetWindowPos(NULL, iX+300-40, iY+35*2+10, 80,30 , SWP_DRAWFRAME); GetDlgItem(IDC_STATIC_10)->SetWindowPos(NULL, iX+300-40, iY+35*3+20, 80,30 , SWP_DRAWFRAME); GetDlgItem(IDC_STATIC_11)->SetWindowPos(NULL, iX+300-40, iY+35*4+30, 80,30 , SWP_DRAWFRAME); GetDlgItem(IDC_STATIC_12)->SetWindowPos(NULL, iX+300-40, iY+35*5+40, 80,30 , SWP_DRAWFRAME);

//Check Boxes column 2 GetDlgItem(IDC_CHECK8)->SetWindowPos(NULL, iX+245, iY+35+2, 20,30 , SWP_NOSIZE); GetDlgItem(IDC_CHECK9)->SetWindowPos(NULL, iX+245, iY+35*2+2+10, 20,30 , SWP_NOSIZE); GetDlgItem(IDC_CHECK10)->SetWindowPos(NULL, iX+245, iY+35*3+2+20, 20,30 , SWP_NOSIZE); GetDlgItem(IDC_CHECK11)->SetWindowPos(NULL, iX+245, iY+35*4+2+30, 20,30 , SWP_NOSIZE); GetDlgItem(IDC_CHECK12)->SetWindowPos(NULL, iX+245, iY+35*5+2+40, 30,20 , SWP_NOSIZE);

return;}

HRESULT COdbDefaultGraphic::OnSelDlgRealtime(BOOL bTabEnable) { if (bTabEnable) { // Disable the other tab OnSelDlgTroubleCode(false); OnSelDlgFreeze(false); OnSelDlgVehicle(false); OnSelDlgMonitor(false); OnSelDlgOxygenSensors(false); m_nMode = 0; CRect rect; GetClientRect(m_hGuiWnd, rect); Draw(rect); CTreeCtrl *pCtrl = (CTreeCtrl*) GetDlgItem(IDC_TREE_FILES); pCtrl->DeleteAllItems(); }

GetDlgItem(IDC_STATIC_1)->SetWindowText("Hastighet:"); GetDlgItem(IDC_STATIC_2)->SetWindowText("Varvtal:"); GetDlgItem(IDC_STATIC_3)->SetWindowText("Motorlast:"); GetDlgItem(IDC_STATIC_4)->SetWindowText("Temp Kylare:"); GetDlgItem(IDC_STATIC_5)->SetWindowText("Temp Insug:"); GetDlgItem(IDC_STATIC_6)->SetWindowText("Gaspedalsläge:"); GetDlgItem(IDC_STATIC_7)->SetWindowText("Tryck insugningsrör:"); GetDlgItem(IDC_STATIC_8)->SetWindowText("Bränsletryck:"); GetDlgItem(IDC_STATIC_9)->SetWindowText("Status System 1:"); GetDlgItem(IDC_STATIC_10)->SetWindowText("Status System 2:"); GetDlgItem(IDC_STATIC_11)->SetWindowText("Kortsiktig bränsletrim:"); GetDlgItem(IDC_STATIC_12)->SetWindowText("Långsiktig bränsletrim:");

GetDlgItem(IDC_FRAME_1)->SetWindowText("Generella parametrar"); GetDlgItem(IDC_FRAME_2)->SetWindowText("Bränslesystem");

GetDlgItem(IDC_STATIC_UNIT_1)->SetWindowText("km/h"); GetDlgItem(IDC_STATIC_UNIT_2)->SetWindowText("vpm"); GetDlgItem(IDC_STATIC_UNIT_3)->SetWindowText("%"); GetDlgItem(IDC_STATIC_UNIT_4)->SetWindowText("°C"); GetDlgItem(IDC_STATIC_UNIT_5)->SetWindowText("°C"); GetDlgItem(IDC_STATIC_UNIT_6)->SetWindowText("%");

8

GetDlgItem(IDC_STATIC_UNIT_7)->SetWindowText("kPa"); GetDlgItem(IDC_STATIC_UNIT_8)->SetWindowText("kPa"); GetDlgItem(IDC_STATIC_UNIT_9)->SetWindowText(" "); GetDlgItem(IDC_STATIC_UNIT_10)->SetWindowText(" "); GetDlgItem(IDC_STATIC_UNIT_11)->SetWindowText("%"); GetDlgItem(IDC_STATIC_UNIT_12)->SetWindowText("%");

GetDlgItem(IDC_FRAME_1)->ShowWindow(bTabEnable); GetDlgItem(IDC_FRAME_2)->ShowWindow(bTabEnable);

GetDlgItem(IDC_EDIT_1)->ShowWindow(bTabEnable); GetDlgItem(IDC_EDIT_2)->ShowWindow(bTabEnable); GetDlgItem(IDC_EDIT_3)->ShowWindow(bTabEnable); GetDlgItem(IDC_EDIT_4)->ShowWindow(bTabEnable); GetDlgItem(IDC_EDIT_5)->ShowWindow(bTabEnable); GetDlgItem(IDC_EDIT_6)->ShowWindow(bTabEnable); GetDlgItem(IDC_EDIT_7)->ShowWindow(bTabEnable); GetDlgItem(IDC_EDIT_8)->ShowWindow(bTabEnable); GetDlgItem(IDC_EDIT_9)->ShowWindow(bTabEnable); GetDlgItem(IDC_EDIT_10)->ShowWindow(bTabEnable); GetDlgItem(IDC_EDIT_11)->ShowWindow(bTabEnable); GetDlgItem(IDC_EDIT_12)->ShowWindow(bTabEnable);

GetDlgItem(IDC_STATIC_UNIT_1)->ShowWindow(bTabEnable); GetDlgItem(IDC_STATIC_UNIT_2)->ShowWindow(bTabEnable); GetDlgItem(IDC_STATIC_UNIT_3)->ShowWindow(bTabEnable); GetDlgItem(IDC_STATIC_UNIT_4)->ShowWindow(bTabEnable); GetDlgItem(IDC_STATIC_UNIT_5)->ShowWindow(bTabEnable); GetDlgItem(IDC_STATIC_UNIT_6)->ShowWindow(bTabEnable); GetDlgItem(IDC_STATIC_UNIT_7)->ShowWindow(bTabEnable); GetDlgItem(IDC_STATIC_UNIT_8)->ShowWindow(bTabEnable); GetDlgItem(IDC_STATIC_UNIT_9)->ShowWindow(bTabEnable); GetDlgItem(IDC_STATIC_UNIT_10)->ShowWindow(bTabEnable); GetDlgItem(IDC_STATIC_UNIT_11)->ShowWindow(bTabEnable); GetDlgItem(IDC_STATIC_UNIT_12)->ShowWindow(bTabEnable);

GetDlgItem(IDC_STATIC_1)->ShowWindow(bTabEnable); GetDlgItem(IDC_STATIC_2)->ShowWindow(bTabEnable); GetDlgItem(IDC_STATIC_3)->ShowWindow(bTabEnable); GetDlgItem(IDC_STATIC_4)->ShowWindow(bTabEnable); GetDlgItem(IDC_STATIC_5)->ShowWindow(bTabEnable); GetDlgItem(IDC_STATIC_6)->ShowWindow(bTabEnable); GetDlgItem(IDC_STATIC_7)->ShowWindow(bTabEnable); GetDlgItem(IDC_STATIC_8)->ShowWindow(bTabEnable); GetDlgItem(IDC_STATIC_9)->ShowWindow(bTabEnable); GetDlgItem(IDC_STATIC_10)->ShowWindow(bTabEnable); GetDlgItem(IDC_STATIC_11)->ShowWindow(bTabEnable); GetDlgItem(IDC_STATIC_12)->ShowWindow(bTabEnable);

GetDlgItem(IDC_CHECK1)->ShowWindow(bTabEnable); GetDlgItem(IDC_CHECK2)->ShowWindow(bTabEnable); GetDlgItem(IDC_CHECK3)->ShowWindow(bTabEnable); GetDlgItem(IDC_CHECK4)->ShowWindow(bTabEnable); GetDlgItem(IDC_CHECK5)->ShowWindow(bTabEnable); GetDlgItem(IDC_CHECK6)->ShowWindow(bTabEnable); GetDlgItem(IDC_CHECK7)->ShowWindow(bTabEnable); GetDlgItem(IDC_CHECK8)->ShowWindow(bTabEnable); GetDlgItem(IDC_CHECK9)->ShowWindow(bTabEnable); GetDlgItem(IDC_CHECK10)->ShowWindow(bTabEnable); GetDlgItem(IDC_CHECK11)->ShowWindow(bTabEnable); GetDlgItem(IDC_CHECK12)->ShowWindow(bTabEnable);

if(GetDlgItem(IDC_BUTTON_STOP)->IsWindowEnabled()) { GetDlgItem(IDC_STATIC_PROGRESS_REALTIME)->ShowWindow(bTabEnable); GetDlgItem(IDC_PROGRESS_REALTIME)->ShowWindow(bTabEnable); }

GetDlgItem(IDC_STATIC_MORE_PIDS)->ShowWindow(bTabEnable);

return S_OK;} // OnSelDlgRealtime

9

void COdbDefaultGraphic::DrawTabMonitor(CRect rect){ int iX = 400; int iY = rect.top + 100; int iWidth = rect.Width()-20-iX; int iHeight = rect.Height()-40;

// Report list GetDlgItem(IDC_FRAME_1)->MoveWindow(iX+30, iY-10, 180, 160, true); GetDlgItem(IDC_FRAME_2)->MoveWindow(iX+230, iY-10, 180, 310, true);//Edit boxes column 1 GetDlgItem(IDC_EDIT_1)->SetWindowPos(NULL, iX+140, iY+35, 60,20 , SWP_DRAWFRAME); GetDlgItem(IDC_EDIT_2)->SetWindowPos(NULL, iX+140, iY+35*2, 60,20 , SWP_DRAWFRAME); GetDlgItem(IDC_EDIT_3)->SetWindowPos(NULL, iX+140, iY+35*3, 60,20 , SWP_DRAWFRAME); //Statics column 1 GetDlgItem(IDC_STATIC_1)->SetWindowPos(NULL, iX+50, iY+35+3, 80,30 , SWP_DRAWFRAME); GetDlgItem(IDC_STATIC_2)->SetWindowPos(NULL, iX+50, iY+35*2+3, 80,30 , SWP_DRAWFRAME); GetDlgItem(IDC_STATIC_3)->SetWindowPos(NULL, iX+50, iY+35*3, 80,30 , SWP_DRAWFRAME);

//Edit boxes column 2iX+=330; GetDlgItem(IDC_EDIT_4)->SetWindowPos(NULL, iX, iY+35*1, 60,20 , SWP_DRAWFRAME); GetDlgItem(IDC_EDIT_5)->SetWindowPos(NULL, iX, iY+35*2, 60,20 , SWP_DRAWFRAME); GetDlgItem(IDC_EDIT_6)->SetWindowPos(NULL, iX, iY+35*3, 60,20 , SWP_DRAWFRAME); GetDlgItem(IDC_EDIT_7)->SetWindowPos(NULL, iX, iY+35*4, 60,20 , SWP_DRAWFRAME); GetDlgItem(IDC_EDIT_8)->SetWindowPos(NULL, iX, iY+35*5, 60,20 , SWP_DRAWFRAME); GetDlgItem(IDC_EDIT_9)->SetWindowPos(NULL, iX, iY+35*6, 60,20 , SWP_DRAWFRAME); GetDlgItem(IDC_EDIT_10)->SetWindowPos(NULL, iX, iY+35*7, 60,20 , SWP_DRAWFRAME); GetDlgItem(IDC_EDIT_11)->SetWindowPos(NULL, iX, iY+35*8, 60,20 , SWP_DRAWFRAME); GetDlgItem(IDC_EDIT_12)->SetWindowPos(NULL, iX, iY+35*9, 60,20 , SWP_DRAWFRAME);

iX-=80;//Statics column 2

GetDlgItem(IDC_STATIC_4)->SetWindowPos(NULL, iX, iY+35*1+3, 80,30 , SWP_DRAWFRAME); GetDlgItem(IDC_STATIC_5)->SetWindowPos(NULL, iX, iY+35*2, 80,30 , SWP_DRAWFRAME); GetDlgItem(IDC_STATIC_6)->SetWindowPos(NULL, iX, iY+35*3+3, 80,30 , SWP_DRAWFRAME); GetDlgItem(IDC_STATIC_7)->SetWindowPos(NULL, iX, iY+35*4+3, 80,30 , SWP_DRAWFRAME); GetDlgItem(IDC_STATIC_8)->SetWindowPos(NULL, iX, iY+35*5+3, 80,30 , SWP_DRAWFRAME); GetDlgItem(IDC_STATIC_9)->SetWindowPos(NULL, iX, iY+35*6+3, 80,30 , SWP_DRAWFRAME); GetDlgItem(IDC_STATIC_10)->SetWindowPos(NULL,iX, iY+35*7, 80,30 , SWP_DRAWFRAME); GetDlgItem(IDC_STATIC_11)->SetWindowPos(NULL,iX, iY+35*8, 80,30 , SWP_DRAWFRAME); GetDlgItem(IDC_STATIC_12)->SetWindowPos(NULL,iX, iY+35*9, 80,30 , SWP_DRAWFRAME); return;}

HRESULT COdbDefaultGraphic::OnSelDlgMonitor(BOOL bTabEnable) { if (bTabEnable) { // Disable the other tab OnSelDlgTroubleCode(false); OnSelDlgFreeze(false); OnSelDlgVehicle(false); OnSelDlgRealtime(false); OnSelDlgOxygenSensors(false);

m_nMode = 4; CRect rect;

10

GetClientRect(m_hGuiWnd, rect); Draw(rect); CTreeCtrl *pCtrl = (CTreeCtrl*) GetDlgItem(IDC_TREE_FILES); pCtrl->DeleteAllItems(); }

GetDlgItem(IDC_STATIC_1)->SetWindowText("Misständning:"); GetDlgItem(IDC_STATIC_2)->SetWindowText("Bränslesystem:"); GetDlgItem(IDC_STATIC_3)->SetWindowText("Särskilda komponenter:"); GetDlgItem(IDC_STATIC_4)->SetWindowText("Katalysator: "); GetDlgItem(IDC_STATIC_5)->SetWindowText("Upphettad Katalysator: "); GetDlgItem(IDC_STATIC_6)->SetWindowText("Avdunst.system: "); GetDlgItem(IDC_STATIC_7)->SetWindowText("Luftsystem 2: "); GetDlgItem(IDC_STATIC_8)->SetWindowText("A/C kylning:"); GetDlgItem(IDC_STATIC_9)->SetWindowText("Syresensor:"); GetDlgItem(IDC_STATIC_10)->SetWindowText("Syresensor uppvärmare:");

GetDlgItem(IDC_FRAME_1)->SetWindowText("Kontinuerliga självtester"); GetDlgItem(IDC_FRAME_2)->SetWindowText("Icke kontinuerliga självtester");


GetDlgItem(IDC_EDIT_1)->ShowWindow(bTabEnable); GetDlgItem(IDC_EDIT_2)->ShowWindow(bTabEnable); GetDlgItem(IDC_EDIT_3)->ShowWindow(bTabEnable); GetDlgItem(IDC_EDIT_4)->ShowWindow(bTabEnable); GetDlgItem(IDC_EDIT_5)->ShowWindow(bTabEnable); GetDlgItem(IDC_EDIT_6)->ShowWindow(bTabEnable); GetDlgItem(IDC_EDIT_7)->ShowWindow(bTabEnable); GetDlgItem(IDC_EDIT_8)->ShowWindow(bTabEnable); GetDlgItem(IDC_EDIT_9)->ShowWindow(bTabEnable); GetDlgItem(IDC_EDIT_10)->ShowWindow(bTabEnable);

GetDlgItem(IDC_STATIC_1)->ShowWindow(bTabEnable); GetDlgItem(IDC_STATIC_2)->ShowWindow(bTabEnable); GetDlgItem(IDC_STATIC_3)->ShowWindow(bTabEnable); GetDlgItem(IDC_STATIC_4)->ShowWindow(bTabEnable); GetDlgItem(IDC_STATIC_5)->ShowWindow(bTabEnable); GetDlgItem(IDC_STATIC_6)->ShowWindow(bTabEnable); GetDlgItem(IDC_STATIC_7)->ShowWindow(bTabEnable); GetDlgItem(IDC_STATIC_8)->ShowWindow(bTabEnable); GetDlgItem(IDC_STATIC_9)->ShowWindow(bTabEnable); GetDlgItem(IDC_STATIC_10)->ShowWindow(bTabEnable);

GetDlgItem(IDC_BUTTON_UPDATE)->ShowWindow(bTabEnable);

return S_OK;} // OnSelDlgRealtime

void COdbDefaultGraphic::DrawTabFreeze(CRect rect){ int iX = 400; int iY = rect.top + 100+50; int iWidth = rect.Width()-20-iX; int iHeight = rect.Height()-40;

GetDlgItem(IDC_FRAME_1)->MoveWindow(iX+30, iY-10, 180, 300, true); GetDlgItem(IDC_FRAME_2)->MoveWindow(iX+230, iY-10, 180, 300, true);

11

GetDlgItem(IDC_STATIC_ERASE)->MoveWindow(iX+230, iY+305, 180, 60,TRUE); GetDlgItem(IDC_BUTTON_ERASE)->MoveWindow(iX+270, iY+325, 100, 30,TRUE);

GetDlgItem(IDC_EDIT_1)->SetWindowPos(NULL, iX+140, iY+35-3, 30,20 , SWP_DRAWFRAME); GetDlgItem(IDC_EDIT_2)->SetWindowPos(NULL, iX+140, iY+35*2-3, 30,20 , SWP_DRAWFRAME); GetDlgItem(IDC_EDIT_3)->SetWindowPos(NULL, iX+140, iY+35*3-3, 30,20 , SWP_DRAWFRAME); GetDlgItem(IDC_EDIT_4)->SetWindowPos(NULL, iX+140, iY+35*4-3, 30,20 , SWP_DRAWFRAME); GetDlgItem(IDC_EDIT_6)->SetWindowPos(NULL, iX+140, iY+35*5-3, 30,20 , SWP_DRAWFRAME); GetDlgItem(IDC_EDIT_7)->SetWindowPos(NULL, iX+140, iY+35*6, 30,20 , SWP_DRAWFRAME); GetDlgItem(IDC_EDIT_8)->SetWindowPos(NULL, iX+140, iY+35*7-3, 30,20 , SWP_DRAWFRAME); GetDlgItem(IDC_STATIC_1)->SetWindowPos(NULL, iX+50, iY+35, 80,30 , SWP_DRAWFRAME); GetDlgItem(IDC_STATIC_2)->SetWindowPos(NULL, iX+50, iY+35*2, 80,30 , SWP_DRAWFRAME); GetDlgItem(IDC_STATIC_3)->SetWindowPos(NULL, iX+50, iY+35*3, 80,30 , SWP_DRAWFRAME); GetDlgItem(IDC_STATIC_4)->SetWindowPos(NULL, iX+50, iY+35*4, 80,30 , SWP_DRAWFRAME); GetDlgItem(IDC_STATIC_6)->SetWindowPos(NULL, iX+50, iY+35*5, 80,30 , SWP_DRAWFRAME); GetDlgItem(IDC_STATIC_7)->SetWindowPos(NULL, iX+50, iY+35*6, 80,30 , SWP_DRAWFRAME); GetDlgItem(IDC_STATIC_8)->SetWindowPos(NULL, iX+50, iY+35*7, 80,30 , SWP_DRAWFRAME);

GetDlgItem(IDC_STATIC_UNIT_1)->SetWindowPos(NULL, iX+175, iY+35, 30,30 , SWP_DRAWFRAME); GetDlgItem(IDC_STATIC_UNIT_2)->SetWindowPos(NULL, iX+175, iY+35*2, 20,30 , SWP_NOSIZE); GetDlgItem(IDC_STATIC_UNIT_3)->SetWindowPos(NULL, iX+175, iY+35*3, 20,30 , SWP_NOSIZE); GetDlgItem(IDC_STATIC_UNIT_4)->SetWindowPos(NULL, iX+175, iY+35*4, 20,30 , SWP_NOSIZE); GetDlgItem(IDC_STATIC_UNIT_6)->SetWindowPos(NULL, iX+175, iY+35*5, 30,20 , SWP_NOSIZE); GetDlgItem(IDC_STATIC_UNIT_7)->SetWindowPos(NULL, iX+175, iY+35*6+3, 30,20 , SWP_NOSIZE); GetDlgItem(IDC_STATIC_UNIT_8)->SetWindowPos(NULL, iX+175, iY+35*7, 30,20 , SWP_NOSIZE);

//New column Fuel System: GetDlgItem(IDC_EDIT_5)->SetWindowPos(NULL, iX+330, iY+35-3, 30,20 , SWP_DRAWFRAME); GetDlgItem(IDC_EDIT_9)->SetWindowPos(NULL, iX+330, iY+35*2+10, 70,20 , SWP_DRAWFRAME); GetDlgItem(IDC_EDIT_10)->SetWindowPos(NULL, iX+330, iY+35*3+20, 70,20 , SWP_DRAWFRAME); GetDlgItem(IDC_EDIT_11)->SetWindowPos(NULL, iX+330, iY+35*4+30, 30,20 , SWP_DRAWFRAME); GetDlgItem(IDC_EDIT_12)->SetWindowPos(NULL, iX+330, iY+35*5+40, 30,20 , SWP_DRAWFRAME); GetDlgItem(IDC_STATIC_5)->SetWindowPos(NULL, iX+300-40, iY+35, 80,30 , SWP_DRAWFRAME); GetDlgItem(IDC_STATIC_9)->SetWindowPos(NULL, iX+300-40, iY+35*2+10, 80,30 , SWP_DRAWFRAME); GetDlgItem(IDC_STATIC_10)->SetWindowPos(NULL, iX+300-40, iY+35*3+20, 80,30 , SWP_DRAWFRAME); GetDlgItem(IDC_STATIC_11)->SetWindowPos(NULL, iX+300-40, iY+35*4+30, 80,30 , SWP_DRAWFRAME); GetDlgItem(IDC_STATIC_12)->SetWindowPos(NULL, iX+300-40, iY+35*5+40, 80,30 , SWP_DRAWFRAME);

GetDlgItem(IDC_STATIC_UNIT_5)->SetWindowPos(NULL, iX+365, iY+35, 20,30 , SWP_NOSIZE); GetDlgItem(IDC_STATIC_UNIT_9)->SetWindowPos(NULL, iX+365, iY+35*2+10, 20,30 , SWP_NOSIZE); GetDlgItem(IDC_STATIC_UNIT_10)->SetWindowPos(NULL, iX+365, iY+35*3+20, 20,30 , SWP_NOSIZE); GetDlgItem(IDC_STATIC_UNIT_11)->SetWindowPos(NULL, iX+365, iY+35*4+30+3, 20,30 , SWP_NOSIZE); GetDlgItem(IDC_STATIC_UNIT_12)->SetWindowPos(NULL, iX+365, iY+35*5+40+3, 30,20 , SWP_NOSIZE);

GetDlgItem(IDC_STATIC_UNIT_1)->SetWindowText("km/h"); GetDlgItem(IDC_STATIC_UNIT_2)->SetWindowText("vpm"); GetDlgItem(IDC_STATIC_UNIT_3)->SetWindowText("%"); GetDlgItem(IDC_STATIC_UNIT_4)->SetWindowText("°C"); GetDlgItem(IDC_STATIC_UNIT_5)->SetWindowText("kPa"); GetDlgItem(IDC_STATIC_UNIT_6)->SetWindowText("%"); GetDlgItem(IDC_STATIC_UNIT_7)->SetWindowText("kPa"); GetDlgItem(IDC_STATIC_UNIT_8)->SetWindowText("°C"); GetDlgItem(IDC_STATIC_UNIT_9)->SetWindowText(" "); GetDlgItem(IDC_STATIC_UNIT_10)->SetWindowText(" "); GetDlgItem(IDC_STATIC_UNIT_11)->SetWindowText("%"); GetDlgItem(IDC_STATIC_UNIT_12)->SetWindowText("%");

return;}

HRESULT COdbDefaultGraphic::OnSelDlgFreeze(BOOL bTabEnable) {

12

if (bTabEnable) { // Disable the other tabs OnSelDlgTroubleCode(false); OnSelDlgRealtime(false); OnSelDlgVehicle(false); OnSelDlgMonitor(false); OnSelDlgOxygenSensors(false); m_nMode = 2; CRect rect; GetClientRect(m_hGuiWnd, rect); Draw(rect); CTreeCtrl *pCtrl = (CTreeCtrl*) GetDlgItem(IDC_TREE_FILES); pCtrl->DeleteAllItems(); }

GetDlgItem(IDC_STATIC_1)->SetWindowText("Hastighet:"); GetDlgItem(IDC_STATIC_2)->SetWindowText("Varvtal:"); GetDlgItem(IDC_STATIC_3)->SetWindowText("Motorlast:"); GetDlgItem(IDC_STATIC_4)->SetWindowText("Temp Kylare:"); GetDlgItem(IDC_STATIC_5)->SetWindowText("Bränsletryck:"); GetDlgItem(IDC_STATIC_6)->SetWindowText("Gaspedalsläge:"); GetDlgItem(IDC_STATIC_7)->SetWindowText("Tryck insugningsrör:"); GetDlgItem(IDC_STATIC_8)->SetWindowText("Temp Insug:"); GetDlgItem(IDC_STATIC_9)->SetWindowText("Status System 1:"); GetDlgItem(IDC_STATIC_10)->SetWindowText("Status System 2:"); GetDlgItem(IDC_STATIC_11)->SetWindowText("Kortsiktig bränsletrim:"); GetDlgItem(IDC_STATIC_12)->SetWindowText("Långsiktig bränsletrim:");

GetDlgItem(IDC_FRAME_1)->SetWindowText("Generella parametrar"); GetDlgItem(IDC_FRAME_2)->SetWindowText("Bränslesystem");

GetDlgItem(IDC_FRAME_1)->ShowWindow(bTabEnable); GetDlgItem(IDC_FRAME_2)->ShowWindow(bTabEnable); GetDlgItem(IDC_EDIT_1)->ShowWindow(bTabEnable); GetDlgItem(IDC_EDIT_2)->ShowWindow(bTabEnable); GetDlgItem(IDC_EDIT_3)->ShowWindow(bTabEnable); GetDlgItem(IDC_EDIT_4)->ShowWindow(bTabEnable); GetDlgItem(IDC_EDIT_5)->ShowWindow(bTabEnable); GetDlgItem(IDC_EDIT_6)->ShowWindow(bTabEnable); GetDlgItem(IDC_EDIT_7)->ShowWindow(bTabEnable); GetDlgItem(IDC_EDIT_8)->ShowWindow(bTabEnable); GetDlgItem(IDC_EDIT_9)->ShowWindow(bTabEnable); GetDlgItem(IDC_EDIT_10)->ShowWindow(bTabEnable); GetDlgItem(IDC_EDIT_11)->ShowWindow(bTabEnable); GetDlgItem(IDC_EDIT_12)->ShowWindow(bTabEnable);


GetDlgItem(IDC_STATIC_UNIT_1)->ShowWindow(bTabEnable); GetDlgItem(IDC_STATIC_UNIT_2)->ShowWindow(bTabEnable); GetDlgItem(IDC_STATIC_UNIT_3)->ShowWindow(bTabEnable); GetDlgItem(IDC_STATIC_UNIT_4)->ShowWindow(bTabEnable); GetDlgItem(IDC_STATIC_UNIT_5)->ShowWindow(bTabEnable); GetDlgItem(IDC_STATIC_UNIT_6)->ShowWindow(bTabEnable); GetDlgItem(IDC_STATIC_UNIT_7)->ShowWindow(bTabEnable); GetDlgItem(IDC_STATIC_UNIT_8)->ShowWindow(bTabEnable); GetDlgItem(IDC_STATIC_UNIT_9)->ShowWindow(bTabEnable); GetDlgItem(IDC_STATIC_UNIT_10)->ShowWindow(bTabEnable); GetDlgItem(IDC_STATIC_UNIT_11)->ShowWindow(bTabEnable); GetDlgItem(IDC_STATIC_UNIT_12)->ShowWindow(bTabEnable);

GetDlgItem(IDC_STATIC_FELKODEN)->ShowWindow(bTabEnable); GetDlgItem(IDC_EDIT_FAULTCODE)->ShowWindow(bTabEnable);

13

GetDlgItem(IDC_STATIC_ERASE)->ShowWindow(bTabEnable); GetDlgItem(IDC_BUTTON_ERASE)->ShowWindow(bTabEnable);

return S_OK;} // OnSelDlgFreeze

void COdbDefaultGraphic::DrawTabVehicle(CRect rect){ int iX = 385; int iY = rect.top + 100; int iWidth = rect.Width()-20-iX; int iHeight = rect.Height()-40;

GetDlgItem(IDC_FRAME_1)->MoveWindow(iX+35, iY-10, 400, 350, true);

GetDlgItem(IDC_EDIT_1)->SetWindowPos(NULL, iX+140, iY+40, 80,20 , SWP_DRAWFRAME); GetDlgItem(IDC_EDIT_2)->SetWindowPos(NULL, iX+140, iY+40*2, 80,20 , SWP_DRAWFRAME); GetDlgItem(IDC_EDIT_3)->SetWindowPos(NULL, iX+140, iY+40*3, 110,20 , SWP_DRAWFRAME); GetDlgItem(IDC_EDIT_4)->SetWindowPos(NULL, iX+140, iY+40*4, 40,20 , SWP_DRAWFRAME); GetDlgItem(IDC_EDIT_9)->SetWindowPos(NULL, iX+140, iY+40*5, 20,20 , SWP_DRAWFRAME); GetDlgItem(IDC_EDIT_5)->SetWindowPos(NULL, iX+140, iY+40*7, 210,20 , SWP_DRAWFRAME); GetDlgItem(IDC_EDIT_6)->SetWindowPos(NULL, iX+140, iY+40*6, 60,20 , SWP_DRAWFRAME);

GetDlgItem(IDC_STATIC_1)->SetWindowPos(NULL, iX+50, iY+40, 80,30 , SWP_DRAWFRAME); GetDlgItem(IDC_STATIC_2)->SetWindowPos(NULL, iX+50, iY+40*2+3, 80,30 , SWP_DRAWFRAME); GetDlgItem(IDC_STATIC_3)->SetWindowPos(NULL, iX+50, iY+40*3+3, 80,30 , SWP_DRAWFRAME); GetDlgItem(IDC_STATIC_4)->SetWindowPos(NULL, iX+50, iY+40*4+3, 80,30 , SWP_DRAWFRAME); GetDlgItem(IDC_STATIC_9)->SetWindowPos(NULL, iX+50, iY+40*5+3, 80,30 , SWP_DRAWFRAME); GetDlgItem(IDC_STATIC_5)->SetWindowPos(NULL, iX+50, iY+40*7+3, 80,30 , SWP_DRAWFRAME); GetDlgItem(IDC_STATIC_6)->SetWindowPos(NULL, iX+50, iY+40*6+3, 80,30 , SWP_DRAWFRAME);//Next column... GetDlgItem(IDC_EDIT_7)->SetWindowPos(NULL, iX+140+180, iY+40, 105,20 , SWP_DRAWFRAME); GetDlgItem(IDC_EDIT_8)->SetWindowPos(NULL, iX+140+180, iY+40*2, 80,20 , SWP_DRAWFRAME); GetDlgItem(IDC_EDIT_10)->SetWindowPos(NULL, iX+140+180, iY+40*4, 40,20 , SWP_DRAWFRAME); GetDlgItem(IDC_EDIT_11)->SetWindowPos(NULL, iX+140+180, iY+40*5, 80,20 , SWP_DRAWFRAME); GetDlgItem(IDC_EDIT_12)->SetWindowPos(NULL, iX+140+180, iY+40*6, 55,20 , SWP_DRAWFRAME);

GetDlgItem(IDC_STATIC_7)->SetWindowPos(NULL, iX+70+180-5, iY+40+3, 80,30 , SWP_DRAWFRAME); GetDlgItem(IDC_STATIC_8)->SetWindowPos(NULL, iX+70+180-5, iY+40*2+3, 80,30 , SWP_DRAWFRAME); GetDlgItem(IDC_STATIC_10)->SetWindowPos(NULL, iX+70+180-5, iY+40*4+3, 80,30 , SWP_DRAWFRAME); GetDlgItem(IDC_STATIC_11)->SetWindowPos(NULL, iX+70+180-5, iY+40*5+3, 80,30 , SWP_DRAWFRAME); GetDlgItem(IDC_STATIC_12)->SetWindowPos(NULL, iX+70+180-5, iY+40*6+3, 80,30 , SWP_DRAWFRAME);

return;

}

HRESULT COdbDefaultGraphic::OnSelDlgVehicle(BOOL bTabEnable) { if (bTabEnable) { // Disable the other tabs OnSelDlgTroubleCode(false); OnSelDlgRealtime(false); OnSelDlgFreeze(false); OnSelDlgMonitor(false); OnSelDlgOxygenSensors(false); m_nMode = 3; CRect rect; GetClientRect(m_hGuiWnd, rect); Draw(rect); CTreeCtrl *pCtrl = (CTreeCtrl*) GetDlgItem(IDC_TREE_FILES); pCtrl->DeleteAllItems(); } GetDlgItem(IDC_FRAME_1)->SetWindowText("Information om det aktuella fordonet"); GetDlgItem(IDC_FRAME_1)->ShowWindow(bTabEnable);

14

GetDlgItem(IDC_STATIC_1)->SetWindowText("Geografiskt Område:"); GetDlgItem(IDC_STATIC_2)->SetWindowText("Land:"); GetDlgItem(IDC_STATIC_3)->SetWindowText("Biltillverkare:"); GetDlgItem(IDC_STATIC_4)->SetWindowText("Produktlinje:"); GetDlgItem(IDC_STATIC_5)->SetWindowText("Modellserie:"); GetDlgItem(IDC_STATIC_6)->SetWindowText("Karossutförande:"); GetDlgItem(IDC_STATIC_7)->SetWindowText("Växellåda:"); GetDlgItem(IDC_STATIC_8)->SetWindowText("Motorvariant:"); GetDlgItem(IDC_STATIC_9)->SetWindowText("Kontrollsiffra:"); GetDlgItem(IDC_STATIC_10)->SetWindowText("Årsmodell:"); GetDlgItem(IDC_STATIC_11)->SetWindowText("Produktionsort:"); GetDlgItem(IDC_STATIC_12)->SetWindowText("Tillverkningsnr:");

GetDlgItem(IDC_EDIT_1)->ShowWindow(bTabEnable); GetDlgItem(IDC_EDIT_2)->ShowWindow(bTabEnable); GetDlgItem(IDC_EDIT_3)->ShowWindow(bTabEnable); GetDlgItem(IDC_EDIT_4)->ShowWindow(bTabEnable); GetDlgItem(IDC_EDIT_5)->ShowWindow(bTabEnable); GetDlgItem(IDC_EDIT_6)->ShowWindow(bTabEnable); GetDlgItem(IDC_EDIT_7)->ShowWindow(bTabEnable); GetDlgItem(IDC_EDIT_8)->ShowWindow(bTabEnable); GetDlgItem(IDC_EDIT_9)->ShowWindow(bTabEnable); GetDlgItem(IDC_EDIT_10)->ShowWindow(bTabEnable); GetDlgItem(IDC_EDIT_11)->ShowWindow(bTabEnable); GetDlgItem(IDC_EDIT_12)->ShowWindow(bTabEnable);


return S_OK;} // OnSelDlgVehicle

void COdbDefaultGraphic::DrawTabOxygenSensors(CRect rect){ int iX = 385; int iY = rect.top + 100; int iWidth = rect.Width()-20-iX; int iHeight = rect.Height()-40;

GetDlgItem(IDC_FRAME_1)->MoveWindow(iX+40, iY-10, 190, 350, true); GetDlgItem(IDC_FRAME_2)->MoveWindow(iX+240, iY-10, 190, 350, true);

GetDlgItem(IDC_EDIT_1)->SetWindowPos(NULL, iX+140, iY+40, 50,20 , SWP_DRAWFRAME); GetDlgItem(IDC_EDIT_2)->SetWindowPos(NULL, iX+140, iY+40+20, 50,20 , SWP_DRAWFRAME);

GetDlgItem(IDC_EDIT_3)->SetWindowPos(NULL, iX+140, iY+40*3, 50,20 , SWP_DRAWFRAME); GetDlgItem(IDC_EDIT_4)->SetWindowPos(NULL, iX+140, iY+40*3+20, 50,20 , SWP_DRAWFRAME);



GetDlgItem(IDC_STATIC_1)->SetWindowPos(NULL, iX+55, iY+40+3, 80,20 , SWP_DRAWFRAME); GetDlgItem(IDC_STATIC_2)->SetWindowPos(NULL, iX+55, iY+40+3+20, 80,20 , SWP_DRAWFRAME); GetDlgItem(IDC_STATIC_3)->SetWindowPos(NULL, iX+55, iY+40*3+3, 80,20 , SWP_DRAWFRAME); GetDlgItem(IDC_STATIC_4)->SetWindowPos(NULL, iX+55, iY+40*3+20+3, 80,20 , SWP_DRAWFRAME); GetDlgItem(IDC_STATIC_5)->SetWindowPos(NULL, iX+55, iY+40*5+3, 80,20 , SWP_DRAWFRAME); GetDlgItem(IDC_STATIC_6)->SetWindowPos(NULL, iX+55, iY+40*5+20+3, 80,20 , SWP_DRAWFRAME);

15

GetDlgItem(IDC_STATIC_7)->SetWindowPos(NULL, iX+55, iY+40*7+3, 80,20 , SWP_DRAWFRAME); GetDlgItem(IDC_STATIC_8)->SetWindowPos(NULL, iX+55, iY+40*7+20+3, 80,20 , SWP_DRAWFRAME); GetDlgItem(IDC_STATIC_UNIT_1)->SetWindowPos(NULL, iX+200, iY+40+3, 20,20 , SWP_DRAWFRAME); GetDlgItem(IDC_STATIC_UNIT_2)->SetWindowPos(NULL, iX+200, iY+40+20+3, 20,20 , SWP_DRAWFRAME); GetDlgItem(IDC_STATIC_UNIT_3)->SetWindowPos(NULL, iX+200, iY+40*3+3, 20,20 , SWP_DRAWFRAME); GetDlgItem(IDC_STATIC_UNIT_4)->SetWindowPos(NULL, iX+200, iY+40*3+20+3, 20,20 , SWP_DRAWFRAME); GetDlgItem(IDC_STATIC_UNIT_5)->SetWindowPos(NULL, iX+200, iY+40*5+3, 20,20 , SWP_DRAWFRAME); GetDlgItem(IDC_STATIC_UNIT_6)->SetWindowPos(NULL, iX+200, iY+40*5+20+3, 20,20 , SWP_DRAWFRAME); GetDlgItem(IDC_STATIC_UNIT_7)->SetWindowPos(NULL, iX+200, iY+40*7+3, 20,20 , SWP_DRAWFRAME); GetDlgItem(IDC_STATIC_UNIT_8)->SetWindowPos(NULL, iX+200, iY+40*7+20+3, 20,20 , SWP_DRAWFRAME);

iX = 400;//Next column... GetDlgItem(IDC_EDIT_9)->SetWindowPos(NULL, iX+140+180, iY+40, 50,20 , SWP_DRAWFRAME); GetDlgItem(IDC_EDIT_10)->SetWindowPos(NULL, iX+140+180, iY+40+20, 50,20 , SWP_DRAWFRAME);

GetDlgItem(IDC_EDIT_11)->SetWindowPos(NULL, iX+140+180, iY+40*3, 50,20 , SWP_DRAWFRAME); GetDlgItem(IDC_EDIT_12)->SetWindowPos(NULL, iX+140+180, iY+40*3+20, 50,20 , SWP_DRAWFRAME);



GetDlgItem(IDC_STATIC_9)->SetWindowPos(NULL, iX+70+165, iY+40+3, 80,20 , SWP_DRAWFRAME); GetDlgItem(IDC_STATIC_10)->SetWindowPos(NULL, iX+70+165, iY+40+20+3, 80,20 , SWP_DRAWFRAME); GetDlgItem(IDC_STATIC_11)->SetWindowPos(NULL, iX+70+165, iY+40*3+3, 80,20 , SWP_DRAWFRAME); GetDlgItem(IDC_STATIC_12)->SetWindowPos(NULL, iX+70+165, iY+40*3+20+3, 80,20 , SWP_DRAWFRAME); GetDlgItem(IDC_STATIC_13)->SetWindowPos(NULL, iX+70+165, iY+40*5+3, 80,20 , SWP_DRAWFRAME); GetDlgItem(IDC_STATIC_14)->SetWindowPos(NULL, iX+70+165, iY+40*5+20+3, 80,20 , SWP_DRAWFRAME); GetDlgItem(IDC_STATIC_15)->SetWindowPos(NULL, iX+70+165, iY+40*7+3, 80,20 , SWP_DRAWFRAME); GetDlgItem(IDC_STATIC_16)->SetWindowPos(NULL, iX+70+165, iY+40*7+20+3, 80,20 , SWP_DRAWFRAME);

GetDlgItem(IDC_STATIC_UNIT_9)->SetWindowPos(NULL, iX+380, iY+40+3, 20,20 , SWP_DRAWFRAME); GetDlgItem(IDC_STATIC_UNIT_10)->SetWindowPos(NULL, iX+380, iY+40+20+3, 20,20 , SWP_DRAWFRAME); GetDlgItem(IDC_STATIC_UNIT_11)->SetWindowPos(NULL, iX+380, iY+40*3+3, 20,20 , SWP_DRAWFRAME); GetDlgItem(IDC_STATIC_UNIT_12)->SetWindowPos(NULL, iX+380, iY+40*3+20+3, 20,20 , SWP_DRAWFRAME); GetDlgItem(IDC_STATIC_UNIT_13)->SetWindowPos(NULL, iX+380, iY+40*5+3, 20,20 , SWP_DRAWFRAME); GetDlgItem(IDC_STATIC_UNIT_14)->SetWindowPos(NULL, iX+380, iY+40*5+20+3, 20,20 , SWP_DRAWFRAME); GetDlgItem(IDC_STATIC_UNIT_15)->SetWindowPos(NULL, iX+380, iY+40*7+3, 20,20 , SWP_DRAWFRAME); GetDlgItem(IDC_STATIC_UNIT_16)->SetWindowPos(NULL, iX+380, iY+40*7+20+3, 20,20 , SWP_DRAWFRAME); //BANK 1 GetDlgItem(IDC_STATIC_SENSOR_BANK1_NR1)->SetWindowPos(NULL, iX+95, iY+20, 80,20 , SWP_DRAWFRAME); GetDlgItem(IDC_STATIC_SENSOR_BANK1_NR2)->SetWindowPos(NULL, iX+95, iY+20+40*2, 80,20 , SWP_DRAWFRAME); GetDlgItem(IDC_STATIC_SENSOR_BANK1_NR3)->SetWindowPos(NULL, iX+95, iY+20+40*4, 80,20 , SWP_DRAWFRAME); GetDlgItem(IDC_STATIC_SENSOR_BANK1_NR4)->SetWindowPos(NULL, iX+95, iY+20+40*6, 80,20 , SWP_DRAWFRAME); //BANK 2

16

GetDlgItem(IDC_STATIC_SENSOR_BANK2_NR1)->SetWindowPos(NULL, iX+95+195, iY+20, 80,20 , SWP_DRAWFRAME); GetDlgItem(IDC_STATIC_SENSOR_BANK2_NR2)->SetWindowPos(NULL, iX+95+195, iY+20+40*2, 80,20 , SWP_DRAWFRAME); GetDlgItem(IDC_STATIC_SENSOR_BANK2_NR3)->SetWindowPos(NULL, iX+95+195, iY+20+40*4, 80,20 , SWP_DRAWFRAME); GetDlgItem(IDC_STATIC_SENSOR_BANK2_NR4)->SetWindowPos(NULL, iX+95+195, iY+20+40*6, 80,20 , SWP_DRAWFRAME); return;

}

HRESULT COdbDefaultGraphic::OnSelDlgOxygenSensors(BOOL bTabEnable) { if (bTabEnable) { // Disable the other tabs OnSelDlgTroubleCode(false); OnSelDlgRealtime(false); OnSelDlgFreeze(false); OnSelDlgMonitor(false); m_nMode = 5; CRect rect; GetClientRect(m_hGuiWnd, rect); Draw(rect); CTreeCtrl *pCtrl = (CTreeCtrl*) GetDlgItem(IDC_TREE_FILES); pCtrl->DeleteAllItems(); } GetDlgItem(IDC_FRAME_1)->SetWindowText("Syresensorer Bank 1"); GetDlgItem(IDC_FRAME_2)->SetWindowText("Syresensorer Bank 2");

GetDlgItem(IDC_STATIC_1)->SetWindowText("Spänning:"); GetDlgItem(IDC_STATIC_2)->SetWindowText("Korts.Bränsletrim:"); GetDlgItem(IDC_STATIC_3)->SetWindowText("Spänning:"); GetDlgItem(IDC_STATIC_4)->SetWindowText("Korts.Bränsletrim:"); GetDlgItem(IDC_STATIC_5)->SetWindowText("Spänning:"); GetDlgItem(IDC_STATIC_6)->SetWindowText("Korts.Bränsletrim:"); GetDlgItem(IDC_STATIC_7)->SetWindowText("Spänning:"); GetDlgItem(IDC_STATIC_8)->SetWindowText("Korts.Bränsletrim:"); GetDlgItem(IDC_STATIC_9)->SetWindowText("Spänning:"); GetDlgItem(IDC_STATIC_10)->SetWindowText("Korts.Bränsletrim:"); GetDlgItem(IDC_STATIC_11)->SetWindowText("Spänning:"); GetDlgItem(IDC_STATIC_12)->SetWindowText("Korts.Bränsletrim:"); GetDlgItem(IDC_STATIC_13)->SetWindowText("Spänning:"); GetDlgItem(IDC_STATIC_14)->SetWindowText("Korts.Bränsletrim:"); GetDlgItem(IDC_STATIC_15)->SetWindowText("Spänning:"); GetDlgItem(IDC_STATIC_16)->SetWindowText("Korts.Bränsletrim:");

GetDlgItem(IDC_STATIC_UNIT_1)->SetWindowText("V"); GetDlgItem(IDC_STATIC_UNIT_2)->SetWindowText("%"); GetDlgItem(IDC_STATIC_UNIT_3)->SetWindowText("V"); GetDlgItem(IDC_STATIC_UNIT_4)->SetWindowText("%"); GetDlgItem(IDC_STATIC_UNIT_5)->SetWindowText("V"); GetDlgItem(IDC_STATIC_UNIT_6)->SetWindowText("%"); GetDlgItem(IDC_STATIC_UNIT_7)->SetWindowText("V"); GetDlgItem(IDC_STATIC_UNIT_8)->SetWindowText("%"); GetDlgItem(IDC_STATIC_UNIT_9)->SetWindowText("V"); GetDlgItem(IDC_STATIC_UNIT_10)->SetWindowText("%"); GetDlgItem(IDC_STATIC_UNIT_11)->SetWindowText("V"); GetDlgItem(IDC_STATIC_UNIT_12)->SetWindowText("%"); GetDlgItem(IDC_STATIC_UNIT_13)->SetWindowText("V"); GetDlgItem(IDC_STATIC_UNIT_14)->SetWindowText("%"); GetDlgItem(IDC_STATIC_UNIT_15)->SetWindowText("V"); GetDlgItem(IDC_STATIC_UNIT_16)->SetWindowText("%");


GetDlgItem(IDC_EDIT_1)->ShowWindow(bTabEnable);

17

GetDlgItem(IDC_EDIT_2)->ShowWindow(bTabEnable); GetDlgItem(IDC_EDIT_3)->ShowWindow(bTabEnable); GetDlgItem(IDC_EDIT_4)->ShowWindow(bTabEnable); GetDlgItem(IDC_EDIT_5)->ShowWindow(bTabEnable); GetDlgItem(IDC_EDIT_6)->ShowWindow(bTabEnable); GetDlgItem(IDC_EDIT_7)->ShowWindow(bTabEnable); GetDlgItem(IDC_EDIT_8)->ShowWindow(bTabEnable); GetDlgItem(IDC_EDIT_9)->ShowWindow(bTabEnable); GetDlgItem(IDC_EDIT_10)->ShowWindow(bTabEnable); GetDlgItem(IDC_EDIT_11)->ShowWindow(bTabEnable); GetDlgItem(IDC_EDIT_12)->ShowWindow(bTabEnable); GetDlgItem(IDC_EDIT_13)->ShowWindow(bTabEnable); GetDlgItem(IDC_EDIT_14)->ShowWindow(bTabEnable); GetDlgItem(IDC_EDIT_15)->ShowWindow(bTabEnable); GetDlgItem(IDC_EDIT_16)->ShowWindow(bTabEnable);

GetDlgItem(IDC_STATIC_1)->ShowWindow(bTabEnable); GetDlgItem(IDC_STATIC_2)->ShowWindow(bTabEnable); GetDlgItem(IDC_STATIC_3)->ShowWindow(bTabEnable); GetDlgItem(IDC_STATIC_4)->ShowWindow(bTabEnable); GetDlgItem(IDC_STATIC_5)->ShowWindow(bTabEnable); GetDlgItem(IDC_STATIC_6)->ShowWindow(bTabEnable); GetDlgItem(IDC_STATIC_7)->ShowWindow(bTabEnable); GetDlgItem(IDC_STATIC_8)->ShowWindow(bTabEnable); GetDlgItem(IDC_STATIC_9)->ShowWindow(bTabEnable); GetDlgItem(IDC_STATIC_10)->ShowWindow(bTabEnable); GetDlgItem(IDC_STATIC_11)->ShowWindow(bTabEnable); GetDlgItem(IDC_STATIC_12)->ShowWindow(bTabEnable); GetDlgItem(IDC_STATIC_13)->ShowWindow(bTabEnable); GetDlgItem(IDC_STATIC_14)->ShowWindow(bTabEnable); GetDlgItem(IDC_STATIC_15)->ShowWindow(bTabEnable); GetDlgItem(IDC_STATIC_16)->ShowWindow(bTabEnable);

GetDlgItem(IDC_STATIC_UNIT_1)->ShowWindow(bTabEnable); GetDlgItem(IDC_STATIC_UNIT_2)->ShowWindow(bTabEnable); GetDlgItem(IDC_STATIC_UNIT_3)->ShowWindow(bTabEnable); GetDlgItem(IDC_STATIC_UNIT_4)->ShowWindow(bTabEnable); GetDlgItem(IDC_STATIC_UNIT_5)->ShowWindow(bTabEnable); GetDlgItem(IDC_STATIC_UNIT_6)->ShowWindow(bTabEnable); GetDlgItem(IDC_STATIC_UNIT_7)->ShowWindow(bTabEnable); GetDlgItem(IDC_STATIC_UNIT_8)->ShowWindow(bTabEnable); GetDlgItem(IDC_STATIC_UNIT_9)->ShowWindow(bTabEnable); GetDlgItem(IDC_STATIC_UNIT_10)->ShowWindow(bTabEnable); GetDlgItem(IDC_STATIC_UNIT_11)->ShowWindow(bTabEnable); GetDlgItem(IDC_STATIC_UNIT_12)->ShowWindow(bTabEnable); GetDlgItem(IDC_STATIC_UNIT_13)->ShowWindow(bTabEnable); GetDlgItem(IDC_STATIC_UNIT_14)->ShowWindow(bTabEnable); GetDlgItem(IDC_STATIC_UNIT_15)->ShowWindow(bTabEnable); GetDlgItem(IDC_STATIC_UNIT_16)->ShowWindow(bTabEnable);

GetDlgItem(IDC_STATIC_SENSOR_BANK1_NR1)->ShowWindow(bTabEnable); GetDlgItem(IDC_STATIC_SENSOR_BANK1_NR2)->ShowWindow(bTabEnable); GetDlgItem(IDC_STATIC_SENSOR_BANK1_NR3)->ShowWindow(bTabEnable); GetDlgItem(IDC_STATIC_SENSOR_BANK1_NR4)->ShowWindow(bTabEnable); GetDlgItem(IDC_STATIC_SENSOR_BANK2_NR1)->ShowWindow(bTabEnable); GetDlgItem(IDC_STATIC_SENSOR_BANK2_NR2)->ShowWindow(bTabEnable); GetDlgItem(IDC_STATIC_SENSOR_BANK2_NR3)->ShowWindow(bTabEnable); GetDlgItem(IDC_STATIC_SENSOR_BANK2_NR4)->ShowWindow(bTabEnable);

GetDlgItem(IDC_BUTTON_UPDATE)->ShowWindow(bTabEnable);

return S_OK;} // OnSelDlgVehicle

void COdbDefaultGraphic::SetComboContent(UINT uiCombo, CStringList *poList){ CComboBox* poCombo = (CComboBox*) GetDlgItem(uiCombo); if (!poCombo) { return;

18

} poCombo->ResetContent(); LONG lIndex = 0; POSITION oPos = poList->GetHeadPosition(); LONG lRow = 0; while (oPos) { lRow = poCombo->AddString(poList->GetNext(oPos)); poCombo->SetItemData(lRow, lIndex++ ); } poCombo->SetCurSel(0);

return;}

CString COdbDefaultGraphic::GetComboSelText(UINT uiCombo){ CString sValue; CComboBox* poCombo = (CComboBox*) GetDlgItem(uiCombo); if (!poCombo) { return sValue; } int nIndex = poCombo->GetCurSel(); if (nIndex > -1) { poCombo->GetLBText(nIndex, sValue); }

return sValue;}

HRESULT COdbDefaultGraphic::OnSelDlgTroubleCode(BOOL bTabEnable) { if (bTabEnable) { // Disable the other tabs OnSelDlgRealtime(false); OnSelDlgFreeze(false); OnSelDlgVehicle(false); OnSelDlgMonitor(false); OnSelDlgOxygenSensors(false); m_nMode = 1; CRect rect; GetClientRect(m_hGuiWnd, rect); Draw(rect); }

GetDlgItem(IDC_STATIC_DTC)->ShowWindow(bTabEnable); GetDlgItem(IDC_LIST_DTC)->ShowWindow(bTabEnable); GetDlgItem(IDC_EDIT_DEF)->ShowWindow(bTabEnable); GetDlgItem(IDC_STATIC_DEF)->ShowWindow(bTabEnable); GetDlgItem(IDC_STATIC_OLD_DTC)->ShowWindow(bTabEnable); GetDlgItem(IDC_LIST_OLD_DTC)->ShowWindow(bTabEnable); GetDlgItem(IDC_EDIT_OLD_DEF)->ShowWindow(bTabEnable); GetDlgItem(IDC_STATIC_OLD_DEF)->ShowWindow(bTabEnable); GetDlgItem(IDC_STATIC_EARL_SERVICE)->ShowWindow(bTabEnable); GetDlgItem(IDC_COMBO_EARL_SERVICE)->ShowWindow(bTabEnable); GetDlgItem(IDC_STATIC_ERASE)->ShowWindow(bTabEnable); GetDlgItem(IDC_BUTTON_ERASE)->ShowWindow(bTabEnable);

return S_OK;}

// -------------------------- ACCESS METHODS --------------------------

19

// InitDlg.h: interface for the CInitDlg class.////////////////////////////////////////////////////////////////////////

#if !defined(AFX_INITDLG_H__DDE84A3B_8793_403F_A9E4_AB583C86C567__INCLUDED_)#define AFX_INITDLG_H__DDE84A3B_8793_403F_A9E4_AB583C86C567__INCLUDED_

#if _MSC_VER > 1000#pragma once#endif // _MSC_VER > 1000#include "..\..\sys\atsyscommon\AtTemcError.h"

class CInitDlg : public CAtStatusDlg{public: CInitDlg(); virtual ~CInitDlg(); void InitProcessBar(); void UppdateProcessBar(int percent); void HideProgressBar();

private: //CProgressCtrl *pProg;

};

#endif // !defined(AFX_INITDLG_H__DDE84A3B_8793_403F_A9E4_AB583C86C567__INCLUDED_)

1

// InitDlg.cpp: implementation of the CInitDlg class.////////////////////////////////////////////////////////////////////////

#include "stdafx.h"#include "atodbgui.h"#include "InitDlg.h"#include "Afxcmn.h"#include "resource.h"



CInitDlg::CInitDlg(){// pProg = new CProgressCtrl; }

void CInitDlg::InitProcessBar(){ CProgressCtrl* pProg = (CProgressCtrl*) CWnd::FromHandle(::GetDlgItem(this->m_hWnd,IDC_PROGRESS1)); pProg->SetRange(0,100); pProg->SetPos(0); }void CInitDlg::UppdateProcessBar(int percent){ CProgressCtrl* pProg = (CProgressCtrl*) CWnd::FromHandle(::GetDlgItem(this->m_hWnd,IDC_PROGRESS1)); pProg->SetPos(percent); }

void CInitDlg::HideProgressBar(){ (CWnd::FromHandle(::GetDlgItem(this->m_hWnd,IDC_PROGRESS1))->ShowWindow(false));}

CInitDlg::~CInitDlg(){

}

1

Bilaga F: Simulator När programvaran utvecklades så växte behovet av att kunna testköra programvaran, utan att alltid testa mot en bil. Då skapades en simulator, som simulerar interfacekretsen. Simulatorn är ett DOS-program som tar emot kommandon som interfacekretsen skulle ha tagit emot, och svarar med ett programmerat svar. Simulatorn går att köra på samma dator som OBD programmet med förutsättningen att datorn har två serieportar, och att man kopplar in en nollmodemkabel emellan portarna. Det går givetvis att köra simulatorn på en dator och OBD programmet på en annan. Simulatorprogrammet är programmerat i Microsoft Visual C++ 6.0 och är uppbyggd med en cpp fil innehållande enbart en main-funktion.

#include <iostream.h>#include "stdafx.h"#include <windows.h>#include <dos.h>#include <stdlib.h>#include <process.h>#include <iostream.h>#include <dos.h>#include <stdlib.h>#include <conio.h>#include <process.h>

#include <stdio.h>#include <time.h>

//using namespace std;

void main(){

char ok[8]="ATZ OK>"; char Mode1Pid00[14]="4100FFFFFFF0>"; int Mode1Pid00Size=12;

char Mode1Pid01[50]="410186C9B40F"; int Mode1Pid01Size=12;

char Mode1Pid04[50]="41 04 55 "; int Mode1Pid04Size=9;

char Mode1Pid05[50]="41 05 78 "; int Mode1Pid05Size=9;

char Mode1Pid0C[50]="410C0A64"; int Mode1Pid0CSize=8;

char Mode1Pid0D[50]="410D64"; int Mode1Pid0DSize=6;

char Mode1Pid0A[50]="410A22"; int Mode1Pid0ASize=6;

char Mode1Pid0B[50]="410B40"; int Mode1Pid0BSize=6;

char Mode1Pid0F[50]="410F40"; int Mode1Pid0FSize=6;

char Mode1Pid11[50]="411150"; int Mode1Pid11Size=6;




char Mode1Pid1C[50]="411C06"; int Mode1Pid1CSize=6;


1

char Mode2Pid00[50]="4200FFFFFFFF"; int Mode2Pid00Size=12;



char Mode3[50]="43013301110134. 43013601370138"; int Mode3Size=30; Mode3[14]=13;

char Mode4[50]="44"; int Mode4Size=2;

char Mode9Pid02[500]="49 02 01 00 00 00 59 .49 02 02 53 33 45 42 .49 02 03 35 39 43 58 .49 02 04 32 33 30 33 .49 02 05 39 37 31 36 ."; Mode9Pid02[21]=13; Mode9Pid02[43]=13; Mode9Pid02[65]=13; Mode9Pid02[87]=13; Mode9Pid02[108]=13;

int Mode9Pid02Size=109;

char Enter[2]=">"; int EnterSize=1;

char indata[200]; int i; char inBuffer;

char businit[15]="BUS INIT:.OK >";

//-----------Serieport inställningar-------------------------------------------

HANDLE hComm; DCB dcb;

char *pcCommPort = "COM1"; bool fSuccess; hComm = CreateFile( pcCommPort, GENERIC_READ | GENERIC_WRITE, 0, // must be opened with exclusive-access NULL, // no security attributes OPEN_EXISTING, // must use OPEN_EXISTING 0, // not overlapped I/O NULL // hTemplate must be NULL for comm devices );

fSuccess = GetCommState(hComm, &dcb);

dcb.BaudRate = CBR_9600; // set the baud rate dcb.ByteSize = 8; // data size, xmit, and rcv dcb.Parity = NOPARITY; // no parity bit dcb.StopBits = ONESTOPBIT; // one stop bit

fSuccess = SetCommState(hComm, &dcb);

2

unsigned long BytesRead = 1; LPDWORD nBytesRead=&BytesRead; unsigned long outTest = 1; LPDWORD lpNumberOfBytesWritten=&outTest;

//------------------TIMEOUT-------------------------------

COMMTIMEOUTS Timeouts;

Timeouts.ReadIntervalTimeout=500000000; Timeouts.ReadTotalTimeoutConstant=5000000000; Timeouts.ReadTotalTimeoutMultiplier=500000000; Timeouts.WriteTotalTimeoutConstant=500; Timeouts.WriteTotalTimeoutMultiplier=500; SetCommTimeouts(hComm, &Timeouts);//----------------------------------------------------------

while(true) { inBuffer='b'; for(i=0; inBuffer != 13 ; i++) { ReadFile(hComm, &inBuffer, 1, nBytesRead, NULL); if(inBuffer=='b') i=0; else indata[i]=inBuffer; } indata[i+1]='\0'; cout <<indata <<endl <<endl;

Sleep(400);

if(indata[0]=='a' || indata[0]=='A' || indata[1]=='A' || indata[1]=='a') { int j=0; if(indata[1]=='A' || indata[1]=='a') j=1; if((indata[j]=='a' || indata[j]=='A') && (indata[j+1]=='t' || indata[j+1]=='T') && (indata[j+2]=='z' || indata[j+2]=='Z')) { WriteFile(hComm, ok, 7, lpNumberOfBytesWritten, NULL); inBuffer='b'; for(i=0; inBuffer != 13 ; i++) { ReadFile(hComm, &inBuffer, 1, nBytesRead, NULL); indata[i]=inBuffer; }

indata[i+1]='\0'; cout <<indata <<endl <<endl;

if((indata[j]=='a' || indata[j]=='A') && (indata[j+1]=='t' || indata[j+1]=='T') && (indata[j+2]=='z' || indata[j+2]=='Z')) { WriteFile(hComm, ok, 7, lpNumberOfBytesWritten, NULL);

inBuffer='b'; for(i=0; inBuffer != 13 ; i++) { ReadFile(hComm, &inBuffer, 1, nBytesRead, NULL); indata[i]=inBuffer; }

indata[i+1]='\0'; cout <<indata <<endl <<endl;

3

WriteFile(hComm, businit, 14, lpNumberOfBytesWritten, NULL);

} else WriteFile(hComm, businit, 14, lpNumberOfBytesWritten, NULL); } else WriteFile(hComm, ok, 7, lpNumberOfBytesWritten, NULL); } else { if(indata[0]=='0' && indata[1]=='1' && indata[2]=='0' && indata[3]=='0' ) { WriteFile(hComm, Mode1Pid00, Mode1Pid00Size, lpNumberOfBytesWritten, NULL); WriteFile(hComm, Enter, EnterSize, lpNumberOfBytesWritten, NULL); } if(indata[0]=='0' && indata[1]=='1' && indata[2]=='0' && indata[3]=='1' ) { WriteFile(hComm, Mode1Pid01, Mode1Pid01Size, lpNumberOfBytesWritten, NULL); WriteFile(hComm, Enter, EnterSize, lpNumberOfBytesWritten, NULL); } if(indata[0]=='0' && indata[1]=='1' && indata[2]=='0' && indata[3]=='4' ) { WriteFile(hComm, Mode1Pid04, Mode1Pid04Size, lpNumberOfBytesWritten, NULL); WriteFile(hComm, Enter, EnterSize, lpNumberOfBytesWritten, NULL); } if(indata[0]=='0' && indata[1]=='1' && indata[2]=='0' && indata[3]=='5' ) { WriteFile(hComm, Mode1Pid05, Mode1Pid05Size, lpNumberOfBytesWritten, NULL); WriteFile(hComm, Enter, EnterSize, lpNumberOfBytesWritten, NULL); } if(indata[0]=='0' && indata[1]=='1' && indata[2]=='0' && indata[3]=='C' ) { WriteFile(hComm, Mode1Pid0C, Mode1Pid0CSize, lpNumberOfBytesWritten, NULL); WriteFile(hComm, Enter, EnterSize, lpNumberOfBytesWritten, NULL); } if(indata[0]=='0' && indata[1]=='1' && indata[2]=='0' && indata[3]=='D' ) { WriteFile(hComm, Mode1Pid0D, Mode1Pid0DSize, lpNumberOfBytesWritten, NULL); WriteFile(hComm, Enter, EnterSize, lpNumberOfBytesWritten, NULL); } if(indata[0]=='0' && indata[1]=='1' && indata[2]=='0' && indata[3]=='A' ) { WriteFile(hComm, Mode1Pid0A, Mode1Pid0ASize, lpNumberOfBytesWritten, NULL); WriteFile(hComm, Enter, EnterSize, lpNumberOfBytesWritten, NULL); }

if(indata[0]=='0' && indata[1]=='1' && indata[2]=='0' && indata[3]=='B' ) { WriteFile(hComm, Mode1Pid0B, Mode1Pid0BSize, lpNumberOfBytesWritten, NULL); WriteFile(hComm, Enter, EnterSize, lpNumberOfBytesWritten, NULL); }

if(indata[0]=='0' && indata[1]=='1' && indata[2]=='0' && indata[3]=='F' ) { WriteFile(hComm, Mode1Pid0F, Mode1Pid0FSize, lpNumberOfBytesWritten, NULL); WriteFile(hComm, Enter, EnterSize, lpNumberOfBytesWritten, NULL); }

if(indata[0]=='0' && indata[1]=='1' && indata[2]=='1' && indata[3]=='1' ) { WriteFile(hComm, Mode1Pid11, Mode1Pid11Size, lpNumberOfBytesWritten, NULL); WriteFile(hComm, Enter, EnterSize, lpNumberOfBytesWritten, NULL); }

if(indata[0]=='0' && indata[1]=='1' && indata[2]=='0' && indata[3]=='6' ) { WriteFile(hComm, Mode1Pid06, Mode1Pid06Size, lpNumberOfBytesWritten, NULL); WriteFile(hComm, Enter, EnterSize, lpNumberOfBytesWritten, NULL); } if(indata[0]=='0' && indata[1]=='1' && indata[2]=='0' && indata[3]=='7' ) { WriteFile(hComm, Mode1Pid07, Mode1Pid07Size, lpNumberOfBytesWritten, NULL); WriteFile(hComm, Enter, EnterSize, lpNumberOfBytesWritten, NULL);

4

} if(indata[0]=='0' && indata[1]=='1' && indata[2]=='0' && indata[3]=='3' ) { WriteFile(hComm, Mode1Pid03, Mode1Pid03Size, lpNumberOfBytesWritten, NULL); WriteFile(hComm, Enter, EnterSize, lpNumberOfBytesWritten, NULL); }

if(indata[0]=='0' && indata[1]=='1' && indata[2]=='1' && indata[3]=='C' ) { WriteFile(hComm, Mode1Pid1C, Mode1Pid1CSize, lpNumberOfBytesWritten, NULL); WriteFile(hComm, Enter, EnterSize, lpNumberOfBytesWritten, NULL); }


if(indata[0]=='0' && indata[1]=='1' && indata[2]=='1' && indata[3]=='5' ) { WriteFile(hComm, Mode1Pid14, Mode1Pid14Size, lpNumberOfBytesWritten, NULL); WriteFile(hComm, Enter, EnterSize, lpNumberOfBytesWritten, NULL); } if(indata[0]=='0' && indata[1]=='1' && indata[2]=='1' && indata[3]=='6' ) { WriteFile(hComm, Mode1Pid14, Mode1Pid14Size, lpNumberOfBytesWritten, NULL); WriteFile(hComm, Enter, EnterSize, lpNumberOfBytesWritten, NULL); } if(indata[0]=='0' && indata[1]=='1' && indata[2]=='1' && indata[3]=='7' ) { WriteFile(hComm, Mode1Pid14, Mode1Pid14Size, lpNumberOfBytesWritten, NULL); WriteFile(hComm, Enter, EnterSize, lpNumberOfBytesWritten, NULL); } if(indata[0]=='0' && indata[1]=='1' && indata[2]=='1' && indata[3]=='8' ) { WriteFile(hComm, Mode1Pid14, Mode1Pid14Size, lpNumberOfBytesWritten, NULL); WriteFile(hComm, Enter, EnterSize, lpNumberOfBytesWritten, NULL); } if(indata[0]=='0' && indata[1]=='1' && indata[2]=='1' && indata[3]=='9' ) { WriteFile(hComm, Mode1Pid14, Mode1Pid14Size, lpNumberOfBytesWritten, NULL); WriteFile(hComm, Enter, EnterSize, lpNumberOfBytesWritten, NULL); } if(indata[0]=='0' && indata[1]=='1' && indata[2]=='1' && indata[3]=='A' ) { WriteFile(hComm, Mode1Pid14, Mode1Pid14Size, lpNumberOfBytesWritten, NULL); WriteFile(hComm, Enter, EnterSize, lpNumberOfBytesWritten, NULL); } if(indata[0]=='0' && indata[1]=='1' && indata[2]=='1' && indata[3]=='B' ) { WriteFile(hComm, Mode1Pid14, Mode1Pid14Size, lpNumberOfBytesWritten, NULL); WriteFile(hComm, Enter, EnterSize, lpNumberOfBytesWritten, NULL); }

if(indata[0]=='0' && indata[1]=='2' && indata[2]=='0' && indata[3]=='0' ) { WriteFile(hComm, Mode2Pid00, Mode2Pid00Size, lpNumberOfBytesWritten, NULL); WriteFile(hComm, Enter, EnterSize, lpNumberOfBytesWritten, NULL); } else if(indata[0]=='0' && indata[1]=='2' && indata[2]=='0' && indata[3]=='2' ) { WriteFile(hComm, Mode2Pid02, Mode2Pid02Size, lpNumberOfBytesWritten, NULL); WriteFile(hComm, Enter, EnterSize, lpNumberOfBytesWritten, NULL); } else if(indata[0]=='0' && indata[1]=='2') { WriteFile(hComm, Mode2Pid04, Mode2Pid04Size, lpNumberOfBytesWritten, NULL); WriteFile(hComm, Enter, EnterSize, lpNumberOfBytesWritten, NULL); }

5

if(indata[0]=='0' && indata[1]=='3' ) { WriteFile(hComm, Mode3, Mode3Size, lpNumberOfBytesWritten, NULL); WriteFile(hComm, Enter, EnterSize, lpNumberOfBytesWritten, NULL); }

if(indata[0]=='0' && indata[1]=='4' ) { WriteFile(hComm, Mode4, Mode4Size, lpNumberOfBytesWritten, NULL); WriteFile(hComm, Enter, EnterSize, lpNumberOfBytesWritten, NULL); Mode1Pid01[4]='0'; Mode1Pid01[5]='0'; }


} }

}

6

on board diagnostics - per-olovper-olov.se/onewebmedia/rapport-obd.pdf · 2015. 7. 15. ·...

Documents