Para melhorar a sua experiência este site utiliza cookies. Ao navegar, está a consentir a sua utilização. Saiba mais sobre os nossos cookies.

Kit Diagnóstico para Automóveis - SparkFun

72,50 €
Com IVA
ef17b0196sk

Este Kit de Diagnóstico para Automóvel permite fazer a ligação OBD-II do seu carro. Fornece uma interface de série usando o conjunto de comandos ELM327 e suporta todos os principais padrões OBD-II, como CAN e JBUS. A placa também fornece uma pegada que se emparelha diretamente ao FTDI Basic ou um Bluetooth Mate. Inclui um cabo de ligação OBD-II para DB9.

Quantidade
Em stock

Este Kit de Diagnóstico para Automóveis permite fazer a ligação OBD-II do seu carro. Fornece uma interface de série usando o conjunto de comandos ELM327 e suporta todos os principais padrões OBD-II, como CAN e JBUS. A placa também fornece uma pegada que se emparelha diretamente ao FTDI Basic ou um Bluetooth Mate. Inclui um cabo de ligação OBD-II para DB9. 

Diagnóstico a Bordo, Segunda Geração (OBD-II) é um conjunto de normas para a implementação de um sistema baseado em computador para controlar as emissões dos veículos. Foi introduzido primeiramente nos Estados Unidos em 1994, e transformou-se uma exigência para todos os veículos de 1996 ou mais novos. Outros países, incluindo Canadá, partes da União Europeia, Japão, Austrália e Brasil adotaram uma legislação similar. Uma grande parte da moderna frota de veículos apoia OBD-II ou um dos seus sabores regionais. 

Entre outras coisas, o OBD-II exige que cada veículo compatível seja equipado com um conector de diagnóstico padrão (DLC) e descreva uma forma padrão de comunicação com o computador do veículo, também conhecido como ECU (Unidade de Controlo Electrónico). Uma grande quantidade de informações pode ser obtida tocando no barramento OBD, incluindo o status da luz indicadora de mau funcionamento (MIL), códigos de problemas de diagnóstico (DTCs), informações de inspeção e manutenção (I / M), congelamento de quadros, VIN, centenas de parâmetros em tempo real e muito mais. 

STN1110 é um OBD para UART interpretador que pode ser usado para converter mensagens entre qualquer um dos OBD-II protocolos atualmente em uso, e UART. É totalmente compatível com o conjunto de comandos padrão da indústria ELM327. Baseado num núcleo de processador de 16 bits, o STN1110 oferece mais recursos e melhor desempenho do que qualquer outro IC compatível com ELM327. 

Características:
• Totalmente compatível com o conjunto de comandos ELM327 AT;
• Grande conjunto de comandos ST;
• Interface UART (taxas de transmissão de 38 bps para 10 Mbps);
• Carregador seguro para atualizações de firmware fáceis;
• Suporte para todos os protocolos OBD II:
                           → ISO 15765-4 (CAN);
                           → ISO 14230-4 (Protocolo de palavras-chave 2000);
                           → ISO 9141-2 (veículos asiáticos, europeus, Chrysler);
                           → SAE J1850 VPW (veículos GM);
                           → SAE J1850 PWM (veículos Ford);
• Suporte para protocolos OBD não legislados:
                           → ISO 15765;
                           → ISO 11898 (CAN bruto);
• Suporte para protocolo SAE J1939 OBD;
• Algoritmo de detecção automática de protocolo superior;
• Grande buffer de memória;
• Entrada de tensão para monitorização de bateria. 

Inclui:
• 1x Placa OBD-II UART;
• 1x Cabo OBD-II para DB9. 

Documentos:
→ Esquema
→ Guia
→ Datasheet (STN1110)
→ Datasheet (MCP2551)
→ Listagem de Comandos 

Esquema de Ligação:

Código Exemplo: 

#include <SoftwareSerial.h>
//Create an instance of the new soft serial library to control the serial LCD
//Note, digital pin 3 of the Arduino should be connected to Rx of the serial LCD.
SoftwareSerial lcd(2,3);
//This is a character buffer that will store the data from the serial port
char rxData[20];
char rxIndex=0;
//Variables to hold the speed and RPM data.
int vehicleSpeed=0;
int vehicleRPM=0;
void setup(){
//Both the Serial LCD and the OBD-II-UART use 9600 bps.
lcd.begin(9600);
Serial.begin(9600);
//Clear the old data from the LCD.
lcd.write(254);
lcd.write(1);
//Put the speed header on the first row.
lcd.print("Speed: ");
lcd.write(254);
//Put the RPM header on the second row.
lcd.write(128+64);
lcd.print("RPM: ");
//Wait for a little while before sending the reset command to the OBD-II-UART
delay(1500);
//Reset the OBD-II-UART
Serial.println("ATZ");
//Wait for a bit before starting to send commands after the reset.
delay(2000);
//Delete any data that may be in the serial port before we begin.
Serial.flush();
}
void loop(){
//Delete any data that may be in the serial port before we begin.
Serial.flush();
//Set the cursor in the position where we want the speed data.
lcd.write(254);
lcd.write(128+8);
//Clear out the old speed data, and reset the cursor position.
lcd.print(" ");
lcd.write(254);
lcd.write(128+8);
//Query the OBD-II-UART for the Vehicle Speed
Serial.println("010D");
//Get the response from the OBD-II-UART board. We get two responses
//because the OBD-II-UART echoes the command that is sent.
//We want the data in the second response.
getResponse();
getResponse();
//Convert the string data to an integer
vehicleSpeed = strtol(&rxData[6],0,16);
//Print the speed data to the lcd
lcd.print(vehicleSpeed);
lcd.print(" km/h");
delay(100);
//Delete any data that may be left over in the serial port.
Serial.flush();
//Move the serial cursor to the position where we want the RPM data.
lcd.write(254);
lcd.write(128 + 69);
//Clear the old RPM data, and then move the cursor position back.
lcd.print(" ");
lcd.write(254);
lcd.write(128+69);
//Query the OBD-II-UART for the Vehicle rpm
Serial.println("010C");
//Get the response from the OBD-II-UART board
getResponse();
getResponse();
//Convert the string data to an integer
//NOTE: RPM data is two bytes long, and delivered in 1/4 RPM from the OBD-II-UART
vehicleRPM = ((strtol(&rxData[6],0,16)*256)+strtol(&rxData[9],0,16))/4;
//Print the rpm data to the lcd
lcd.print(vehicleRPM);
//Give the OBD bus a rest
delay(100);
}
/The getResponse function collects incoming data from the UART into the rxData buffer
// and only exits when a carriage return character is seen. Once the carriage return
// string is detected, the rxData buffer is null terminated (so we can treat it as a string)
// and the rxData index is reset to 0 so that the next string can be copied.
void getResponse(void){
char inChar=0;
//Keep reading characters until we get a carriage return
while(inChar != 'r'){
//If a character comes in on the serial port, we need to act on it.
if(Serial.available() > 0){
//Start by checking if we've received the end of message character ('r').
if(Serial.peek() == 'r'){
//Clear the Serial buffer
inChar=Serial.read();
//Put the end of string character on our data string
rxData[rxIndex]='';
//Reset the buffer index so that the next character goes back at the beginning of the string.
rxIndex=0;
}
//If we didn't get the end of message character, just add the new character to the string.
else{
//Get the new character from the Serial port.
inChar = Serial.read();
//Add the new character to the string, and increment the index variable.
rxData[rxIndex++]=inChar;
}
}
}
}