hi,
sorry for the late response but i fryde my Arduino.. and needed to fix it. i think i know how to communication works. i can get table 16 from the bike and calculate the RPM.

now i just need to implement it with your code.
This is my code: ( yeah its a mess, just needed it to talk)

`*/
#define SWversion "version 0.4"
// Serial Debug USB
#define debug Serial
//Serial to connect to the bike
#define bike Serial1
#define TX_PIN 18
#define t0

//Status Flags
#define SUCCESS 0
#define TIMEOUT 1
#define BUSY 2
#define BUFFEROVERFLOW 3

// default variable
// Flag for ECU connection
byte ECUconnected;
byte resbuf[26];
byte resState;
uint16_t RPM;

//initialise communications messages
byte MessageWakeup[] = {0xFE, 0x04, 0x72, 0x8C}; // wakeup no responce from ECU
byte MessageInitialise[] = {0x72, 0x05, 0x00, 0xF0, 0x99}; //initialise communications The ECU should respond with: 02 04 00 FA

//get info from ECU VFR Specific
byte Table00[] = { 0x72, 0x07, 0x72, 0x00, 0x00, 0x06, 0x0F}; //unknown
byte Table10[] = { 0x72, 0x07, 0x72, 0x10, 0x00, 0x06, 0xFF}; //unknown
byte Table11[] = { 0x72, 0x07, 0x72, 0x11, 0x00, 0x06, 0xFE}; //unknown
byte Table16[] = { 0x72, 0x07, 0x72, 0x16, 0x00, 0x06, 0xF9}; //vfr 1200f responce
byte Table20[] = { 0x72, 0x07, 0x72, 0x20, 0x00, 0x06, 0xEF}; //unknown
byte Table21[] = { 0x72, 0x07, 0x72, 0x21, 0x00, 0x06, 0xEE}; //unknown
byte TableD0[] = { 0x72, 0x07, 0x72, 0xD0, 0x00, 0x06, 0x3F}; //unknown
byte TableD1[] = { 0x72, 0x07, 0x72, 0xD1, 0x00, 0x06, 0x3E}; //unknown
byte Table61[] = { 0x72, 0x07, 0x72, 0x61, 0x00, 0x06, 0xAE}; //unknown
byte Table70[] = { 0x72, 0x07, 0x72, 0x70, 0x00, 0x06, 0x9F}; //unknown

// needed to calculate checksum
byte calculate[] = {0x72, 0x07, 0x72, 0x60, 0x00, 0x06};

void setup() {
// put your setup code here, to run once:
debug.begin(115200);// For debugging
debug.println("Starting setup");
// needed for Bluetooth
//EEBlue.begin(9600); //Default Baud for comm, it may be different for your Module.

}

void loop() {

unsigned long startedWaiting = millis();

ECUconnected = BUSY;
//Try to connect with the ECU
while (ECUconnected == BUSY){
 ECUconnected = initHonda();
 }
while (ECUconnected == SUCCESS) {

   // Request table 16
  bike.write(Table16, sizeof(Table16));
  bike.flush();
  bikeFlush();
  // Receive the response. Receiving this way will block the Arduino.
  resState = BUSY;
  delay(300);
  //checkResponse();
  while (resState == BUSY) {
    resState = getResponse(resbuf);
  }
  // Successfully received the response message which is stored in resbuf
  if (resState == SUCCESS) {
   // Check if response is positive
     if (resbuf[3] == 0x16) { // change from 0x16 to D1
        uint16_t varY = resbuf[5];
        varY = varY << 8;
        varY = varY + resbuf[4];
        RPM = varY;            
        // Do something with RPM e.g. show on LCD
        debug.println("");
        debug.print("RPM ");
        debug.println(RPM,DEC);
        debug.println("");  
        debug.println("Tabel 16");          
        debug.print("hex");
        debug.println("");
        
        for(int i = 0; i< 26; i++)
         {
           debug.print(resbuf[i],HEX);
           debug.print("-");
          }
        debug.println("");

     } 
     else {
        // No positive response, reset ECU connection
        ECUconnected = BUSY;
     }
} 
else if (resState == TIMEOUT) {
  // Timeout, reinitiate ECU
  debug.println("Timeout Getting Responce");
  RPM = 0;
 ECUconnected = BUSY;

}

// Simple check the response to debug terminal
void checkResponse(){
while (bike.available() > 0){
byte incomingByte = bike.read();
debug.print(incomingByte, HEX);
debug.print(' ');
}
}
// cleare bike terminal
void bikeFlush(){
while(bike.available()) bike.read();
}

//initialise communications
byte initHonda(){
debug.println("Starting initialise Honda");
bike.end();
delay(350);
//Sending LOW
digitalWrite(TX_PIN, LOW);
delay(70);
//Sending High
digitalWrite(TX_PIN, HIGH);
delay(120);
pinMode(TX_PIN, OUTPUT);
//Start Bike serial1
bike.begin(10400);
bike.write(MessageWakeup, sizeof(MessageWakeup)); //Send WakeUp
delay(200);
bike.write(MessageInitialise, sizeof(MessageInitialise)); // initialise communications
bike.flush(); // wait to send all

resState = BUSY;
// Try to read a wakeup is send
while (resState == BUSY) resState = getResponse(resbuf);
if (resState == SUCCESS) {
delay(300);
resState = BUSY;
// Try to read initialise responce
while (resState == BUSY) resState = getResponse(resbuf);
if (resState == SUCCESS) {
if (resState == SUCCESS) {
return SUCCESS;
} else {
debug.println("Failed init Honda, somthing is wrong retry"); // Return false if diagnostic mode request was denied or failed
return BUSY;
}
}
if (resState == TIMEOUT){
debug.println("TIMEOUT init Honda"); // Return false if diagnostic mode request was denied or failed
return BUSY;
}
}
if (resState == TIMEOUT){
debug.println("TIMEOUT WakeUp Honda"); // Return false if diagnostic mode request was denied or failed
return BUSY;
}
}

byte getResponse(byte *rbuffer) {
// These bytes remain unchanged in between function calls
// Used to monitor the response while not blocking the program
static int index = 0;
static int len = 255;
static unsigned long t = 0;

// After a request is send the timer is set
if (t == 0) t = millis();
// Check if function call is within timeout limit
if (millis() - t < 250) {
// Check if more bytes need to be received
if (index < len) {
// Check if bytes are available
unsigned long startedWaiting = millis();
while (bike.available() > 0) {
t=0;
rbuffer[index] = bike.read();

    // First received byte must be correct 0xFE, 0x04, 0x72, 0x8C
    if (rbuffer[0] == 0xFE){
   // debug.print(rbuffer[0], HEX);
      // Clear bike RX buffer
      while(bike.available()) bike.read();
      memset(rbuffer, 0, sizeof(rbuffer));
      debug.println("Wakeup OK");
       
          t = 0;
          index = 0;
          len = 255; 
      return SUCCESS;
      
     }

     if ((rbuffer[0] == 0x02) && (rbuffer[1] == 0x04) && (rbuffer[2] == 0x00) && (rbuffer[3] == 0xFA)){
        // Clear bike RX buffer
        while(bike.available()) bike.read();
        debug.println("ini OK");  
          t = 0;
          index = 0;
          len = 255;
          delay(200);
          memset(rbuffer, 0, sizeof(rbuffer));
        return SUCCESS;
     }
    if (rbuffer[3] == 0x16){

          t = 0;
          //index = 0;
          index++;
          len = 12;
        return BUSY;
     }
     index++;
      return BUSY; 
      
   }
   debug.println("Timeout");
    return TIMEOUT;
    
 }
  // Read all bytes, reset timer, index and length
 else {
  t = 0;
  index = 0;
  len = 255;
  delay(55);
  //debug.println("succes");
  return SUCCESS;
 }

}
else {
t = 0;
index = 0;
len = 255;
//debug.println("Timeout");
return TIMEOUT;
//return BUSY;
}
}
`

this is the Result from the serial interface:

Starting initialise Honda
Wakeup OK
ini OK
RPM 0
Tabel 16
hex
2-C-72-16-0-0-0-19-A-0-0-47-0-0-0-0-0-0-0-0-0-0-0-0-0-0-

Connect with Honda #5

Description

Metadata

Metadata

Assignees

Labels

Projects

Milestone

Relationships

Development

Issue actions