Nibobee Ping Pong! WAS ist denn das???

[vnrobot1]

hallo,
ich versuche das Programm PingPong (S.27-29) zu kapieren

aber irgendwie sind die Erklärung ein bisschen zu kurz bzw. zu ungenau (da ich auch ein fast absolute anfänger bin!!!)

Kann mir jemand das Programm ein bisschen näher erläutern?

Ich habe das Programm auch kompliiert und die rechte gelbe LED (LED3) von den biene leuchtet auf und es reagiert gar nicht wenn ich auf den Fühler drücke. das macht mich irgendwie noch mehr verwirrt,:confused::confused::confused:

Für was ist eigentlich das Programm???


danke im voraus

gruß,
vnrobot1

[Sebas]

das ist ein recht sinnfreies "spiel".
die leuchtende led verkörpert den ball. wenn du den fühler auf der seite wo der ball ist zurückziehst und schnalzenlässt bewegt sich der "ball" auf die andere seite. und so weiter und so fort.
hoffe das war verständlich :-)
ein demoprogramm halt nichts sinnvolles.
mfg Sebastian

[vnrobot1]

achso, das ist der "Funktion" von das Programm
danke Sebas,

aber ich verstehe den code immer noch nicht?
Kann mir vielleicht jemand den code stück für stück erklären?
Hier ist der code:


#include <nibobee/iodefs.h>
#include <nibobee/led.h>
#include <nibobee/sens.h>
#include <nibobee/delay.h>
enum {
STATE_IDLE = 0,
STATE_PULL0 = 1,
STATE_PULL1 = 2,
STATE_KICK = 3,
STATE_PUSH = 4
};
uint8_t calculate_state(uint8_t state, int8_t sensor) {
switch (state) {
case STATE_PUSH:
case STATE_IDLE:
if (sensor==-1) {
return STATE_PULL0;
} else if (sensor==+1) {
return STATE_PUSH;
}
return STATE_IDLE;

case STATE_PULL0:
if (sensor==-1) {
return STATE_PULL1;
} else if (sensor==+1) {
return STATE_PUSH;
}
return STATE_IDLE;

case STATE_PULL1:
if (sensor==-1) {
return STATE_PULL1;
}
return STATE_KICK;

case STATE_KICK:
return STATE_IDLE;
}
return state;
}
int main() {
led_init();
sens_init();
uint8_t ball_pos = 3;
int8_t direction = -1;
uint8_t state_l = STATE_IDLE;
uint8_t state_r = STATE_IDLE;
while(1==1) {
delay(100);
state_l = calculate_state(state_l, sens_getLeft());
if( ((state_l==STATE_PUSH) && (ball_pos==1)) ||
((state_l==STATE_KICK) && (ball_pos==0)) ) {
direction = +1;
}
state_r = calculate_state(state_r, sens_getRight());
if( ((state_r==STATE_PUSH) && (ball_pos==2)) ||
((state_r==STATE_KICK) && (ball_pos==3)) ) {
direction = -1;
}
if(direction==+1) {
if(ball_pos<3) {
ball_pos++;
} else {
direction=0;
}
}

if(direction==-1) {
if(ball_pos>0) {
ball_pos--;
} else {
direction=0;
}
}
led_set(LED_L_YE, ball_pos==0);
led_set(LED_L_RD, ball_pos==1);
led_set(LED_R_RD, ball_pos==2);
led_set(LED_R_YE, ball_pos==3);
}
return 0;
}Woher kommt diese Zustandsautomaten, wurde es in das Programm irgendwie definiert
Und was soll den das ganze "case STATE_..." ?

Ich hoffe ihr könnt mir dabei weiterhelfen

danke im voraus

mfg
vnrobot

[radbruch]

Hallo


...es reagiert gar nicht wenn ich auf den Fühler drücke.Die Schalter der Fühler sind nicht optimal aufgebaut:
https://www.roboternetz.de/community/showthread.php/45237-NIBObee-Erfahrungsberichte?p=435341&viewfull=1#post435341

Zur Funktionsweise des Ping-Pong kannst du ja mal beim Entwickler nachfragen:

http://www.roboter.cc/index.php?option=com_kunena&view=entrypage&defaultmenu=21&Itemid=20

Vielleicht kann er die fehlenden Kommentare für das Programm nachliefern. Früher hatte er hier auch mitgelesen...

Gruß

mic

[Edit]
Ich habe mal versucht das Programm zu kommentieren. Ohne Gewähr:

// PingPong für die bee aus den Tutorial 9.8.2011 mic

// Umformatiert und kommentiert von mic :)

// Spielbeschreibung:

// Mit den Fühlern kann man den virtuellen Ball ins Spiel bringen oder zurückschlagen.
// Eingeworfen wird durch das Ziehen am Fühler und anschliesendem Loslassen des Fühlers
// (ähnlich wie die Startvorrichtung beim Flipper).

// Zurückschlagen kann man den Ball, wenn man gegen den Fühler drückt, wenn sich der Ball
// eine Position vor der Endlage des jeweiligen Fühlers befindet.

#include <nibobee/iodefs.h>
#include <nibobee/led.h>
#include <nibobee/sens.h>
#include <nibobee/delay.h>

// Die statemachine schaltet den Status weiter
// Es werden 5 Zustände definiert die für jede Seite getrennt weitergeschaltet werden:

enum {
STATE_IDLE = 0, // nichts zu tun
STATE_PULL0 = 1, // Fühler wurde nach außen gezogen (Ball drückt von innen auf Fühler)
STATE_PULL1 = 2, // Ball drückt immer noch bedeutet kein Prellen am Konkakt
STATE_KICK = 3, // Fühler ist wieder frei (nicht mehr gedrückt oder gezogen)
STATE_PUSH = 4 // Fühler wurde von außen nach innen gedrückt
};

uint8_t calculate_state(uint8_t state, int8_t sensor)
{
switch (state)
{
case STATE_PUSH: // Volleyreturn

case STATE_IDLE: // rumlungern und warten bis "Sensor" betätigt wird
if (sensor==-1)
{
return STATE_PULL0; // "sensor" meldet "Fühler gezogen", weiter mit Entprellen 1
}
else if (sensor==+1)
{
return STATE_PUSH; // "sensor" meldet "Fühler gedrückt", zurückschlagen möglich?
}
return STATE_IDLE;

case STATE_PULL0: // Beim zweiten Aufruf von calculate_state() ist der
if (sensor==-1)
{
return STATE_PULL1; // Fühler immer noch gezogen, deshalb weiter mit warten auf loslassen
}
else if (sensor==+1)
{
return STATE_PUSH; // inzwischen hat der Status des Fühlers gewechselt, zurückschlagen möglich?
}
return STATE_IDLE;

case STATE_PULL1: // Warten auf loslassen
if (sensor==-1)
{
return STATE_PULL1; // Fühler immer noch gezogen
}
return STATE_KICK; // Ball abgeschossen

case STATE_KICK: // Einwerfen fertig
return STATE_IDLE;
}
return state;
}

int main(void)
{
led_init();
sens_init();

uint8_t ball_pos = 3; // Startposition ist rechts und
int8_t direction = -1; // Richtung ist nach links: Lauflicht beim Einschalten
uint8_t state_l = STATE_IDLE; // Statusspeicher für beide Seiten
uint8_t state_r = STATE_IDLE; // dummystatus ist idle

while(1==1)
{
delay(100);

state_l = calculate_state(state_l, sens_getLeft()); // Status für linken Fühler berechnen
// Status Zurückschlagen oder Einwerfen?
if( ((state_l==STATE_PUSH) && (ball_pos==1)) || ((state_l==STATE_KICK) && (ball_pos==0)) )
{
direction = +1; // Dann soll Ball nach rechts fliegen
}

state_r = calculate_state(state_r, sens_getRight()); // Status für rechten Fühler berechnen
// Status Zurückschlagen oder Einwerfen?
if( ((state_r==STATE_PUSH) && (ball_pos==2)) || ((state_r==STATE_KICK) && (ball_pos==3)) )
{
direction = -1; // Dann soll Ball nach links fliegen
}

if(direction==+1) // wenn Richtung nach rechts...
{
if(ball_pos<3) // und rechts noch nicht erreicht wurde, dann...
{
ball_pos++; // weiter nach rechts wandern
}
else // aber wenn schon rechts angekommen
{
direction=0; // dann keine Richtung setzen
}
}

if(direction==-1) // wenn Rinchtung nach links...
{
if(ball_pos>0)
{
ball_pos--;
}
else
{
direction=0;
}
}

// Darstellung des "Balls". Von Hinten (Akkuseite) betrachtet ist Pos0 links und Pos3 rechts

// led_set() erwartet als ersten Parameter die Nummer der LED (0-3) Diese werden indirekt
// über led.h und iodefs_nibobee.h definiert:

// enum { // aus led.h
// LED_L_YE = IO_LEDS_BIT_L_YE,
// LED_L_RD = IO_LEDS_BIT_L_RD,
// LED_R_RD = IO_LEDS_BIT_R_RD,
// LED_R_YE = IO_LEDS_BIT_R_YE
// };

/*! LED group */ // aus iodefs_nibobee.h
// #define IO_LEDS_PORT PORTB
// #define IO_LEDS_MASK 0x0f
// #define IO_LEDS_DDR DDRB
// #define IO_LEDS_BIT_L_YE 0
// #define IO_LEDS_BIT_L_RD 1
// #define IO_LEDS_BIT_R_RD 2
// #define IO_LEDS_BIT_R_YE 3

// zweiter Parameter ist eigentlich vom Typ Boolean und kann deshalb true oder false sein
// True schaltet die betreffende LED an, false schltet sie aus

led_set(LED_L_YE, ball_pos==0); // wenn ball_pos==0 ergibt true wenn ball-pos 0 ist (links)
led_set(LED_L_RD, ball_pos==1);
led_set(LED_R_RD, ball_pos==2);
led_set(LED_R_YE, ball_pos==3); // wenn ball_pos==3 ergibt true wenn ball-pos 3 ist (recht)
}
return 0; // wird nie erreicht
}

// ich hoffe, das passt so ;)