Looking for asistance with ALDL project...

[Quaraxkad]

I tried manually setting numbers for all three values after 0x58 one at a time, and the second one is the only one that causes the gauge to respond. Even if my MSB and LSB calculation is correct, the LSB doesn't do anything! I can *not* imagine that's how the gauge works with only ~27 steps between 0 and 7000.

I could play with eehack, but that's just another thing I don't understand and would have to learn how to wire up and use...

[Quaraxkad]

Success! I changed my code to this and got a smooth sweep from 500 up...

byte msb = 0;
byte lsb = 0;

void setup() {
  Serial.begin(8192);
}

void loop() {
  delay(10);
  lsb++;
  if (lsb > 254) {
    msb++;
    lsb = 0;
  }

  byte b2[5] = {0x0A, 0x58, 0x00, msb, lsb};

  unsigned int x = 0, sum = 0;
  for (x = 0; x < sizeof(b2); x++) sum += b2[x];
  byte cs2 = ( 256 - ( sum % 256 ) );
  Serial.write(b2, 5);
  Serial.write(cs2);
}

Now to figure out what I was doing wrong to begin with. It's gotta be the LSB math?

[steveo]

it worked already!?
that byte order thing always screws me around too.
the uno int is 16 bit so you can probably just cast it.

b2[3] = (unsigned int)rpm;

[Quaraxkad]

Something is weird here... I had the cluster out of the car because I was tired of walking back and forth to the garage for every tiny code change... That's when I got the smooth sweep. The gauge starts at 600, increases by one segment up to 3000, then two segments the rest of the way to 7000. I thought I was done with the precariously alligator-clipped bench setup, so I put it back in the car, may or may not have made changes to the code, can't remember... And now we're back to 5-7 segment chunks instead of 1-2. I'm finished fiddling for the day. Here's where I ended:

int rpm = 0;

void setup() {
  Serial.begin(8192);
}


uint8_t get_cs(uint8_t *barray) {
  int x = 0;
  int sum = 0;
  int len = *(&barray + 1) - barray;
  for (x = 0; x < len; x++) sum += barray[x];
  return ( 256 - ( sum % 256 ) );
}

void loop() {
  if (Serial.availableForWrite() > 0) {
    delay(10);
    rpm++;
    uint8_t msb = (byte)((rpm >> 8) & 0xFFu);
    uint8_t lsb = (byte)(rpm & 0xFFu);

    //byte msg1[12] = {0x05, 0x5F, 0x00, 0x20, 0x00, 0x3C, 0x80, 0x00, 0x00, 0x02, 0x00, 0x01};
    //byte msg1_cs = get_cs(msg1);

    uint8_t msg2[5] = {0x0A, 0x58, 0x00, msb, lsb};
    uint8_t msg2_cs = get_cs(msg2);

    //byte msg3[4] = {0xF0, 0x56, 0xF4, 0xC6};

    Serial.write(msg2, 5);
    Serial.write(msg2_cs);
  }
}

[steveo]

i don't think this is working code:

int len = *(&barray + 1) - barray;

you could use the length byte in the datastream message itself

int len = barray[1] - 0x51;

[Quaraxkad]

I wasn't sure if sizeof(barray) was working, so I found that with a google search... Most of this code is copy/pasted from google searches. I don't really understand c-like syntax, I'm a VB.net programmer! Anyway, I got it working again with a potentiometer input, I can control the display perfectly.

void setup() {
  Serial.begin(8192);
}

void loop() {
  delay(10);
  int rpm = analogRead(2) * 7;
  byte msb = ((rpm >> 8) & 0xFFu);
  byte lsb = (rpm & 0xFFu);
  byte b2[5] = {0x0A, 0x58, 0x00, msb, lsb};

  unsigned int x = 0, sum = 0;
  for (x = 0; x < sizeof(b2); x++) sum += b2[x];
  byte cs2 = ( 256 - ( sum % 256 ) );
  Serial.write(b2, 5);
  Serial.write(cs2);
}

Now comes the part I will definitely need help with: finding a tachometer input source. The car this PCM came out of (04 Impala) sends a Class 2 signal to its gauge cluster for the tach. Is that a viable RPM source? Would I have to code an entire OBDII interface system to use it?

[steveo]

totally viable. it would be a bit of a pain from the ground up and you'd need to build some hardware

other people have already made solutions for that: https://freematics.com/store/index.p...&product_id=83

it has an api

int value;
obd.read(PID_RPM, value);

40 bucks, though, and all the extra hardware, doesn't seem very elegant.

personally i'd get an input connected to maybe the coil trigger wire or even the crank or cam sensor, then sample it.

that's what i did when i needed to tap a VSS sensor to make the speedo interface for my bike.

you could even do inductive pickup if you wanted to, i think an optocoupler and a simple coil would suffice? never tried but then your arduino could take the rpm of anything that sparks, given the number of hits per engine revolution, which means your project could be re-used by anyone that possesses this dashboard and has swapped ECMs.

there are lots of ways to do it on the software end

i personally used the analog input as my signal ended up being a bit too noisy for the digital input to be reliable, and did my own sampling. the logic i used was kind of like this,

if pin is low, and voltage above (switching point + x), pin is high
if pin is high, and voltage below (switching point - x), pin is low

you can then tune x to a sufficiently large threshold to filter any noise around the switch point

then you just need to determine how many milliseconds have passed between switch events to derive the frequency of the input.

there's the millis() function that returns an always increasing counter, so you can just have a millis_at_last_switch variable, then subtract current millis() to get the elapsed time since the last event.