Hallo Leute,
ich habe ein kleines Problem:
Ich habe ein Gehäuse mit Motoren des CC-RP5, AT89C5131 & einen PCF8591 welchen ich über I²C an den µC angebunden habe(zum auslesen von Analogsensoren). Das wird ein kleiner autonomer Roboter / ist es schon.
Mein derzeitiges Programm :
Code:
/*------------------------------------------------------------------+
| File: Roboterfahrzeug |
| Autor: |
| Klasse: E3GS1 |
| Controller: at89c5131 |
| Datum: 27.03.13 |
| Version: 2 |
+--------------------------------------------------------------------+
| Beschreibung: |
| |
+-----------------------------------------------------------------------------*/
#include <at89c5131.h> // fuer Atmel AT89C5131
/* adda_kniel.c *********************************************************************************
* Hilfsprogramme für den AD- und DA- Umsetzer mit I2C-Bus ********************************
* An DA-Umsetzer wert ausgeben: void aout (unsigned char wert)
* AD-Umsetzer einlesen, Kanal = 0,1,2,3: unsigned char ain (unsigned char kanal)
******************************************************************************************/
// geänderte Version 11/2007: Start und Stop-Bedingungen, funktioniert mit US-Sensoren
// geänderte Version 12/2006: funktioniert endlich aus als Library: adda.obj mit
// Tool -> Library-Manager in die Bibliothek RC51atms.lib einfügen
#include <reg51.h> // Registerdefinitionen
//#include <intrins.h> // für Rotationsfunktion
// !-!-!-!-!-!-!-!-!-!-!-!-!-!-!-!-!-!-!-!-!-!-!-!-!-!-!-!-!-!-!-!-!-!-!-!-!-!-!-!-!-!-!-!
//****** verwendete I2C-Leitungen *********************************************************
sbit SDA = P4^1; // SDA-Leitung: ED2-Boards P3_5, (USB-Boards P4_1)
sbit SCL = P4^0; // SCL-Leitung: ED2-Boards P3_4, (USB-Boards P4_0)
//****************************************************************************************
// !-!-!-!-!-!-!-!-!-!-!-!-!-!-!-!-!-!-!-!-!-!-!-!-!-!-!-!-!-!-!-!-!-!-!-!-!-!-!-!-!-!-!-!
//***** verwendete Adressen und Kontrollbyte für den AD- und DA-Umsetzter ****************
#define Motor1 P1
#define Motor2 P2
#define vor 0x50
#define zurueck 0x44
#define stopp 0x40
#define adr_lies 0x91 // 10010001 -> 1001 fest, 000 durch Platine, 1 Wert lesen
#define adr_schreib 0x90 // 10010000 -> 1001 fest, 000 durch Platine, 0 Wert lesen
#define contr_ain 0x40 // 01000000 -> Kontrollbyte 4 einzelne ADU, Kanal= Offset dazu
sbit acc7 = 0xE7; // für Aus- und Eingabe eines Bits des Akkus
//void warte(int z);
// *****************************************************************************************
// I2C- Routinen zur Ansteuerung eins I2C-Slaves
// I2C-Bus-Funktionen i2c_init, i2c_start, i2c_stop, i2c_schreiben, i2c_lesen auch für andere
// I2C-Bus-ICs verwendbar
// *****************************************************************************************
// **** Zeitverzögerung zur Verlangsamung der Datenübertragungsrate ***********************
// **** i=2 bis i=100 wählen je nach I2C-IC und Pull-Up-Widerstand
void zeit (void) {unsigned char i; for (i=5;i!=0;i--) ;}
void vorwaerts (void);
void rueckwaerts (void);
void drehen (void);
void speaker(void);
void warte(int z);
void stop(void);
// ****************************************************************************************
// ****** Initialiserung I2C-Bus **********************************************************
void i2c_init (void)
{
SDA = 1; // Leitungen in den Grundzustand High
zeit ();
SCL = 1;
zeit ();
}
// ****** Startbedingung I2C-Bus **********************************************************
void i2c_start (void)
{
SDA = 1; // Grundzustand
SCL = 1; // neu eingefügt 11/07
zeit();
SDA = 0; // Wechsel SDA von 1 -> 0 während SCL = 1
zeit ();
SCL = 0;
zeit ();
}
//****** Stoppbedingung I2C-Bus ***********************************************************
void i2c_stop (void)
{
SDA = 0; // neu eingefügt 11/07
SCL = 1;
zeit ();
SDA = 1; // Wechsel von SDA 0 -> 1 während SCL =1
zeit ();
}
//*****************************************************************************************
// * Byte ausgeben an I2C-Bus , Rückgabewert = Acknoledgebit = 0 wenn erfolgreich
// ****************************************************************************************
bit i2c_schreiben (unsigned char byte)
{
unsigned char z; // Zähler
bit ack; // Acknoledge-Bit
ACC = byte; // Rotationsregister Akku
for (z = 8; z != 0; z --) // Zähler: serielle Ausgabe von 8 Bit
{
SDA = acc7; // Bit7 des Akku ausgeben
zeit ();
SCL = 1; // Daten sind gültig
asm {0x23}; // Akku links schieben
//ACC = _crol_ (ACC,1); // links rotieren, Funktion von intrins.h
zeit ();
SCL = 0; // Datenausabe beendet
zeit ();
}
SDA = 1; // Leitung freigeben für Acknoledge-Bit
zeit ();
SCL = 1; // Slave kann bestätigen
zeit (); // warten
ack = SDA; // Acknoledge-Bit lesen
zeit ();
SCL = 0; // Slave soll Ackn-Ausgabe beenden
zeit();
return (ack); // Acknoledge-Bit ist Rückgabewert der Funktion
// ack = 0 bedeutet "verstanden" !!!!!!
}
//*****************************************************************************************
// * Byte einlesen vom I2C-Bus. Bei Ack=1 wird Acknoledgebit gesendet, sonst nicht
// *****************************************************************************************
unsigned char i2c_lesen (bit ack)
{
unsigned char z,byte;
SDA = 1; // Leitung freigeben (high) für Daten
for (z = 8; z != 0; z --) // Zähler: serielles Einlesen von 8 Bit
{
SCL = 1; // Daten sind gültig
zeit ();
acc7 = SDA; // Datenbit in den Akku
asm {0x23}; // Akku links schieben
// ACC = _crol_ (ACC,1); // links rotieren, Funktion von intrins.h
//P2_7 = SDA;
zeit();
SCL = 0; // Daten lesen beendet
zeit();
}
byte = ACC; // Eingelesenes Byte
if (ack == 1) {SDA = 0;} // Acknowledge-Bit senden
else {SDA = 1;} // kein Acknowledge-Bit
zeit ();
SCL = 1; // Ackn. gültig
zeit ();
SCL = 0; // Ackn. beendet
zeit ();
SDA = 0; // Leitung SDA vorbereiten für Stoppbed.
zeit ();
return (byte); // eingelesenes Byte = Rückgabewert
}
//************************** ADU und DAU- Funktionen *************************************
//*****************************************************************************************
// * AD-Umsetzter einlesen, Kanal = Nr des ADU: 0,1,2,3
// *****************************************************************************************
unsigned char ain (unsigned char kanal)
{
unsigned char wert;
i2c_init (); // I2C-Bus initialisieren (Grundzustand)
i2c_start (); // Startbedingung I2C-Bus ausgeben
i2c_schreiben (adr_schreib); // Adresse des IC und Schreibwunsch (zur Kanalwahl)
i2c_schreiben ( (kanal&0x03) | contr_ain); // Controll-Byte mit Kanalnummer
i2c_stop (); // Stoppbedingung I2C-Bus ausgeben
i2c_start (); // Startbedingung I2C-Bus ausgeben
i2c_schreiben (adr_lies); // Adresse des IC und Lesewunsch
i2c_lesen (1); // neue AD-Wandlung Acknoledge = 1
wert = i2c_lesen (0); // Wert abholen Acknoledge =0
i2c_stop (); // Stoppbedingung I2C-Bus ausgeben
return (wert);
}
//*****************************************************************************************
// * An DA-Umsetzer wert ausgeben
// *****************************************************************************************
void aout (unsigned char wert)
{
i2c_init (); // I2C-Bus initialisieren (Grundzustand)
i2c_start (); // Startbedingung I2C-Bus ausgeben
i2c_schreiben (adr_schreib); // Adresse ADU
i2c_schreiben (contr_ain); // Control-Byte acu für Analogwert einlesen
i2c_schreiben (wert); // Wert ausgeben
i2c_stop (); // Stoppbedingung I2C-Bus ausgeben
}
void main (void) // Hauptprogramm
{
unsigned char wert; //Definition Variable wert
unsigned char swert; //Definition Variable swert zum abfragen
P0=0x00; // Port0 - Port3 als Ausgang deklarieren
P1=0x00;
P2=0x00;
P3=0x00;
while(1) //While Schleife
{
P3_1=1; //linke weiße LED ausschalten
P3_3=1; //linke rote LED ausschalten
P3_5=1; //rechte rote LED ausschalten
P3_7=1; //rechte linke LED ausschalten
wert = ain(0); //Kanal 0 einlesen und auf wert schreiben
P0 = ~wert; //wert auf P0 schreiben
swert=wert&0x80; //swert = wert mit 80 Hex "und"-Verknüpft
switch(swert) // abfrage von swert
{
case 0x80: rueckwaerts(); //Wenn swert = 80 Hex dann führe das Programm rückwärtsfahren aus
break; // Break um die Abfragen von einander zu trennen
default: vorwaerts(); break; // Wenn swert ungleich 80 Hex dann führe das Programm vorwärtsfahren aus
}
wert = ain(1);
P0 = ~wert;
swert=wert&0x80;
switch(swert)
{
case 0x80: rueckwaerts();
break;
default: vorwaerts(); break;
}
wert = ain(2);
P0 = ~wert;
swert=wert&0x80;
switch(swert)
{
case 0x80: rueckwaerts();
break;
default: vorwaerts(); break;
}
}
}
void vorwaerts (void) //Unterprogramm Vorwärtsfahren
{
Motor1 = vor; // die höherwertige 1 ist der Enable Pin
Motor2 = vor; // die niederwertige 1 ist die Richtung des Motors
}
void rueckwaerts (void) //Unterprogramm Rückwärtsfahren
{
unsigned char hinten_abfrage;
hinten_abfrage = ain(3);
if(hinten_abfrage>=0x40)
{
drehen();
}
else
{
stop(); // Sprung ins Unterprogramm stop
P3_1=0; // LED links weiß an
P3_3=1; // LED links rot aus
P3_5=1; // LED rechts rot aus
P3_7=0; // LED rechts weiß an
Motor1 = zurueck; // Motoren nach hinten fahren lassen
Motor2 = zurueck;
speaker(); // Unterprogramm für den Piepser
drehen(); // Verzweigungs ins Unterprogramm drehen
}
}
void drehen (void) // Unterprogramm drehen
{
double long x; // Variable x mit einem großen Datenbereich adressieren
Motor1 = zurueck; // Motor 1 rückwärts fahren lassen
Motor2 = vor; // Motor 2 vorwärts fahren lassen
for(x=0;x<2100;x++); // Warteschleife in der x hochgezählt wird
}
void stop(void) // Unterprogramm stop & rote LEDS an
{
Motor1=stopp; // Enable pin & Drehrichtungsangabe aus
Motor2=stopp;
P3_3=0; // LED links rot an
P3_5=0; // LED rechts rot an
warte(50); // Sprung ins unterprogramm warte mit Übergabe einer Variablen
}
void speaker (void) // Unterprogamm für die Lautsprecher
{
P3_0=1; // Lautsprecher an
warte(25); // Sprung ins unterprogramm warte mit Übergabe einer Variablen
P3_0=0; // Lautsprecher aus
warte(10); // Sprung ins unterprogramm warte mit Übergabe einer Variablen
P3_0=1;
warte(25);
P3_0=0;
}
void warte(int z) // Unterprogramm fürs Warten
{
int s, x; // definieren von Variablen
for(s=z;s>0;s--) // s nimmt den Wert von z an welche vorher übergeben wurde. s wird runtergezählt
{
for(x=2000;x>0;x--); // for schleife in welcher x runtergezählt wird
}
}
Nun meine Frage : wie bekomme ich eine PWM zur Steuerung der Motoren möglichst einfach hin ? Die Motoren werden über einen L298 geschalten.
Zitat von Regnator
Berechtigungen
Zitieren
Lesezeichen