Strom über den Motor messen (RB40, L298, Shunt)

[Xaver]

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

/**    
* 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");
		}