Looking for asistance with ALDL project...

[kur4o]

The whole conversion might be wrong

 ldd     #$168
RESERVED:90BF                 ldx     word_1C3 minorloop reference
RESERVED:90C2                 fdiv
RESERVED:90C3                 cpx     #$168
RESERVED:90C6                 bhi     loc_90CB
RESERVED:90C8                 ldx     #0
RESERVED:90CB
RESERVED:90CB loc_90CB:                               ; CODE XREF: BYTE_d1_SOME_SPEEDO_RELsub_8FEB+DBj
RESERVED:90CB                 stx     word_1B26
RESERVED:90CE                 xgdx
RESERVED:90CF                 lsrd
RESERVED:90D0                 lsrd
RESERVED:90D1                 lsrd
RESERVED:90D2                 adcb    #0
RESERVED:90D4                 adca    #0
RESERVED:90D6                 std     word_15D streamed word

This is the pcm calculation from 94 pcm $0A 58 message. It is some kind of high res rpm, but time based than revolution based.

To get a better picture of the dash conversion start dumping 0a 58 xx xx xx messages with raw mode in eehack program and look how it is interpreted by the dash.

It could also be

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

[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?