centralina accensione motore

diciamo che dopo molti tentativi senza risultati potrei mettercela la punta... ma da 24 ahahah

michele visto che tu sei molto ferrato (vista la tua guida) che dici, sarebbe molto difficile far funzionare quel micro onboard una volta montato su una basetta che renda i pin umani? :smiley:

Non c'è niente di difficile, c'è solo da fare pratica, se lavori con componenti smd ti serve un saldatore con punta finissima per i componenti passivi e per gli integrati a passo SOIC; dal TSSOP in poi (pin molto più ravvicinati) si usa una punta più larga ed il flussante, esistono su YT migliaia di video che spiegano come si salda.Se anche usi l'adattatore la saldatura smd la devi fare comunque, tanto vale salradrlo direttamente sul PCB.

beh fare un pcb con quelle piste potrebbe essere complicato per me :smiley:

sono indeciso se passare al 1284 o fare un enorme balzo al SAM3X8E...
credo che partirò acquistando una board arduino 2 (che sono sei mesi che mi trattengo dal comprare visto che non so manco sfruttare la uno ahaha)
voglio vedere di iniziare a integrare un controllo del carico per l'anticipo
e questo potrei farlo col 1284
ma poi non potrei provare a fare un sistema di iniezione, che con il SAM3X8E ci starebbe alla grande con tutta quella ram e le prestazioni decisamente superiori (avrò bisogno di calcoli più complessi)
è vero non ha eeprom ma pazienza, ce ne metto una esterna o una sd, posso iniziare con la flash in ogni caso ne ha tantissima :smiley:

ho ottimizzato il codice, più tardi vado a provarlo ma andrà quasi di sicuro
ora nella eeprom metto i valori dell'anticipo che sono molto più leggibili

#include <EEPROM.h>

  byte arrayMappatura[]={  //array per mappatura






25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 
24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 
23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 
22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 
21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 
20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 
19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 
17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 
16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 
15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 
14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 
13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 
12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 
11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 
10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 
9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  
8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  
7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  
6,  6,  6,  6,  6,  6,  6,  6,  6,  6,  6,  6,  6,  6,  6,  6,  6,  6,  6,  6,  6,  6,  6,  6,  6,  6,  6,  6,  6,  6,  6,  6,  6,  6,  6,  6,  6,  6,  6,  6,  
5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  
4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  
3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  
2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  
1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  



                               
              };

void setup()
{ }

void loop()
{
 for (int i=0; i < 1000; i++){                         //per ogni valore della mappa
  
      EEPROM.write(i, arrayMappatura[i]);                   //inserisci valore 0 mappatura in posizione 0 eeprom fino a valore 999 in posizione 999

      delay(10);
   } 
  
}

e il programma della centralina lo trasforma in ritardo in setmapping
ho anche inserito il limitatore di giri alla fine della mappa

#include <StopWatch.h>
#include <EEPROM.h>

const byte bobina1 = 7;    // output bobina1 su pin7
const byte pin2 = 2;       // interrupt startt
const byte pin3 = 3;       // interrupt stopp

volatile int statestartt = HIGH;    // stato normale startt
volatile int statestopp=HIGH;       // stato normale stopp

StopWatch sw_micros(StopWatch::MICROS);    // timer durata dente
StopWatch sw_micros1(StopWatch::MICROS);   // timer attesa

byte mappatura[1000];      //dichiaro array mappatura
byte ritardo=90;           //dichiaro ritardo
byte cut=0;                //per limitatore rpm
long time = 0;             //valore durata dente microsecondi
long tritardo1 = 0;        //valore durata ritardo in microsecondi

void setup() {
  pinMode(bobina1, OUTPUT);  //bobina
  pinMode(pin2, INPUT_PULLUP);
  pinMode(pin3, INPUT_PULLUP);
  attachInterrupt(0, startt, FALLING);   //interrupt in inizio dente
  attachInterrupt(1, stopp, RISING);     //interrupt fine dente
  SetMapping();                          //compila mappatura[] copiando la eeprom interna
}

void loop()
{

  if(statestartt == LOW){                //se il dente è iniziato
    sw_micros.start();                   //avvia timer durata dente
    statestartt=HIGH;                    // reimposta startt
  }


  if(statestopp == LOW) {                //se il dente è finito
    time=sw_micros.elapsed();            //memorizza durata dente in "time"
    sw_micros1.start();                  //avvia timer attesa
    statestopp = HIGH;                   //reimposta stopp
    sw_micros.reset();                   //azzera timer durata dente

    if(time<250){                        // se il dente dura meno di 250 micros, rpm maggiore di 6666
      cut=1;                             //disabilita accensione candela
    }                                            
    else
      cut=0;                             // se rpm minore di 6666 abilita accensione candela
    if(time>1250){                       // se il dente dura più di 1250 micros, rpm minore di 1333                  
      ritardo=90;                        // anticipo fisso 0°btdc  
    }  
    
    else ritardo=mappatura[time-250];    // se la durata del dente è tra 250 e 1250 micros assegna il valore di ritardo in mappatura
                                         // time-250 trasla time alla posizione esatta in mappa, time=250  250-250=0, verrà usato mappatura[0]

      tritardo1=(time*ritardo)/10;       //calcola durata ritardo in microsecondi, è importante che la moltiplicazione avvenga prima della divisione, genera un errore più piccolo
  }

 
  if(cut==0){                               // se rpm minore di 6666
    if(sw_micros1.elapsed() >= tritardo1){  //se il tempo che è passato dalla fine del dente è maggiore della durata del ritardo
      sw_micros1.reset();                   //azzera timer ritardo

      digitalWrite(bobina1, HIGH);          //scocca scintilla
      
      delayMicroseconds(10);                //attendi

      digitalWrite(bobina1, LOW);           //carica condensatore
      
    } 
  }


} // End Loop

void startt()//interrupt startt
{
  statestartt = !statestartt;  //inverti startt
}

void stopp()//interrupt stopp
{
  statestopp = !statestopp;    //inverti stopp
}

void SetMapping()                          //per copia mappatura da eeprom a ram in setup
{
  for (int x; x<1000;x++)                  //per ogni valore della mappatura
  {
    mappatura[x] = 90- EEPROM.read(x);     //converti mappatura anticipo eeprom in mappatura ritardo rispetto a fine dente
                                           // questo solo perchè la mappatura anticipo è più leggibile di quella ritardo
  }                                       
}

Io salderei il chippettino con solder cream e aria calda. Un bel chinotto e un adattatore professionale.

Non è la tecnica giusta , devi fare dei movimenti specifici con il saldatore e non puramenti perpendicolari al pcb

Mi piace questo tuo lavoro, soprattutto per la velocità con il quale fai le modifiche, sembra che non stai pensando ad altro in questo periodo :smiley:

icio:

[quote author=lucaleo ]
se monto un saldatore con una punta molto molto fine sulla struttura di un trapano a colonna (per far salire e scendere il saldatore senza vibrazioni ecc) io penso di poterci riuscire :smiley:
poi sposto la basetta dal di sotto per allineare il pin che vglio saldare (stile carrelli di una fresa)
certo non è semplice e non è veloce ma secndo me si può fare ahaha

Non è la tecnica giusta , devi fare dei movimenti specifici con il saldatore e non puramenti perpendicolari al pcb

Mi piace questo tuo lavoro, soprattutto per la velocità con il quale fai le modifiche, sembra che non stai pensando ad altro in questo periodo :smiley:
[/quote]

in effetti è così ahaha
complice il fatto che il lavoro quest'anno purtroppo è poco e che il posto di lavoro è lo stesso posto in cui cazzeggio con sta roba :smiley:

Questo parte

    if(time<250){                        // se il dente dura meno di 250 micros, rpm maggiore di 6666
      cut=1;                             //disabilita accensione candela
    }                                            
    else
      cut=0;

la puoi anche scrivere con l'operatore ternario

cut = (time<250) ? 1 : 0;  // se il dente dura meno di 250 micros, rpm maggiore di 6666, disabilita accensione candela

Fa più figo. :grin:
Ed è più veloce.
--> Switch Case C e operatori ternari: sintassi ed esempi| HTML.it

PaoloP:
Questo parte

    if(time<250){                        // se il dente dura meno di 250 micros, rpm maggiore di 6666

cut=1;                             //disabilita accensione candela
    }                                           
    else
      cut=0;



la puoi anche scrivere con l'operatore ternario


cut = (time<250) ? 1 : 0;  // se il dente dura meno di 250 micros, rpm maggiore di 6666, disabilita accensione candela




Fa più figo. :grin:
Ed è più veloce.
--> http://www.html.it/pag/15404/controlli-condizionali-switch-e-operatori-ternari/

sono in officina ora lo provo :smiley:

intanto ho recuperato un tps (posizione acceleratore)
un bulbo temperatura acqua
e un debimetro

ravattando nei rimasugli :smiley:

Per favore non quotate per intero il messaggio immediatamente precedente, lo trovo inutile e rende il post illeggibile, così come il quote dei quote.
Grazie. :wink:

hai ragione effettivamente non serve :slight_smile:

ho inserito la riga e funziona benissimo

qualche giorno fa mi avevi anche parlato di ottimizzare la scelta del valore in mappa tramite i puntatori, ora vedo di capirci qualcosa :smiley:

cmq quello che ho recuperato non è un debimetro ma un sensore che legge temperatura aria aspirata e pressione aria aspirata

in ogni caso se non sbaglio all'aumentare della portata d'aria (e quindi della velocità) la pressione dovrebbe scendere, quindi potrei combinarci qualcosa...

devo anche recampare un iniettore e altra robina

mi sa che mi ordino la due e inizio a integrare gia li sopra la lettura dell'acceleratore per la scintilla :smiley:

Inizia a scaricare l'IDE 1.5.3. Con la DUE devi usare quello.

installato l'IDE 1.5.3 senza togliere 1.0.4
mi consigliate di togliere il vecchio o di tenerlo? sono in cartella di installazione differenti ma condividono quella dei salvataggi

ho provato a compilare su board arduino2 programming port questo codice dopo aver eliminato la lettura eeprom
ho dovuto anche modificare time a tempo, mi dava ridichiarazione di time, forse time nella 2 è una di quelle parole riservate??

#include <StopWatch.h>

const byte bobina1 = 7;    // output bobina1 su pin7
const byte pin2 = 2;       // interrupt startt
const byte pin3 = 3;       // interrupt stopp

volatile int statestartt = HIGH;    // stato normale startt
volatile int statestopp=HIGH;       // stato normale stopp

StopWatch sw_micros(StopWatch::MICROS);    // timer durata dente
StopWatch sw_micros1(StopWatch::MICROS);   // timer attesa

byte mappatura[1000];      //dichiaro array mappatura
byte ritardo=90;           //dichiaro ritardo
byte cut=0;                //per limitatore rpm
unsigned long tempo=0;             //valore durata dente microsecondi
unsigned long tritardo1 = 0;        //valore durata ritardo in microsecondi

void setup() {
  pinMode(bobina1, OUTPUT);  //bobina
  pinMode(pin2, INPUT_PULLUP);
  pinMode(pin3, INPUT_PULLUP);
  attachInterrupt(0, startt, FALLING);   //interrupt in inizio dente
  attachInterrupt(1, stopp, RISING);     //interrupt fine dente

}

void loop()
{

  if(statestartt == LOW){                //se il dente è iniziato
    sw_micros.start();                   //avvia timer durata dente
    statestartt=HIGH;                    // reimposta startt
  }


  if(statestopp == LOW) {                //se il dente è finito
    tempo=sw_micros.elapsed();            //memorizza durata dente in "time"
    sw_micros1.start();                  //avvia timer attesa
    statestopp = HIGH;                   //reimposta stopp
    sw_micros.reset();                   //azzera timer durata dente

    if(tempo<250){                        // se il dente dura meno di 250 micros, rpm maggiore di 6666
      cut=1;                             //disabilita accensione candela
    }                                            
    else
      cut=0;                             // se rpm minore di 6666 abilita accensione candela
    if(tempo>1250){                       // se il dente dura più di 1250 micros, rpm minore di 1333                  
      ritardo=90;                        // anticipo fisso 0°btdc  
    }  
    
    else ritardo=mappatura[tempo-250];    // se la durata del dente è tra 250 e 1250 micros assegna il valore di ritardo in mappatura
                                         // time-250 trasla time alla posizione esatta in mappa, time=250  250-250=0, verrà usato mappatura[0]

      tritardo1=(tempo*ritardo)/10;       //calcola durata ritardo in microsecondi, è importante che la moltiplicazione avvenga prima della divisione, genera un errore più piccolo
  }

 
  if(cut==0){                               // se rpm minore di 6666
    if(sw_micros1.elapsed() >= tritardo1){  //se il tempo che è passato dalla fine del dente è maggiore della durata del ritardo
      sw_micros1.reset();                   //azzera timer ritardo

      digitalWrite(bobina1, HIGH);          //scocca scintilla
      
      delayMicroseconds(10);                //attendi

      digitalWrite(bobina1, LOW);           //carica condensatore
      
    } 
  }


} // End Loop

void startt()//interrupt startt
{
  statestartt = !statestartt;  //inverti startt
}

void stopp()//interrupt stopp
{
  statestopp = !statestopp;    //inverti stopp
}

la libreria stopwatch me la compila anche sulla due, presumo che sia quindi compatibile...

ho notato una cosa però, compilando il codice sopra con ide 1.5.3 su board arduino uno la dimensione è 2.104 bytes

mentre se la compilo su board arduino due è 11.136 bytes

questo forse perchè int e long sulla due sono più grossi seguendo le normali convenzioni del c come ho letto??

EDIT
ho anche dato un'occhiata a delle eeprom esterne spi (dato che non ho trovato riferimenti ad i2c sulla due) che sono anche più veloci come mi aveva consigliato maurotec

STMicroelectronics
M95640-WMN6TP

64K-Bit 8Kx8Bits 3.3V / 5V
Serial SPI EEPROM 10Mhz
Package: SOP 8

qua sopra ci metto gia un bel po' di mappe!
RIEDIT
ho visto che ne ha due di i2c ahah!

Ma la SPI è mooolto più veloce.
Tieni pure la 1.5.3 ma anche la 1.0.5. :grin:

Allora tanto vale che uso spi :slight_smile:
Adesso mi ordino la arduino due ahahah
Non resisto più
Ovviamente tutte le volte che ordino qualcosa è venerdi o sabato cosi mi tocca di aspettare =(

guardate un po' a 23.50 come salda smd passo 0.5
non ho capito se è un maestro oppure se in realtà non è così complicato ahaha

PaoloP:
Fa più figo. :grin:
Ed è più veloce.
--> Switch Case C e operatori ternari: sintassi ed esempi| HTML.it

Questo vale per i PC :stuck_out_tongue:
L'operatore ternario e un if/else generano lo stesso identico codice assembly, probabilmente perché il compilatore ottimizza il codice per la dimensione (sull'Arduino) e non per l'efficienza.

Però fa più figo lo stesso ahaha

guardate un po' a 23.50 come salda smd passo 0.5
non ho capito se è un maestro oppure se in realtà non è così complicato ahaha

A me sembra alle prime armi con il saldatore in mano, poi come ha saldato il pad del'ultimo componente mi è di ulteriore conferma. Comunque il merito è del flussante e della trecciola di rame che usa per asportare lo stagno in eccesso.

Quindi si il processore ARM montato nella A2 può essere saldato a mano, ma ci vuole un buon saldatore con temperatura regolabile (cioè la potenza viene regolata in base alla temperatura della punta), un flussante migliore di quello usato in quel video, una buon PCB meglio se con finitura HAL, la trecciola di rame e una buona vista.

Ciao.

benissimo :slight_smile:
ora inizierò a interfacciarmi con la scheda che ho fatto e arduino due e vedere se riesco ad aggiungere il controllo del carico per l'anticipo e poi di integrare una piccola iniezione elettronica
a questo punto mi fermo con la parte riguardate il pcb per ritirare fuori il discorso quando avrò idea dell'hardware da usare e sarà un pcb con sam3x8 :smiley:

anche se voglio sviluppare anche una schedina per il solo controllo di anticipo come quella che ho gia con il controllo di due sole scintille (per 4 cilindri a scintilla persa) con il 328 da usare solo quando è necessaria un'accensione elementare
sostanzialmente quello a cui sono arrivato adesso è l'obiettivo che mi ero prefissato all'inizio
una centralina elettronica con 328 onboard con mappatura anticipo per i motori a spinterogeno, ed è fatta sostanzialmente :smiley:

ora però voglio di più :smiley:

Io comunque ti consiglio di utilizzare una basetta per il Sam e poi installare la basetta sul pcb. In questo modo non dovrai creare piste piccolissime per saldarci il Sam.