Sie sind auf Seite 1von 7

// NudeMCU V3 und CAN-BUS Shield MC2515 auf Audi A4 B8 Motorcan

#include <mcp_can.h> // Can Bibliothek


#include <SPI.h> // Spi Schnittstelle Bibliothek
/******** WIFI Access Point **************************/
#include <ESP8266WiFi.h>
#include <WiFiClient.h>
#include <ESP8266WebServer.h>
#include "index_html.h" // In dieser Datei befindet sich die Steuerung Webseite
ESP8266WebServer server(80); //Serverport
const char *ssid = "Audi"; // Wlan Audi (FaryLink_0AA54E)
const char *password = ""; // a4b8
int val = 0; // f�r �bergabe Button zustand
/* Verbinde Dich mit SSID "Audi" Wlan
* Gehe zu http://192.168.4.1 in einen webrowser */
void handleRoot() { server.send(200, "text/html", indexHTML);} //dann Index
Webseite senden (sehe Datei "index_html.h")

/******** WIFI Access Point ende **************************/


// Hardware anbindung MCP2515 zu NodeMCU V3 !
// Set Int zu D2 Set CLK zu D5 Set Miso zu D6 Set Mosi zu D7 Set CS zu D8
//***************** Variablen f�r MR Diagnose
*****************************************************/
long unsigned int rxId; // Empfangene ID
unsigned char len = 0; // Datenl�nge
unsigned char rxBuf[8]; // Daten Bytes
#define CAN0_INT 4 // Set Interupt zu pin D2
MCP_CAN CAN0(15); // Set CS to pin 15 (D8 on my NodeMCU)
byte offline =0; // bei 0 Anzeigen werden geschrieben 5 kein Can
senden
unsigned long wert; // Variable f�r 4 Bytes vom Can
unsigned long mrTimer; // Mr Timer
unsigned int mrtime=200; // Mr 0x7E0 Senden zeit 200ms
char Fin[17]; // Variable f�r FIN
byte p=0; // Zeiger f�r pid lesen
byte diag_mr[8] = {0x03, 0x22, 0x11, 0x4E, 0x55, 0x55, 0x55, 0x55}; // Diagnose
anfrage Motor 0x7E0
//PID 0 1 2 3 4 5 6 7 8 9 10 11 12 13
14 15 16 17 18 19 20
byte pid1
[]={0x11,0x11,0x11,0x11,0x11,0x11,0xF4,0x10,0x11,0x11,0x10,0x10,0x12,0x10,0xF4,0x10
,0x11,0x10,0x11}; // Lowbyte
byte pid2
[]={0xC1,0x4e,0x4f,0x53,0x56,0x1A,0x0C,0xF9,0xBC,0xA7,0x5E,0xF3,0xFB,0x56,0x10,0x47
,0x16,0x47,0x3D}; // Highbyte
float daten[]={0,1.2,12.35,0.18,130,1.2,664,340,64,120,13.45 ,
0.5,302000,946,48,63,14.79,34,80,320,0.08 ,2000,95,2.5,0,0,0,0,0,0,0};
float
faktor[]={1,0.01,0.01,0.01,1,0.01,0.2,0.04865,0.004,1,0.02,0.01,100,1,0.01,0.09,0.0
1,0.1,1,1,1};
// Faktoren 1 2 3 4 5 6 7 8 10 11 12 14 15
16 17 18 19 20 21

//***************** Variablen f�r Webseite


*****************************************************/
String webstring=""; // zur aufnahme Variablen als String zum senden mit Ajax
byte t=1; // z�hler f�r �bergabe Daten an Webseite
int dl=24; // l�nge von umgesetzte Daten zu Webseite +1
unsigned long azTimer; // Anzeige Timer
unsigned int aztime=60000; // Anzeige Zeit Serial
byte Relais1 =0; // D3 NodeMCU
byte Relais2 =2; // D4 NodeMCU Blaue LED
byte Relais3 =5; // D1 NodeMCU
byte Relais4 =3; // D9 NodeMCU
void setup()

{
/******** WIFI Access Point **************************/
daten[19]=20;daten[20]=30;daten[21]=40;
Serial.begin(115200); // Seriele Schnittstelle
Serial.println();
Serial.print("Configuring access point...");
WiFi.mode(WIFI_AP); // Access Point
WiFi.softAP(ssid, password);
//WiFi.begin(ssid, password);
server.on("/", Ereignis_Index);
server.onNotFound ( handleNotFound );
server.begin();// Starte den Server
Serial.println("Audi"); //2. ESP-0AA54E
Serial.println("HTTP server started");

Serial.print("Status= ");Serial.print(WiFi.status());
// Warte auf verbindung
/*while (WiFi.status() != WL_CONNECTED)
{
delay(500);Serial.print("Status= ");Serial.println(WiFi.status());
Serial.print(".");
}*/
Serial.println("");
Serial.print("Verbunden mit ");
Serial.println(ssid);
Serial.print("IP address: ");
Serial.println(WiFi.localIP());
// ENDE Mit Haus WLAN Verbinden

server.begin(); // Starte den Server


Serial.println("NodeMCU V3: ESP-0AA428 "); //2. ESP-0AA54E
Serial.println("HTTP server started");
/******** WIFI Access Point **************************/

for (int b=0;b<17;b++) {Fin[b]=0x20;} // 0x20 Leerzeichen


if(CAN0.begin(MCP_STDEXT, CAN_500KBPS, MCP_8MHZ) == CAN_OK) // if(CAN_OK ==
CAN.begin(CAN_500KBPS))
{Serial.println("Can1 MCP2515 Initialized Successfully!");
;delay(500);}
else
{Serial.println("Error Initializing MCP2515...");delay(4000);}
// Can Hardware Filter
CAN0.init_Mask(0,0,0x07FF0000); // Init first mask alle sperren...
CAN0.init_Filt(0,0,0x06400000); // Init first filter 0x640
Sensoren
CAN0.init_Filt(1,0,0x06B70000); // Init second filter 0x6B7 Tank

CAN0.init_Mask(1,0,0x07FF0000); // Init second mask...


CAN0.init_Filt(2,0,0x07E80000); // Init third filter MR Diag rx
CAN0.init_Filt(3,0,0x06B40000); // Init fouth filter. FIN
CAN0.init_Filt(4,0,0x010B0000); // Init fifth filter ACC Hebel
CAN0.init_Filt(5,0,0x03C00000); // Init fifth filter Key Status
0x16 1 = Key on 7 =Z�ndung an

pinMode(Relais1, OUTPUT); //pin 0 D3 Relais 1 (High Kl 15


an)
pinMode(Relais2, OUTPUT); //pin 2 D4 Relais 2 (High Can
Daten RX)
pinMode(Relais3, OUTPUT); //pin 5 D1 Relais 2 (Frei)
pinMode(Relais4, OUTPUT); //pin 3 D9 Relais 4 (Frei)
pinMode(4, INPUT);// Setze pin 4 f�r Eingang /INT (D2 an NodeMCU)
CAN0.setMode(MCP_NORMAL); // Set operation mode to normal so the MCP2515 sends
acknowlegde to received data.
Serial.println("MCP2515 mit 500kB auf dem Motorcan...");
digitalWrite(Relais2, HIGH);

} // Void Setup ende


//***************** Senderoutine f�r MR Diagnoseanfrage
*****************************************************
void mrsend() // Senden auf MR Can 500kB Pid Zeiger in p
{
mrtime=200;
diag_mr[2]=pid1[p]; // p = 0 bis 17 auswahl welche diagnose anfrage
diag_mr[3]=pid2[p];
//send data: ID = 0x7E0, Standard CAN Frame, Data length = 8 bytes, 'data' =
array of data bytes to send
if (p!=21&offline!=5) // bei p =20 nix senden (Test Diag VCDS)
{byte sndStat = CAN0.sendMsgBuf(0x7E0, 0, 8, diag_mr);
if(sndStat == CAN_OK){
Serial.print("TX: 7E0 Data: ");
for(int i = 0; i<8; i++) // Schreibe jedes Sendebyte
{ Serial.print(diag_mr[i], HEX);
Serial.print(" "); }
//Serial.print(pid1[p],HEX);Serial.print(" ");Serial.print(pid2[p],HEX);

}
else {
if(offline==0)
{
Serial.println(" 0x7E0 TX Error Sending Message !");
mrtime=1000;
} // if
daten[3]+=0.01;daten[1]+=0.005;
} //else
} //sndstat
Serial.println();
} // mrsend ende

// ************************ Void mrsend ende


***********************************************************
void Ereignis_Index() // Wird ausgef�hrt wenn "http://<ip address>/" aufgerufen
wurde 192.168.4.1
{
if (server.args() > 0) // wenn Argumente im GET Anfrage vorhanden sind z.B
http://<ip address>/?zustand=r
{//Serial.println("Server args");

server.sendHeader("Cache-Control", "no-cache"); // wichtig! nicht aus dem


cache kommen
if (server.arg("ulli") == "0") // pr�fen ob "/?ulli=0"
{
webstring="data"+String(int(t))+":" + String(float(daten[t]) );
server.send(200, "text/plain", webstring);
}
if (server.arg("rel") == "0") // pr�fen ob "/?relais=0"
{
Serial.println("Relais3 Aus");
val = 0;offline=1; // Ausschalten
digitalWrite(Relais3, 0);
//server.send(200, "text/plain", String(int(val) ) );
}
if (server.arg("rel") == "1") // pr�fen ob "/?relais=1"
{
Serial.println("Relais3 Ein");
val = 1;offline=0; // Einschalten
digitalWrite(Relais3, 1);
//server.send(200, "text/plain", String(int(val) ) );
}

if (server.arg("rel") == "2") // Reset gedr�ckt


{
Serial.println("Reset Button");
val = 2; //Maxwerte l�schen

daten[19]=0;daten[20]=0;daten[21]=0;daten[23]=0;
server.send(200, "text/plain", String(int(val) ) );
delay(500);
}//return;
server.send(200, "text/plain", String(int(val) ) ); // Antwort an Internet
Browser senden nur eine Zahl ("0"/"1")

} // If Server Ende
else // wenn keine Argumente im GET Anfrage
{
Serial.println("Sende Index.html");
server.send(200, "text/html", indexHTML); //dann Index Webseite
senden (sehe Datei "index_html.h")
}//else>
t=t+1; if (t>=dl){ t=1; }; // Z�hler t zur�ck setzen
} // Index ende
void handleNotFound()
{
server.send(404, "text/plain", "404: Not found"); // Send HTTP status 404
(Not Found)
}
// ********************* Hauptschleife
***************************************************
void loop()
{
server.handleClient();
digitalWrite(Relais2, 1);
if( p == 17) {p=0;} // Diagnose von 0 bis 17
// Maxwerte in Variablen speichern nur Z�ndung sind manche werte auf 0xFFFF
if(daten[15]>=daten[19]&daten[15]<500) {daten[19]=daten[15];} // Motor ^Moment
max speichern
if(daten[11]>=daten[20]&daten[11]<=150) {daten[20]=daten[11];} // Differenzdruck
max speichern
if(daten[13]>=daten[21]){daten[21]=daten[13];} // Ladedruck max
speichern
if(daten[5]>=daten[23]) {daten[23]=daten[5];}
// ********************* Timer Senden MR Diag
**********************************************
if (millis()>mrTimer+mrtime)
{
p+=1;mrTimer=millis();mrsend();
//Serial.print("Senden von Diagnose Nr. ");Serial.println(p);
} // alle 0,2 sekunden aufrufen
// ********************* Timer n�chste Diagnose
********************************************

if(!digitalRead(4)) // Wenn D2 ist low, dann lese Can


Buffer
{ digitalWrite(Relais2, 0); // blaue Led ein
CAN0.readMsgBuf(&rxId, &len, rxBuf); // Daten lesen: len = daten
l�nge, rxbuf = data byte(s) 0 bis 8
Serial.print("ID: ");
if(rxId < 0x100) { Serial.print("0");} // Wenn kleiner als 0x100, eine 0
vor stellen
Serial.print(rxId, HEX);
Serial.print(" Data: ");
for(int i = 0; i<len; i++) // Schreibe jedes Datenbyte
{
if(rxBuf[i] < 0x10) { Serial.print("0"); }// Wenn kleiner als 0x10, eine 0
vor stellen

Serial.print(rxBuf[i], HEX);
Serial.print(" ");
}// x Bytes ende
Serial.println();

// ************************* MR Antwort in daten[xx] ablegen


******************************************
if(rxId == 0x7e8) // Antwort MR auf Anfrage 0x7E0 0x03 0x22 0x?? 0x??
{
if(rxBuf[0]==5&rxBuf[1]==0x62) // Antwort mit 2 Byte Daten
{ // Diagantwort 2 Bytes
wert=rxBuf[4]*0x100+rxBuf[5]; // 2 Byte zu Word ziehen
Serial.print("Daten Word");Serial.println(wert);
if (rxBuf[2]==pid1[p]&rxBuf[3]==pid2[p]) // univerell
{daten[p]=wert*faktor[p];}
} // Ende if 0x7E8 0x05 0x62 Diagnose Antwort
if(rxBuf[0]==7&rxBuf[1]==0x62) // Antwort mit 4 Byte Daten
{ // Diagantwort 4 Bytes
wert=rxBuf[4]*0x1000000+rxBuf[5]*0x10000;+rxBuf[6]*0x100+rxBuf[7]; // 4
Byte zu long ziehen
Serial.print("Daten Word");Serial.println(wert);
if (rxBuf[2]==0x11&rxBuf[3]==0x56) // Weg seit Regeneration
{daten[4]=wert/1000;daten[23]=wert;
Serial.print("Weg seit Regeneration Data: ");Serial.println(daten[4]);

Serial.print("4 ");Serial.print(rxBuf[4],HEX);
Serial.print("5 ");Serial.print(rxBuf[5],HEX);
Serial.print("6 ");Serial.print(rxBuf[6],HEX);
Serial.print("7 ");Serial.println(rxBuf[7],HEX);
}
} // Ende if 0x7E8 0x07 0x62

} // Ende if rx 0x7E8
//************************ Sensoren vom Can holen
******************************************************
// ******Motor�l***K�hlwasser***************
if(rxId == 0x640) // Abfrage MR Sensoren vom Can
{daten[18]=rxBuf[2]-60; // K�hlwasser
daten[22]=rxBuf[3]*0.75-48;} // Motor�ltemp Ende MR_640
// ******Tankinhalt*************************
if(rxId == 0x6B7) // Abfrage MR Tank (6 Bits)
{daten[17]=rxBuf[5]&0x7F;}
//************************ Fin holen
*******************************************************************
if(rxId == 0x6B4) // Fahrgestellnummer in Fin holen
{ if(rxBuf[0]==1) // 2. Zeichen ZZZ8K69
{ for (int b=1;b<8;b++) {Fin[b]=rxBuf[b];} }

if(rxBuf[0]==2) // 3. Zeichen A92****


{ for (int b=1;b<8;b++) {Fin[b+7]=rxBuf[b];} }
Serial.print("WAU");Serial.write(Fin);Serial.println();
} // rxID 0x6B4 Ende
//************************ Kl15 Relais
******************************************************************
if(rxId == 0x3C0) // Abfrage Key Status ist auf alle Cans
{
//if(bitRead(rxBuf[2],0)==1) // 1. Bit gesetzt Schl�ssel gesteckt Relais 1
ein
//{digitalWrite(Relais1, HIGH);} else {digitalWrite(Relais1, LOW);}
if(bitRead(rxBuf[2],2)==1) // 3. Bit gesetzt Z�ndung an Relais 2 ein
{digitalWrite(Relais2, LOW);} else {digitalWrite(Relais2, HIGH);}
} // Ende 0x3C0
} // digital Read ende

//************************ Anzeige Test


******************************************************************
if (millis()>azTimer+aztime)
{ azTimer=millis();

if (offline==0)
{
Serial.print("Audi A4 B8 0588 AHC ");Serial.print("Fahrgestell-Nr
WAU");Serial.println(Fin);
Serial.println("1 ---------------------------------------------");
Serial.print("Feldgeneration = ");Serial.print(daten[0]);Serial.println("
1=an 0=aus");
Serial.print("Beladung DPF = "); Serial.print(daten[1]);Serial.println(" g
gemessen");
Serial.print("Beladung DPF = "); Serial.print(daten[2]);Serial.println(" g
berechnet");
Serial.print("�lasche "); Serial.print(daten[3]);Serial.println("g ");
Serial.print("Kilometer seit Regeneration =
");Serial.print(daten[4]);Serial.println(" Kilometer");
Serial.print("Abgas n DPF Temp = "); Serial.print(daten[7]);Serial.println("
�C");
Serial.println("2 ---------------------------------------------");
Serial.print("Motor�l Temp = "); Serial.print(daten[22]);Serial.println("
�C");
Serial.print("Motor�lstand = "); Serial.print(daten[8]);Serial.println("
mm");
Serial.print("K�hlwasser Temp = ");Serial.print(daten[19]);Serial.println("
�C");
Serial.print("L�fter 1 = ");Serial.print(daten[16]);Serial.println(" %");
Serial.print("Generator Leistung = ");Serial.print(daten[9]);Serial.println("
Watt");
Serial.print("Bordspannung = ");Serial.print(daten[10]);Serial.println("
Volt");
Serial.print("Tankinhalt = ");Serial.print(daten[20]);Serial.println("
Liter");
Serial.println("3---------------------------------------------");
Serial.print("Motormoment ");Serial.print(daten[15]);Serial.print(" Nm
Maximal = ");Serial.println(daten[19]);
Serial.print("Ladedruck ");Serial.print(daten[13]);Serial.print(" hPa Maximal
= ");Serial.println(daten[21]);
Serial.print("Differenzdruck DPF");Serial.print(daten[11]);Serial.print(" hPa
Maximal = ");Serial.println(daten[20]);
Serial.print("Kraftstoffhochdruck ");Serial.print(daten[12]);Serial.println("
hPa");
Serial.print("Luftmasse im Ansaugkanal
");Serial.print(daten[14 ]);Serial.println(" g/s");
Serial.println("4---------------------------------------------");
}

} // az Timer
} // Void loop Ende

/
***********************************************************************************
**********************
END FILE
***********************************************************************************
**********************/