Centralina SabbaJet (memjet) mappabile

[unsampei]

Vorrei provare a creare una centralina MemJet in stile SabbaJet però auto adattabile in base ai giri motore.
In pratica, analogamente al funzionamento di alcuni contamarce, vorrei leggere i valori di uscita del contagiri dalla ecu ed in base a questo creare una decina di step ognuno con propria resistenza.

Perché? Perché il principio della Memjet è andare a modificare la carburazione su tutta la linea a differenza delle classiche power commander non è regolabile nelle varie zone della curva e questo incrementa i consumi e rende alcune zone scarburate.

Ho analizzato le curve medie proposte dalla DynoJet ed altre effettuate a banco da utenti ed ho semplificato a questa tabella:

giri motore|	Valori medi farfalla pc5	| valori resistivi
0-1250	0	0
1250-2000	4	1,4
2000-3000	13	4,55
3000-3500	5	1,75
3500-4250	10,5	3,675
4250-6500	7	2,45
6500-7250	5	1,75
7250-10250	4	1,4
10250-13250	3	1,05
13250-14000	0	0

I valori resistivi sono stati calcolati con una resistenza da 6.5Kohm come 100% ed una da 560ohm verso massa non volendo mai superare però il 70% d’intervento quindi con resistenza massima di 4.55Kohm.
Chiaramente poi si potrebbe valutare l’inserimento di trimmer per effettuare una regolazione dei singoli step.

Idee? Suggerimenti per effettuare lo switch delle linee resistive?
Qualcuno sa già che tipo di segnale esce dalla ecu per il contagiri? Sapete gli step di segnale per i vari giri/min ?

[unsampei]

Son già qui con alcune news trovate ovviamente solo dopo aver creato la discussione.

Il segnale del contagiri è ad onda quadra, non ne conosco però la frequenza massima.

Se la frequenza è entro i 50 kHz potrei utilizzare arduino (ATMega32 con la funzione pulseLn() per leggere ed interpretare i dati e mandare un segnale di attivazione ad un chip MosFet per aprire e chiudere i rispettivi settori.

[unsampei]

Ho trovato anche questa formula:
RPM = Freq * 120 / n.cilindri

Da cui ho estratto i vari range di frequenze.

Ecco la prima bozza del programma per arduino (in teoria già indicativamente adatta al mio scopo):

//###################################################################################
// Programma di attivazione uscita digitale in base alla frequenza ingresso onda quadra

// Dichiaro i pin
int outputled = 13;
int inputSensor = 8;
int output0ohm = 2;
int output1100ohm = 3;
int output1600ohm = 4;
int output2200ohm = 5;
int output3300ohm = 6;

int output4500ohm = 7;
unsigned long frequenza;
int stepfrequenza;

void setup()
{
// attivo il led della scheda per segnalare l’attivazione
pinMode(outputled, OUTPUT);
digitalWrite(outputled, HIGH);

pinMode(inputSensor, INPUT);

pinMode(output0ohm, OUTPUT);
pinMode(output1100ohm, OUTPUT);
pinMode(output1600ohm, OUTPUT);
pinMode(output2200ohm, OUTPUT);
pinMode(output3300ohm, OUTPUT);
pinMode(output4500ohm, OUTPUT);
}
void loop()
{
// Leggo frequenza d’ingresso
frequenza = pulseIn(inputSensor, HIGH);
// Imposto in base alla frequenza le uscite corrette
Stepfrequenza = 0 // di default 0 per valori fuori scala
If ( frequenza < 41.67 )
{
Stepfrequenza = 0
}
If (( frequenza < 41.67 ) && (frequenza < 66.67))
{
Stepfrequenza = 1
}
If (( frequenza < 66.67) && (frequenza < 100))
{
Stepfrequenza = 2
}
If (( frequenza < 100) && (frequenza < 116.67))
{
Stepfrequenza = 3
}
If (( frequenza < 116.67) && (frequenza < 141.67))
{
Stepfrequenza = 4
}
If (( frequenza < 141.67) && (frequenza < 216.67))
{
Stepfrequenza = 5
}
If (( frequenza < 216.67) && (frequenza < 241.67))
{
Stepfrequenza = 6
}
If (( frequenza < 241.67) && (frequenza < 341.67))
{
Stepfrequenza = 7
}
If (( frequenza < 341.67) && (frequenza < 441.67))
{
Stepfrequenza = 8
}
If (( frequenza < 441.67) && (frequenza < 446.67))
{
Stepfrequenza = 9
}


switch (frequenza) {
case 7,8:
digitalWrite(output0ohm, LOW);
digitalWrite(output1600ohm, LOW);
digitalWrite(output2200ohm, LOW);
digitalWrite(output3300ohm, LOW);
digitalWrite(output4500ohm, LOW);
digitalWrite(output1100ohm, HIGH);
break;

case 3,6:
digitalWrite(output0ohm, LOW);
digitalWrite(output1100ohm, LOW);
digitalWrite(output2200ohm, LOW);
digitalWrite(output3300ohm, LOW);
digitalWrite(output4500ohm, LOW);
digitalWrite(output1600ohm, HIGH);
break;
case 5:
digitalWrite(output0ohm, LOW);
digitalWrite(output1100ohm, LOW);
digitalWrite(output1600ohm, LOW);
digitalWrite(output3300ohm, LOW);
digitalWrite(output4500ohm, LOW);
digitalWrite(output2200ohm, HIGH);
break;


case 4:
digitalWrite(output0ohm, LOW);
digitalWrite(output1100ohm, LOW);
digitalWrite(output1600ohm, LOW);
digitalWrite(output2200ohm, LOW);
digitalWrite(output4500ohm, LOW);
digitalWrite(output3300ohm, HIGH);
break;
case 2:
digitalWrite(output0ohm, LOW);
digitalWrite(output1100ohm, LOW);
digitalWrite(output1600ohm, LOW);
digitalWrite(output2200ohm, LOW);
digitalWrite(output3300ohm, LOW);
digitalWrite(output4500ohm, HIGH);
break;


default:
// 9 e 0
digitalWrite(output1100ohm, LOW);
digitalWrite(output1600ohm, LOW);
digitalWrite(output2200ohm, LOW);
digitalWrite(output4500ohm, LOW);
digitalWrite(output0ohm, HIGH);

break;
}
}
//###################################################################################

Posterò presto le news a riguardo... chissà che si riesca a creare la prima centralina open source.

[_sabba_]

Idea molto interessante, ma io limiterei il range di azione di ogni resistenza a step di 250 giri, al massimo di 500 giri, per evitare variazioni di carburazione troppo continue e repentine.
Solo che così facendo il numero di resistenze salirebbe a una cinquantina.
Comunque bello, e grazie per l'onore di avere un post dedicato a una mia realizzazione.

[unsampei]

I complimenti a te che hai condiviso la tua idea e le tue rilevazioni.

Se vogliamo far così tanti step allora già che pensavo di tradurre con arduino il segnale del contagiri potremmo sfruttarlo per comandare un MCP4131-103 o un AD5220 che sono un chip con resistenza variabile a 128 step con valore max 10Kohm comandabile tramite comandi seriali. Molto più elegante e meno costoso delle serie di resistenze a mio avviso.

In questo modo risparmierei dei pin e potrei sfruttare la cosa per integrare in un secondo tempo anche la predisposizione un display lcd 7 segmenti per il contamarce oppure integrare un transponder come ha fatto questo tipo:
http://rcarduino.blogspot.it/p/project-index.html

Vedo di procurarmi i potenziometri elettronici poi comincio a lavorarci sul serio.

[unsampei]

Ok... ho comprato tutto il necessario. Tot. spesa 24€ compreso arduino, potenziometro, kit case plastico, interruttore, comando a manubrio e piastra forata

[Ufo]

Wow... dall'alto della mia profonda e totale ignoranza in ambito elettrico/elettronico ti faccio i miei complimenti..... bravissimo....

[SUPER GOKU]

Quando sarà in vendita ????????????????????

[unsampei]

Possibile che una volta completato il progetto sarà costruibile da chiunque seguendo la guida con una spesa come la suddetta e un'oretta di lavoro. Volendo potrò poi provare ad accordarmi con un officina per effettuare le installazioni e le prove a banco dei tester.

Intanto sto procedendo a grandi passi, qui il programma aggiornato per Arduino per leggere i giri motore e comandare il potenziometro elettronico (con una mappatura teoricamente pronta all'uso per fz6). Ho fatto come consigliato da Sabba step da 500 giri soprattutto per limitare le risorse della scheda e ottenere una maggiore velocità di risposta.

//###################################################################################
// Programma di attivazione uscita digitale in base alla frequenza ingresso onda quadra
// includo libreria comunicazione seriale
#include <SPI.h>

// Dichiaro i pin
int outputled = 13;
int inputSensor = 7;
int outpucCsPot = 6;

// dichiaro variabili frequenza
unsigned long frequenza;
unsigned long numeroGiri;
byte posizionePotenziometro = 0; //valore decimale da 0 a 128
//byte posizionePotenziometroKm = 0; //valore decimale da 0 a 128 - Opzionale


void setup()
{
// attivo il led della scheda per segnalare l’attivazione
pinMode(outputled, OUTPUT);
digitalWrite(outputled, HIGH);

// setto il pin contagiri come input
pinMode(inputSensor, INPUT);

// setto il pin di attivazione modifiche potenziometro come output
pinMode(outpucCsPot, OUTPUT);

// metto alto il pin di att. Modifiche pot. Per disattivarle
digitalWrite(outpucCsPot, HIGH);

//Inizializzo la libreria SPI
SPI.begin();

//Inizializzo la porta seriale
Serial.begin(9600);

}
void loop()
{
// Leggo frequenza d’ingresso
frequenza = pulseIn(inputSensor, HIGH);

// calcolo il numero dei giri/minuto
numeroGiri = frequenza*120/4

// Imposto in base alla frequenza le uscite corrette
posizionePotenziometro = 0 // di default 0 per valori fuori scala

// Opzionale contakm resistivo
// Calcolo posizione secondo potenziometro contakm automaticamente
// Formula utilizzata= N°Step potenziometro : Hz massimi * frequenza istantanea
//posizionePotenziometroKm = 0.27428571428*frequenza

If ((numeroGiri > 0) && (numeroGiri <= 250 )){
posizionePotenziometro = 0
}
If ((numeroGiri > 250) && (numeroGiri <= 500 )){
posizionePotenziometro = 0
}
If ((numeroGiri > 500) && (numeroGiri <= 1000 )){
posizionePotenziometro = 0
}
If ((numeroGiri > 1000) && (numeroGiri <= 1500 )){
posizionePotenziometro = 0
}
If ((numeroGiri > 1500) && (numeroGiri <= 2000 )){
posizionePotenziometro = 14
}
If ((numeroGiri > 2000) && (numeroGiri <= 2500 )){
posizionePotenziometro = 52
}
If ((numeroGiri > 2500) && (numeroGiri <= 3000 )){
posizionePotenziometro = 35
}
If ((numeroGiri > 3000) && (numeroGiri <= 3500 )){
posizionePotenziometro = 32
}
If ((numeroGiri > 3500) && (numeroGiri <= 4000 )){
posizionePotenziometro = 43
}
If ((numeroGiri > 4000) && (numeroGiri <= 4500 )){
posizionePotenziometro = 21
}
If ((numeroGiri > 4500) && (numeroGiri <= 5000 )){
posizionePotenziometro = 21
}
If ((numeroGiri > 5000) && (numeroGiri <= 5500 )){
posizionePotenziometro = 28
}
If ((numeroGiri > 5500) && (numeroGiri <= 6000 )){
posizionePotenziometro = 22
}
If ((numeroGiri > 6000) && (numeroGiri <= 6500 )){
posizionePotenziometro = 12
}
If ((numeroGiri > 6500) && (numeroGiri <= 7000 )){
posizionePotenziometro = 21
}
If ((numeroGiri > 7000) && (numeroGiri <= 7500 )){
posizionePotenziometro = 23
}
If ((numeroGiri > 7500) && (numeroGiri <= 8000 )){
posizionePotenziometro = 27
}
If ((numeroGiri > 8000) && (numeroGiri <= 8500 )){
posizionePotenziometro = 22
}
If ((numeroGiri > 8500) && (numeroGiri <= 9000 )){
posizionePotenziometro = 20
}
If ((numeroGiri > 9000) && (numeroGiri <= 9500 )){
posizionePotenziometro = 20
}
If ((numeroGiri > 9500) && (numeroGiri <= 10000 )){
posizionePotenziometro = 21
}
If ((numeroGiri > 10000) && (numeroGiri <= 10500 )){
posizionePotenziometro = 18
}
If ((numeroGiri > 10500) && (numeroGiri <= 11000 )){
posizionePotenziometro = 11
}
If ((numeroGiri > 11000) && (numeroGiri <= 11500 )){
posizionePotenziometro = 16
}
If ((numeroGiri > 11500) && (numeroGiri <= 12000 )){
posizionePotenziometro = 14
}
If ((numeroGiri > 12000) && (numeroGiri <= 12500 )){
posizionePotenziometro = 15
}
If ((numeroGiri > 12500) && (numeroGiri <= 13000 )){
posizionePotenziometro = 12
}
If ((numeroGiri > 13000) && (numeroGiri <= 13500 )){
posizionePotenziometro = 12
}
If ((numeroGiri > 13500) && (numeroGiri <= 14000 )){
posizionePotenziometro = 0
}
If ((numeroGiri > 14000) && (numeroGiri <= 14500 )){
posizionePotenziometro = 0
}
If ((numeroGiri > 14500) && (numeroGiri <= 15000 )){
posizionePotenziometro = 0
}
digitalWrite(outpucCsPot, LOW);
//Invio il primo byte per eseguire una scrittura sul registro Wiper
SPI.transfer(0);
//Invio il valore della posizione dello Wiper valori da 00H a 80H (0-128 in decimale)
SPI.transfer(posizionePotenziometro);
digitalWrite(outpucCsPot, HIGH);
}
//###################################################################################

[_sabba_]

Mi piace il potenziometro elettronico, che apre la strada a step di intervento ancor più ravvicinati (100 giri), sfruttandone tutte le sue potenzialità (128 step, che ricoprono abbondantemente tutto il range di utilizzo delle moto stradali).
Il valore di 10k va bene per tutte le possibili applicazioni (anche il potenziometro contenuto nella MemJet ha quel valore, anche se solitamente viene settato sui 4-6k).
Con step da 100 giri, l'intervento del circuito diverrebbe così preciso che non avverrebbero mai vuoti di carburazione per improvvisi smagrimenti/ingrassamenti dovuti alla repentina variazione del valore resistivo.
Ma dovrebbero essere sufficienti step di 200-250 giri.
Vabbè, visto che è tutto programmabile questo è un "problema secondario", nel senso che basta scrivere qualche linea di comando in più o in meno (al massimo 128!) per ottemperare alle regole imposte.