Arduino CDI für CX500

[brummbaehr]

Auf wunsch hier das Arduino-Projekt als RAR-Datei

Anmerkungen, Verbesserungen, Kritik ist ausdrücklich erwünscht.

Was mir persönlich nicht so ganz gefällt ist die Tabelle der Vorzündungskurve.
Diese ist fest in Schritten von 1000µS aufgeteilt.
Bei kleinen Drehzahlen ist der Abstand zwischen den Schritten viel zu klein. (10 Upm)
Bei hohen Drehzahlen könnter der Abstand wiederum etwas kleiner sein.
Die Tabelle geht von 750 - 15000 Upm

Code: Alles auswählen

i;RPM;USROTationEng;usDelay;Slope
0;15000.00;4000;55;1
1;12000.00;5000;69;1
2;10000.00;6000;83;1
3;8571.43;7000;97;1
4;7500.00;8000;111;1
5;6666.67;9000;125;1
6;6000.00;10000;138;1
7;5454.55;11000;152;1
8;5000.00;12000;166;5
9;4615.38;13000;208;5
10;4285.71;14000;249;5
11;4000.00;15000;291;9
12;3750.00;16000;366;9
13;3529.41;17000;441;9
14;3333.33;18000;516;9
15;3157.89;19000;591;9
16;3000.00;20000;666;16
17;2857.14;21000;791;16
18;2727.27;22000;916;16
19;2608.70;23000;1041;16
20;2500.00;24000;1166;16
21;2400.00;25000;1291;16
22;2307.69;26000;1416;16
23;2222.22;27000;1541;16
24;2142.86;28000;1666;16
25;2068.97;29000;1791;16
26;2000.00;30000;1916;12
27;1935.48;31000;2013;12
28;1875.00;32000;2111;12
29;1818.18;33000;2208;12
30;1764.71;34000;2305;12
31;1714.29;35000;2402;12
32;1666.67;36000;2500;12
33;1621.62;37000;2597;12
34;1578.95;38000;2694;12
35;1538.46;39000;2791;12
36;1500.00;40000;2888;11
37;1463.41;41000;2977;11
38;1428.57;42000;3066;11
39;1395.35;43000;3155;11
40;1363.64;44000;3244;11
41;1333.33;45000;3333;11
42;1304.35;46000;3422;11
43;1276.60;47000;3511;11
44;1250.00;48000;3599;11
45;1224.49;49000;3688;11
46;1200.00;50000;3777;11
47;1176.47;51000;3866;11
48;1153.85;52000;3955;11
49;1132.08;53000;4044;11
50;1111.11;54000;4133;11
51;1090.91;55000;4222;11
52;1071.43;56000;4311;11
53;1052.63;57000;4400;11
54;1034.48;58000;4488;11
55;1016.95;59000;4577;11
56;1000.00;60000;4666;9
57;983.61;61000;4744;9
58;967.74;62000;4822;9
59;952.38;63000;4900;9
60;937.50;64000;4977;9
61;923.08;65000;5055;9
62;909.09;66000;5133;9
63;895.52;67000;5211;9
64;882.35;68000;5288;9
65;869.57;69000;5366;9
66;857.14;70000;5444;9
67;845.07;71000;5522;9
68;833.33;72000;5600;9
69;821.92;73000;5677;9
70;810.81;74000;5755;9
71;800.00;75000;5833;9
72;789.47;76000;5911;9
73;779.22;77000;5988;9
74;769.23;78000;6066;9
75;759.49;79000;6144;9
76;750.00;80000;6222;9

Arduino_CDI_V181.rar

[nanno]

Könnte man die besagte Tabelle nicht einfach mit einer mathematischen Formel y= kx+d abbilden? d= 55µs und k wäre 1/f(x), wobei f(x) irgendeine non-lineare Formel ist, mit der du dich der gewünschten Kurve annäherst? (Wobei ich nicht abschätzen kann ob du mit der Rechenleistung vom Arduino da (bequem) hinkommst.) Müsste man im Zweifelsfall mit Derive oder so durchspielen.

[brummbaehr]

Die eigentliche Tabelle der Vorzündungskurve besteht nur aus 8 Zeilen

Code: Alles auswählen

const uint8_t CURVE_DATA[ NO_OF_CURVES * NO_OF_POINTS_PER_CURVE ][ 2 ] = {
  {10, 14},   // 1000 RPM = 60ms/R
  {15, 16},   // 1500 RPM = 40ms/R 
  {20, 19},   // 2000 RPM = 30ms/R
  {30, 30},   // 3000 RPM = 20ms/R
  {40, 35},   // 4000 RPM = 15ms/R
  {50, 37},   // 5000 RPM = 12ms/R
  {100, 37},   // 10000 RPM = 6ms/R
  {110, 20}};  // 11000 RPM = ms/R

Daraus erzeugt dann die Funktion calculateArrayValues() diese Tabelle:

Code: Alles auswählen

i;RPM;USROTationEng;usDelay;Slope
0;15000.00;4000;55;1
1;12000.00;5000;69;1
2;10000.00;6000;83;1
3;8571.43;7000;97;1
4;7500.00;8000;111;1
5;6666.67;9000;125;1
6;6000.00;10000;138;1
7;5454.55;11000;152;1
8;5000.00;12000;166;5
9;4615.38;13000;208;5
10;4285.71;14000;249;5
11;4000.00;15000;291;9
12;3750.00;16000;366;9
13;3529.41;17000;441;9
14;3333.33;18000;516;9
15;3157.89;19000;591;9
16;3000.00;20000;666;16
17;2857.14;21000;791;16
18;2727.27;22000;916;16
19;2608.70;23000;1041;16
20;2500.00;24000;1166;16
21;2400.00;25000;1291;16
22;2307.69;26000;1416;16
23;2222.22;27000;1541;16
24;2142.86;28000;1666;16
25;2068.97;29000;1791;16
26;2000.00;30000;1916;12
27;1935.48;31000;2013;12
28;1875.00;32000;2111;12
29;1818.18;33000;2208;12
30;1764.71;34000;2305;12
31;1714.29;35000;2402;12
32;1666.67;36000;2500;12
33;1621.62;37000;2597;12
34;1578.95;38000;2694;12
35;1538.46;39000;2791;12
36;1500.00;40000;2888;11
37;1463.41;41000;2977;11
38;1428.57;42000;3066;11
39;1395.35;43000;3155;11
40;1363.64;44000;3244;11
41;1333.33;45000;3333;11
42;1304.35;46000;3422;11
43;1276.60;47000;3511;11
44;1250.00;48000;3599;11
45;1224.49;49000;3688;11
46;1200.00;50000;3777;11
47;1176.47;51000;3866;11
48;1153.85;52000;3955;11
49;1132.08;53000;4044;11
50;1111.11;54000;4133;11
51;1090.91;55000;4222;11
52;1071.43;56000;4311;11
53;1052.63;57000;4400;11
54;1034.48;58000;4488;11
55;1016.95;59000;4577;11
56;1000.00;60000;4666;9
57;983.61;61000;4744;9
58;967.74;62000;4822;9
59;952.38;63000;4900;9
60;937.50;64000;4977;9
61;923.08;65000;5055;9
62;909.09;66000;5133;9
63;895.52;67000;5211;9
64;882.35;68000;5288;9
65;869.57;69000;5366;9
66;857.14;70000;5444;9
67;845.07;71000;5522;9
68;833.33;72000;5600;9
69;821.92;73000;5677;9
70;810.81;74000;5755;9
71;800.00;75000;5833;9
72;789.47;76000;5911;9
73;779.22;77000;5988;9
74;769.23;78000;6066;9
75;759.49;79000;6144;9
76;750.00;80000;6222;9

Das Ganze frisst dann schon einiges von den 2kB Ram im Arduino.
Wäre schön wenn man das irgendwie "verschlanken" könnte.
Wobei das aber gut funktioniert und ich mir hier vielleicht auch ganz unnötig nen Kopf mach

[Emil1957]

Das sieht ja nach meinem Code aus . Freut mich, dass er in Benutzung ist. Dann will ich mal ein paar Dinge erläutern.

-Es können verschiedene Zündkurven eingetragen werden. Da entsprechende Grafiken i.d.R im Frequenzbereich dargestellt werden, erfolgt die Eingabe auch in dieser Form. Dazu werden einige charakteristische Wertepaare (rpm, Frühzündungswinkel) hinterlegt (im Array CURVE_DATA).

-Das Programm arbeitet aber im Zeitbereich (da ja Umdrehungszeiten gemessen werden). Daher wird beim Start aus den Werten der Zündkurve (im Frequenzbereich) eine (zeitlich) äquidistantes Array berechnet. Das erfolgt mit der Prozedur "calculateArrayValues". Das erzeugt die von brummbaehr gezeigten (durchnummerierten) Werte (Zeit für eine halbe Umdrehung der Kurbelwelle und zugehörige Frühzündungszeit, beides in µs).

-Zusätzlich wird aber auch die Geradensteigung zwischen zwei Wertepaaren berechnet und gespeichert. Aus Platz- und Zeitgründen alledings nicht als float- sondern als integer-Werte. Um einen (für uint_8) brauchbaren Wertebereich zu bekommen, wird eine Multiplikation mit 128 durchgeführt (128 deshalb, weil man mit 2er Potenzen Multiplikationen und Divisionen mittels Shift-Befehlen sehr schnell durchführen kann, gleichzeitig bleiben die Werte in einer "platzsparenden" Größenordnung).

Das alles erfolgt beim Programmstart (Einschalten der Zündung). Im laufenden Betreib passiert dann folgendes

-Aus zwei aufeinanderfolgenden Signalen des Hallsensors (oder des Pickups) wird die (halbe) Umdrehungszeit der Kurbelwelle berechnet

-Über die Funktion "BinarySearchIndex" wird dann im Array usHalfRotationEngine das zugehörige Zeitintervall in der Wertetabelle ermittelt

-Da die tatsächliche Umdrehungszeit irgendwo im ermittelten Intervall liegt, wird mittels des "slopes" eine lineare Interpolation (aus Geschwindigkeitsgründen wieder mit integer-Arithmetik) durchgeführt, um die korrekte Frühzündungszeit zu berechnen. Sofern die Tabelle eine ausreichende Anzahl von Stützstellen enthält (was im kokreten Beispiele wohl der Fall sein dürfte) liefert das ein hinreichend korrektes Ergebnis.

Lange Rede, kurzer Sinn:

Wobei das aber gut funktioniert und ich mir hier vielleicht auch ganz unnötig nen Kopf mach

Vermutlich machts Du Dir wirklich einen unnötigen Kopf.

[brummbaehr]

Ja, das mit dem Array ist der Code von deiner TCI-Zündung.
Bei der CX sitzen die Picups (Zwei je Zylinder) quasie auf der Kurbelwelle! Es wird also in jeder Kurbelwellenumdrehung gezündet. Ein Zündfunke geht dann halt in die Abgase.
Diese DWELLTIME (Ladezeit der Zündspule) gibt es bei einer CDI nicht. Dafür muss dann der DCDC-Wandler welcher die Kondensatoren auf ca. 300V aufläd vor dem Zünden eines Tyristors deaktiviert werden und danach möglichst schnell wieder aktiviert werden, damit die Zündkondensatoren zur nächsten Zündung wieder voll geladen sind.
Die CX macht ja pro Zylinder pro KW Umdrehung zwei Impulse.
Der erste Impuls ist die max. mögliche Vorzündung ca. 42°
Der zweite Impuls die kleinste Vorzündung (Standgas) ca. 15°.
Berechnet wird die Verzögerungszeit vom ersten Impuls (42°) bis zum gewünschten Vorzündungswinkel.
Beim Starten (<750RPM) wird unmittelbar beim zweiten Impuls gezündet.
Dann habe ich noch einige unsign-Werte in int-Werte geändert, so das der Vorzündungswinkel bei zu großer Drehzahl auch wieder kleiner werden kann.
Über die Serielle Ausgabe werden dann noch zyklisch (nur bei angestecktem USB-Kabel) einige Daten wie Drehzahl, Zündwinkel, Spannung etc. übertragen.

[powermosfet]

Hallo,
könnte man eventuell einen Schaltplan bekommen?
Würde diese Zündung gerne für meinen Eigenbau Viertaktmotor verwenden.
MfG Powermosfet

[ntmario]

Was hast Du denn für eine Schalung/Elektronik genommen? Selbst entwickelt?

[brummbaehr]

Siehe http://www.cx500ww.de/schrauberecke/ard ... /index.php

[ntmario]

Hallo brummbaer,

erst mal vielen Dank für Deine Antwort. Ich denke auch, dass es an der Zündspule liegt. Welche Zündspule hast Du denn verbaut?

Jetzt zum Thema. Dich nervt die Größe deines Array.

Ich würde das so lösen (spart eine menge Mathe in deinem Code)

Du erstellst Dir in Excel die Zeit (vor OT), wann der Triac "feuern" soll. Und zwar in 256er Schritten. Das löst unter anderem das Problem mit der Auflösung. Du bekommst dann 80 Werte für eine Drehzahl bis 20480. Dann ermittelst Du die Drehzahl zwischen zwei Umdrehungen zu Beispiel 15432. Dann Bit Shifting mit 8 nach rechts ergibt 60 . Also nimmst Du den 60 Wert aus dem Array.

Wenn du noch "engere" Schritte möchtest, dann das Array mit 128er Schritten (160 Werte) aufbauen und Bit Shifting nach rechts mit 9.

int ArrayTime[] = { 9.766,
4.883,
3.255,
2.441,
1.953,
1.628,
1.395,
1.221,
1.085,
977,
982,
987,
1.002,
930,
868,
814,
766,
723,
685,
651,
620,
592,
566,
543,
521,
501,
482,
465,
449,
434,
420, ...usw.... };

Time= ArrayTime[RPM >> 8];

...sind dann nur noch zwei Zeilen Code mit Bit Shifting. Ich denke schneller wird's nicht.
... und 160 Byte (320) für das Array. :-)

Screenshot der Excel Datei:
die grüne Kurve ist die Zeit in us mit 17 Grad vor OT (Zelle B2)
die blaue Kurve ist die Zeit, abhängig von der Zündkurve (grau)

Bildschirmfoto 2021-02-10 um 18.24.48.png

[brummbaehr]

Sorry, aber ich kann Dir da nicht folgen.
Spalte A ist jetzt was?
- Zeit vor OT in µs?
- Drehzahl in U/min?
- ...

"Die Drehzahl zwischen zwei Umdrehungen" was soll das sein?

Zündspule ist eine für CDI Zündungen, bzw. die Originale halt