Roboternetz - Robby RP6

[ERLEDIGT] PA0, PA1 benutzen

Mr.Deepbass — Wed, 09 May 2012 11:55:32 GMT

Hallo Forumgemeinde,

ich habe vor, die Ports ADC0 und ADC1 der Base als Aug�nge zu verwenden um eine LED anzusteuern. Da diese 30mA zieht habe ich schonmal eine entsprechende Treiberschaltung auf einer kleinen PLatine mit ienem BC547C realisiert.
Meine Frage an euch: welche Register muss ich nun genau beschreiben und wo ? Ich vermute die RP6 Base header Datei, wo ich die Ports als Ausg�nge definieren muss um dann anschlie�end im Code mit einem Befehl diese auf 1 setzen zu k�nnen. Ich habe im Forum gesucht, gegoogelt usw. bin aber nicht so richtig schlau aus dem ganzen geworden. Danke im Vorraus.

Gru� Christian

RP6v2 M256 WiFi !?

Dirk — Tue, 08 May 2012 13:15:06 GMT

Hallo Leute,

auf der Verpackung des RP6v2 ist ein neues (?) Erweiterungsmodul "RP6v2 M256 WiFi" abgebildet. Auf der Abbildung kann man auch eine WLAN-Kurzantenne erkennen.

Wer weiss etwas dar�ber? Wird es bald ein Modul mit einem Atmel ARM-Prozessor und WLAN geben?

Gibts Infos/Spekulationen/Preise/Auslieferungs-"Roadmap"/Bezugsquelle?

[ERLEDIGT] ADC0/1 Eing�nge um�ndern

wenckstar — Tue, 01 May 2012 10:41:05 GMT

Brauche auch Hilfe.

Ich habe vor die Eing�nge ADC0/1 als Ausg�nge zu beschalten, um etwas anzusteuern. Eine Logik Schaltung.
Was muss ich dort umschreiben? Wei� das jemand?

Vielen Dank.

Hier ist ein auszug aus der Base.h

#define UBAT (1 << PINA7) // ADC7 (Input)
#define MCURRENT_L (1 << PINA6) // ADC6 (Input)
#define MCURRENT_R (1 << PINA5) // ADC5 (Input)
#define E_INT1 (1 << PINA4) // INT1 (input per default... can be output)
#define LS_L (1 << PINA3) // ADC3 (Input)
#define LS_R (1 << PINA2) // ADC2 (Input)
#define ADC1 (1 << PINA1) // ADC1 (Input)
#define ADC0 (1 << PINA0) // ADC0 (Input)

// Initial value of port and direction registers.
#define INIT_DDRA 0b00000000
#define INIT_PRTA 0b00000000

// ---------------------------------------------------
// PORTA A/D Convertor channels

#define ADC_BAT 7
#define ADC_MCURRENT_L 6
#define ADC_MCURRENT_R 5
#define ADC_LS_L 3
#define ADC_LS_R 2
#define ADC_ADC1 1
#define ADC_ADC0 0

RP6 Stop Funktion

Corsin Obrist — Sun, 29 Apr 2012 12:27:33 GMT

Hallo!
Brauche hilfe!

Ich steuere meinen Rp6 �ber ein WiFly Modul fom Laptop aus!
Nun wollte ich noch ein paar anpassungen machen... aber verzweifle nun an kleinen problemen!

Die Funktion Stop verstehe ich nicht!

Um sie anzuwenden hab ich auf die schnelle ein einfaches Programm geschrieben..

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////

void anhalten (void);

int main (void)
{
int i;
int lese_wert;
initRobotBase();
powerON();
while(1)
{

for (i = 0; i<=1000; i++)
{
changeDirection(FWD);
task_motionControl();
moveAtSpeed(180,180);
mSleep(5);
}

anhalten();
mSleep(2000);

for (i = 0; i<=1000; i++)
{
changeDirection(BWD);
task_motionControl();
moveAtSpeed(180,180);
mSleep(5);
}

void anhalten(void)
{
stop();
setStopwatch1(0);
while(getStopwatch1()<300)
{
task_motionControl();
}

}

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////

Das problem ist, dass der Roboter sich nach der Stopfunktion aufh�ng....

Kann mir jemand das erkl�ren?

[ERLEDIGT] Stopwatch wird ignoriert/ falsch interpretiert

Mac80 — Fri, 20 Apr 2012 20:49:53 GMT

Hallo, ich bin wieder auf ein neues Problem gesto�en.
Der Roboter soll bei der ACS links+rechts Erkennung eine kurze Pause einlegen (ca 5000ms) und danach weiterfahren, laut Programm. Ich habe hier den nur den Base als Master.

Mein Code-Ausschnitt (aus Examples Base Move 5):

Code:

#define AVOID_SPEED_L_ARC_LEFT  30

#define AVOID_SPEED_L_ARC_RIGHT 40 // 90

#define AVOID_SPEED_R_ARC_LEFT  40 // 90

#define AVOID_SPEED_R_ARC_RIGHT 30

#define AVOID_SPEED_ROTATE         30     // 60

#define AVOID_SPEED_WAIT 0   //Motoren halt



// States for the Avoid FSM:

#define AVOID_OBSTACLE_RIGHT                 1

#define AVOID_OBSTACLE_LEFT                 2

#define AVOID_OBSTACLE_MIDDLE            3

#define AVOID_OBSTACLE_MIDDLE_WAIT         4

#define AVOID_END                                         5

behaviour_command_t avoid = {0, 0, FWD, false, false, 0, IDLE};



void behaviour_avoid(void)

{

        static uint8_t last_obstacle = LEFT;

        static uint8_t obstacle_counter = 0;

        switch(avoid.state)

        {

                case IDLE: 

                        if(obstacle_right && obstacle_left) // left AND right sensor have detected something...

                                avoid.state = AVOID_OBSTACLE_MIDDLE;

                        else if(obstacle_left)  // Left "sensor" has detected something

                                avoid.state = AVOID_OBSTACLE_LEFT;

                        else if(obstacle_right) // Right "sensor" has detected something

                                avoid.state = AVOID_OBSTACLE_RIGHT;

                break;

                case AVOID_OBSTACLE_MIDDLE:

                        avoid.dir = last_obstacle;

                        avoid.speed_left = AVOID_SPEED_WAIT;

                        avoid.speed_right = AVOID_SPEED_WAIT;

                        setStopwatch4(0);

                        startStopwatch4();

                                                

                        while(getStopwatch4() >= 4990){                // Die while Schleife verursacht nur Probleme....

                        if (getStopwatch4() >=5000)

                        {

                        setStopwatch4(0);

                        }}

                        avoid.speed_left = AVOID_SPEED_ROTATE;

                        avoid.speed_right = AVOID_SPEED_ROTATE;

                        //else

                        

                        

                                        

                        

                                                

                        if(!(obstacle_left || obstacle_right))

                        {

                                if(obstacle_counter > 3)

                                {

                                        obstacle_counter = 0;

                                        setStopwatch4(0);

                                }

                                else

                                        setStopwatch4(400);

                                startStopwatch4();

                                avoid.state = AVOID_END;

                        }

                break;

                case AVOID_OBSTACLE_RIGHT:

                        avoid.dir = FWD;

                        

                        avoid.speed_left = AVOID_SPEED_L_ARC_LEFT;

                        avoid.speed_right = AVOID_SPEED_L_ARC_RIGHT;

                        if(obstacle_right && obstacle_left)

                                avoid.state = AVOID_OBSTACLE_MIDDLE;

                        if(!obstacle_right)

                        {

                                setStopwatch4(500);

                                startStopwatch4();

                                avoid.state = AVOID_END;

                        }

                        last_obstacle = RIGHT;

                        obstacle_counter++;

                break;

                case AVOID_OBSTACLE_LEFT:

                        avoid.dir = FWD;

                        avoid.speed_left = AVOID_SPEED_R_ARC_LEFT;

                        avoid.speed_right = AVOID_SPEED_R_ARC_RIGHT;

                        if(obstacle_right && obstacle_left)

                                avoid.state = AVOID_OBSTACLE_MIDDLE;

                        if(!obstacle_left)

                        {

                                setStopwatch4(500); 

                                startStopwatch4();

                                avoid.state = AVOID_END;

                        }

                        last_obstacle = LEFT;

                        obstacle_counter++;

                break;

                case AVOID_END:

                        if(getStopwatch4() > 1000) // We used timing based movement here!

                        {        stopStopwatch4();

                                setStopwatch4(0);

                                avoid.state = IDLE;

                        }

                break;

        }

}

Die Wartezeit soll nur einmal aufgerufen werden pro Ausweichman�ver.
Ich habe da verschieden Schleifenvariationen ausprobiert und der RP6 ignoriert die Erkennung oder bleibt stehen. Ohne Schleife wird immer ein Teil �bersprungen.
W�re es sinnvoller den Timer in einem weiteren case z.B. AVOID_OBSTACLE_MIDDLE_WAIT einzurichten und mit einem "avoid.state = AVOID_OBSTACLE_MIDDLE;" �berzuleiten? Oder l�uft es auf das selbe Ergebnis heraus?

Wer sieht meinen Fehler?

RP6 Gleichlauf der Motoren

Schwammi — Tue, 17 Apr 2012 12:03:19 GMT

Hallo Community,

ich habe mir vor einem Monat den RP6 zugelegt. Im Moment passe ich mir die RP6 Library an, und hier vor allem die Antriebsfunktionen.
Und zwar habe ich selbst einen PI-Regler programmiert. Er funktioniert sehr gut, beim freien Geradeausfahren habe ich eine Abweichung von ca. 5mm/m. Damit kann ich leben. Jedoch beim Starten habe ich das Problem, dass einer der beiden Motoren fr�her zu drehen beginnt und sich daraus nat�rlich gleich von Anfang an eine falsche Richtung ergibt.

Meine Ans�tze w�ren Folgende:
1.) Einen zweiten Regler, der die Drehzahldifferenz auf 0 h�lt.
2.) Einen Distanzregler laufen lassen, der die Distanzdifferenz der beiden Motoren auf 0 h�lt, und den Geschwindigkeitssollwert anpasst.

Daraus ergeben sich jetzt zwei Fragen:
1.) Haben diese Ans�tze Erfolgsaussichten?
2.) Habt ihr selbst Ideen, wie man das mach bzw. hat sich schon jemand damit befasst und eine L�sung gefunden?

Mit freundlichen Gr��en

Schwammi