NefMoto

Hi guys,

I'm going to give a little background to my problem before I delve into the deep.  I'm planning on building a little Arduino board with a can-bus shield and plan on reading some basic variables in the ECU and displaying them on the cluster.  I've programmed before, but never used ASM so I'm going to have to do a bit of reading. 

The first problem, I know the MK4 Golf wasn't fully can-bus, but the clock pinout has a 3? can-bus pairs.  Can I use the can-bus to display information on the cluster, or does the cluster not support can as standard?

Even if the cluster does support can, what about the rest of the car?  I have a feeling some modules are connected with can-bus, but does the loom run to all of them?  Specifically, does the ECU support can-bus, and how do you grab from it?

Obviously it's programmed through the k-line and that's how you log from it, but logging into the ECU takes time (3 seconds) and I'd like to use the Arduino to display on the clocks as soon as the ignition comes on, to display "Hello, Adam" or similar.  So logging into the clocks with the k-line would take too much time and hence not be suitable. 

So, can I use can-bus on the cluster to display a welcome screen and then go to k-line to log the ECU for display on the cluster?

I know it sounds convoluted, probably because I'm making it, but this is all new to me.  For now, even if I can get the cluster to display nmot, or gangi or whatever I'd be happy, a Welcome screen is a bonus.

Yes, I know you can buy a magic box, but that's no fun.

Fanxxxxxxx

yes you can grab some vars from the can-bus
like an IAT, nmot or coolant temp. but there is bo boost, no egt, no gangi or something else that maybe really useful
another way - using kline and kwp1281 :) ro read what you need. (or better kwp2000 with direct memory access :)  )

clocks display working by 3LB protocol (in my mk4) and there is no problem with time delay login. im using one of these boxes to display useful data at screen and welcome message working good on it.

mk4 uses different can-bus networks for engine and comfort

btw which transeiver you are using? and do you have a library and working sniffer? im planning to make some air suspension controller with can-bus shield

I was thinking of you when I wrote the post!  I knew you had it working on a 032HN 0001 bin - which is the one I'm using!

Can you get the code from the box?  I'm curious to see how the welcome screen works.  I was just worried about the time delay for the clocks to respond to login and then display Welcome on the screen when the ignition is turned on.  So you turn on the ignition, the Arduino becomes live, has to wait to log in to the clocks and THEN displays Welcome.  This long delay would look bad, almost like the clocks have to "boot".

I remember you linked to the box in another thread but the guy is no longer selling them.  I wonder what chip they're based on.  I'll look into Arduino and k-line/kwp1281. 

I've bought a SeeedStudio canbus shield, but obviously it's now not going to work as I'd hoped.

So, how can I connect to the clocks and the ECU with an Arduino.  Can you break it down for me, I'm really new to this.  I'm going to start preparing notes when I get home from work! :)

http://kovo-blog.blogspot.ro/2013/11/audi-fis-3-line-protocol.html

Seems like a start. 

nono
3LB doesnt require login, cluster will display any message instantly after turning on ignition. arduino is another story, as i remember it tooks a few seconds to boot and its not good :(

this box uses PIC18F4585-I/PT and its all i know about it. i have firmware for this but no sources, i think reading about 3LB protocol will be much more useful for you. as i remember there is just a flag that tell a clocks to use all screen instead of top 1/3

also this box doesnt work on audis because of .. something different idk

Awesome!  It's not quite what I wanted to hear, but thanks!

I might look into getting a box, because it seems simpler.  I like the challenge of being able to do it myself though.  I guess I could have the Arduino permanently powered up and then it just receives the ignition on signal which starts the code - that way I can display a Welcome screen.

I'm going to have a read when I go home; thanks!

Will keep this thread updated with my progress!

KWP2000 and pulling things from ECU ram:

https://github.com/KEOpenSource/ME7Explorer

To write some text on the instrument cluster with the 3LB protocol is easy.

Every message consists of 18 bytes.
The first byte is always 0xF0 and the last byte is a checksum. The 16 characters in between are the actual text. For upper case letters it's simple ASCII.

Keep in mind that all bits on the 3LB are inverted.

I attached two logic analyzer traces of the 3LB. You can open them with the Saleae Logic tool.

"radio_to_fis.logicdata" is a trace of a real Audi radio, sending data to the cluster.

Recently I implemented a demo of the 3LB on an ATMega32. I used the timer interrupts to get the timing as accurate as possible.
"avr_to_fis.logicdata" is the trace of the ATMega sending data to the cluster.

I also add the source code for the microcontroller. I used WinAVR to compile it.
The external clock was 11.059 MHz.
If you want to port the code to another AVR or use another crystal, you will have to modify the timer settings accordingly.

Regards, Stefan

I was going to email you Stefan!  Your username and actual name obviously refer to the product you already sell, but I didn't want to email because I thought it would be cheeky and you wouldn't want to give away any secrets!

However, that is the total polar opposite, thank you!

I've just bought a TTL UART cable so that I can k-line connect with the car and Arduino.

Am I right in thinking that you can control the whole LCD, rather than just the top half?  Your product seems to suggest that. 

Just now, I just want to connect to the cluster and display some text, I will move on to trying to get a Welcome screen to work - as I think that will be the hardest part, and then get the cluster displaying ECU variables.  Nyet has already posted up a link that I'm going to help use to create this.

The Arduino cable that I've bought seems to have well documented libraries that I can us to help me.

Your information has been fantastic, thanks! :)

I have been looking at VW CAN Bus protocol 2.0, and seems to me that other info and/or engine variables can be requested to ECU.

Yes, you can control the whole screen via 3LB, but the protocol is more complex than the example given above.

I suggest to go step by step. First write some simple text to the cluster. Then gather the needed parameters from the K-line or the CAN bus that you want to display.

That's what I'm going to do.  I've just bought the UART cable from America so should see it hopefully around the middle of next week at best. 

I know that I can grab variables from the ECU with the k-line, but I'm not convinced the MK4 is linked to the ECU with CAN, so I think using that would be fruitless.

Going from that, I think it would be best to use the k-line to display and grab data from the ECU, assuming that the k-line can be used to control the whole LCD.

You could just post the source code to your FIS-control. ;)

If I understand you right, you want to use the K-line to read data from the ECU and also to write data to the cluster screen.

First of all, I don't even know if you can control the cluster screen via K-line. Maybe this is possible using some OBD commands that allow to modify the RAM of the cluster.
Another problem would be, that you can not use the K-line to communicate with two control units at the same time. Ok, you could solve this by separating the K-line of the cluster from the rest.


Please check the preconditions:
- How to get data from the ECU:
Connect VCDS and have a look at the used protocol. All Mk4 should use KWP1281. Only the R32 is using KWP2000.
If your Mk4 already has CAN bus, there should be some data there (like RPM, speed, oil temperature and so on).

- How to write text to the cluster:
3LB should always work for the Mk4. If the part number of the cluster is "1Jx 920  xxx", then you can also use CAN bus.

That was the idea, but I've not really given it deep thought, just passing ideas around just now.  Never even gave the thought of sending/receiving data from two separate modules at the same time.

My ECU uses KWP1281, not sure if it has can-bus (it's a 2001 model), but I have a feeling it might, I'll need to check.

The part number of the cluster is 1Jx 920 xxx, so I guess I can use can-bus.  I noticed that there is two can-bus pairs on the clocks, are they the same?  I'll check with a multimeter when I get home. 

So, I use a UART module to read the ECU and pull data from it, and then parse it and write it to the cluster with 3LB, or can-bus?

So:
1: ECU > UART > Arduino > 3LB/Cluster
2: ECU > UART > Arduino > Canbus/Cluster

Thoughts?

The canbus pairs on the clocks are not the same, so they must feed different modules within the clocks.  Needles, LCD, something else?

Going to have a look at code next to get the display to atleast say something.

So, got the Arduino to connect to the canbus, with the coolant level check warning coming up, I receive:
18   0   255   0   0   0   0   0   

With the warning disabled, I receive:
6   0   255   0   0   0   0   0     (something like that, I can't remember now), will check in a bit.

That's just using the basic Read example from Arduino and getting the baud rate correct.  Assuming that's connecting to the 000 address?

Will have to inspect to the code to see how to read other addresses.

I've written up a little code that I'm going to try at home.  It seems that the 3LB protocol is just a 3 wire (SPI) interface.  It communicates between the cluster and the radio for the navigation.

After doing some reading, the OEM radio communicates down the Clock, Data and Enable line - which is illustrated on the back of the radio.  This harness is in the form of a green plug that would go into the radio, and make its way to the cluster.

Tracing the wires with the help of the internet, it makes its way to the cluster to the green plug - namely pins 30, 31, 32, with the labels clock, data and enable respectfully.

I'm going to connect the Arduino's clock, data and enable pins to the appropriate cluster pins to see what the outcome is.

Once I can get data on the screen, I have to work how the Nav system takes control of the whole screen, and how I can go from there.

I've ordered a TTL cable that will allow me to connect to the k-line, so once I can display data, I can use the TTL cable to connect to the ECU to get logging.

I'm getting somewhere.  I now want to know how I can use the whole LCD screen - assuming it still works through the CLK, DAT, ENA lines, but how do I use it from initial ignition on so that I can create a new Welcome screen.

I'll get the cluster hooked up when I get home and let you know.

A TTL cable is not what you need to interface the K line. Or do you mean KKL cable?

http://arduinodev.com/hardware/obd-kit/

Basically a KKL cable.  It seems to be FTDI based.

Compiled code for this but still not getting to far.  I've connected:

//data MOSI  pin -> uno: 11
//clk  SCK     pin -> uno: 13
//ena           pin -> uno: 2

So far, nothing.  The top of the cluster is still black, but not sure if it needs to be in the car to "wake up", or if it'll respond from the bench.

Obviously because I'm using the Uno, ZZottel's code doesn't transfer across because he's used a different AVR.  I'm convinced that the timings are wrong, but this is still way over my head.

[quote code]
#include <SPI.h>
//spi version:
//http://arduino.cc/en/Reference/SPI
//data MOSI pin -> uno/due: 11,mega: 51
//clk  SCK  pin -> uno/due: 13,mega: 52
//ena       pin -> uno/due/mega 2
#define useSPI

//nospi version:
//data pin 4
//clk  pin 3
//ena  pin 2

//WRITE TO CLUSTER
#define FIS_WRITE_ENA 2
#ifndef useSPI
#define FIS_WRITE_CLK 13
#define FIS_WRITE_DATA 11
#endif
#define FIS_WRITE_PULSEW 50
#define FIS_WRITE_STARTPULSEW 50
#define FIS_WRITE_START 15 //something like address, first byte is always 15
//END WRITE TO CLUSTER

//#define BINCODE 000011111011111010101010101110111011011010111100101100111010101010111101101011001011001110110000101010011011111010110100101101101011111010010011
//                000011111011111010101010101110111011011010111100101100111010101010111101101011001011001110110000101010011011111010110100101101101011111010010011

//int BINCODE[144]={
//0,0,0,0,1,1,1,1,
//1,0,1,1,1,1,1,0,
//1,0,1,0,1,0,1,0,
//1,0,1,1,1,0,1,1,
//1,0,1,1,0,1,1,0,
//1,0,1,1,1,1,0,0,
//1,0,1,1,0,0,1,1,
//1,0,1,0,1,0,1,0,
//1,0,1,1,1,1,0,1,
//1,0,1,0,1,1,0,0,
//1,0,1,1,0,0,1,1,
//1,0,1,1,0,0,0,0,
//1,0,1,0,1,0,0,1,
//1,0,1,1,1,1,1,0,
//1,0,1,1,0,1,0,0,
//1,0,1,1,0,1,1,0,
//1,0,1,1,1,1,1,0,
//1,0,0,1,0,0,1,1};

//WRITE TO CLUSTER
String FIS_WRITE_line1="";
String FIS_WRITE_line2="";
long FIS_WRITE_rotary_position_line1=-8;
long FIS_WRITE_rotary_position_line2=-8;
char FIS_WRITE_CHAR_FROM_SERIAL;
int FIS_WRITE_line=1;
long FIS_WRITE_last_refresh=0;
int FIS_WRITE_nl=0;
int FIS_WRITE_ENA_STATUS=0;
//END WRITE TO CLUSTER

//WRITE TO CLUSTER
void FIS_WRITE_sendTEXT(String FIS_WRITE_line1,String FIS_WRITE_line2);
void FIS_WRITE_sendByte(int Bit);
void FIS_WRITE_startENA();
void FIS_WRITE_stopENA();
//END WRITE TO CLUSTER

void setup(){
//WRITE TO CLUSTER
pinMode(FIS_WRITE_ENA, OUTPUT);
digitalWrite(FIS_WRITE_ENA,LOW);
#ifndef useSPI
pinMode(FIS_WRITE_CLK, OUTPUT);
digitalWrite(FIS_WRITE_CLK, LOW);
pinMode(FIS_WRITE_DATA, OUTPUT);
digitalWrite(FIS_WRITE_DATA, LOW);
#endif
Serial.begin(19200);
//END WRITE TO CLUSTER
}

void loop(){
//WRITE TO CLUSTER
if (Serial.available()) {
        FIS_WRITE_CHAR_FROM_SERIAL=(char)Serial.read();
        Serial.print(FIS_WRITE_CHAR_FROM_SERIAL);
        if (FIS_WRITE_CHAR_FROM_SERIAL == '\n') {
          FIS_WRITE_nl=1;
          if (FIS_WRITE_line==1){
            FIS_WRITE_line=2;
          } else {
            FIS_WRITE_line=1;
           }
        } else {
          if (FIS_WRITE_line==1){
              if (FIS_WRITE_nl){
                FIS_WRITE_nl=0;
                FIS_WRITE_line1="";
                FIS_WRITE_rotary_position_line1=-8;
                }
              FIS_WRITE_line1+=FIS_WRITE_CHAR_FROM_SERIAL;
          } else {
              if (FIS_WRITE_nl){
                FIS_WRITE_nl=0;
                FIS_WRITE_line2="";
                FIS_WRITE_rotary_position_line2=-8;
                }
               FIS_WRITE_line2+=FIS_WRITE_CHAR_FROM_SERIAL;
          }
        }

 }
   
  int FIS_WRITE_line1_length=FIS_WRITE_line1.length();
  int FIS_WRITE_line2_length=FIS_WRITE_line2.length();
  String FIS_WRITE_sendline1="        ";
  String FIS_WRITE_sendline2="        ";

 
   
    //do rotary and refresh each 0.5second
    //refresh cluster each 5s
    if(millis()-FIS_WRITE_last_refresh>500 && !FIS_WRITE_line1_length || !FIS_WRITE_line2_length){
    FIS_WRITE_startENA(); //try to enable
     if (FIS_WRITE_ENA_STATUS){ //enable set to HIGH, good to go
      if (FIS_WRITE_line1_length>8){
      for (int i=0;i<8;i++){
        if (FIS_WRITE_rotary_position_line1+i>=0 && (FIS_WRITE_rotary_position_line1+i)<FIS_WRITE_line1_length) {
          FIS_WRITE_sendline1=FIS_WRITE_line1[FIS_WRITE_rotary_position_line1+i];
        }
      }
       if (FIS_WRITE_rotary_position_line1<FIS_WRITE_line1_length){
              FIS_WRITE_rotary_position_line1++;
       } else {
              FIS_WRITE_rotary_position_line1=-8;
              FIS_WRITE_sendline1="        ";
       }
     } else {
       FIS_WRITE_sendline1=FIS_WRITE_line1;
     }
     if (FIS_WRITE_line2_length>8){
      for (int i=0;i<8;i++){
        if (FIS_WRITE_rotary_position_line2+i>=0 && (FIS_WRITE_rotary_position_line2+i)<FIS_WRITE_line2_length) {
          FIS_WRITE_sendline2=FIS_WRITE_line2[FIS_WRITE_rotary_position_line2+i];
        }
      }
       if (FIS_WRITE_rotary_position_line2<FIS_WRITE_line2_length){
              FIS_WRITE_rotary_position_line2++;
       } else {
             
              FIS_WRITE_rotary_position_line2=-8;
       }
     } else {
       FIS_WRITE_sendline2=FIS_WRITE_line2;
     }
      // Serial.println("refresh");
      FIS_WRITE_sendTEXT(FIS_WRITE_sendline1,FIS_WRITE_sendline2);
      FIS_WRITE_last_refresh=millis();
      FIS_WRITE_stopENA();
    //end refresh
     }
  }
//END WRITE TO CLUSTER 
}

//WRITE TO CLUSTER
void FIS_WRITE_sendTEXT(String FIS_WRITE_line1,String FIS_WRITE_line2) {
  int FIS_WRITE_line1_length=FIS_WRITE_line1.length();
  int FIS_WRITE_line2_length=FIS_WRITE_line2.length();
    if (FIS_WRITE_line1_length<=8){
        for (int i=0;i<(8-FIS_WRITE_line1_length);i++){
          FIS_WRITE_line1+=" ";
          //Serial.println(FIS_WRITE_line1);
        }
    }
    if (FIS_WRITE_line2_length<=8){
      for (int i=0;i<(8-FIS_WRITE_line2_length);i++){
        FIS_WRITE_line2+=" ";
      }
    }

int crc=(255-FIS_WRITE_START+FIS_WRITE_line1[0]+FIS_WRITE_line1[1]+FIS_WRITE_line1[2]+FIS_WRITE_line1[3]+FIS_WRITE_line1[4]+FIS_WRITE_line1[5]+FIS_WRITE_line1[6]+FIS_WRITE_line1[7]+FIS_WRITE_line2[0]+FIS_WRITE_line2[1]+FIS_WRITE_line2[2]+FIS_WRITE_line2[3]+FIS_WRITE_line2[4]+FIS_WRITE_line2[5]+FIS_WRITE_line2[6]+FIS_WRITE_line2[7])%256;
#ifdef useSPI
  SPI.begin();
  SPI.setDataMode(SPI_MODE2);
  SPI.setBitOrder(MSBFIRST);
  SPI.setClockDivider(SPI_CLOCK_DIV128);
  #endif
FIS_WRITE_sendByte(FIS_WRITE_START);
FIS_WRITE_sendByte(255-FIS_WRITE_line1[0]);
FIS_WRITE_sendByte(255-FIS_WRITE_line1[1]);
FIS_WRITE_sendByte(255-FIS_WRITE_line1[2]);
FIS_WRITE_sendByte(255-FIS_WRITE_line1[3]);
FIS_WRITE_sendByte(255-FIS_WRITE_line1[4]);
FIS_WRITE_sendByte(255-FIS_WRITE_line1[5]);
FIS_WRITE_sendByte(255-FIS_WRITE_line1[6]);
FIS_WRITE_sendByte(255-FIS_WRITE_line1[7]);
FIS_WRITE_sendByte(255-FIS_WRITE_line2[0]);
FIS_WRITE_sendByte(255-FIS_WRITE_line2[1]);
FIS_WRITE_sendByte(255-FIS_WRITE_line2[2]);
FIS_WRITE_sendByte(255-FIS_WRITE_line2[3]);
FIS_WRITE_sendByte(255-FIS_WRITE_line2[4]);
FIS_WRITE_sendByte(255-FIS_WRITE_line2[5]);
FIS_WRITE_sendByte(255-FIS_WRITE_line2[6]);
FIS_WRITE_sendByte(255-FIS_WRITE_line2[7]);
FIS_WRITE_sendByte(crc);
#ifdef useSPI
  SPI.end();
#endif
FIS_WRITE_stopENA();
}

void FIS_WRITE_sendByte(int Byte){
#ifdef useSPI
  SPI.transfer(Byte);
#else
  shiftOut(FIS_WRITE_DATA,FIS_WRITE_CLK,MSBFIRST,Byte);
#endif
}

void FIS_WRITE_startENA(){
  if (!digitalRead(FIS_WRITE_ENA)) {
  digitalWrite(FIS_WRITE_ENA,HIGH);
  delayMicroseconds(FIS_WRITE_STARTPULSEW);
  digitalWrite(FIS_WRITE_ENA,LOW);
  delayMicroseconds(FIS_WRITE_STARTPULSEW);
  digitalWrite(FIS_WRITE_ENA,HIGH);
  delayMicroseconds(FIS_WRITE_STARTPULSEW);
  FIS_WRITE_ENA_STATUS=1;
  }
}

void FIS_WRITE_stopENA(){
 digitalWrite(FIS_WRITE_ENA,LOW);
 FIS_WRITE_ENA_STATUS=0;
}
//END WRITE TO CLUSTER

[/quote]

Using that for code, but I'm getting nothing.  Just wanting something that'll display "Hello world" so I can understand the timings, that's all.

Gads.

You are using the hardware SPI of the Arduino Uno.
The Uno has a 16 MHz clock.
You set the SPI divider to 128.
This results in an SPI clock of 125 kHz.
The 3LB is between 7 and 8 kHz.

Thanks man.  I'm going to have a look tonight to see how I can get the bus to go that low, first impressions show that it won't.

If it's not obvious, this is my first venture with custom hardware and software combined.  I have no past experience with SPI's, buses, ports, timings, etc, and all of this is massively new to me.

I'm going to keep reading and if you want, you can keep supplying snippets of advice, its fantastic! :)

So I did a bit of reading last night, discovered that the SPI divider is obviously the divider against the crystal clock speed.  In case of the Uno - which is 16MHz, a divider of 128 would result in a clock speed of 125kHz.

Since the SPI of the clocks is between 7 and 8kHz, I'd need a larger divider.  You can half the clock speed of the Uno, but its a bad method of programming, so I'm not going to go down that road.

Spent a good while researching bit banging, so seem to have a few ideas that I'm going to try.  I'll need to buy a sillyscope to help with matching the outputs.

All this prescaler, WGM12, DDRB is giving me a headache, but I'm going to plod on.  Trying to understand Port outputs, etc is difficult as I have no past experience with it.

I guess all of these questions are for an Arduino forum, rather than here though.  Just like to keep the thread updated with progress. :)

Hi there!  Any updates?
  (@adam-)

I'm very interested, too.

http://secuduino.blogspot.co.uk/2011/10/fis-seat-leon-cupra-english.html

@bennyboi  Thanks for the link!
Just what I'm looking for.

Hello, is there any update?

Yes, I have a fully working FIS control on GitHub.

This works in a rs4 b5 2001 with can bus?

i need this too  8) 8) but for can bus cluster :) kwp1280 skoda fabia 5j 2008 1,9tdi PD

It should , the clusters should still have 3lb bus - it was dropped in a6 c5 clusters from my2002 ver.d12