El proyecto consiste en el diseño y fabricación de un Simulador capaz de comunicarse con un equipo de diagnóstico de cualquier vehículo con el protocolo ISO 9141-2. Permite simular parámetros del vehículo en tiempo real, lectura-borrado de códigos de fallo motor y activación de luz indicadora de avería "MIL"

1. 8-12-2019
SIMULADOR Diagnosis OBDII
Diseño, construcción y programación.
Autor: Joaquin Berrocal Piris
ARDUINO MEGA, EAGLE, TORQUE PRO,

2. Simulador Diagnosis OBDII con protocolo ISO 9141-2 por Joaquín Berrocal Piris

3. Simulador Diagnosis OBDII con protocolo ISO 9141-2 por Joaquín Berrocal Piris

4. Simulador Diagnosis OBDII con protocolo ISO 9141-2 por Joaquín Berrocal Piris

5. Simulador Diagnosis OBDII con protocolo ISO 9141-2 por Joaquín Berrocal Piris

6. Simulador Diagnosis OBDII con protocolo ISO 9141-2 por Joaquín Berrocal Piris

7. Simulador Diagnosis OBDII con protocolo ISO 9141-2 por Joaquín Berrocal Piris

8. Simulador Diagnosis OBDII con protocolo ISO 9141-2 por Joaquín Berrocal Piris
CONSTRUCCIÓN Y MONTAJE
(Se montará la placa shield sobre la Arduino Mega 2560 R3)
Diseño en el programa EAGLE 8.0 del circuito y de la placa shield a montar sobre la placa Arduino Mega 2560 R3

9. Simulador Diagnosis OBDII con protocolo ISO 9141-2 por Joaquín Berrocal Piris
Llegada de la placa que se diseñó

10. Simulador Diagnosis OBDII con protocolo ISO 9141-2 por Joaquín Berrocal Piris
MONTAJE DE COMPONENTES

11. Simulador Diagnosis OBDII con protocolo ISO 9141-2 por Joaquín Berrocal Piris

12. Simulador Diagnosis OBDII con protocolo ISO 9141-2 por Joaquín Berrocal Piris

13. Simulador Diagnosis OBDII con protocolo ISO 9141-2 por Joaquín Berrocal Piris
Luz verde activa indica que hay entendimiento, vía bluetooth, entre el programa TORQUE PRO del
móvil con la interfaz OBDII ELM327 de la placa.
Tendremos la posibilidad de lectura de parámetros y lectura/borrado de averías,
1 Pos Acelerador
2 Velocímetro
3 rpm Motor
4 Nivel
Aforador
5 Temp
Ambiente
6 Temp
Refrigerante

14. Simulador Diagnosis OBDII con protocolo ISO 9141-2 por Joaquín Berrocal Piris
La conexión inicial se hará con el protocolo OBDII ISO 9141-2 a 5 baud.
Está programado para la lectura de 6 parámetros del vehículo:
(debe encontrarse el SWICH 1 en ON, es decir, puesto a masa)
1-. Posición del acelerador 4-. Nivel de combustible
2-. Velocímetro (Speed) 5-. Temperatura del Aire ºC
3-. Rpm del Motor 6-. Temperatura del refrigerante motor ºC
Y para la lectura de 7 posibles averías: (debe encontrarse el SWICH 1 en OFF, es decir puesto a nivel 1)
El Swich 4-7 y 8 provocan averías Graves y activan el led ambar.
SWICH 1 En OFF, es decir, a nivel 1 que corresponde a estar desplazado hacia el número
SWICH 2 DTC P0301 Fallo en el cilindro nº 1
SWICH 3 DTC P0340 Mal functo del sensor de posición del árbol de levas
SWICH 4 DTC P0217 Engine Coolant Over Temperature condition
SWICH 5 DTC P0171 System too lean (exceso de oxígeno en los gases de escape)
SWICH 6 DTC P0500 Vehícle Speed Sensor (Sensor de velocidad)
SWICH 7 DTC P0420 Catalyst System Efficiency Below threshold
SWICH 8 DTC P0068 Diferencias entre el MAP/MAF Sensor de posición del acelerador
1 Pos Acelerador
2 Velocímetro
3 rpm Motor 6 Temp
Refrigerante
5 Temp.
Ambiente
4 Nivel
Combutible
Off ^
On
18 -------

15. Simulador Diagnosis OBDII con protocolo ISO 9141-2 por Joaquín Berrocal Piris
CONFIGURACIÓN Y USO DEL PROGRAMA DE DIAGNOSIS TORQUE PRO V1.8.190
Debido a sus limitaciones no se podrán ver más de 3 ó 4 parámetros operativos a la vez.
La conexión con la interfaz ELM 327 se hace vía bluetooth.

16. Simulador Diagnosis OBDII con protocolo ISO 9141-2 por Joaquín Berrocal Piris
LECTURA DE PARÁMETROS DEL VEHÍCULO
(La información son de los 6 potenciómetros que simulan sensores del vehículo)

17. Simulador Diagnosis OBDII con protocolo ISO 9141-2 por Joaquín Berrocal Piris
LECTURA DE AVERÍAS. Switch 1 en OFF. (Switch 2 a 7 total hasta 6 averías)
Por limitaciones del programa Torque Pro, seleccionar un máximo de 3 ó 4 averías a la vez.

18. Simulador Diagnosis OBDII con protocolo ISO 9141-2 por Joaquín Berrocal Piris
LA PLACA ESTÁ PREPARADA PARA AÑADIRLE UN LCD 4X20 VÍA I2CLCD. PRESENTO IMÁGENES
(En este proyecto lo descarto, pues me da problema en las lecturas OBDII)

19. Simulador Diagnosis OBDII con protocolo ISO 9141-2 por Joaquín Berrocal Piris
DOS MANERAS DE PODER MONTAR LA LCDI2C 4X20 SOBRE LA PLACA SHIELD

20. Simulador Diagnosis OBDII con protocolo ISO 9141-2 por Joaquín Berrocal Piris
La placa Shield construida se montará sobre la placa Arduino mega 2560 R3
(nota; no hago uso en este proyecto de la LCD por problemas en la comunicación con el torquepro)

21. Simulador Diagnosis OBDII con protocolo ISO 9141-2 por Joaquín Berrocal Piris
PROGRAMACIÓN CON ARDUINO V1-6-4
1 /*"Simulador_OBDII_Joaquin_Berrocal_Piris_Marzo_2018.ino"
2 realizado por: JOAQUÍN BERROCAL PIRIS
3 El proyecto consiste en el diseño y fabricación de un Simulador capaz de
comunicarse
con un equipo de diagnóstico
4 de cualquier vehículo con el protocolo ISO 9141-2. Enviar y recibir tramas según
el
estándar.
5 Simular parámetros del vehículo en tiempo real, lectura-borrado de códigos de
fallo
motor, activación de
6 luz indicadora de avería "MIL".
7 Nos evita la necesidad de tener el vehículo y de trabajar con los propios sensores
del mismo, teniendo que pinchar
8 en su cableado, lo que podría producir su deterioro.
9 Con este desarrollo se anulan estos problemas, al ser todo a nivel software y
placa
"shield" que tendremos que construir.
10
11 Es por ello, por lo que está muy indicado para cursos de formación sobre
diagnosís
de fallos de motor y, muy especialmente,
12 en la formación en los ciclos formativos pertenecientes a la familia profesional
de
13 “Transporte y Mantenimiento de Vehículos" como son; Automoción / Electromecánica
de
Vehículos Automóviles etc.
14
15 La placa shield se montará sobre una tarjeta ARDUINO MEGA 2560 y de la que se
alimentará a través de
16 su borne "Vin" a 11,3V, siendo la tensión de la Arduino Mega de 12V.
17 Dispondrá, para la simulación de:
18 -. 6 Potenciómetros, que harán las veces de sensores del vehículo
19 -. 8 Microinterruptores para distintas Funciónes como, detección de averías,
lectura
ECU, borrado..
20 -. 1 led Rojo: para indicar que está alimentada.
21 -. 1 led Verde: para indicar que tiene comunicación correcta con la arduino mega
y
el OBDII
22 -. 1 led Rojo: para indicación de avería importante "MIL"
23 -. Conector OBDII para su conexión a la interfaz OBDII "ELM327"
24 -. Y como equipo de diagnostico se usará por su bajo precio, unos 4€, la interfaz
"ELM327"
25 (El ELM327 hace de puente entre el lenguaje del sistema OBDII y el RS232)
26 -. Programa "TORQUE PRO.apk" para que, desde el tfno móvil, podamos controlar la
interfaz "ELM327" vía bluetooth
27 -. También se podrán ver los datos a través del puerto serie (USB)de la placa
arduino con un PC.
28
29
30 +++++++++++++++++CONEXIONES PLACA SHIELD CON ARDUINO E INTERFAZ
ELM327++++++++++++++
31 ----------- SHIELD con el CONECTOR OBDII-ELM327;-----------
32 + Lo primero que debemos hacer es insertar en la Arduino MEGA la placa shield
fabricada en su posición adecuada
33
34 + Alimentar la Arduino MEGA a 12V DC. así obtendremos por su borne "Vin" los
11.3V
necesario para alimentar.
35 la placa shield y, desde ahí, alimentar por el borne 16 del conector OBDII al
ELM327.
36 Bornes del interfaz ELM327 usados:
37 borne 7 (K-Line del protocolo ISO 9141-2) esta línea es de doble dirección.
38 borne 5 GND
39 Borne 16 alimentación a través del borne VIN de la mega 11,3V.

22. Simulador Diagnosis OBDII con protocolo ISO 9141-2 por Joaquín Berrocal Piris
40
41 + Acoplar el interfaz ELM327-OBDII. Abrir la app TORQUEPRO desde un teléfono
android. Vincular el dispositivo
42 de diagnóstico por bluetooth y esperamos que se nos encienda el led Verde de
inicialización.
43
44 En la inicialización el tester, primero se verifica la alimentación y la conexión
bluetooth con el dispoitivo Android,
45 luego debe reconocer el protocolo que usa el simulador del vehículo y después
enviar
las tramas de petición de
46 los diferentes PIDs que se encuentran en la pantalla. Si éstos se reciben
correctamente y en el tiempo establecido
47 se tendrá un resultado correcto.
48
49 -----------------------------------------------------------
50 ------------- SHIELD con ARDUINO MEGA;----------------
51 LED_MIL (R_MIL) al pin 50
52 LED_ready (V_PREPARADO_OK) al pin 52
53
54 POT16 al pin A0 Acelerador
55 POT17 al pin A1 Velocidad
56 POT18 al pin A2 Revoluciones motor
57
58 POT19 al pin A3 Nivel combustible
59 POT20 al pin A4 Temperatura aire
60 POT21 al pin A5 Temperatura refrigerante motor.
61
62 microinterruptores
63 SW1 pin 38 SW2 pin 36 SW3 pin 34 SW4 pin 32 SW5 pin 30 SW6 pin 28 SW7 pin 26
SW8 pin 24
64
65
66 Comunicación Pines: 14TX3 y 15RX3
67 NO USADOS EN ESTE PROYECTO:
68 Comunicación con LCD4x20-I2C Pines: SDA20 y SCL21 y pin +5V y GND
69
70 -----------------------------------------------------------
71
72 */
73 //---Variables Globales-------
74
75 //CONSTANTES
76 //INICIALIZACION
77 const int flanco_bajada = 0;
78 const int bit_start = 1;
79 const int up_bits_1 = 2;
80 const int low_bits_1 = 3;
81 const int up_bits_2 = 4;
82 const int low_bits_2 = 5;
83 const int margen_inf_200 = 195;
84 const int margen_sup_200 = 205;
85 const int margen_inf_400 = 395;
86 const int margen_sup_400 = 405;
87 const byte SINC = 0x55;
88 //const byte KW1 = 0x08;
89 //const byte KW2 = 0x08;
90 //const byte KW2_NEG = 0xF7;
91 const byte KW1 = 0x94; //KW para poner P2min a 0 (un solo ECU)
92 const byte KW2 = 0x94;
93 const byte KW2_NEG = 0x6B; //KW2_neg de 0x94
94 const byte DIR_NEG = 0xCC;
95 //PIDs
96 const byte PIDs_supported = 0x00; //PIDs soportados del 1 al 20
97 const byte MILyDTC = 0x01; //Estado del indicador MIL y numero de DTCs
almacenados
98 const byte coolant = 0x05; //Temperatura del refrigerante
99 const byte rpm = 0x0C; //Revoluciones por minuto del motor
100 const byte vehicle_speed = 0x0D; //Velocidad del vehículo

23. Simulador Diagnosis OBDII con protocolo ISO 9141-2 por Joaquín Berrocal Piris
101 const byte throttle_position = 0x11; //Posición del acelerador
102 const byte OBD_standard = 0x1C; //Posicion del acelerador
103 const byte total_time = 0x1F; //Tiempo desde el arranque
104 const byte PIDs_supported_20 = 0x20; //PIDs soportados del 21 al 40
105 const byte fuel_level = 0x2F;
106 const byte PIDs_supported_40 = 0x40; //PIDs soportados del 41 al 60
107 const byte air_temp = 0x46; //Temperatura ambiente
108
109 const byte fuel_type = 0x51; //Posicion del acelerador
110 //MODOS DE OPERACION
111 const byte mode1 = 0x01;
112 const byte mode3 = 0x03;
113 const byte mode4 = 0x04;
114 //ESTADOS
115 const int INICIALIZACION_1 = 0;
116 const int INICIALIZACION_2 = 1;
117 const int PETICIÓN_1 = 2;
118 const int PETICIÓN_2 = 3;
119 const int RESPUESTA = 4;
120 //PINES
121 const int obdpin = 15; //Posterior RX3 de la UART (Para INI a 5 baud)
122 const int LED_ready = 52;
123 const int LED_MIL = 50;
124 const char throttle_pin = A0;
125 const char speed_pin = A1;
126 const char rpm_pin = A2;
127 const char fuel_pin = A3;
128 const char temp_pin = A4;
129 const char coolant_pin = A5;
130 const char sw1 = 38;
131 const char sw2 = 36;
132 const char sw3 = 34;
133 const char sw4 = 32;
134 const char sw5 = 30;
135 const char sw6 = 28;
136 const char sw7 = 26;
137 const char sw8 = 24;
138 //VARIABLES
139 float A;
140 int valor = 0;
141 boolean ini5baud = false;
142 boolean ini = false;
143 boolean iter = false;
144 int num_DTC = 0;
145 boolean MIL = false;
146 int estado = 0;
147 int estado_ini_5baud = 0;
148 boolean estado_ini_rapida = false;
149 long tiempo_parado = 0;
150 long previousMillis = 0;
151 long principio_W4 = 0;
152 byte trama_rx[11];
153 byte trama_tx[11];
154 byte pos_H[4];
155 byte pos_L[4];
156 byte sum = 0x00;
157 int length_rx = 0;
158 int length_tx = 0;
159 byte mode = 0x00;
160 byte PID = 0x00;
161 byte byte_aux = 0x00;
162 boolean manual_mode = false;
163 int manual_flag = 0;
164 float throttle_manual = 0;
165 float speed_manual = 0;
166 float rpm_manual = 0;
167 float fuel_manual = 0;
168 float temp_manual = 0;
169 float coolant_manual = 0;

24. Simulador Diagnosis OBDII con protocolo ISO 9141-2 por Joaquín Berrocal Piris
170
171 // ++++++++++++++++++++++++++++++++++++++++++++++++++
172 void setup() {
173 Serial.begin(9600); //son los pines 0 y 1
174 Serial3.begin(10400); // son los pines 15RX3 y 14TX3
175 pinMode(obdpin, INPUT); //pin 15Rx3 de la placa ya esta declarado const int
obdpin = 15;
176 pinMode(LED_ready, OUTPUT);
177 pinMode(LED_MIL, OUTPUT);
178 pinMode(sw1, INPUT); //sw1 = 38 sw2 = 36 ... sw8 = 24 van de par en par
179 pinMode(sw2, INPUT);
180 pinMode(sw3, INPUT);
181 pinMode(sw4, INPUT);
182 pinMode(sw5, INPUT);
183 pinMode(sw6, INPUT);
184 pinMode(sw7, INPUT);
185 pinMode(sw8, INPUT);
186
187 } //fin setup()
188
189 // ++++ CONJUNTO DE FUNCIÓNES UTILIZADAS +++
190
191 //Función que va testeando los flancos de la señal en la línea K del protocolo
192 //ISO9141-2 a 5Baud/s para comprobar que recibimos 0x33
193 int fun_ini5baud(){
194 unsigned long currentMillis = millis();
195 valor = digitalRead(obdpin); //lectura digital de pin
196
197 switch (estado_ini_5baud) {
198
199 //Estado que comprueba si la línea pasa a nivel bajo
200 case flanco_bajada:
201 if (valor==LOW){
202 estado_ini_5baud = bit_start;
203 previousMillis = currentMillis; //Se guarda el instante de inicio de estado 1
204 }
205 break;
206
207 //Estado que comprueba bit de start a 0, dura 200ms (ponemos un margen de
208 //5ms para evitar errores
209
210 case bit_start:
211 if ((valor==HIGH) && (currentMillis-previousMillis > margen_inf_200) &&
212 (currentMillis-previousMillis < margen_sup_200)) {
213 estado_ini_5baud = up_bits_1;
214 previousMillis = currentMillis;
215 }
216 else if((valor==HIGH) && (currentMillis-previousMillis < margen_inf_200)) {
217 estado_ini_5baud = flanco_bajada;
218 }
219 else{
220 estado_ini_5baud = bit_start;
221 }
222 break;
223
224 //Estado que comprueba 2 bits a nivel alto, dura 400ms (ponemos margen de
225 //5ms para evitar errores)
226
227 case up_bits_1:
228 if ((valor==LOW) && (currentMillis-previousMillis > margen_inf_400) &&
229 (currentMillis-previousMillis < margen_sup_400)) {
230 estado_ini_5baud = low_bits_1;
231 previousMillis = currentMillis;
232 }
233 else if((valor==LOW) && (currentMillis-previousMillis < margen_inf_400))
234 {
235 estado_ini_5baud = flanco_bajada;
236 }
237 else{

25. Simulador Diagnosis OBDII con protocolo ISO 9141-2 por Joaquín Berrocal Piris
238 estado_ini_5baud = up_bits_1;
239
240 }
241 break;
242 //Estado que comprueba 2 bits a nivel bajo, dura 400ms (ponemos margen de 5ms
para evitar errores)
243 case low_bits_1:
244 if ((valor==HIGH) && (currentMillis-previousMillis > margen_inf_400) &&
(currentMillis-previousMillis < margen_sup_400)) {
245 estado_ini_5baud = up_bits_2;
246 previousMillis = currentMillis;
247 }
248 else if((valor==HIGH)&& (currentMillis-previousMillis < margen_inf_400)) {
249 estado_ini_5baud = flanco_bajada;
250 }
251 else{
252 estado_ini_5baud = low_bits_1;
253 }
254 break;
255
256 //Estado que comprueba 2 bits a nivel alto, dura 400ms (ponemos margen de 5ms
para
evitar errores)
257 case up_bits_2:
258 if ((valor==LOW) && (currentMillis-previousMillis > margen_inf_400) &&
(currentMillis-previousMillis < margen_sup_400)) {
259 estado_ini_5baud = low_bits_2;
260 previousMillis = currentMillis;
261 }
262 else if((valor==LOW) && (currentMillis-previousMillis <
margen_inf_400)) {
263
264 estado_ini_5baud = flanco_bajada;
265 }
266 else{
267 estado_ini_5baud = up_bits_2;
268 }
269 break;
270
271 //Estado que comprueba 2 bits a nivel bajo, dura 400ms (ponemos margen de 5ms
para
evitar errores)
272
273 case low_bits_2:
274 if ((valor==HIGH) && (currentMillis-previousMillis > margen_inf_400)
&& (currentMillis-previousMillis < margen_sup_400)) {
275 ini5baud=true;
276 delay(200);
277 }
278 else if ((valor==HIGH) && (currentMillis-previousMillis <
margen_inf_400)) {
279 estado_ini_5baud = flanco_bajada;
280 }
281 else {
282 estado_ini_5baud = low_bits_2;
283 }
284 break;
285 }//fin de switch (estado_ini_5baud)
286 return ini5baud;
287 }//fin de int fun_ini5baud()
288
289
290 //Función que recibe señal INI a 5Baud/s y manda señales de sincronización y
291 //keywords correspondientes al protocolo ISO9141-2
292
293 int fun_ini() {
294 unsigned long final_W4 = millis();
295
296 switch(estado_ini_rapida){

26. Simulador Diagnosis OBDII con protocolo ISO 9141-2 por Joaquín Berrocal Piris
297 case false:
298 delay(20); //W1 [20-300ms]
299 Serial3.write(SINC); //Sincronización a 10.4 kbps (0x55)
300 delay(5); //W2 [5-20ms]
301 Serial3.write(KW1); //KeyWord 1
302 delay(5); //W3 [0-20ms]
303 Serial3.write(KW2); //Al enviar el segundo KeyWord estamos asignando P2min=25ms;
304 principio_W4=final_W4;
305 estado_ini_rapida=true;
306 break;
307 case true:
308 //Comprueba la señal recibida de KW2 invertida y manda señal de INI
309 //invertida (después acaba la inicialización)
310
311 if (Serial3.available() > 0){
312 byte_aux = Serial3.read();
313 if(byte_aux==KW2_NEG){
314 delay(25);
315 Serial3.write(DIR_NEG); //0x33 (INI) invertido = 0xCC
316 ini=true; //Listo para comunicarse
317 estado_ini_rapida=false;
318 }
319 else{
320 //si pasan 5 seg de inactividad o cree que es el protocolo KWP2000
321 if((final_W4 - principio_W4 > 5000)||(byte_aux==0x16)){
322 estado=INICIALIZACION_1;
323 }
324 ini=false;
325
326 }
327 }
328 break;
329 }
330 return ini;
331 }
332
333 void manda_resp(){
334 trama_tx[0] = trama_rx[0]-0x20;
335 trama_tx[1] = 0x6B;
336 trama_tx[2] = 0xD1; //dirección ECU 1
337 trama_tx[3] = mode + 0x40;
338
339 //Hacemos el checksum de la trama a enviar
340 for (int cont=0; cont<length_tx-1; cont++){
341 sum = sum+trama_tx[cont];
342 }
343 trama_tx[length_tx-1]=sum;
344 delay(25);//Esperamos tiempo P2
345
346 //Enviamos trama con tiempo P1=0s;
347 for (int cont2 = 0; cont2<length_tx; cont2++){
348 Serial3.write(trama_tx[cont2]);
349 }
350 }
351 //--------------------------------------------
352 void fun_mode1(){
353 PID=trama_rx[4];
354 if (manual_mode==false){
355 Serial.println("PID=");
356 Serial.println(trama_rx[4],HEX);
357 }
358 trama_tx[4]=PID;
359 //Marcamos la longitud del mensaje a enviar para el cálculo del checksum
360 length_tx=7; //Por defecto para un solo byte de dato
361
362 switch(PID){
363 case PIDs_supported:
364 Serial.println("PIDs soportados [1-20]n");
365 length_tx=10;

27. Simulador Diagnosis OBDII con protocolo ISO 9141-2 por Joaquín Berrocal Piris
366 trama_tx[5]=0x88; //Con estado MIL y num. DTCs y Temperatura del
refrigerante.
367 trama_tx[6]=0x18; //Con rpm y velocidad
368
369 trama_tx[7]=0x80; //Con posicion acelerador
370 trama_tx[8]=0x13; //Con estándar OBD, tiempo desde arranque y
371 PIDs_supported_40;
372 manda_resp();
373 break;
374 case MILyDTC:
375 Serial.println("Estado MIL y num. DTCsn");
376 length_tx=10;
377 if (MIL==true){
378 trama_tx[5]=0x80 + num_DTC; //MIL ON y número de DTCs
379 }
380 else{
381 trama_tx[5]=0x00 + num_DTC;
382 }
383 trama_tx[6]=0x00;
384 trama_tx[7]=0x00;
385 trama_tx[8]=0x00;
386 manda_resp();
387 break;
388 case coolant:
389 if (manual_mode==true){
390 trama_tx[5]=coolant_manual+40;
391 }
392 else{
393 Serial.println("Temperatura del refrigeranten");
394 A=analogRead(coolant_pin);
395 A=A*(200.0/1023.0);
396 trama_tx[5]=A+40;
397 }
398 manda_resp();
399 break;
400
401 case rpm:
402 length_tx=8;
403 if (manual_mode==true){
404 trama_tx[5]=rpm_manual*4/256;
405 trama_tx[6]=rpm_manual-(A*4/256);
406 }
407 else{
408 Serial.println("Revoluciones por minuton");
409 A=analogRead(rpm_pin);
410 A=A*(8000.0/1023.0);
411 trama_tx[5]=A*4/256;
412 trama_tx[6]=A-(A*4/256);
413 }
414 manda_resp();
415 break;
416
417 case vehicle_speed:
418 if (manual_mode==true){
419 trama_tx[5]=speed_manual;
420 }
421 else{
422 Serial.println("Velocidad del vehiculon");
423 A=analogRead(speed_pin);
424 trama_tx[5]=A*(255.0/1023.0);
425 }
426 manda_resp();
427 break;
428
429 case throttle_position:
430 if (manual_mode==true){
431 trama_tx[5]=throttle_manual*(255.0/100.0);
432 }
433 else{

28. Simulador Diagnosis OBDII con protocolo ISO 9141-2 por Joaquín Berrocal Piris
434 Serial.println("Posicion del aceleradorn");
435 A=analogRead(throttle_pin);
436 trama_tx[5]=A*(255.0/1023.0);
437 }
438 manda_resp();
439 break;
440
441 case OBD_standard:
442 Serial.println("Standard OBDn");
443 trama_tx[5]=0x09; //Soporta OBD, OBD2 y EOBD
444 manda_resp();
445 break;
446
447 case total_time:
448 Serial.println("Tiempo desde el arranquen"); length_tx=8;
449 A=millis()/1000; //Pasamos de milisegundos a segundos
trama_rx[5]=A/256;
450 trama_rx[6]=A-A/256;
451 manda_resp();
452 break;
453
454 case PIDs_supported_20:
455 Serial.println("PIDs soportados [21-40]n");
456 length_tx=10;
457 trama_tx[5]=0x00;
458 trama_tx[6]=0x02; //Con nivel combustible
459 trama_tx[7]=0x00;
460 trama_tx[8]=0x01; //Con PIDs_supported_40
461 manda_resp();
462 break;
463
464 case fuel_level:
465 if (manual_mode==true){
466 trama_tx[5]=fuel_manual*(255.0/100.0);
467 }
468 else{
469 Serial.println("Nivel de combustiblen");
470 A=analogRead(fuel_pin);
471 trama_tx[5]=A*(255.0/1023.0);
472 }
473 manda_resp();
474 break;
475
476 case PIDs_supported_40:
477 Serial.println("PIDs soportados [41-60]n");
478 length_tx=10;
479 trama_tx[5]=0x04; //Con temperatura ambiente
480 trama_tx[6]=0x00;
481 trama_tx[7]=0x80; //Con tipo de combustible
482 trama_tx[8]=0x00;
483 manda_resp();
484 break;
485
486 case air_temp:
487 if (manual_mode==true){
488 trama_tx[5]=temp_manual+40;
489 }else{
490 Serial.println("Temperatura ambienten");
491 A=analogRead(temp_pin);
492 A=A*(40.0/1023.0);
493 trama_tx[5]=A+40;
494 }
495 manda_resp();
496 break;
497
498 case fuel_type:
499 Serial.println("Tipo de combustiblen");
500 trama_tx[5]=0x04; //Combustible diesel
501 manda_resp();

29. Simulador Diagnosis OBDII con protocolo ISO 9141-2 por Joaquín Berrocal Piris
502 break;
503 }
504 }
505 //------------------------------------------------
506 void fun_mode3(){
507 //Por simplicidad se contemplarán 4 DTCs a la vez como máximo
Serial.println("Numero de DTCs: ");
508 Serial.println(num_DTC);
509 if (num_DTC==0){
510 MIL=false;
511 }
512 else if (num_DTC < 3){
513 trama_tx[4]=num_DTC;
514 trama_tx[5]=pos_H[0];
515 trama_tx[6]=pos_L[0];
516 if (num_DTC==2){
517 trama_tx[7]=pos_H[1];
518 trama_tx[8]=pos_L[1];
519 manda_resp();
520 }
521 else{
522 trama_tx[7]=0x00;
523 trama_tx[8]=0x00;
524 manda_resp();
525 }
526 }
527 else{
528 if (iter==false){
529 trama_tx[4]=num_DTC;
530 trama_tx[5]=pos_H[0];
531 trama_tx[6]=pos_L[0];
532 trama_tx[7]=pos_H[1];
533 trama_tx[8]=pos_L[1];
534 manda_resp();
535 iter=true;
536 }
537 else{
538 trama_tx[4]=num_DTC;
539 trama_tx[5]=pos_H[2];
540
541 trama_tx[6]=pos_L[2];
542 if (num_DTC==4){
543 trama_tx[7]=pos_H[3];
544 trama_tx[8]=pos_L[3];
545 manda_resp();
546 iter=false;
547 }
548 else{
549 trama_tx[7]=0x00;
550 trama_tx[8]=0x00;
551 manda_resp();
552 iter=false;
553 }
554 }
555 }
556 }
557 //-------------------------------------------
558
559 void comprueba_switch(){
560 int pos=0;
561 if (digitalRead(sw1) == 1){
562 manual_mode=true;
563 comprueba_manual();
564 }
565 else{ //Si se desactiva se resetean las banderas de los PIDs usados manualmente
566 manual_mode=false;
567 manual_flag=0;
568 throttle_manual=0;
569 speed_manual=0;

30. Simulador Diagnosis OBDII con protocolo ISO 9141-2 por Joaquín Berrocal Piris
570 rpm_manual=0;
571 fuel_manual=0;
572 temp_manual=0;
573 coolant_manual=0;
574 }
575 if (digitalRead(sw2) == 1){
576 pos_H[pos]=0x03;
577 pos_L[pos]=0x01;
578 pos=pos+1;
579 }
580 if (digitalRead(sw3) == 1){
581 pos_H[pos]=0x03;
582 pos_L[pos]=0x40;
583 pos=pos+1;
584 }
585
586
587 if (digitalRead(sw4) == 1){
588 pos_H[pos]=0x02;
589 pos_L[pos]=0x17;
590 MIL=true;
591 digitalWrite(LED_MIL,HIGH);
592 pos=pos+1;
593 }
594 if (digitalRead(sw5) == 1){
595 pos_H[pos]=0x01;
596 pos_L[pos]=0x71;
597 pos=pos+1;
598 }
599 if (digitalRead(sw6) == 1){
600 pos_H[pos]=0x05;
601 pos_L[pos]=0x00;
602 pos=pos+1;
603 }
604 if (digitalRead(sw7) == 1){
605 pos_H[pos]=0x04;
606 pos_L[pos]=0x20;
607 MIL=true;
608 digitalWrite(LED_MIL,HIGH);
609 pos=pos+1;
610 }
611 if (digitalRead(sw8) == 1){
612 pos_H[pos]=0x00;
613 pos_L[pos]=0x68;
614 MIL=true;
615 digitalWrite(LED_MIL,HIGH);
616 pos=pos+1;
617 }
618 num_DTC=pos;
619 }
620 //-------------------------------------------
621 void comprueba_manual(){
622 char c = ' ';
623 String mensaje = "";
624 String mensaje2 = "";
625 if (Serial.available()){
626 while((c != '=')) //Leemos hasta el igual
627 {
628 mensaje = mensaje + c;
629 c = Serial.read();
630 delay(25);
631 }
632 mensaje.trim(); //Elimina los espacios en blanco
633 mensaje.toLowerCase(); //Pasa a minusculas
634 if (mensaje == "throttle"){manual_flag=1;}
635 else if (mensaje == "speed"){manual_flag=2;}
636 else if (mensaje == "rpm"){manual_flag=3;}
637 else if (mensaje == "fuel"){manual_flag=4;}
638 else if (mensaje == "temp"){manual_flag=5;}

31. Simulador Diagnosis OBDII con protocolo ISO 9141-2 por Joaquín Berrocal Piris
639 else if (mensaje == "coolant"){manual_flag=6;}
640 else{
641 manual_flag=0;
642 }
643 mensaje = ""; //Reseteo la cadena de caracteres
644 }
645 if ((Serial.available())&&(c=='=')){
646 c = Serial.read(); //Elimino el '='
647 delay(25);
648 while((c=='0')||(c=='1')||(c=='2')||(c=='3')||(c=='4')||(c=='5')||(c=='6')||
649 (c=='7')||(c=='8')||(c=='9')||(c==' ')||(c=='-')) //Leemos la cantidad
650 {
651 mensaje2 = mensaje2 + c;
652 c = Serial.read();
653 delay(25);
654 }
655 mensaje.trim(); //Elimina los espacios en blanco
656
657 switch(manual_flag){ //Asignamos el valor en tipo entero para su cambio en
fun_mode1
658 case 1:
659 if ((mensaje2.toInt()<0)||(mensaje2.toInt()>100)){
660 Serial.println("Throttle range = [0 - 100]");
661 }
662 else{
663 throttle_manual=mensaje2.toInt();
664 }
665 break;
666
667 case 2:
668 if ((mensaje2.toInt()<0)||(mensaje2.toInt()>255)){
669 Serial.println("Speed range = [0 - 255]");
670
671 }
672 else{
673 speed_manual=mensaje2.toInt();
674 }
675 break;
676
677 case 3:
678 if ((mensaje2.toInt()<0)||(mensaje2.toInt()>16000)){
679 Serial.println("Rpm range = [0 - 16000]");
680 }
681 else{
682 rpm_manual=mensaje2.toInt();
683 }
684 break;
685
686 case 4:
687 if ((mensaje2.toInt()<0)||(mensaje2.toInt()>100)){
688 Serial.println("Fuel range = [0 - 100]");
689 }
690 else{
691 fuel_manual=mensaje2.toInt();
692 }
693 break;
694
695 case 5:
696 if ((mensaje2.toInt()<-40)||(mensaje2.toInt()>215)){
697 Serial.println("Temp range = [-40 - 215]");
698 }
699 else{
700 temp_manual=mensaje2.toInt();
701 }
702 break;
703
704 case 6:
705 if ((mensaje2.toInt()<-40)||(mensaje2.toInt()>215)){
706 Serial.println("Coolant range = [-40 - 215]");

32. Simulador Diagnosis OBDII con protocolo ISO 9141-2 por Joaquín Berrocal Piris
707 }
708 else{
709 coolant_manual=mensaje2.toInt();
710 }
711 break;
712
713 case 0:
714 Serial.println("PID erroneo o no soportado en modo manual");
715 break;
716 }
717
718 mensaje2 = "";
719 }
720 }
721 //------------------------------------------
722 void loop(){
723 comprueba_switch();
724 unsigned long tiempo_actual = millis();
725
726 switch (estado){
727 //Estado de la fase de inicialización del protocolo
728 case INICIALIZACION_1:
729 digitalWrite(LED_ready,LOW);
730 ini5baud=fun_ini5baud();
731 if (ini5baud==true){
732 estado=INICIALIZACION_2;
733 estado_ini_5baud=0;
734 ini5baud=false;
735 }
736 break;
737
738 case INICIALIZACION_2:
739 ini=fun_ini();
740 if (ini==true) {
741 digitalWrite(LED_ready,HIGH); //Se enciende el LED verde cuando se esta
preparado para la comunicacion
742 estado=PETICIÓN_1;
743 length_rx=0;
744 tiempo_parado=tiempo_actual;
745 Serial3.flush();
746 ini=false;
747 }
748 break;
749
750 //Estado que espera hasta que le llegue el principio de
751 //la trama de petición y lo guarda
752
753 case PETICIÓN_1:
754 if(Serial3.available()>0){
755 byte_aux=Serial3.read();
756 if(byte_aux==0x68){
757 trama_rx[length_rx]=byte_aux;
758 length_rx = length_rx + 1;
759 estado=PETICIÓN_2;
760 }
761 else if (tiempo_actual - tiempo_parado > 5000){ //Si hay dato, no es el
principio de trama y han pasado mas de 5 segundos
762 estado=INICIALIZACION_1;
763 }
764 }
765 else if (tiempo_actual - tiempo_parado > 10000){ //Si han pasado 10 segundos
de inactividad
766 estado=INICIALIZACION_1;
767 ini5baud=false;
768 ini=false;
769 estado_ini_5baud=0;
770 estado_ini_rapida=false;
771 }
772 break;

33. Simulador Diagnosis OBDII con protocolo ISO 9141-2 por Joaquín Berrocal Piris
773 //Estado que recibe y guarda la petición del tester hasta el checksum
774 case PETICIÓN_2:
775 if(length_rx<12){ //Si cumple la longitud maxima de trama
776 if(Serial3.available()>0){
777 byte_aux=Serial3.read();
778 trama_rx[length_rx]=byte_aux;
779 length_rx=length_rx+1;
780 if(length_rx>4){ //Cuando ya tenemos el primer byte de dato empezamos a
comprobar el checksum
781 for (int cont3=0; cont3<length_rx-1; cont3++){
782 sum=sum+trama_rx[cont3];
783 }
784 //Si hemos llegado al checksum y es correcto paso a responder a la
785 if(sum==trama_rx[length_rx-1]){
786 estado=RESPUESTA;
787 sum=0x00;
788 }
789 else{
790 sum=0x00;
791 }
792 }
793 }
794 else if (tiempo_actual - tiempo_parado > 5000){ //Si no hay dato y han
pasado más de 5 segundos
795 estado=INICIALIZACION_1;
796 }
797 }
798 else{ //En el caso que se corrompan los datos recibid
799 estado=PETICIÓN_1;
800 tiempo_parado=tiempo_actual; length_rx=0;
801 sum=0x00;
802 }
803 break;
804 //Estado que comprueba que la trama es correcta y actúa según el modorequerido
805 case RESPUESTA:
806 mode=trama_rx[3];
807 if(manual_mode==false){
808 Serial.println("MODO=");
809 Serial.println(trama_rx[3],HEX);
810 }
811 switch(mode){
812 //Función que procesa peticiones de modo 1
813 case mode1:
814 fun_mode1();
815 estado=PETICIÓN_1; //Después de interpretar la petición vuelvo a esperar otra
816 tiempo_parado=tiempo_actual; //Guardo el momento desde que empiezo a
escuchar si hay trama de petición
817 break;
818
819 //Función que procesa peticiones de modo 3
820 case mode3:
821 fun_mode3();
822 estado=PETICIÓN_1;
823 length_rx=0;
824 tiempo_parado=tiempo_actual;
825 break;
826 //Función que procesa peticiones de modo 4
827 case mode4:
828 MIL=false;
829 num_DTC=0;
830 digitalWrite(LED_MIL,LOW);
831 estado=PETICIÓN_1;
832 length_rx=0;
833 tiempo_parado=tiempo_actual;
834 break;
835 //Si nos pide algún modo no implementado vuelvo a esperar trama de petición
836 default:
837 estado=PETICIÓN_1;
838 length_rx=0;

34. Simulador Diagnosis OBDII con protocolo ISO 9141-2 por Joaquín Berrocal Piris
839 tiempo_parado=tiempo_actual;
840 break;
841 }
842 break;
843 }
844 }
845 //----------------FIN DEL PROGRAMA---------------------
846
847
848