Go Down

Topic: Comandare ventola PWM con LIN BUS (Read 3009 times) previous topic - next topic

PM68

dubbio: oltra alla loop() hai copiato anche la parserizza(), vero?


ma dove trovo la parserizza()?

Patrick_M

per inserire (lo sketch) il programma, dall'IDE clicca modifica, clicca copia per il forum poi vieni qui e incolla nel tuo post (ctrl+v) ;)

PM68

#32
Jun 21, 2018, 10:00 pm Last Edit: Jun 21, 2018, 10:05 pm by PM68
Ho completato il codice scritto da Nelson "StandardOil" con tutti i miei parametri.
La compilazione non da errori.
L'ho provato ma non si accende niente, sicuramente ho sbagliato qualcosa.
Metto il codice di seguito:

Code: [Select]

// CODICE RILEVAZIONE EVENTI SU LINBUS LEXUS e COMANDO VENTOLE PWM
// di Nelson "StandardOil"
// Idea da sviluppare:

#include <DuePWM.h>
#define PIN_RXE 19
#define PIN_TXE 18
#define PIN_CS 2
#define PIN_FAULT 9
#define PWM_FREQ1  20000
#define PWM_FREQ2  20000
uint8_t rxByte[8];
uint32_t pwm_duty = 0;
DuePWM pwm( PWM_FREQ1, PWM_FREQ2 );

void setup(void)
{
  pinMode(PIN_TXE, OUTPUT);
  pinMode(PIN_CS, OUTPUT);
  digitalWrite(PIN_TXE, HIGH);
  digitalWrite(PIN_CS, HIGH);
  Serial.begin(9600); //debug serial
  Serial.println("Due debug Comms");
  Serial1.begin(19200, SERIAL_8E1); //LIN Serial Rx, 8E1 is BMW iBus standard
  pwm.setFreq1( PWM_FREQ1 );
  pwm.setFreq2( PWM_FREQ2 );
  pwm.pinFreq1( 6 );  // Pin 6 freq set to "pwm_freq1" on clock A
  pwm.pinFreq2( 7 );  // Pin 7 freq set to "pwm_freq2" on clock B
}

void loop(void)
{ byte comando = 0;
  if (Serial1.available())

  {
    // un byte disponibile
    // passo a trattarlo
    comando = parserizza((byte)Serial1.read());
    // tutto il lavoro lo fa la parserizza
    // che restituisce un valore numerico
    // 0 per non trovato
    // 1 per trovato primo comando
    // 2 per trovato.......
  }

  switch (comando)
  {
    case 0:
      // nessun comando da eseguire
      break;

    case 1:
      pwm_duty = 60; // 75% duty cycle
      pwm.pinDuty( 6, pwm_duty );  // 75% duty cycle on Pin 6
      break;

    case 2:
      pwm_duty = 130; // 50% duty cycle
      pwm.pinDuty( 6, pwm_duty );  // 50% duty cycle on Pin 6
      break;

    case 3:
      pwm_duty = 200; // 25% duty cycle
      pwm.pinDuty( 6, pwm_duty );  // 25% duty cycle on Pin 6
      break;

    case 4:
      pwm_duty = 60; // 75% duty cycle
      pwm.pinDuty( 7, pwm_duty );  // 75% duty cycle on Pin 6
      break;

    case 5:
      pwm_duty = 130; // 50% duty cycle
      pwm.pinDuty( 7, pwm_duty );  // 50% duty cycle on Pin 6
      break;

    default:
      // comando non trovato
      break;
  }
}

byte parserizza(byte in)
{
  // riceve byte a byte un comando e lo usa per riconoscere il comando complessivo
  // dichiaro una matrice di matrici di byte
  // il problema è che le sequenza non hanno lunghezza uguale tra loro
  // quindi devo anche dichiarare un array di lunghezze
  // potessi usare le stringhe, sarebbe comodo ma esistono degli 00 nel flusso
  // quindi una matrice bidimensionale di byte (larga quanto il più lungo comando)
  // con una matrice monodimensionale di lunghezze
  byte comandi[6][9];// 6 comandi per nove byte massimi
  byte lunghez[6]; // 6 lunghezze
  // inizializzo
  comandi[1][1] = 0x00;
  comandi[1][2] = 0x60;
  comandi[1][3] = 0xFE;
  comandi[1][4] = 0x00;
  lunghez[1] = 4;

  comandi[2][1] = 0x00;
  comandi[2][2] = 0x66;
  comandi[2][3] = 0xFE;
  comandi[2][4] = 0x00;
  lunghez[2] = 4;

  comandi[3][1] = 0x00;
  comandi[3][2] = 0x78;
  comandi[3][3] = 0xFE;
  comandi[3][4] = 0x00;
  lunghez[3] = 4;

  comandi[4][1] = 0x00;
  comandi[4][2] = 0xF8;
  comandi[4][3] = 0x00;
  lunghez[4] = 3;

  comandi[5][1] = 0x00;
  comandi[5][2] = 0xF8;
  comandi[5][3] = 0xFE;
  comandi[5][4] = 0x00;
  lunghez[5] = 4;

  //siccome leggo il comando byte a byte devo tenere traccia di quanto lungo ho letto
  //e siccome devo confrontarlo con 6 possibili comandi devo avere sei indici, uno per possibile comando
  // statico per non perdere l'informazione da un ingresso al successivo
  static byte trovato[6] = {0, 0, 0, 0, 0, 0}; // variabili locali vanno inizializzate
  // adesso conosco un byte e vedo se corrisponde con la posizione raggiunta in ognuno dei possibili comandi
  for (byte i = 0; i < 6; i++)

  {
    // per ogni comando
    if (comandi[i][trovato[i]] != in)
    {
      // se il byte 'in' non corrisponde al byte in posizione [trovato[i]]
      // non e' il carattere giusto
      trovato[i] = 0; // riporto indietro il contatore
    }
    else
    {
      // è il carattere giusto
      // delle due l'una
      // o siamo alla fine del comando oppure no
      if (trovato[i] == lunghez[i])
      {
        // comando finito, ho trovato tutti i byte
        // riporto a zero l'indice, per ripartire bene la prossima volta
        trovato[i] = 0;
        // me ne esco da questa funzione restituendo il numero del comando trovato
        // più uno perchè zero indica comando non trovato
        return i + 1;
      }
      else
      {
        // comando non ancora finito, devo aspettare altri byte per sepere se è il giusto
        // aggiorno l'indice per controllare il prossimo byte
        trovato[i]++;
      }
    }
  }

  // se sono arrivato fin qui vuol dire che non ho trovato nessun comando
  // restituisco 0 -> comando non trovato
  return 0;
}


Vorrei visualizzare sulla seriale qualche variabile per capire cosa sta facendo e magari mi aiuta a capire dove si blocca. Pensavo alla variabile "trovato"  però se aggiungo
Code: [Select]
      Serial.println(trovato[i], HEX);   
mi dice 'i' was not declared in this scope.

Standardoil

infatti, ne trovato ne i sono globali, puoi farlo solo nella parserizza, quella variabili "vivono" solo nella parserizza()
anzi, per l'esattezza la i anche solo nella for() della parserizza
magari nella else, dopo la riga
Code: [Select]
// è il carattere giusto
puoi mettere una stampa, li le due variabili "vivono"
per altro non mi sembra di vedere errori, ma è anche mezzanotte passata
sono accettati consigli da forumisti più bravi di me
Prima legge di Nelson (che sono io): Se vuoi il mio aiuto dimostrami almeno che hai letto il nostro "aiutateCi ad aiutarVi"

Non bado a studenti, che copino altrove

Tu hai problema-Io ti domando-Tu non mi rispondi: vuol dire che non ti serve più

PM68

#34
Jun 22, 2018, 08:15 pm Last Edit: Jun 23, 2018, 09:25 am by PM68
Funziona! E' da perfezionare ma funziona!

1° problema quando accendo il quadro la ventola parte a cannone anche se non ho comandato nessuna accensione.

Quando comando l'accensione rallenta e va correttamente alla velocità 3, quando comando di passare alla velocità 2 passa correttamente alla 2.

2° problema quando comando di passare alla velocità 1 va avanti alla 2. Probabilmente non riconosce il codice.

3° problema quando spengo non si spegne perchè non c'è niente che gli dice di spegnersi.

Dovrei mettere un millis che dopo 1 sec che non riceve comandi si spegne.
Oppure provo a vedere se c'è un codice che gira solo quando le ventole sono comandate spente.


PM68

Un aggiornamento:

ho capito che non stavo leggendo interamente i frame sulla Lin Bus.
Dopo vari tentativi a varie velocità penso di essere arrivato alla quadra.

Serial1 19200
Serial 57600 (molto più veloce per non perdere pezzi).

Ora leggo dei frame molto regolari. Es.:

66 66 78 1E 0 1E 0 E0 0 E0 0 0 FE E6 0
66 66 6 0 0 0 0 0 0 0 FE FE 0
66 66 9E 0 1E 0 0 0 0 0 0 E0 0
66 66 1E 0 6 60 80
18 18 60 86 0 

66 66 78 1E 0 1E 0 E0 0 E0 0 0 FE E6 0
66 66 6 0 0 0 0 0 0 0 FE FE 0
66 66 9E 0 1E 0 0 0 0 0 0 E0 0
66 66 1E 0 6 60 80
18 18 60 86 0 

66 66 78 1E 0 1E 0 E0 0 E0 0 0 FE E6 0
66 66 6 0 0 0 0 0 0 0 FE FE 0
66 66 9E 0 1E 0 0 0 0 0 0 E0 0
66 66 1E 0 6 60 80
18 18 60 86 0 

66 66 78 1E 0 1E 0 E0 0 E0 0 0 FE E6 0
66 66 6 0 0 0 0 0 0 0 FE FE 0
66 66 9E 0 1E 0 0 0 0 0 0 E0 0
66 66 1E 0 6 60 80
18 18 60 86 0 

Ho analizzato 45 sec di trasmissione (circa 3400 righe) dove ho cambiato stato ogni 5 sec tenendo traccia della modifica e ho identificato i frame che girano in ogni stato.

Se qualcuno è interessato posso mandare file di Excel dove ho usato vari colori in modo che si capisce abbastanza bene come cambiano i codici.

PM68

#36
Jun 30, 2018, 03:28 pm Last Edit: Jun 30, 2018, 03:38 pm by PM68
Help!
Il codice non da errori ma la parserizza restituisce sempre "0".
Cosa sbaglio?
Code: [Select]

// CODICE RILEVAZIONE EVENTI SU LINBUS LEXUS e COMANDO VENTOLE PWM
// di Nelson "StandardOil":

#include <DuePWM.h>
#define PIN_RXE 19
#define PIN_TXE 18
#define PIN_CS 2
#define PIN_FAULT 9
#define PWM_FREQ1  20000
#define PWM_FREQ2  20000
uint16_t rxByte[16];
uint32_t pwm_duty = 0;
DuePWM pwm( PWM_FREQ1, PWM_FREQ2 );

void setup(void)
{
  pinMode(PIN_TXE, OUTPUT);
  pinMode(PIN_CS, OUTPUT);
  digitalWrite(PIN_TXE, HIGH);
  digitalWrite(PIN_CS, HIGH);
  Serial.begin(57600); //debug serial
  Serial.println("Due debug Comms");
  Serial1.begin(19200, SERIAL_8E1); //LIN Serial Rx, 8E1 is BMW iBus standard
  pwm.setFreq1( PWM_FREQ1 );
  pwm.setFreq2( PWM_FREQ2 );
  pwm.pinFreq1( 6 );  // Pin 6 Vent SX freq set to "pwm_freq1" on clock A
  pwm.pinFreq2( 7 );  // Pin 7 Vent DX freq set to "pwm_freq2" on clock B
}

void loop(void)
{ byte comando = 0;
  if (Serial1.available())
  {
    // un byte disponibile -  passo a trattarlo
    comando = parserizza((byte)Serial1.read());
    // tutto il lavoro lo fa la parserizza che restituisce un valore numerico
    // 0 per non trovato
    // 1 per trovato primo comando
    // 2 per trovato.......
  }

  switch (comando)
  {
    case 0: //comando non trovato non fa niente

      break;

    case 1: //vent SX 3
      pwm_duty = 70; // 75% duty cycle
      pwm.pinDuty( 6, pwm_duty );  // 75% duty cycle on Pin 6
      break;

    case 2: //vent SX 3
      pwm_duty = 70; // 75% duty cycle
      pwm.pinDuty( 6, pwm_duty );  // 75% duty cycle on Pin 6
      break;

    case 3: //vent SX 3
      pwm_duty = 70; // 75% duty cycle
      pwm.pinDuty( 6, pwm_duty );  // 75% duty cycle on Pin 6
      break;

//HO DOVUTO CANCELLARE UN PEZZO PER NON ECCEDERE I 9000 CARATTERI

    case 47: //SPENTO_VENT_SX
      pwm_duty = 255; // 0% duty cycle
      pwm.pinDuty( 6, pwm_duty );  // 0% duty cycle on Pin 6*/
      break;

    default:

      break;
  }
}

byte parserizza(byte in)
{
  // riceve byte a byte un comando e lo usa per riconoscere il comando complessivo
  // dichiaro una matrice di matrici di byte
  // il problema è che le sequenza non hanno lunghezza uguale tra loro
  // quindi devo anche dichiarare un array di lunghezze
  // potessi usare le stringhe, sarebbe comodo ma esistono degli 00 nel flusso
  // quindi una matrice bidimensionale di byte (larga quanto il più lungo comando)
  // con una matrice monodimensionale di lunghezze
  byte comandi[47][57];// 47 comandi per 57 byte massimi
  byte lunghez[5]; // 5 lunghezze
  // inizializzo
  //SX3
  comandi [1][1] = 0x66;
  comandi [1][2] = 0x66;
  comandi [1][3] = 0x78;
  comandi [1][4] = 0x1E;
  comandi [1][5] = 0x00;
  comandi [1][6] = 0x1E;
  comandi [1][7] = 0x00;
  comandi [1][8] = 0xE0;
  comandi [1][9] = 0x00;
  comandi [1][10] = 0xE0;
  comandi [1][11] = 0x00;
  comandi [1][12] = 0x00;
  comandi [1][13] = 0xFE;
  comandi [1][14] = 0xE6;
  comandi [1][15] = 0x00;
  comandi [1][16] = 0x66;
  comandi [1][17] = 0x66;
  comandi [1][18] = 0x06;
  comandi [1][19] = 0x00;
  comandi [1][20] = 0x00;
  comandi [1][21] = 0x00;
  comandi [1][22] = 0x00;
  comandi [1][23] = 0x00;
  comandi [1][24] = 0x00;
  comandi [1][25] = 0x00;
  comandi [1][26] = 0xFE;
  comandi [1][27] = 0xFE;
  comandi [1][28] = 0x00;
  comandi [1][29] = 0x66;
  comandi [1][30] = 0x66;
  comandi [1][31] = 0x9E;
  comandi [1][32] = 0x00;
  comandi [1][33] = 0x1E;
  comandi [1][34] = 0xF8;
  comandi [1][35] = 0x00;
  comandi [1][36] = 0x00;
  comandi [1][37] = 0x00;
  comandi [1][38] = 0x00;
  comandi [1][39] = 0x00;
  comandi [1][40] = 0x00;
  comandi [1][41] = 0xE0;
  comandi [1][42] = 0xFE;
  comandi [1][43] = 0x00;
  comandi [1][44] = 0x66;
  comandi [1][45] = 0x66;
  comandi [1][46] = 0x1E;
  comandi [1][47] = 0x00;
  comandi [1][48] = 0x06;
  comandi [1][49] = 0x60;
  comandi [1][50] = 0x80;
  comandi [1][51] = 0x18;
  comandi [1][52] = 0x18;
  comandi [1][53] = 0x60;
  comandi [1][54] = 0x86;
  comandi [1][55] = 0x00;
  lunghez [1] = 55;
  //SX3
  comandi [2][1] = 0x66;
  comandi [2][2] = 0x66;
  comandi [2][3] = 0x78;
  comandi [2][4] = 0x1E;
  comandi [2][5] = 0x00;
  comandi [2][6] = 0x1E;
  comandi [2][7] = 0x00;
  comandi [2][8] = 0xE0;
  comandi [2][9] = 0x00;
  comandi [2][10] = 0xE0;
  comandi [2][11] = 0x00;
  comandi [2][12] = 0x00;
  comandi [2][13] = 0xFE;
  comandi [2][14] = 0xE6;
  comandi [2][15] = 0x00;
  comandi [2][16] = 0x66;
  comandi [2][17] = 0x66;
  comandi [2][18] = 0x06;
  comandi [2][19] = 0x9E;
  comandi [2][20] = 0x00;
  comandi [2][21] = 0x00;
  comandi [2][22] = 0x00;
  comandi [2][23] = 0x00;
  comandi [2][24] = 0x00;
  comandi [2][25] = 0x00;
  comandi [2][26] = 0x60;
  comandi [2][27] = 0xFE;
  comandi [2][28] = 0x00;
  comandi [2][29] = 0x66;
  comandi [2][30] = 0x66;
  comandi [2][31] = 0x9E;
  comandi [2][32] = 0x00;
  comandi [2][33] = 0x1E;
  comandi [2][34] = 0xF8;
  comandi [2][35] = 0x00;
  comandi [2][36] = 0x00;
  comandi [2][37] = 0x00;
  comandi [2][38] = 0x00;
  comandi [2][39] = 0x00;
  comandi [2][40] = 0x00;
  comandi [2][41] = 0xE0;
  comandi [2][42] = 0xFE;
  comandi [2][43] = 0x00;
  comandi [2][44] = 0x66;
  comandi [2][45] = 0x66;
  comandi [2][46] = 0x1E;
  comandi [2][47] = 0x00;
  comandi [2][48] = 0x06;
  comandi [2][49] = 0x60;
  comandi [2][50] = 0x80;
  comandi [2][51] = 0x18;
  comandi [2][52] = 0x18;
  comandi [2][53] = 0x60;
  comandi [2][54] = 0x86;
  comandi [2][55] = 0x00;
  lunghez [2] = 55;

//HO DOVUTO CANCELLARE UN PEZZO PER NON ECCEDERE I 9000 CARATTERI

  //SPENTO_SX
  comandi [47][1] = 0x66;
  comandi [47][2] = 0x66;
  comandi [47][3] = 0x78;
  comandi [47][4] = 0x1E;
  comandi [47][5] = 0x00;
  comandi [47][6] = 0x1E;
  comandi [47][7] = 0x00;
  comandi [47][8] = 0xE0;
  comandi [47][9] = 0x00;
  comandi [47][10] = 0xE0;
  comandi [47][11] = 0x00;
  comandi [47][12] = 0x00;
  comandi [47][13] = 0xFE;
  comandi [47][14] = 0xE6;
  comandi [47][15] = 0x00;
  comandi [47][16] = 0x66;
  comandi [47][17] = 0x66;
  comandi [47][18] = 0x06;
  comandi [47][19] = 0x00;
  comandi [47][20] = 0x78;
  comandi [47][21] = 0x00;
  comandi [47][22] = 0x00;
  comandi [47][23] = 0x00;
  comandi [47][24] = 0x00;
  comandi [47][25] = 0x00;
  comandi [47][26] = 0xFE;
  comandi [47][27] = 0x00;
  comandi [47][28] = 0x00;
  comandi [47][29] = 0x66;
  comandi [47][30] = 0x66;
  comandi [47][31] = 0x9E;
  comandi [47][32] = 0x00;
  comandi [47][33] = 0x1E;
  comandi [47][34] = 0x00;
  comandi [47][35] = 0x00;
  comandi [47][36] = 0x00;
  comandi [47][37] = 0x00;
  comandi [47][38] = 0x00;
  comandi [47][39] = 0x00;
  comandi [47][40] = 0xE0;
  comandi [47][41] = 0x00;
  comandi [47][42] = 0x00;
  comandi [47][43] = 0x66;
  comandi [47][44] = 0x66;
  comandi [47][45] = 0x1E;
  comandi [47][46] = 0x00;
  comandi [47][47] = 0x06;
  comandi [47][48] = 0x60;
  comandi [47][49] = 0x80;
  comandi [47][50] = 0x00;
  comandi [47][51] = 0x18;
  comandi [47][52] = 0x18;
  comandi [47][53] = 0x60;
  comandi [47][54] = 0x86;
  comandi [47][55] = 0x00;
  lunghez [47] = 55;

  //siccome leggo il comando byte a byte devo tenere traccia di quanto lungo ho letto
  //e siccome devo confrontarlo con 6 possibili comandi devo avere sei indici, uno per possibile comando
  // statico per non perdere l'informazione da un ingresso al successivo
  static byte trovato[57] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; // variabili locali vanno inizializzate
  // adesso conosco un byte e vedo se corrisponde con la posizione raggiunta in ognuno dei possibili comandi
  for (byte i = 0; i < 57; i++)

  {
    // per ogni comando
    if (comandi[i][trovato[i]] != in)
    {
      // se il byte 'in' non corrisponde al byte in posizione [trovato[i]]
      // non e' il carattere giusto
      trovato[i] = 0; // riporto indietro il contatore
    }
    else
    {
      // è il carattere giusto delle due l'una o siamo alla fine del comando oppure no
      Serial.println(trovato[1], HEX);
      if (trovato[i] == lunghez[i])
      {
        // comando finito, ho trovato tutti i byte riporto a zero l'indice, per ripartire bene la prossima volta
        trovato[i] = 0;
        // me ne esco da questa funzione restituendo il numero del comando trovato più uno perchè zero indica comando non trovato
        return i + 1;
      }
      else
      {
        // comando non ancora finito, devo aspettare altri byte per sepere se è il giusto
        // aggiorno l'indice per controllare il prossimo byte
        trovato[i]++;
      }
    }
  }

  // se sono arrivato fin qui vuol dire che non ho trovato nessun comando
  // restituisco 0 -> comando non trovato
  return 0;
}

PM68

Buongiorno a tutti,
mi succede che quando la scheda Arduino Due è collegata al PC e quindi alimentata da quest'ultimo il programma si comporta in un certo modo mentre quando stacco il PC e alimento l'Arduino tramite i 12v dell'auto si comporta diversamente.
Qualcuno mi sa dare una spiegazione?

Patrick_M

per inserire (lo sketch) il programma, dall'IDE clicca modifica, clicca copia per il forum poi vieni qui e incolla nel tuo post (ctrl+v) ;)

PM68

Non pensavo ai disturbi perchè le prove le faccio a motore spento e i 12v dell'auto sono da batteria quindi stabili.
Pensavo più alla resistenza di pullup che ho messo sul segnale di ingresso perchè Arduino Due ha il processore a 3.3v. Può essere che cambiando l'alimentazione dai 5v dell'USB ai 12v dell'auto devo modificare la resistenza?

Standardoil

Se metti lo schema sappiamo di cosa stiamo parlando
Comunque il programma che hai postato è fallato, come programma
E stai andando nella direzione sbagliata, come concetto
Adesso sono sul lavoro, stasera ti spiego...
Prima legge di Nelson (che sono io): Se vuoi il mio aiuto dimostrami almeno che hai letto il nostro "aiutateCi ad aiutarVi"

Non bado a studenti, che copino altrove

Tu hai problema-Io ti domando-Tu non mi rispondi: vuol dire che non ti serve più

PM68

#41
Jul 30, 2018, 05:28 pm Last Edit: Jul 30, 2018, 05:37 pm by PM68
Grazie Nelson,
aspetto le tue spiegazioni.
Di seguito lo schema:


Standardoil

#42
Jul 30, 2018, 08:24 pm Last Edit: Jul 30, 2018, 08:34 pm by Standardoil
Dopo  una giornata in ditta col condizionatore guasto e due ore dal medico in 30 in sala d'attesa mi sono preso il colpo della strega con l'aria condizionata a casa; se sarò quindi un po' brusco mi sopporterai.....
la prima cosa che ho notato nel tuo programma attuale è che hai dimensionato 47 comandi ma l'array di lunghezze è lungo solo 5; dovrebbe, anzi "deve" avere la stessa lunghezza della prima dimensione dell'array dei comandi, messo così come lo hai messo tu il programma se va lo fa solo per fortuna
per seconda cosa, 47 comandi per solo 2 ventole a tre velocità (5 contando "fermo" e "massimo") sono troppi, non è la strada giusta
Allora ho cercato il datasheet del chip mcp2004: è poco più di un puro convertitore di livello, dal 12 V del LIN bus alla tensione di lavoro dell'arduino, non interpreta i dati, ne fa sincronizzazione o simili, tutto lavoro che quindi deve fare l'arduino, e li tu non lo fai
In particolare non "strippa" il codice 0x55 che sarebbe l'inizio della trasmissione, e in nessuno dei tuoi "elenchi di cose ricevute" si vede. Se non lo vedi è perchè non lo ricevi, e se non lo ricevi è perchè hai problemi a livello di comunicazione lato LIN bus
e qui ho visto un paio di cose: di default il LIN bus sembra andare a 9600bps, non 19200, ti conviene provare un po' di velocità, con costanza apri la seriale a 19200, poi a 9600, poi a 4800, e via così
poi la parità che usi (8E1) non è lo standard LIN, viene usata da BMW, ma non in un LIN bus, in una sua cosa propietaria
da una ricerca è saltato fuori che varie persone sono riuscite a leggere il LINbus con una UNO e la sua software serial, quindi nemmeno c'è la possibilità di cambiare parità, ergo usa la parità di default
inoltre io sono sempre convinto che la trasmissione LIN è composta da massimo 11 byte preceduti da un "silenzio" lungo almeno 13 bit
1 byte 0x55 Start e sincronismo tra i device
1 byte di indirizzo, dove alcuni bit specificano l'indirizzo, e altri sono di parità aggiuntiva
1, 2, 4 oppure 8 (ma non 3 o 5 o 6 o 7) byte di "risposta" (viene chiamata risposta anche quando viene trasmessa dal master)
1 byte di CRC o checksum o quello che è
ora, 1 + 2 + al massimo 8 fa al massimo 11
dagli esempi che ho trovato sono sicuro che la lunghezza di messaggi "omologhi" (che vuol dire che fanno cose simili) è costante, dipende dal tipo di messaggio, ma non esiste che per regolare una ventola un messaggio sia lungo 7 mentre per regolare l'altra il messaggio sia lungo 45, anche perchè è evidente che le ventole sono "simili" come progetto, quindi non è che in sede di installazione l'operaio che le monta debba scoprire la lunghezza del messaggio
da ultimo tieni presente che il protocollo LINbus prevede delle tolleranze sulle velocità, e siccome i device slave "non" hanno un oscillatore a cristallo, ma si regolano in base alla cadenza dello 0x55 iniziale non è escluso che le tolleranze dell'oscillatore di arduino non vadano bene , potrebbe essere necessario, per migliorare la qualità della trasmissione, di "aggiustare" di qualche percento i bps della seriale
Comunque, ripeto, fino a che non vedi gli 0x55 NON stai ricevendo correttamente dal lato LINbus
da ultimo lo schema: spero tu ti sia sbagliato e non sia quello lo schema che usi, dato che ti sei dimenticato di mettere il regolatore di tensione citato nella documentazione del trasnceiver
quindi vedi di mettere un regolatore a 3v3 e usare quello per connetttere la resistenza di Pull-up
Inoltre il piedino di fault lo metti in una define, ma non ne fai la pinmode e non lo usi, credo debba essere alto
E adesso lasiamelo dire: metà di queste cose te le avevo già dette, l'altra meta viene da una veloce scorsa al datasheet del 2004, che potevi fare anche tu
Prima legge di Nelson (che sono io): Se vuoi il mio aiuto dimostrami almeno che hai letto il nostro "aiutateCi ad aiutarVi"

Non bado a studenti, che copino altrove

Tu hai problema-Io ti domando-Tu non mi rispondi: vuol dire che non ti serve più

PM68

Grazie Nelson, porta pazienza ma sono un perito meccanico.
Ora cerco di capire quello che hai scritto e metterlo in pratica.


Standardoil

Tranquillo, io son perito elettrotecnico
basta non essere ingannieri................
Prima legge di Nelson (che sono io): Se vuoi il mio aiuto dimostrami almeno che hai letto il nostro "aiutateCi ad aiutarVi"

Non bado a studenti, che copino altrove

Tu hai problema-Io ti domando-Tu non mi rispondi: vuol dire che non ti serve più

Go Up