Das CC2Net-Forum

F�r dieses Forum muß
Javascript im Browser
aktiviert werden!

Zur Übersicht - INFO - Neueste 50 Beiträge - Neuer Beitrag - Suchen - FAQ - Zum CC1-Forum - Zum CC-Pro-Forum

Kann mir jemand das in C für die Keil-IDE übersetzen? Kategorie: Programmierung (von Erich - 27.06.2006 11:25)

Ich nutze:
C-Control II Unit, CC2-Application-Board, OSOPT V3.0

//------------
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;
}

wäre echt super nett!

Antwort schreiben

Antworten: