mikrocontroller.net

Forum: Mikrocontroller und Digitale Elektronik Beratung: Suche pendant zu C-Control II ?


Autor: Erich (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
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

Autor: Geri (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
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;)

Autor: ,,, (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
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.

Autor: Erich (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
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!

Autor: ,,, (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
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.

Autor: papa_of_t (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
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...

Autor: Erich (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Soll ich euch den Quältext geben? Kompliziert ist es nicht - am
kompliziertesten ist das richtige Ausrichten des Reglers (PID).

Autor: papa_of_t (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
mit Worten beschreiben und Quelltext dazu wäre besser ( ergibt
potentiell mehr Antworten :-)

Autor: Erich (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
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;
}

Autor: papa_of_t (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
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"

Autor: Sebastian Heyn (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Bascom und avr. Da hast du treiber für standard LCD 's dabei etc.  Und
die AVR sind recht flott im abarbeiten des code

Autor: Erich (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
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.

Autor: Erich (Gast)
Datum:
Angehängte Dateien:

Bewertung
0 lesenswert
nicht lesenswert
Da isses

Autor: Hannes Lux (hannes)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
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.

...

Autor: Thomas O. (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
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

Autor: Thomas O. (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
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.

Autor: nitraM (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Hallo Erich,
ich sehe Deine erfolglosen Hilferufe im CControl Forum zum Thema Keil
lassen Dich auf dumme Gedanken kommen..  ;-)

nitraM

Autor: Erich (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
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.

Autor: Erich (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
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.

Autor: Philipp Burch (philipp_burch)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
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 ;)

Autor: Erich (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Wir reden aneinander vorbei. Macht nix.

Antwort schreiben

Die Angabe einer E-Mail-Adresse ist freiwillig. Wenn Sie automatisch per E-Mail über Antworten auf Ihren Beitrag informiert werden möchten, melden Sie sich bitte an.

Wichtige Regeln - erst lesen, dann posten!

  • Groß- und Kleinschreibung verwenden
  • Längeren Sourcecode nicht im Text einfügen, sondern als Dateianhang

Formatierung (mehr Informationen...)

  • [c]C-Code[/c]
  • [avrasm]AVR-Assembler-Code[/avrasm]
  • [code]Code in anderen Sprachen, ASCII-Zeichnungen[/code]
  • [math]Formel in LaTeX-Syntax[/math]
  • [[Titel]] - Link zu Artikel
  • Verweis auf anderen Beitrag einfügen: Rechtsklick auf Beitragstitel,
    "Adresse kopieren", und in den Text einfügen




Bild automatisch verkleinern, falls nötig
Bitte das JPG-Format nur für Fotos und Scans verwenden!
Zeichnungen und Screenshots im PNG- oder
GIF-Format hochladen. Siehe Bildformate.
Hinweis: der ursprüngliche Beitrag ist mehr als 6 Monate alt.
Bitte hier nur auf die ursprüngliche Frage antworten,
für neue Fragen einen neuen Beitrag erstellen.

Mit dem Abschicken bestätigst du, die Nutzungsbedingungen anzuerkennen.