- 12V Akku mit 280 Ah bauen         
Seite 2 von 3 ErsteErste 123 LetzteLetzte
Ergebnis 11 bis 20 von 23

Thema: Nibobee Liniensensoren kalibrieren

  1. #11
    Benutzer Stammmitglied
    Registriert seit
    12.01.2010
    Beiträge
    53
    Anzeige

    LiFePo4 Akku selber bauen - Video
    Hallo zusammen,

    vermutlich wird die Biene die beste Linienverfolgung erreichen, wenn die Original-Halbkugel unter die Biene gesetzt wird. Der halbe Tischtennisball verschlechtert das "Linienfinden".

    Die Erklärung ist so einfach und trotzdem nicht naheliegend: Die IR-Dioden haben einen festen Abstrahlwinkel. Wenn die Original-Halbkugel verwendet wird, ist der Abstand so, dass die Dioden zwei Kreise auf dem Boden erhellen, die sich berühren und deren Ränder von allen Fototransistoren "gesehen" werden.

    Wenn ein halbierter Tischtennisball benutzt wird, liegt die Biene tiefer - und damit sind auch die beiden erleuchteten Kreise kleiner. Sogar so klein, dass sie sich nicht einmal berühren. Also wird der Bereich direkt unter den Fototransistoren gar nicht mehr durch die IR-LEDs beleuchtet.

    So wird auch klar, warum die Biene mit einem halben Tischtennisball mehr Probleme hat, die Linen zu finden. Klar sehen die Fototransistoren noch einen Teil des IR-Lichts, aber der Signal-Rausch-Abstand nimmt deutlich ab.

    Mein erster Versuch ist, die beiden äußeren Fototransistoren ein wenig nach innen zu biegen, so dass diese mehr unter die beiden IR-LEDs schauen. Da ich auf der SW-Seite leider noch nicht so weit bin, kann ich noch nicht so genau über Erfolg oder Misserfolg berichten. Vielleicht hilft es euch aber weiter?

    Übrigens: Die IR-Leuchtpunkte lassen sich sichtbar machen, indem man mit der Biene in einen abgedunkelten Raum (muss nicht stockdunkel sein) geht, sie auf einen weißen Untergrund stellt und eine Digitalkamera (Handy ist OK) auf die Fläche unter die IR-LEDs richtet. Digitalkameras sind - im Gegensatz zu unseren Augen - empfindlich gegenüber IR-Licht und stellen dass "hell" dar

    Ich hoffe, ich konnte ein wenig helfen

    Ciao bantyy

  2. #12
    Erfahrener Benutzer Robotik Einstein Avatar von Rabenauge
    Registriert seit
    13.10.2007
    Ort
    Osterzgebirge
    Alter
    56
    Beiträge
    2.210
    Meine Digicam "erkennt" schon nach einem halben Stündchen gerade noch die LED`s selbst als leuchtende Punkte, eine Helligkeit auf dem Untergrund schon nicht mehr (zugegeben, ich hab auch nicht lange mit ihr herumprobiert), offenbar sind die verwendeten IR-LED`s nicht besonders stark.

    Inzwischen bin ich dabei, mir ein Programm zu schreiben, mit dem ich- ohne Display- die gemessenen Werte der Fototransistoren über die LED`s auf Wunsch ausgeben kann.
    Allerdings habe ich einen Stolperstein: ich bin zu doof, aus dem gemessenen Wert (line_get(LINE_L)) eine vernünftige Zahl zu machen, die aber brauche ich um den Wert auf die vier LED`s aufteilen zu können.
    Weise ich dem Wert eine Variable zu, bekomme ich Warnungen, und weiss somit nicht, ob die Ausgabe stimmen wird.
    Direkt den Wert zerlegen klappt auch nicht, da wird der Compiler richtig böse.
    Wie kriege ich den Wert in eine Form, die man mathematisch zerlegen kann?

    Warum das Ganze? Meine Biene will bevorzugt in eine bestimmte Richtung drehen, und das darf sie nicht..

  3. #13
    Moderator Robotik Visionär Avatar von radbruch
    Registriert seit
    27.12.2006
    Ort
    Stuttgart
    Alter
    62
    Beiträge
    5.799
    Blog-Einträge
    8
    Hallo

    Hier ein Beispiel wie man auf die Ziffern der einzelnen Stellen kommt:
    Code:
    // aus: https://www.roboternetz.de/phpBB2/ze...=328394#328394
    void PrintChar(unsigned int x)
    {
       char ergebnis[5]  = {'0','0','0','0','0'};
       while (x >=10000) { ergebnis[0]++; x -=10000; }
       while (x >= 1000) { ergebnis[1]++; x -= 1000; }
       while (x >=  100) { ergebnis[2]++; x -=  100; }
       while (x >=   10) { ergebnis[3]++; x -=   10; }
       ergebnis[4] +=x;
       SerWrite(ergebnis,5);
    }
    In Ergebniss[0] bis [4] stehen dann die 10tsd, 1tsd, hunis, zehner und einer. Allerdings als ASCII-Code, weil der Startwert jeweils '0' (48 oder 0x30) war. Wenn man die Zuweisung der Startwerte in

    char ergebnis[5] = {0, 0, 0, 0, 0};

    ändert, enthält das Array nur noch die Werte 0 bis 9 für die jeweilige Ziffer.

    Meinen TT-Ball habe ich oberhalb der Taile abgeschnitten, der Abstand meiner Liniensensoren entspricht deshalb eher dem Anstand mit der orginalen Halbkugel. Wenn ich die echten Werte mit eingeschalteten IR-Leds ausgeben lasse, habe ich mit diesem Abstand so ziemlich das Maximum erreicht (Werte für weises Blatt bei knapp 1000). Wenn ich die Sensoren anhebe oder senke werden die Werte kleiner. Die Lichtkegel der IR-LEDs werde ich heut abend mal anschauen.

    Gruß

    mic
    Bild hier  
    Atmel’s products are not intended, authorized, or warranted for use
    as components in applications intended to support or sustain life!

  4. #14
    Benutzer Stammmitglied
    Registriert seit
    12.01.2010
    Beiträge
    53
    Hallo,

    Zitat Zitat von Rabenauge
    Meine Digicam "erkennt" schon nach einem halben Stündchen gerade noch die LED`s selbst als leuchtende Punkte, eine Helligkeit auf dem Untergrund schon nicht mehr (zugegeben, ich hab auch nicht lange mit ihr herumprobiert), offenbar sind die verwendeten IR-LED`s nicht besonders stark.
    Das mit der halben Stunde verstehe ich nicht?!? Die LEDs sind "stark" genug, ich sehe da sehr deutlich die zwei Leuchtpunkte. Das Umgebungslicht sollte allerdings nicht zu hell sein, wenn die Kamera schon hell sieht, können die IR-LEDs das nicht noch heller werden lassen

    Wenn Du wissen willst, was die IR-Transistoren sehen, müsstest Du einen Filter vor die Kamera setzen, der nur noch IR durchlässt.

    Im übrigen haben die meisten höherwertigen Kameras einen IR-Filter eingebaut, so dass dort nicht die volle IR-Intensität zu sehen ist. Ein ganz billiges Handy mit Kamera zeigt da oft mehr - weil dort kein IR-Filter eingebaut ist

    Allerdings habe ich einen Stolperstein: ich bin zu doof, aus dem gemessenen Wert (line_get(LINE_L)) eine vernünftige Zahl zu machen, die aber brauche ich um den Wert auf die vier LED`s aufteilen zu können.
    Mit den vier LEDs kannst Du nur 16 Werte anzeigen. Entweder Du gibst die Zahl als HEX-Wert aus, dann kannst Du immer ein Nibble zusammenfassen (4 Bit) und das an den LEDs ausgeben oder Du gibst sie als BCD-Code aus.

    Du kannst nur Ziffernweise vorgehen, deswegen musst Du Dir ein eindeutiges "Pausensignal" und "Zahlstart" usw einfallen lassen.

    Ich hoffe, dass hilft ein wenig?

    Ciao bantyy

  5. #15
    Moderator Robotik Visionär Avatar von radbruch
    Registriert seit
    27.12.2006
    Ort
    Stuttgart
    Alter
    62
    Beiträge
    5.799
    Blog-Einträge
    8
    Du gibst sie als BCD-Code aus.
    Das erscheint mir am einfachsten. Jede Ziffer belegt dann 4 Bit die man direkt mit den 4 LEDs ausgeben kann:
    - Alle Leds einmal an ist Start linker Sensor (15 ist keine BCD-Ziffer!)
    - kurze Pause
    - nacheinander jeweils die Bitmuster der Einer, Zehner, ...-Stelle anzeigen. (0 als 14?)
    - Dazwischen immer kurze Pause zum Notieren der Ziffern ;)
    - zweimal mit allen LEDs blinken für Start mittlerer Sensor
    - Ziffern nacheinander anzeigen und notieren
    - dreimal alle blinken...

    So würde ich das angehen. Wie lange man die jeweiligen Ziffern darstellt hängt davon ab, wie schnell man die Bitmuster erkennen und in Ziffern umrechnen kann ;)

    Gruß

    mic

    Ich hab's mal wie oben beschrieben umgesetzt:
    Code:
    #include <nibobee/iodefs.h>
    #include <nibobee/delay.h>
    #include <nibobee/led.h>
    
    void ausgabe_BCD(uint8_t startsignal, uint16_t wert)
    {
       uint8_t ziffer=4;
       char ergebnis[5]  = {0,0,0,0,0}; // Speicher für 5 Ziffern bereitstellen
       while (wert >=10000) { ergebnis[0]++; wert -=10000; }
       while (wert >= 1000) { ergebnis[1]++; wert -= 1000; }
       while (wert >=  100) { ergebnis[2]++; wert -=  100; }
       while (wert >=   10) { ergebnis[3]++; wert -=   10; }
       ergebnis[4] +=wert;
    
    // Die LEDs hängen an PB0-PB3 und werden direkt angesteuert. BCD-Bit0 ist LED0:
       while(startsignal--) // Blinken als Kennung des Wertes
    	{
    		PORTB |= 15; 		// alle LEDs an bedeutet Start eines neuen Wertes
    		delay(1000);
    		PORTB &= ~15;     // alle LEDs aus
    		delay(1000);
    	}
    	do // die Ziffern nacheinander anzeigen (Einer zuerst)
    	{
          if(ergebnis[ziffer] == 0) ergebnis[ziffer]=14; // '0' darstellbar machen
    		PORTB |= ergebnis[ziffer]; // Bitmuster anzeigen
          delay(1000);
          PORTB &= ~15;              // und wieder löschen
          delay(1000);
    	}while(ziffer--);
    	delay(1000);
    }
    int main(void)
    {
    	led_init();
    
    	while(1)
       {
          ausgabe_BCD(1, 12345);
          ausgabe_BCD(2, 321);
          ausgabe_BCD(3, 1357);
          ausgabe_BCD(4, 8642);
       }
       return(0);
    }
    Bild hier  
    Atmel’s products are not intended, authorized, or warranted for use
    as components in applications intended to support or sustain life!

  6. #16
    Erfahrener Benutzer Robotik Einstein Avatar von Rabenauge
    Registriert seit
    13.10.2007
    Ort
    Osterzgebirge
    Alter
    56
    Beiträge
    2.210
    Ich merk schon, ich muss wohl noch ein bisschen Pauken.
    Zwar verstehe ich euere Ausführungen ansatzweise, aber eben nur das...

    Ich bin leider in C noch nicht so fit, wie ichs gerne wäre, den RCX hab ich nur in NQC (da gibts bedeutende Einschränkungen, aber es ist auch viel leichter) programmiert..aber dazu hab ich ja die Biene, um auch das zu lernen.

    @bantyy: das mit der halben Stunde ist pro Akkuladung gemeint, da man bei der Biene nie weiss, wie voll die Akkus nun wirklich sind, lassen sie dann unter Umständen schon hübsch nach, und es klappt nicht mehr so gut.

    Und nun üb ich ein bisschen C...
    Zwischendurch werde ich mir mal ein neues Linienfolgeprogramm schreiben (mein jetztiges funktioniert ganz gut, aber sieht weder schön aus, noch ist die Biene schnell und stromsparend ist die pausenlose Pendelei gleich gar nicht), ich hab da einen recht interessanten Ansatz im Kopf.

  7. #17
    Erfahrener Benutzer Robotik Einstein Avatar von Rabenauge
    Registriert seit
    13.10.2007
    Ort
    Osterzgebirge
    Alter
    56
    Beiträge
    2.210

    Messprogramm (für ohne Display, läuft auf Standardbiene)

    So, etwas tippen geübt, eine Packung Zigaretten und einige Liter Kaffe später:

    Das Messprogramm ist soweit fertig.
    Man kann die Biene auf eine beliebige Unterlage stellen und dann mit einem der Fühler (antippen) die drei Liniensensoren messen lassen.
    Im angefügten Programm (dürfte gut genug dokumentiert sein, hoffe ich?) ist eine Variable enthalten, die man nach Lust und Laune ändern kann: es wird im derzeitigen Zustand zehnmal gemessen und ein Durchschnittswert gebildet. Wenn man die Variable ändert, ändert man die anzahl der Messungen.

    Das Ergebnis wird dann der Reihe nach ausgegeben, und zwar über die LED`s und im Klartext: die linke (gelb) LED gibt die Tausender, die linke (rot) die Hunderter, und so weiter. Mann muss nur mitzählen.
    So werden der Reihe nach (genaueres steht im Kommentar am Programmanfang) alle drei Sensorwerte ausgegeben.

    Wers probieren will ein Tipp: lasst nach erfolgter Messung die Biene mal stehen, und messt unter den selben Bedingungen nach einer Stunde erneut, was wird wohl passieren...

    Übrigens habe ich es auf meiner Testunterlage (jaha, die selbe, mit der ich das Kalibrierungsprogramm ausgeführt habe) nie Werte über 600 auf weiss gemessen...

    Code:
    /*Messprogramm für NIBOBee (by Rabenauge)
     Beim betätigen des linken Fühlers nach hinten werden die drei
    Liniensensoren der Reihe nach mehrmals abgefragt und Durchschnittswerte ermittelt. Die An-
    zahl der Messungen wird mit der Variable iv eingestellt. Während des Messvorganges blinken die 
    roten LED für jede Messung kurz auf, während der Zeit sollte der Roboter nicht bewegt werden.
    Nach der Messung werden die Ergebnisse mittels den LED ausgegeben: jede LED steht für eine 
    Stelle, das heisst, links gelb blinkt die Tausender aus, links rot die Hunderter, rechts rot
    die Zehner und rechts gelb die Einer.
    Bevor die Ausgabe beginnt, leuchten kurz alle vier LED, um das Ende der Messung anzuzeigen.
    Danach werden der Reihe nach alle drei Messwerte ausgegeben, vor der Ausgabe wird das je-
    weils durch die roten LED (leuchten anderthalb Sekunden) visualisiert: leuchtet die Linke,
    wird anschliessend der Wert des linken Sensors ausgegeben, leuchten beide, der Wert des mitt-
    leren, leuchtet die rechte dann...
    
    Indem man den linken Fühler nach vorne betätigt, kann das Messergebnis gelöscht werden, um eine 
    neue Messung vorzunehmen.
    
    */
    
    #include <nibobee/iodefs.h>
    #include <nibobee/led.h>
    #include <nibobee/sens.h>
    #include <nibobee/delay.h>
    #include <nibobee/line.h>
    
    int main()
    	{
    	enable_interrupts();
    	led_init(); 
    	sens_init();
    	line_init();
    	 while (1==1)
    	 	{
    		 	
    	     int mode=0;									//Modus, per Eingabe
    		 int i=0;										//Zählervariable
    		 int iv=10;										//Variable Messwiederholung, 
    		 												//ändern für mehr/weniger Messungen
    		 int l_line=0;									//Rückgabe Messergebnis Linie_links
    		 int r_line=0;									//Rückgabe Messergebnis Linie_rechts
    		 int c_line=0;									//Rückgabe Messergebnis Linie_mitte
    		 int status_L =sens_getLeft();					//linker TastSensor 
    		  
       		 switch (status_L)
    		 	{
    			 case -1: mode=1;							//nach hinten	=Messung starten
    			 led_set(LED_L_RD,0);				
    			 led_set(LED_L_YE,1); 						//Auswahl zeigen
    			 delay(1500);
    			 led_set(LED_L_YE,0);
    			 delay(500);
    			 break ;
    			  
    			 case +1: mode=2;							//nach vorne  =Messung zurücksetzen
    			 led_set(LED_L_YE,0);
    			 led_set(LED_L_RD,1);						//Auswahl zeigen
    			 delay(1500);
    			 led_set(LED_L_RD,0); 
    			 delay(500);			
    			 break ; 
    			   
    			 default :led_set(LED_L_RD,0);				//links Mitte
    			    	  led_set(LED_L_YE,0); 
    				break ; 
    				}
    	
    		if(mode!=0)										//was soll es werden?
    			{
    			 switch (mode)
    			 	{
    				 case 1:
    				 for (i=0; i<iv; i++)					//Messchleife
    				 	{
    					 led_set(LED_L_RD,1);
    					 led_set(LED_R_RD,1);
    					 delay(5);
    					 l_line=(l_line + line_get(LINE_L)); //messen und addieren
    					 r_line=(r_line + line_get(LINE_R));
    					 c_line=(c_line + line_get(LINE_C));
    					 led_set(LED_L_RD,0);
    					 led_set(LED_R_RD,0);
    					 delay(500);
    					 }
    
    				 	l_line= (l_line/iv);				 //Ergebnis durch Anzahl Messungen
    					r_line= (r_line/iv);
    					c_line= (c_line/iv);
    					delay(500);
    					break;
    
    				 case 2:
    				 	led_set(LED_L_RD,1);				 //Messergebnisse zurücksetzen
    					led_set(LED_R_RD,1);
    					delay(500);
    					led_set(LED_L_YE,1);
    					led_set(LED_R_YE,1);
    					delay(20);
    					l_line=0;
    					r_line=0;
    					c_line=0;
    					led_set(LED_L_RD,0);
    					led_set(LED_R_RD,0);
    					led_set(LED_L_YE,0);
    					led_set(LED_R_YE,0);
    					break;
    				 
    				 default: 
    				 	{line_get(0);
    					 break;
    					}	
    
    				 
    				 }
    
    				 delay(1000);								//Anzeige der gemessenen Werte
    				 led_set(LED_L_RD,1);						//zuerst den linken Liniensensor
    				 delay(1000);
    				 led_set(LED_L_RD,0);
    				 delay(1500);
    
    				 if (l_line>1000)							//Tausender?
    				 	{
    					 led_set(LED_L_YE,1);
    					 delay(300);
    					 led_set(LED_L_YE,0);
    					 delay(300);
    					 l_line=(l_line-1000);
    					 }
    				 for(i=0; i<10; i++)						//Hunderter?
    				 	{
    				 if (l_line>100)
    					{
    					 led_set(LED_L_RD,1);
    					 delay(300);
    					 led_set(LED_L_RD,0);
    					 delay(300);
    					 l_line=(l_line-100);
    					 }
    					 }
    
    				 for(i=0; i<10; i++)						//Zehner?
    				 	{
    				 if (l_line>10)
    					{
    					 led_set(LED_R_RD,1);
    					 delay(300);
    					 led_set(LED_R_RD,0);
    					 delay(300);
    					 l_line=(l_line-10);
    					 }
    					 }
    				 for(i=0; i<10; i++)						//Einer?
    				 	{
    				 if (l_line>1)
    					{
    					 led_set(LED_R_YE,1);
    					 delay(300);
    					 led_set(LED_R_YE,0);
    					 delay(300);
    					 l_line=(l_line-1);
    					 }
    					 }										//linker Sensor fertig
    
    				 delay(1000);								//Anzeige der gemessenen Werte
    				 led_set(LED_R_RD,1);						//mittlerer Liniensensor
    				 led_set(LED_L_RD,1);
    				 delay(1000);
    				 led_set(LED_R_RD,0);
    				 led_set(LED_L_RD,0);
    				 delay(1500);
    
    				 if (c_line>1000)							//Tausender?
    				 	{
    					 led_set(LED_L_YE,1);
    					 delay(300);
    					 led_set(LED_L_YE,0);
    					 delay(300);
    					 c_line=(c_line-1000);
    					 }
    				 for(i=0; i<10; i++)						//Hunderter?
    				 	{
    				 if (c_line>100)
    					{
    					 led_set(LED_L_RD,1);
    					 delay(300);
    					 led_set(LED_L_RD,0);
    					 delay(300);
    					 c_line=(c_line-100);
    					 }
    					 }
    
    				 for(i=0; i<10; i++)						//Zehner?
    				 	{
    				 if (c_line>10)
    					{
    					 led_set(LED_R_RD,1);
    					 delay(300);
    					 led_set(LED_R_RD,0);
    					 delay(300);
    					 c_line=(c_line-10);
    					 }
    					 }
    				 for(i=0; i<10; i++)						//Einer?
    				 	{
    				 if (c_line>1)
    					{
    					 led_set(LED_R_YE,1);
    					 delay(300);
    					 led_set(LED_R_YE,0);
    					 delay(300);
    					 c_line=(c_line-1);
    					 }
    					 }										//mittlerer Sensor fertig
    
    				 delay(1000);								//Anzeige der gemessenen Werte
    				 led_set(LED_R_RD,1);						//rechter Liniensensor
    				 delay(1000);
    				 led_set(LED_R_RD,0);
    				 delay(1500);
    
    				 if (r_line>1000)							//Tausender?
    				 	{
    					 led_set(LED_L_YE,1);
    					 delay(300);
    					 led_set(LED_L_YE,0);
    					 delay(300);
    					 r_line=(r_line-1000);
    					 }
    				 for(i=0; i<10; i++)						//Hunderter?
    				 	{
    				 if (r_line>100)
    					{
    					 led_set(LED_L_RD,1);
    					 delay(300);
    					 led_set(LED_L_RD,0);
    					 delay(300);
    					 r_line=(r_line-100);
    					 }
    					 }
    
    				 for(i=0; i<10; i++)						//Zehner?
    				 	{
    				 if (r_line>10)
    					{
    					 led_set(LED_R_RD,1);
    					 delay(300);
    					 led_set(LED_R_RD,0);
    					 delay(300);
    					 r_line=(r_line-10);
    					 }
    					 }
    				 for(i=0; i<10; i++)						//Einer?
    				 	{
    				 if (r_line>1)
    					{
    					 led_set(LED_R_YE,1);
    					 delay(300);
    					 led_set(LED_R_YE,0);
    					 delay(300);
    					 r_line=(r_line-1);
    					 }
    					 }										//Ende Ausgabe
    			}
    		
    		}
    	
    	}
    Übrigens: ich _denke_ dass die Ausgaben stimmen, aber ich garantiere es natürlich nicht, schaut bitte mal über den Code, ob sich bei der Auflösung der Werte kein Fehler eingeschlichen hat!
    Schlussendlich aber kommt es wohl kaum auf den exakten Wert an, wichtiger ist es, zu sehen, wie die Sensoren unterschiedliche (ich habe nie drei gleiche Werte bekommen, die liegen locker um 20 auseinander) Ergebnisse liefern.
    Ausserdem kann man so bequem ermitteln, wie "dunkel" das Schwarz oder wie "hell" das Weiss wirklich ist.

  8. #18
    Moderator Robotik Visionär Avatar von radbruch
    Registriert seit
    27.12.2006
    Ort
    Stuttgart
    Alter
    62
    Beiträge
    5.799
    Blog-Einträge
    8
    Hallo

    Prima umgesetzt und gut kommentiert. Dafür erstmal ein Lob von mir. Nachdem ich der main() noch ein void als Parameter eingegeben hatte, konnte ich dein Programm warnungsfrei übersetzen. analog.c muß auch eingebunden sein. Die Werte meiner bee auf einem weißem Blatt:

    0 4 4
    0 21 24
    0 1 0
    0 19 20
    0 17 21
    ...

    ???

    Muß ich zuvor noch kalibrieren? Warum zeigst du nicht auch die echten Sensorwerte an?

    Gruß

    mic
    Bild hier  
    Atmel’s products are not intended, authorized, or warranted for use
    as components in applications intended to support or sustain life!

  9. #19
    Erfahrener Benutzer Robotik Einstein Avatar von Rabenauge
    Registriert seit
    13.10.2007
    Ort
    Osterzgebirge
    Alter
    56
    Beiträge
    2.210
    Das Programm sollte doch die echten Werte anzeigen?

    Warnungen habe ich übrigens auch keine beim compilieren.
    Liegt das irgendwie an den Einstellungen von AVR-Studio? Die nämlich blicke ich absolut nicht...ich benutze die im Tutorial angegebenen (buchstabengetreu, dafür muss ich die Datei immer erst als Nibobee.c speichern)..

    Bei mir kommen Folgen heraus wie:
    528
    516
    536

    oder
    524
    513
    533

    Wobei man den Werten eigentlich noch eine Null voranstellen müsste (es ist ja auf nen Wertebereich jenseits der 1000 ausgelegt), aber die erste LED blinkt natürlich nichts, wenn der Wert unter 1000 ist.

    In Anbetracht der Tatsache, dass die Biene bereits vor dem posten eine ganze Weile in Betrieb war (anfangs warfen die Werte noch so knapp bei 600), dürfte das eigentlich hinhauen. Inzwischen gibts keine Werte mehr (die Biene stand jetzt stundenlang eingeschalten da und ich hab sie immer mal messen lassen, man merkt, wie die Spannung abnimmt).

    Aber wenn da Fehler drin sind, sag es ruhig, ich gehe dann nochmal drüber, das Programm kann man recht leicht für diverse andere Geschichten modifizieren.

    Kalibriert habe ich das Bienchen vor einigen Tagen mal, aber da die Sensorwerte ja ohnehin mit der Akkuspannung schwanken, dürfte auch die Kalibrierung nicht sehr wirksam sein (oder wie funktioniert die?)

  10. #20
    Erfahrener Benutzer Robotik Einstein Avatar von Rabenauge
    Registriert seit
    13.10.2007
    Ort
    Osterzgebirge
    Alter
    56
    Beiträge
    2.210
    Sodele.
    Da meine Biene nun einen LiPo hat, habe ich mal wieder das Messprogramm bemüht.
    Ergebnis: geht doch. =D>

    Messwerte gegen 19.00:
    auf "Weiss"
    Links 474
    Mitte 437
    Rechts 470

    auf "Schwarz"
    Links 124
    Mitte 041
    Rechts 000

    Danach habe ich die Biene ein Stündchen angelassen, und wieder gemessen:

    "Weiss":
    Links 465
    Mitte 342
    Rechts 467

    "Schwarz"
    Links 148
    Mitte 038
    Rechts 000

    Man sieht deutlich, dass es kaum noch Schwankungen gibt, da der Akku in der Biene quasi nie nachlassen kann.
    Interessant ist, dass ich die Biene vorher mit dem Calibrations-Programm auf dem selben Untergrund kalibriert hatte, und trotzdem nicht einmal die Hälfte der zu erwartenden Werte an der Tausend auf weiss erreiche..dafür kommt schwarz erstaunlich gut hin.

    Wäre aber möglich, dass ich die Kalibrierung falsch bedient habe, ich hab nicht nachgeschlagen, wie es geht sondern aus dem Gedächtnis... nunja, ab 40 solls ja nachlassen.

    Allerdings werde ich mir eventuell was einfallen lassen müssen, denn meine Biene wird nun konstant mit 5.07V versorgt, das ist deutlich weniger als mit vollen AAA-Zellen, und so dürften die IR-Dioden wohl noch schwächer funzeln nun.

    Achja: Tischkanten sind mit den Liniensensoren absolut zuverlässig erkennbar, dann gibts nirgends Werte über Null...es genügt schon, die Nase etwas anzuheben und aus ists.
    Mal schauen, ob es heute abend noch irgendwelche Erkenntnisse gibt, jetzt ist erstmal ein anderer Test dran: laufen die Motoren nun besser an?

Seite 2 von 3 ErsteErste 123 LetzteLetzte

Berechtigungen

  • Neue Themen erstellen: Nein
  • Themen beantworten: Nein
  • Anhänge hochladen: Nein
  • Beiträge bearbeiten: Nein
  •  

LiFePO4 Speicher Test