NXC Kurzreferenz

NXC Kurzreferenz
Variablen und
Konstanten
int x
#define TEST 270
sind(x), cosd(x)
Ablauf des Programms
steuern
Wait (sec)
repeat (n)
while (bedingung)
do {Block1} while(Bdg)
for-Schleife
if (Bdg.1)
{block1}
else
{block2}
Eine Variable mit
Namen x vom Typ
Integer wird angelegt
Konstanten werden
groß geschrieben und
bekommen einen festen
Wert (hier 260)
zugewiesen. Ohne
Semikolon am Ende!!!!
Berechnet sin und cos in
Grad (sin(x) berechnet
im Bogenmaß)
int test = 0;
Watet sec Anzahl von
Millisekunden
Ein Block von
Anweisungen wird n
mal wiederholt
Wait (4000);
Solange die Bedingung
erfüllt ist (True liefert)
wird die Schleife immer
wieder durchlaufen
Die Schleife wird auf
jeden Fall 1 Mal
durchlaufen, da die
Bedingung erst am Ende
überprüft wird. Solange
sie True ergibt, wird sie
immer wieder
durchlaufen.
Schleife wird exakt nach
Anweisung durchlaufen:
von x=1 bis x<11 und in
jedem Durchlauf wird x
um eins erhöht
Verzweigung durch
Abfrage von
Bedingungen. Ist Bedg.1
erfüllt (True), so wird
der erste Block von
Anweisungen
ausgeführt, sonst (else)
der zweite Block.
sind(90)=1
repeat (4){
…
…
}
while (x<0){
…
…
}
do{
….
…..
}
while(x<0)
for(x=1; x<11; x=x+1)
{
OutNum(0,LCD_LINE1,x);
Wait(500);
}
if (x<0) {
…
….
}
else{
…
}
TextOut(x,y,text, bool);
NumOut(x,y,zahl, bool)
ClearScreen();
ResetScreen();
Gibt den Text text auf
dem Display in Zeile y
und Spalte x aus. True,
wenn der Text, der
vorher im Dislpay war
gelöscht werden soll.
Sonst false
Gibt eine Zahl zahl auf
dem Display aus in Zeile
y und Spalte x. True,
wenn der Text, der
vorher im Dislpay war
gelöscht werden soll.
Sonst false
Löscht vorhergehende
Inhalte auf Display
Erneuert die Werte auf
dem Display
TextOut(1,2,“HALLO“, false);
Überprüft, ob ein
Button gedrückt wurde
am NXT
Button Exit = 0
Button right = 1
Button left = 2
Button center = 3
Und wieder losgelassen
(release = true)
x= ButtonPressed(2, true);
NumOut(1,2, 5, true);
Buttons auf NXT
bool
ButtonPressed(Button,
release)
Abbrechen
abort();
Stop(bedingung);
Timer
long time = CurrentTick();
Motorensteuerung
OnFwd(Ausgang,
Leistung)
OnRev(Ausgang,
Leistung)
Bricht das Programm ab
Bricht Programm ab,
wenn Bedingung erfüllt
also True liefert
Stop(x==0);
CurrentTick ist ein
Zähler, der in 1/1000
Sekunde zählt.
Time= CurrentTick()*1000;
Bewegt den Motor am
Ausgang x mit einer
Leistung von l in %
vorwärts (Werte von 100 bis 100 sind
möglich)
Bewegt den Motor am
Ausgang x mit einer
Leistung von l in %
rückwärts
OnFwd(OUT_A, 75);
OnFwd(OUT_AC, 75);
#Motor an Ausgang A und C werden mit 75%
vorwärts bewegt
OnRev(OUT_A, 75);
OnRev(OUT_AC, 75);
//Motor an Ausgang A und C werden mit 75%
rückwärts bewegt
Off(Ausgang)
RotateMotor(Ausgang,
Leistung, Drehwinkel)
MotorTachoCount(
Ausgang)
MotorRotationCount(
Ausgang);
ResetRotationCount(A
usgänge)
Float (Ausgang)
OnFwdReg(‘ports',‘spe
ed',‘regmode')
Motoren am Ausgang x
werden ausgeschaltet
Wie OnFwd nur wird
der Drehwinkel
angegeben
Gibt den Tachostand
zurück ->geht nicht, ist
irgendetwas für interne
Zwecke. Benutze
MotorRotationCount
Liefert als Wert den
insgesammt
zurückgelegten
Winkelwert zurück (also
360 wäre genau eine
Umdrehung)
Setzt den Zähler wieder
auf 0 (man muss aber
alle bewegten Ausgänge
wieder resetten. Wurde
also mit OUT_AB
gefahren, so muss
OUT_AB einen Reset
bekommen.
Motoren auschalten
und nicht abbremsen
(wie bei Off(Ausgang)
Geregelte Bewegungen
mit den Motoren
ausführen.
Es gibt 3 reg-modes:
Off(OUT_AC);
RotateMotor(OUT_AB, 75, 270);
MotorTachoCount(OUT_A);
X = MotorRotationCount(OUT_A);
ResetRotationCount(OUT_AB);
Float(Out_AB);
OnFwdReg(Out_AB, 50,
OUT_REGMODE_SYNC);
OUT_REGMODE_IDLE, �
keine PID-Reglung
OUT_REGMODE_SPEED �
die/der Motor wird über
die Geschwindigkeit
reguliert
OUT_REGMODE_SYNC. �
zwei Motoren werden mit
einander synchronisiert
Sensoren
Berührungssensor
SetSensorTouch(Port)
;
Sensor(Port);
Sensor am Port i
(i=1,..,4) initialisieren
und die Art des an dem
Port angeschlossenen
Sensors festlegen.
Man fragt den Zustand
des Touch Sensors ab.
Wenn Touch Sensor,
dann == 1 entspricht
„wurde gedrückt“
SetSensorTouch(S1);
x=Sensor(S1);
if (x ==1){
….
}
Lichtsensor
SetSensorLight(Port);
Sensor(Port);
Sensor am Port i
(i=1,..,4) initialisieren
und die Art des an dem
Port angeschlossenen
Sensors festlegen.
Man fragt den Zustand
des Licht Sensors ab.
Werte 0 bis 100 sind
möglich.
Sensor(Port);
PlayTone(a,b);
PlayToneEx(frequency,
duration, volume, loop);
Ultraschall Sensor
SetSensorLowspeed(Port
);
SensorUS(Port)
x=Sensor(S1);
if (x <30){
….
}
SetSensorType(S3,IN_TYPE_LIGHT_INACTIV
E);
SetSensorMode(S3,IN_MODE_PCTFULLSCALE)
;
ResetSensor(S3);
Lichtsensor klaibrieren
Soundsensor
SetSensorSound(Port);
SetSensorLight(S2);
Sensor am Port i
(i=1,..,4) initialisieren
und die Art des an dem
Port angeschlossenen
Sensors festlegen.
Man fragt den Zustand
des Geräusch Sensors
ab. Werte 0 bis 100 sind
möglich
Spielt einen Ton der
Frequenz a in der Zeit
von b msec
Genauerer Befehl zu
PlayTone
SetSensorSound(S3);
Sensor am Port i
(i=1,..,4) initialisieren
und die Art des an dem
Port angeschlossenen
Sensors festlegen.
SetSensorLowspeed(S4);
Wenn der Wert, den der
Ultraschallsensor
zurückliefert kleiner als
Wert ist, soll ein Block
ausgeführt werden
if(SensorUS(S4)<wert){
…
…}
else{
…
}
x=Sensor(S1);
if (x <30){
….
}
PlayTone(200,300);
Wait(400); //während des Tons nichts weiter
tun
PlayToneEx(200,500,50,2);
Subroutinen
sub name(int x…){…}
inline int name(int x…){
…
return x*x;
}
Parallele Tasks
mutex name
Precedes(task1, task2,…)
Oder start task1;
Acquire(name);
Release(name);
stop(name);
Eine Subroutine mit
dem Namen name wird
angelegt. Um Code, der
immer wieder
ausgeführt werden
muss nicht doppelt zu
schreiben und das
Programm
übersichtlicher zu
machen
Ähnlich einer
Subroutine, es kann
aber einen
Rückgabewert geben.
sub test(int x){
…..
}
Variable, auf die die
parallelen Prozesse
zugreifen können. Sie
wird aquiriert, dann
kann kein anderer Task
loslegen, erst wenn sie
wieder freigeb´geben
wurde. „Mutual
exchange“
Startet die Tasks in der
angegebenen
Reihenfolge und
Priorität
Wenn die
entsprechende mutex
variable frei ist, also
kein anderer Task sie
belegt, wird sie von dem
ausfrufenden task
belegt, solange, bis sie
explizit wieder
freigegeben wird
Freigeben der mutex
Variablen
Task beenden
mutex motor;
inline int Name( Args )
{
//body;
return x*y;
}
Precedes(turn1, turn2);
start turn3;
//beachte das Fehlen der Klammern der
Tasks
Acquire(motor);
Release(motor);
stop(turn1);