Liste der Anhänge anzeigen (Anzahl: 1)
Mit der Sprungantwort versuche ich die Zeitkonstanten des Motors zu ermitteln, denn auf den billigen Motoren steht so etwas nicht drauf. Auch weiß ich die Motorenwerte wie Widerstand R, Induktivität L oder Motorkonstante c nicht. Wenn ich den Widerstand mit einem Multimeter messe schwank er stark, je nach Ankerstellung.
Ich möchte durch messung auf die Ankerzeitkonstante und die Mechanische Zeitkonstante, sowie die Verstärkungen kommen. Ich habe mal eine Presantation gemacht wie man vom Gleichstrommotor zu den Zeitkonstanten kommt. Die ersten Seiten sind nur Herleitungen, aber auf der Letzten stehen Werte, die eigentlich ich wissen möchte.
Liste der Anhänge anzeigen (Anzahl: 1)
Hallo Xaver,
willst du dir das mit der Kaskadenregelung wirklich antun. Eine Lageregelung geht auch mit einer einschleifigen Regelung und die ist um ein vielfaches einfacher als die Kakadenregelung.
Bei deinen Kurven http://www.wsgs.net/nBot/image002.gif und http://www.wsgs.net/nBot/image004.gif stimmt der Zeitmaßstab irgendwie nicht zusammen. Ich kann da keine sinnvolle Zeitkonstante herauslesen. Überprüf nochmal den Maßstab.
Im Anhang ist eine Kennlinie, die ungefähr für den RB40 passen dürfte.
Waste
Liste der Anhänge anzeigen (Anzahl: 3)
Ok, so weit so gut.
Ich trage nun mal zusammen wie ich den Strom messe.
Ich verwende für die Motoren eineH-Brücke mit einem L298. An den Sense-Ausgängen sind 0.22Ohm Lastwiderstände (5W). Von Dort führe ich die Spannung über einen Tiefpass zu einem Verstärker und dann zum MC.
Dort entspricht 5V-> 2,066A und 0V->0A. Ich kann also bis maximal 200mA den Strom des Motor messen und das in 1024 Schritten(+- 2mA).
Das Programm ist besteht aus drei Teilen.
dem AD-Wandler; dem Umrechnung in mA und der Ausgabe über UART.
Die Umrechnung erfolgt immer dann, wenn der Timer0 übergelaufen ist.
Die f_CPU Frequenz ist 11.059MHZ und der prescaler auf 64, das ergibt eine Überlaufzeit von 1.48ms. So oft wird also eine Strommessung gemacht.
Im Anhang habe ich das Komplette AVR-GCC Projekt angefügt.
Es enthält noch Tastenentprellen und Drehzahlmessung mit Interrups.
Ganz zum Schluss habe ich noch den Kurvenverlauf von Strom und Drehzahl, bei einem unbelasteten Motor und sprunghaften Ein- und wieder Ausschalten.
Ich meine, wenn man den Motor "ausrollen" lässt kann man die Trägheit ablesen. Je länger es dauert bis die Drehzahl auf 0 ist, desto Träger ist das System. Die Trägheit J entspricht dann der Steigung oder?
Und wenn die fallende Kurve stark durchgebogen ist, ist die Reibung groß.
Was man Zeit bis der Motor auf Drehzahl ist ablesen kann weiß ich leider nicht, müsste aber einer von euch sicher wissen ;-)
Gruß Bronko
Code:
/**
* AD Wandler
* Dieses Programm enthält funktionen zu auslesen der AD-Wandler
*
* V0.1
*/
#include <avr/io.h> //I/O-Register
#include <stdint.h> //standart Integertypen
#include "adwandler.h"
/***/
/** Routine zum auslesen eines einzelnen A/D-Wertes */
/***/
uint16_t get_adc(uint8_t adc_pin)
{
uint8_t i;
uint32_t result = 0; //Initialisieren wichtig, da lokale Variablen
//nicht automatisch initialisiert werden und
//zufällige Werte haben. Sonst kann Quatsch rauskommen
ADCSRA = (1<<ADEN) | AD_PRE; // Frequenzvorteiler
// setzen auf 8 (1) und ADC aktivieren (1)
ADMUX = adc_pin; // Kanal waehlen
ADMUX |= AD_REF; // Referenzspannung nutzen
//ADMUX |=(1<<ADLAR); // Werte linksbündig schreiben
/* nach Aktivieren des ADC wird ein "Dummy-Readout" empfohlen, man liest
also einen Wert und verwirft diesen, um den ADC "warmlaufen zu lassen" */
ADCSRA |= (1<<ADSC); // eine ADC-Wandlung
while ( ADCSRA & (1<<ADSC) ); // auf Abschluss der Konvertierung warten
/* Eigentliche Messung: Mittelwertbildung aus MITTELWERT aufeinanderfolgenden Wandlungen */
for(i=0;i<MITTELWERT;i++)
{
ADCSRA |= (1<<ADSC); // eine Wandlung "single conversion"
while ( ADCSRA & (1<<ADSC) ); // auf Abschluss der Konvertierung warten
result += ADCW; // Wandlungsergebnisse aufaddieren
}
ADCSRA &= ~(1<<ADEN); // ADC deaktivieren (2)
result /= MITTELWERT; // Summe durch MITTELWERT teilen = arithm. Mittelwert
return result;
}
/**
* MOTOR
* Dieses Programm soll alle funktionen zu den Motoren beinhalten
*
* V0.1
* DEfines für die Motoren definiert
*
* V0.2
* Der Motorstrom kann ausgelesen werden
* Beim Richtungswechsel oder Speed 0 Blokieren die Motoren kurz
*
* V0.3
* PWM auf 21,6kHz geändert (nicht hörbar)
* PWM läst sich nun mit 9 bit einstellen
*
* V0.4
* Drehzahlmessung hinzugefügt
* Die Ausgabe Über UART lässt sich nun mit einer Taste starten/stopen
* Uart sendet PWM[in %] Drehzahl[in Upm] Strom[in mA]
* Fehler in der Drehzahlberechnung behoben
*
*/
/* Ermittelt den Motorstrom */
uint16_t get_Motorstrom(uint8_t motor_shunt)
{
uint16_t data;
/* liest den Aktuellen Wert am AD */
data = get_adc(motor_shunt);
/* Umrechnen in mA */
data = (data * 24)/10;
return(data);
}
/**
* Motorstrom
* Dieses Programm soll den Motorstrom an einem Pin Messen und
* Über Uart ausgeben
*
* V0.1
* programm giebt Spannung und Strom über uart aus
*
* V0.2
* Die Referenzspannungwird auf 0.5V gesenkt und der AD-Wandler im Normalen
* Modus betrieben(nicht Gain 10x)
*
* V0.3
* Der Spannungsabfall am Shunt wird nun mit einem OP 11fach verstärkt.
* Die Referenzspannung wurde wieder auf interne 2.56V gesetz
* der A/D arbeitet mit 172KHz und mittelt 8 Messungen
* die PWM arbeitet mit 21,6kHz und lässt sich mit 9Bit(max 01FF) einstellen
*
*
* V0.4
* Motorstrom wird nun in mA umgerechnet und PWM in prozent
* Die Referenzspannung des A/D-Wandlers ist nun die Versorgungsspannug Vcc (5V)
*
* V0.5
*
* Drehzahl der Motoren wird ausgegeben
*/
/** Programmteil 2 **/
/** status über UARt ausgeben **/
/* Timer0_counter hat sich geändert und sm2 ist aktiv */
if((alt!=timer0_counter)&&(sm & 0x02))
{
alt = timer0_counter;
//LED_PORT ^=(1<<LED1); //LED blinken, ist immer gut
uint16_t strom;
uint16_t drehzahl;
strom = get_Motorstrom(MOTOR_RECHTS_SHUNT); // ermittelt dden Strom
drehzahl= get_Motordrehzahl(); // ermittelt die Drehzahl
//uart_putc(0x0c); // terminal clearsceen (bildschirm löschen)
/*
uart_puts("\r\n");
uart_puts("Statusmeldung\t\trechter Motor\r\n\r\n");
uart_puts("PWM Drehzahl Motorstrom\r\n ");
*/
/* Wert der PWM ausgeben */
itoa(((uint16_t)(speed_r*100)/PWM_MAX), buffer, 10);
uart_puts(buffer);
uart_puts("\t");
/* Drehzahl ausgeben */
utoa(drehzahl, buffer, 10);
uart_puts(buffer);
uart_puts("\t");
/* Strom ausgeben */
utoa(strom, buffer, 10);
uart_puts(buffer);
uart_puts("\r\n");
}
