AVR Freaks

Thanks for the reply. 

At the moment I think I really only need to look at 3 bits. I think I will keep it simple and do the whole byte but will see how I go. 

I was going to try and keep it to RC timing. I don't know how critical it will be at this stage.

Looks like a bit more reading on bitbang and byte in byte out.....what ever they are.

This is the data stream I have managed to get so far.

Bugger. 3217 only has one usart. Mega168/328 might be the go.

Since posting that and doing a little research what you have stated is what I found. Thank you. 

As far as I know I don't need another one.

It should make it a little easier.

Hey Curtvm,

Were you on the piss or jsut making sure I do my homework. ;-) Some interesting tricks/errors in there. Thanks, ,akes my mind do what is needed.

How acurate does the baud rate have to be?

My measurements of the data calulates the pulse width to be 0.128ms. A more "logical" width would be 0.125ms.

0.128ms gives a baud rate of 7812.5

0.125ms gives a baud rate of 8000

The latter makes calulations "in my head at least" much easier. In general would the receiver be able to adjust to this baud rate? I know I am jumping ahead but thats me.

Also while trying to do the code side of this I am confusing myself no end. I will atempt to post some code tomrrow so people can point out my errors......in the code only please.

Now that looks to me like some blatant plugging there.

Ok. I am resurrecting this quest. I have a USB to serial converter so I can supply some packets for capture.

Question, how can I create and save a file that can provide the packets I need?

You make it sound so easy.

I will give it a try.

I have both Win 10 and Linux on a laptop, dual boot. They have both been on there for about the same time. Linux takes about 1 minute to boot......Win 10 lives up to its name, 10 minutes. Blobware.

I have had a bit more of a think regarding the inputs and outputs. 

There will only be 7 bytes RXed as the 8th byte it a checksum byte so I can ignore that as it will be recalculated. Should be simple.

Once they are received I will replace the 5th byte with the value I need. Should be simple. 

Calculate the new checksum and place it in the 8th byte. Already have the code to calculate this.

Now the bit I might need a little help with. I need to send byte 1 then wait for "x"ms then send the next and so on. Would I use millis for this or try and do something with a timer?

Ok. Having lots of fun with all this NOT.

I will get little bits out of the way at a time. Easy one first.

If I have a Serial.write command which I hope will send one byte out and I want to wait 5ms to send the next would delay (5)  delay fromthe start of the first byte or fromthe end of the byte?

I have written a nice bit of code (For me it is anyway. First bit I have written all by myself so I am pretty impressed) that sends out the required serial data with the correct timing. (still need to check it on a CRO). I had some trouble to start with. I did it on a Leonardo I had which has 2 serial ports, USB and USART, which I didn't know I had to refer to differently.

Now my problem. I am using an UNO to "decode" this serial message but it doesn't. Do I have to refer to the USART port as Serial1 as I do on the Leo? Can I set up a different pin as a RX pin?

Yes a real Tektronics one. 4 channel 200MHz.

EDIT: I see your point. It is a digital storage colour display so I suppose it really isn't a CRO in the true sense.

I should still be able to read the RX pin or do I need to unplug it from the USB and power it externally?

Thank you. I will have a read.

I have put them in functions. Hope it makes more sense.

Also what should be inplace if indx=0?

//Wondatre R1.0

#include "Wire.h"
#include <EEPROM.h>
#include <SoftwareSerial.h>

SoftwareSerial RXSerial(2, 3); // RX, TX

byte indx;
uint8_t buf[8];
uint8_t bufIdx;
uint8_t new_byte;
uint8_t x;

int gear_in;
int Gear;
int sensorVal;
int out1 = 5;
int out2 = 6;
int rxd = 13;
int txd = 14;
int gearN = 0x00;
int gear1 = 0x20;
int gear2 = 0x40;
int gear3 = 0x60;
int gear4 = 0x80;
int gear5 = 0xA0;

void setup()

//stolen from PIGPI

{

  delay(500); //wait to settle
  pinMode(out1, OUTPUT);
  pinMode(out2, OUTPUT);
  pinMode(rxd, INPUT_PULLUP);
  pinMode(txd, OUTPUT);
  pinMode(A0, INPUT);

  // Read sensor value

  sensorVal = analogRead (A0);

  //Save Gear to EEPROM

  if (sensorVal < 666 )

  {
    // No Change
    Gear = EEPROM.read(0); //Load gear from EEPROM
  }
  else if  (sensorVal > 667 and sensorVal <= 800)
  {
    Gear = 1; //4th Gear
  }
  else if  (sensorVal > 801 and sensorVal <= 905)
  {
    Gear = 2; //5th Gear
  }

  EEPROM.update(0, Gear); // Only writes if different

  switch (Gear)
  {
    case 1:  digitalWrite(out1, HIGH); break;
    case 2:  digitalWrite(out2, HIGH); break;
  }

  Serial.begin(9600);
  RXSerial.begin(9600);

}

void loop()
{
  sensorVal = analogRead (A0);

  Gear = EEPROM.read(0); //Load gear from EEPROM

  if (sensorVal > 301)

    switch (Gear)
    {
      case 1:  digitalWrite(out1, HIGH); break;
      case 2:  digitalWrite(out2, HIGH); break;
    }

  gear_in = analogRead (A0);      // read gear
  /*  Serial.println(Gear);           // For testing
    Serial.println(gear_in);        // For testing
    delay(1000);                    // For testing
  */

  if (gear_in <= 300)
  {
    new_byte = gearN;
  }

  else if (gear_in > 301 and gear_in <= 420)
  {
    new_byte = gear1;

  }

  else if (gear_in > 421 and gear_in <= 540)
  {
    new_byte = gear2;
  }

  else if (gear_in > 541 and gear_in <= 665)
  {
    new_byte = gear3;
  }

  else if (gear_in > 666 and gear_in <= 800)
  {
    new_byte = gear4;
  }

  else if (gear_in > 801 and gear_in <= 905)
  {
    new_byte = gear5;
  }
  
  /*
    Serial.print ("New_Byte ");       // For testing
    Serial.println (new_byte, HEX);   // For testing
    delay(1000);                      // For testing
  */
  
  read_data_replace_byte5();
  calculate_checksum();
  write_bytes();
  
}
  //EVERYTHING ABOVE THIS LINE WORKS

// This bit is to check every 100ms for the next 8 bytes. Will work this out later.

  /*    for (uint8_t i = 0; i < 100; i++, _delay_ms(1) ) {
        if (read_byte >= 0)it
        } i = 0                           //start over if rx data
    }
    int
  */
  
void read_data_replace_byte5()

  //Read data from ECU and store in buf
  {
    if (RXSerial.available() > 0);
    byte ECU_byte = RXSerial.read();
    indx = 0;

    if (indx < sizeof buf);
    buf [indx++] = ECU_byte;

    Serial.print ("ECU_Byte = ");       // For testing
    Serial.println (ECU_byte, HEX);   // For testing
    Serial.print ("New_Byte = ");       // For testing
    Serial.println (new_byte, HEX);   // For testing
  
    if (indx = 5, buf[5] = new_byte);     //check for byte 5....working
    
    Serial.print ("indx =  ");         // For testing
    Serial.println (indx);            // For testing

    Serial.print ("buf 0 =  ");         // For testing
    Serial.println (buf[0], HEX);            // For testing
    Serial.print ("buf 1 =  ");         // For testing
    Serial.println (buf[1], HEX);            // For testing
    Serial.print ("buf 2 =  ");         // For testing
    Serial.println (buf[2], HEX);            // For testing
    Serial.print ("buf 3 =  ");         // For testing
    Serial.println (buf[3], HEX);            // For testing
    Serial.print ("buf 4 =  ");         // For testing
    Serial.println (buf[4], HEX);            // For testing
    Serial.print ("buf 5 =  ");         // For testing
    Serial.println (buf[5], HEX);            // For testing
    Serial.print ("buf 6 =  ");         // For testing
    Serial.println (buf[6], HEX);            // For testing

  }

void calculate_checksum()

  // Calculate checksum - Appears to be working
  {
    int checksum = 0;
    for (int x = 0; x <= 6; x++); {
      checksum = checksum + buf[x];
      Serial.print ("Checksum =  ");         // For testing
      Serial.println (checksum, HEX);            // For testing

      buf[7] = 0xff - checksum; // Replace byte 7 with new checksum
    }
    Serial.print ("buf 7 =  ");         // For testing
    Serial.println (buf[7], HEX);            // For testing
    delay(0);                      // For testing

  }
void write_bytes()
{
/*
  //write Data to display
  {
    byte write_byte;
    bufIdx = 0;
    while ( bufIdx < 8 ) write_byte;
    buf[bufIdx++];
    RXSerial.write(buf, 7);
    delay(5);      // pauses for 5 milliseconds before sending the next byte
  }
*/
}

Thanks. I will have a play tomorrow.

Ok. I will try and simplify my requirements here. 

In the Void setup() I am detecting the gear the ike is in. If the bike is in any gear other than 4th or 5th it will go to the loop. If it is in 4th or 5th it will safe this value to EEPROM.

Once into void loop() It reads the EEPROM and A0 again and and if sensorval is above 301 sets the output per case1 or case2, these active a transistor to enable an output. This works.

The next step is to determine the actual gearthat is selected whilst riding. The ranges are there because each bike maybe be slightly different but will be apporx in the middle of each range per gear.

Curt, you mentioned that I missed 301 but it doesn't need to be that accurate and if it was anywhere near 301 there would be a problem. I have just made it a nice and wide window for each gear.

Everything up to this point works.

Thanks to the link Curt provided I might do some changes but I will explain what the rest is trying to do.

1.   read the serial in. Store it or now possibly echo as suggested. Currently not working. It is only ever place data in the 1st byte.

2.   When it reads the 6th byte I need to relace it with the hex value of the current gear. Sort of works.

3.   Take the first 7 bytes and calculate the checksum. This works but will try the method in the link. 

I will have a try over the next few nights and see what I can do.

Thanks again for your suggestions

PS. Curt, not sure how this can work. It only gives specific values and not ranges.

const adcGear_t gearTable[] = {
    { 300, 0x00 }, //if <= adcVal, return gearVal
    { 420, 0x20 },
    { 540, 0x40 },
    { 665, 0x60 },
    { 800, 0x80 },
    { 905, 0xA0 },
    // >905 ? error value or ?
    { 0xffff, 0xA0 } //{ 0xffff, 0xff }