Hallo, suche ein Entwicklerboard mit Eigenschaften, die dem Conrad c-control 2 + Applicationboard (Tastatur, Display etc.) entsprechen. Es geht um die Steuerung einer Umspulmaschine (3 Motoren, 3 Encoder, 1 Endlagenschalter), die mit Conrad aufgrund der schlechten Entwicklungsumgebung nicht machbar ist (gehen müsste es, tut es aber nicht - die Sache mit dem OS ist ein Kreuz). Gibt es etwas preisgünstiges, flottes, das auch für Leute, die keine Cracks sind, zugänglich ist? Ich würde mich freuen, wenn es etwas gäbe, bei dem man nicht irgendwie noch Funktionen für Tastatur und/oder Display-Ansteuerung zusammenbasteln müsste und ein Spannungswandler dabei wäre, der den Anschluss an 24Volt erlaubt, ohne dass die Masse das Potential ändert. Freue mich auf Antwort!!!! Erich
Hallo Erich Ich weiss ja nicht genau was Deine Maschinen genau können muss. Vielleicht kommst du aber mit einem Logo-Modul von Siemens (kleine SPS) aus. Beste Grüsse Geri PS: Arbeite nicht bei Siemens oder habe oder erwarete mir dadurch iregendwelche Vorteile;)
wenn du schon ein C-Controll 2 da hast, dann einfach das OS löschen und in C oder ASM das Ding programmieren. So habe ich es zumindest gemacht. Da mich das OS auch genervt hatte.
Jo, würd ich auch gerne mit Keil machen. Aber abgesehen davon, dass ich mich damit NULL auskenne und somit das Programm nicht übersetzen kann, weiß ich nicht, wie ich die Sache flashen soll. Danke trotzdem!
ich hatte nen GNU Compiler der Firma HighTec, Das flashen ist ein problem, zumindestens wenn man den gesamten Speicher braucht. Mein Programm war ca. 30 Kb groß. Das ging in den 1 Sektor und dafür habe ich zum flashen das Conrad flashtool benutzt. Geht ganz gut. Oder man schreibt sich selber ein Bootloader. Na ja ich hatte keine Zeit mehr gehabt, sonst hätte ich mir bestimmt einen geschrieben. Ach es gibt bei ccnet oder so auch ein Tool.
beschreib doch mal die Ansteuerung der Motoren Encoder Endschalter usw. und auch was passieren soll - evtl. geht es mit weit weniger Aufwand? Hört sich nicht so kompliziert / aufwendig an...
Soll ich euch den Quältext geben? Kompliziert ist es nicht - am kompliziertesten ist das richtige Ausrichten des Reglers (PID).
mit Worten beschreiben und Quelltext dazu wäre besser ( ergibt potentiell mehr Antworten :-)
Also:
Es soll ein Gut von einer Spule auf die andere gewickelt werden - beide
Spulen werden angetrieben. Die eine (nehmende Spule) wird von einem
Selbstbauencoder bzgl. der Geschwindigkeit geregelt und die andere
(gebende) von einem Tänzer gesteuert, um die Zugkraft unter Kontrolle
zu halten. Dann is da noch die Führung an einer Wandermutter, die über
ein Motorgetriebenes Gewinde bewegt wird. Der Encoderwert muss pro
Zeiteinheit in einem bestimmten Verhältnis zu dem der nehmenden Spule
sein - an einem bestimmten Punkt (abhängig von der gewählten
Trommelbreite) muss der Motor exakt in die andere Richtung drehen. Da
momentan ein Pulsverhältnis von 50% "Stopp" bedeutet, würde das ein
Schalten von X% auf 100%-X% heißen. Das wird aber noch geändert: am
inversen Motorsteuerungseingang ist momentan ein Spannungsteiler, aber
es soll stattdessen ein Port auf 1 und 0 geschaltet werden -> Ergebnis:
höhere mögliche Geschwindigkeit und Stopp bei einem Pulsverhältnis von
(warum ich nicht gleich darauf gekommen bin....????).
hier der QT in C2:
//------------
thread main
//------------
{
ports.getcount(3);
ports.getcount(1);
ports.getcount(2);
lcdext.init();
/*----------------------------------------------------------------------
---
Index 0 bezieht sich auf aufwickelnden Motor
Index 1 bezieht sich auf Faser-lenkenden Motor
Index 2 bezieht sich auf abwickelnden Motor
a, b und c werden noch festgelegt
------------------------------------------------------------------------
-*/
int
timPer,
RAbstand, TrommelBreite, VWickel, LWickel,
Hoehe[3],
tTor,
Puls0[3], Puls1[3], Puls2[3],
TrommelAbstand, Trommelbreite, counter, count1, count2, boolturn,
turncount, ok, stopp, temp;
float
a, b, c, FD, increment, decrement;
long
timerPuls, timerTor, tA, tAvgl, laenge, Lagen, laengencount,
lagencount,
port0cnt[3], port1cnt[3], port2cnt[3];
string s;
ports.getcount(1);
ports.getcount(2);
ports.getcount(3);
ports.deact(8);
ports.deact(9);
ports.deact(10);
ports.deact(11);
ports.deact(12);
boolturn = 0;
increment = 0;
decrement = 1;
timPer = 3000;
plm.setperiod(0, timPer);
plm.setperiod(1, timPer);
plm.setperiod(2, timPer);
counter = 0;
count1 = 0;
count2 = 0;
turncount = 0;
a = 2; b = 1; c = 1;
port1cnt = 0;
port2cnt = 0;
loop
{
plm.out(1,0);
if ports.get(12) != 0
break;
}
plm.out(1, 1500);
plm.out(0, 0);
plm.out(2, 0);
Puls1[0] = 1500; Puls1[1] = 1500; Puls1[2] = 1500;
Puls0[0] = 0; Puls0[1] = 0; Puls0[2] = 0;
Puls2[0] = 0; Puls2[1] = 0; Puls2[2] = 0;
lagencount = 0;
laengencount = 0;
timerPuls = system.timer();
tAvgl = system.timer();
timerTor = system.timer ();
tTor = 1500;
tA = 500; // Abtastzeit
ok = 0;
loop
{
if (ok == 1)
break;
laenge = 0;
s = "Laenge dm?";
lcdext.goto(1, 0);
lcdext.print(s);
laenge = 50*keyboardmod.getvalue(2,0);
lcdext.clear();
Lagen = 0;
if laenge == 0
{
s = "Lagen";
lcdext.goto(1, 0);
lcdext.print(s);
Lagen = keyboardmod.getvalue(2,0);
lcdext.clear();
}
TrommelAbstand = 0;
while(1==1)
{
if (TrommelAbstand != 0)
break;
s = "TrAbst mm";
lcdext.goto(1, 0);
lcdext.print(s);
TrommelAbstand = 125*(keyboardmod.getvalue(2,0)- 28);
lcdext.clear();
}
Trommelbreite = 0;
loop
{
if (Trommelbreite != 0)
break;
s = "TrBreit mm";
lcdext.goto(1, 0);
lcdext.print(s);
TrommelBreite = TrommelAbstand + 125*keyboardmod.getvalue(2,0);
lcdext.clear();
}
FD = 0;
loop
{
if (FD != 0)
break;
s = "Faserd. in um?";
lcdext.goto(1, 0);
lcdext.print(s);
FD = keyboardmod.getvalue(2,0)/4000;
lcdext.clear();
}
s = "1 = ok";
lcdext.goto(1, 0);
lcdext.print(s);
ok = keyboardmod.getvalue(2,0);
lcdext.clear();
}
counter = ports.getcount(2);
// Wickelführung: Position anfahren
temp = 0;
// while temp < TrommelAbstand
loop
{
temp = temp + ports.getcount(1);
plm.out(1, 2300);
if temp >= TrommelAbstand
break;
}
plm.out(1, 1500);
//Zähler auf Null setzen
stopp = 0;
// while stopp == 0;
loop
{
if (stopp != 0)
break;
//Abbruchbedinungen:
if ((Hoehe[0] < 100) and (increment == 1))
or ((Lagen != 0) and (lagencount == Lagen))
or ((laenge != 0) and (laenge <= counter))
stopp = 1;
//Steuerung der gebenden Trommel abhängig von der Höhe des
Abstandsmessers
if ((system.timer()-tA) >= tAvgl);
{
Hoehe[0] = ports.adc(0) - 500;
//500 wird etwa die Mitte sein... also das Soll
// Achtung! Hier umgekehrt verfahren!!!! bei steigender Höhe Puls
erhöhen!
// ==> + Hoehe[0] und - den Rest!
Puls2[0] = Puls2[2] + a*Hoehe[0] - b*Hoehe[1] - c*Hoehe[2];
//--------------------------
/* hier Regelalgorithmus für die Kraft (PID)
als Basis wird diese digitale Übertragungsfunktion verwendet:
v[k] = v[k-2] - a*u[k] + b*u[k-1] + c*u[k-2]
wobei a = (R1*R2*C1*C2 + 2*R1*C1*tA + 2*R2*C2*tA)/(2*R0*C2*tA)
b = (R1*R2*C1*C2)/(2*R0*C2*tA)
c = (4*R1*R2*C1*C2 - 2*R1*C1*tA - 2*R2*C2*tA)/(2*R0*C2*tA)
die Schaltung, aus der ich diese Algorithmen per bilinearer/Tustin-
Transformation zusammengestöpselt habe, sind auf dem Link ganz unten
zu ersehen
*/
//--------------------------
//Achtung: Reihenfolge
Hoehe[2] = Hoehe[1];
Hoehe[1] = Hoehe[0];
tAvgl = system.timer();
plm.out(2, Puls2[0]);
}
// Abtasten - Encoder der "Zugtrommel". Steuerung der Wickelführung
// abhängig von der Faserstärke. Vergleich mit Encoderwert der
Wickelführung
if ((system.timer()-tTor) >= timerTor);
{
port0cnt[0] = ports.getcount(3)/51;
count1 = ports.getcount(1)/128;
if boolturn == 0
turncount = turncount + count1;
if boolturn == 1
turncount = turncount - count1;
port1cnt[0] = count1 - port0cnt[0] * (FD);// *x/y nicht
vergessen!!!!!
// p1i soll p0i*x/y ... FD ist die Faserstärke, "4" die
Schneckensteigung -
// also das Umdrehungsverhältnis
Puls1[0] = Puls1[2] - a*port1cnt[0] + b*port1cnt[1] +
c*port1cnt[2];
if (Puls1[0] > 100)
Puls1[0] = 100;
//--------------------------
// hier "standard"Regelalgorithmus (PID)
//--------------------------
//Achtung: Reihenfolge!
Puls1[2] = Puls1[1];
Puls1[1] = Puls1[0];
port1cnt[2] = port1cnt[1];
port1cnt[1] = port1cnt[0];
timerTor = system.timer();
// so: und um boolturn zu setzen, muss die verfahrene Strecke genau per
interrupts abgezählt worden sein.
// dann wird abgefragt, ob der Zählerstand einem "RAbstand + RBreite"
entspricht
if (turncount > Trommelbreite) //fiktive Trommelwerte!
{
boolturn = 1;
lagencount = lagencount + 1;
};
if (turncount < TrommelAbstand)
{
boolturn = 0;
lagencount = lagencount + 1;
};
if (boolturn == 0)
plm.out(1, Puls1[0]);
else
plm.out(1, timPer - Puls1[0]);
// Abtasten des "Selbstbau-Encoders" an der Führungsrolle.
// Steuerung der Zugtrommel
count2 = ports.getcount(2);
// Längenmessung - auch hier wäre eine genaue Zählung unheimlich
praktisch
counter = counter + count2;
if ((counter + (5*count2)) >= laenge)
decrement = decrement - 0.2;
/////////////////////////////////////////////////////////////////////
if (decrement < 0)
decrement = 0;
port2cnt[0] = count2 - decrement*3; //Sollwert soll per Poti
eingestellt werden
// Geschwindigkeit langsam senken:
//--------------------------
// hier "standard"-Regelalgorithmus (PID)
//--------------------------
Puls0[0] = Puls0[2] - a*port2cnt[0] + b*port2cnt[1] +
c*port2cnt[2];
//Motor "0" wird ja von Eingang "2" beeinflusst
Puls0[2] = Puls0[1];
Puls0[1] = Puls0[0];
port2cnt[2] = port2cnt[1];
port2cnt[1] = port2cnt[0];
timerTor = system.timer();
// mit increment wird versucht, die Maschine langsam anzufahren
if (increment < 1)
increment = increment + 0.05;
//////////////////////////////////////////////////////////////////////
plm.out(0, increment*Puls0[0]);
}
}
plm.out(1, 3000);
lcdext.clear();
s = "Laenge: ";
str.putint(s, counter);
lcdext.goto(1, 0);
lcdext.print(s);
s = "Lagen: ";
str.putint(s, lagencount);
lcdext.goto(2, 0);
lcdext.print(s);
sleep 3000;
plm.out(1, 1500);
halt;
}
Wow.. mit was für einem Aufwand man 2 Spulen drehen kann :-) Mit "Quältext" hast Du nicht übertrieben, etwas mehr Struktur (Unterprogramme, Prozeduren, Funktionen, Alias-Namen) wären ganz angenehm. Auch habe ich aus Deiner Beschreibung trotz gedanklicher Übersetzungsversuche einiger Begriffe (Selbstbauencoder = Impulsgeber?, Tänzer = Fliehkraftregler?, inverser Motorsteuerungseingang = Schrittmotor?) beim besten Willen nicht richtig herauslesen können, wie das Ganze funktionieren soll. Mach doch mal ein Foto. Nicht desto trotz, wenn es Dir um das eingangs genannte Problem geht, kannst Du mit einem AVR (selbst ein Mega8 sollte das o.g. problemlos schaffen) loslegen. Wenn Du klein und kostengünstig anfangen willst und nicht so viel Zeit investieren, kannst Du z.B. BasCom oder C (wie hier im Tutorial gezeigt) und eine Steckplatine verwenden. Dreh mal an Deiner Spule, und laß Dir die Impulse anzeigen usw. (Display einrichten kostet nur 1-2 Zeilen Quelltext..) usw. Andererseits - wenn Du so ein kompliziertes Programm wie oben auf die Beine gestellt hast - dannn wirst Du doch am Programmieren der C-Control nicht scheitern? Auch dafür gibt es ein Forum.. Daß das o.g. Programm schwer zu debuggen ist, glaube ich sofort lächel wegen "Strukturschwäche"
Bascom und avr. Da hast du treiber für standard LCD 's dabei etc. Und die AVR sind recht flott im abarbeiten des code
Also nachteilig ist natürlich die fehlende Farbe - das hilft bei der Übersicht echt extrem. Der Selbstbauencoder ist nichts anderes als eine der Führungsrollen mit 8 metallenen Schrauben, die sich an einem Endlagenschalter vorbei bewegen -> Drehzahl- und Längenmessung. Der Tänzer ist eine nach oben und unten frei bewegliche Führungsrolle. Er soll in etwa in der Mitte stehenbleiben. Am Träger des Tänzers befindet sich ein induktiver Abstandssensor, der eine schiefe Ebene abtastet und einen Strom liefert (über einen Widerstand als Spannung in einen AD-Port). Ich kucke mal, was ich Bildern hier reinbringe. Und eine Bitte: sagt nix vom CControl-Forum. Habs da schon versucht und mir konnte keiner erklären, warum der Controller eine Endlosschleife nicht unendlich lang ausführt. War ein Testprogramm.
Nunja, ein ATMega dürfte das schaffen.
Die Position des "Tänzers" bestimmt die Verstellung der
Abwickelmotordrehzahl.
Die Umlenkrolle mit "Encoder" ermittelt die umgespulte Länge. Dieser
Eingang müsste natürlich aufgrund der mechanischen Kontakte ordentlich
entprellt werden.
Für die Steuerung der "Führung" sollte aber die Aufwickelspule noch
eine Drehzahlerfassung ("Encoder") bekommen, da die Führung von den
Umdrehungen der Aufwickelspule abhängig ist und nicht von der per
Umlenkrolle ermittelten Umspullänge / Umspulgeschwindigkeit.
Dazu noch ein Text-LCD, einen Drehgeber (mit Taster) oder 4 Taster fürs
Menü, und man kann einstellen, wieviele Meter Material das Ding umspulen
soll. Alternativ könnte das Teil via UART vom PC gesteuert werden.
Um noch etwas Reserve bei den I/O-Pins zu haben, würde ich einen
ATMega8535 einsetzen und in ASM programmieren. In anderen
Programmiersprachen hätte man mit dem Mega16 etwas Reserve bei der
Codegröße.
...
würde mich interessieren für welchen Zweck das genau ist? Willst du Film- oder Tonbandrollen aufspulen? "Die Position des "Tänzers" bestimmt die Verstellung der Abwickelmotordrehzahl." Wandert der Tänzer je nach Geschwindigkeit oder was ermittelst du hier genau. Ich würde den gefederten Tänzer als Endanschlagerkennung nehmen wenn also die Spule zu Ende gezogen wird schlägt der Tänzer aus und das könnte man mit nem Endschalter erkennen und dann den Motor abschalten, dann wäre das für das Band oder was du sonst transportierst nicht so brutal. Zum gezielten abbremsen kannst du ja den Motor Impulsweise in die entgegengesetze Richtung betreiben. Du verwendest einen mechanischen Kontakt? Nervt dich das Tckern oder klickern nicht. Hier solltest du nen Induktiv- oder Hallgeber oder sogar ne Lichtschranke verwenden, das ist ersten geräusch- und verschleißfrei. Ein Hallgeber-IC kostet um 1 und dann noch ein Stabmagnet denn du in mehrere Stücke sägst und deinen Endcoder damit bestückst. Es gibt auch fertige Gabellichtschranken inkl. Winkelscheiben. Keine Angst den Speicher des AVRs wirste damit nicht voll bekommen
Habe noch eine Idee zur Erkennung der Geschwindigkeit. Du könntest auch nen LM2907 (ist ein Frequenz zu Spannungswandler) verwendet dieser bekommt die Impulse deines Encoders zugeführt und macht daraus eine Spannung die du ganz einfach per ADC einlesen kannst. Dann sparst du dir schonmal die Arbeit mit den Timern.
Hallo Erich, ich sehe Deine erfolglosen Hilferufe im CControl Forum zum Thema Keil lassen Dich auf dumme Gedanken kommen.. ;-) nitraM
Hmm?!?? Was sind daran dumme Gedanken? Aber bitte. Hallo Leute, schaut euch doch bitte Quelltext und Bild nochmal an. Alles, was ihr hier fragt ist im Bild oder im Quelltext schon ersichtlich (was umgespult wird, ob dieser und jener Encoder da ist, dass ich keinen EL-Schalter für den Tänzer brauche etc. etc. etc.). Ansonsten sei noch anzumerken: induktive Endlagenschalter sind aufgrund ihres Schmitt-Triggers bereits entprellt. Da ist auch keine Mechanik drni.
Vielleicht sollte ich nochwas erwähnen: ASM mach ich nicht, weil ichs noch weniger kann. Ich will in erster Linie mein fertiges Programm in C haben und das dann flashen können.
Hallo, also ich würde dir auch einen AVR empfehlen, da kannst du z.B. einen Mega16 nehmen, der hat sicher genügend IOs und auch genug Flash (16kB). Deine drei Motoren hängst du an die Hardware-PWMs. Einziges Problem dürfte da die Steuerung der Wandermutter sein, da wäre es besser, es wäre ein Schrittmotor dran, geht aber sicher auch so. Ist natürlich Voraussetzung, dass dein "Encoder" genügend hoch auflöst, damit da mindestens ein Impuls pro Spulenumdrehung kommt, das Ganze ist da dazu da, die Spule schön gleichmässig aufzuwickeln, oder? Beim Starten des Wickelvorgangs fährst du mit dem Motor an der wickelnden Spule per PWM eine Rampe hoch. Damit wird die Faser erstmal gespannt. Je höher der Tänzer dann geht, desto schneller lässt du den abwickel-Motor drehen. Wenn der Tänzer ein analoges Signal liefert, dann kannst du damit möglicherweise sogar direkt den PWM-Ausgang für's Abwickeln steuern ohne überhaupt irgendwas zu rechnen. So gesehen überhaupt kein Problem für den Controller, wenn du nicht noch irgendwo eine Falle eingebaut hast ;)
Thread beobachten
Seitenaufteilung abschaltenBitte melde dich an um einen Beitrag zu schreiben. Anmeldung ist kostenlos und dauert nur eine Minute.
Bestehender Account
Schon ein Account bei Google/GoogleMail? Keine Anmeldung erforderlich!
Mit Google-Account einloggen
Mit Google-Account einloggen
Noch kein Account? Hier anmelden.