Roboterbausatz Nibo

[ehenkes]

... hab jetzt die Doku überflogen, sieht sauber aus, denk' ich könnt' den auch aufbauen. *fg*

Würde mich wirklich freuen, wenn mehr Nibo-Besitzer sich hier einfinden würden. Sowohl die Hardware als auch bereits die allererste C/C++-Bibliothek ist eine hervorragende Basis für eigene Entwicklungen, und der ATmega128 bietet ausreichend Platz und I/O-Ports. Die "Dreckarbeit" (Motor steuern, Kollision vermeiden) erledigen ja bereits die beiden ATtiny44, mit denen der Hauptprozessor über I²C kommuniziert.

Als kleines Beispiel (noch nicht perfekt) für die Motorsteuerung:

#include <avr/interrupt.h>

#include "nibo/niboconfig.h"

#include "nibo/delay.h"
#include "nibo/pwm.h"
#include "nibo/display.h"

#include "nibo/bot.h"
#include "nibo/gfx.h"
#include "nibo/bot.h"
#include "nibo/gfx.h"
#include "nibo/leds.h"
#include "nibo/motco.h"

void textout(int x, int y, char* str, int ft)
{
	gfx_move(x,y);
	gfx_print_text(str,ft);
}

void Go(int dist, int cm_pro_sec)
{
	const float TICKS_PER_CM = 1.75f;

	motco_resetOdometry(0,0);
	motco_update();
	
	int limit = dist * TICKS_PER_CM;
	
	
	int pwm   = cm_pro_sec * 80;
	if (pwm >  1024)  pwm =  1024;
	if (pwm < -1024)  pwm = -1024;

	motco_setPWM(pwm,pwm);
	motco_setSpeed(cm_pro_sec * TICKS_PER_CM , cm_pro_sec * TICKS_PER_CM);
	motco_update();

	delay(3000); //TODO: Verzögerung muss noch weg   

	do
	{	
		motco_update(); /* fährt brav geradeaus */ 
	}
	while(motco_ticks_l < limit);
} 

int main()
{
    sei(); // enable interrupts
    bot_init();
    leds_init();
    pwm_init();
    display_init();
    gfx_init();
  
    leds_set_displaylight(800);

    textout(10,10,"Nibo meldet:",0); 
	textout(10,24,"Motor an!",0); 
	textout(10,38,"Licht an!",0); 
	    
	leds_set_headlights(512); 
	 
    int i,j;
    for(i=1;i<=6;++i)
	{	
	    for(j=0;j<i;++j)
	        leds_set_status(LEDS_GREEN,j);
		
		Go(50,10*i);
	}

	leds_set_headlights(0); 
	
	motco_stop();
	motco_update();
	
	for(j=0;j<6;++j)
	    leds_set_status(LEDS_OFF,j);
	
	textout(10,24,"Motor aus!",0); 
	textout(10,38,"Licht aus!",0); 
    
	while(1);
    return 0;
}

Im Gegensatz zu seinem kleinen Bruder fällt Nibo das Geradeausfahren leicht. Der MOTCO nimmt dem Hauptprozessor delegierbare Regelungs-Arbeit (Geschwindigkeit, Richtung) gerne ab.
Hier der Video-Link (2,7 MB) zum Programm: http://www.henkessoft.de/Roboter/Bilder/Nibo.wmv

Die Abstandsmessung mittels IR-Sensoren wird prinzipiell in diesem Programm gezeigt:

#include <stdlib.h>
#include <avr/interrupt.h>

#include "nibo/niboconfig.h"

#include "nibo/delay.h"
#include "nibo/pwm.h"
#include "nibo/display.h"

#include "nibo/leds.h"
#include "nibo/bot.h"
#include "nibo/gfx.h"
#include "nibo/irco.h"

void float2string(float value, int decimal, char* valuestring)
{
 //... siehe oben!
}

float SupplyVoltage(void)
{
    bot_update();      
    return(0.0166 * bot_supply - 1.19);
}

void textout(int x, int y, char* str, int ft)
{
    gfx_move(x,y);
    gfx_print_text(str,ft);
}

void Init(void)
{
    sei(); // enable interrupts
    bot_init();
    leds_init();
    pwm_init();
    display_init();
    gfx_init();
}

int main()
{
    Init();
 
    leds_set_displaylight(1000);

    while(1)
    {
        float Ubatt = SupplyVoltage();
        char text[6];
        float2string(Ubatt,2,text);     

        textout( 0,0,text,  0);
        textout(35,0,"Volt",0);

        irco_update();
        irco_startMeasure();
        irco_update();
       
        char irco_string[5][5];
        int i;
       
        for(i=0; i<5; ++i)
        {
             textout(i*21,8,"      ",0); //löschen
        }

        for(i=0; i<5; ++i)
        {
             itoa(irco_distance[i],irco_string[i],10);         
             textout(i*21,8,irco_string[i],0);
        }
        delay(200);
    }

    while(1);
    return 0;
}

Allerdings nimmt Nibo bei mir selbst den Boden noch als Hindernis wahr. Das leuchtet mir konstruktiv noch nicht richtig ein.

Das Prinzip ist hier beschrieben: http://nibo.editthis.info/wiki/IR-Controller
Hat jemand eine Idee, wie man die Messung optimieren kann? Das "Raumgefühl" durch Messungen in fünf Richtungen (rechts, vorne rechts, vorne mitte, vorne links, links) soll einer der Vorzüge des Nibo sein. Später können über den Erweiterungsport z.B. weitere Abstandsmessungen nach hinten oder für die berühmten Bürostühle hinzu kommen.

[ehenkes]

Mit diesem Programm kann man die gesamte Sensorik des Nibo in Ruhe analysieren (Batteriespannung, IR-Abstand, Abgrundsensoren, Liniensensoren)

#include <stdlib.h>
#include <avr/interrupt.h>

#include "nibo/niboconfig.h"
#include "nibo/iodefs.h"

#include "nibo/delay.h"
#include "nibo/adc.h"
#include "nibo/pwm.h"
#include "nibo/i2cmaster.h"
#include "nibo/display.h"

#include "nibo/bot.h"
#include "nibo/leds.h"
#include "nibo/gfx.h"
#include "nibo/irco.h"
#include "nibo/motco.h"
#include "nibo/floor.h"

void Init(void)
{
    sei(); // enable interrupts

    i2c_init();
    pwm_init();
    display_init();
	
    bot_init();
    leds_init();
    floor_init();
    gfx_init();
}

void float2string(float value, int decimal, char* valuestring)
{
 	int neg = 0; 	char tempstr[20];
	int i = 0;	int j = 0;	int c; 	long int val1, val2;
	char* tempstring;
	tempstring = valuestring;
	if (value < 0){	neg = 1; value = -value; }
  	for (j=0; j < decimal; j++)	{value = value * 10;}
 	val1 = (value * 2);
 	val2 = (val1 / 2) + (val1 % 2);
 	while (val2 !=0){
 		if ((decimal > 0) && (i == decimal)){
 			tempstr[i] = (char)(0x2E);
 			i++;
 		} 
 		else{
 			c = (val2 % 10);
 			tempstr[i] = (char) (c + 0x30);
 			val2 = val2 / 10;
 			i++;
 		} 
 	}
 	if (neg){
 		*tempstring = '-';
 		tempstring++;
 	}
 	i--;
 	for (;i > -1;i--){
 		*tempstring = tempstr[i];
 		tempstring++;
 	}
 	*tempstring = '\0';
}

float SupplyVoltage(void)
{
	bot_update();   	
	return(0.0166 * bot_supply - 1.19);
} 

void textout(int x, int y, char* str, int ft)
{
	gfx_move(x,y);
	gfx_print_text(str,ft);
}



int main()
{
	Init();
  
        leds_set_displaylight(1000);
	floor_enable_ir();

        while(1)
	{
	    float Ubatt = SupplyVoltage();
            char text[6];
            float2string(Ubatt,2,text);      

            textout( 0,0,text,  0); 
	    textout(35,0,"Volt",0);

	    textout(0,8,"distance:",0);
	    textout(0,24,"floor:",0);
	    textout(0,40,"line:",0);


	    irco_update();
    	    irco_startMeasure();
	    irco_update();
		

	    uint16_t floor_distance[2];
	    uint16_t line_distance[2];
		
	    floor_update();

	    floor_distance[0] = floor_l;
	    floor_distance[1] = floor_r;

	    line_distance[0]  = line_l;
	    line_distance[1]  = line_r;

		//Strings für Display
		char irco_string[5][5];
		char floor_string[2][5];
		char line_string[2][5];
    	
		int i;
	
		/*
			IR-Abstandssensoren
		*/
		
		for(i=0; i<5; ++i)
    	       {
     		textout(i*21,16,"      ",0); //löschen
	    }

		for(i=0; i<5; ++i)
    	{
     		itoa(irco_distance[i],irco_string[i],10);          
     		textout(i*21,16,irco_string[i],0);
	    }

		/*
			IR-Floorsensoren (Abgrunderkennung)
		*/
		
		for(i=0; i<2; ++i)
    	{
     		textout(i*28,32,"       ",0); //löschen
	    }

		for(i=0; i<2; ++i)
    	{
     		itoa(floor_distance[i],floor_string[i],10);          
     		textout(i*28,32,floor_string[i],0);
	    }

		/*
			IR-Liniensensoren 
		*/

		for(i=0; i<2; ++i)
    	{
     		textout(i*28,48,"       ",0); //löschen
	    }

		for(i=0; i<2; ++i)
    	{
     		itoa(line_distance[i],line_string[i],10);          
     		textout(i*28,48,line_string[i],0);
	    }

		delay(100);
	}

	while(1);
    return 0;
}

Damit bewegt er sich so, dass er Hindernissen ausweicht:

#include <stdlib.h>
#include <avr/interrupt.h>

#include "nibo/niboconfig.h"
#include "nibo/iodefs.h"

#include "nibo/delay.h"
#include "nibo/adc.h"
#include "nibo/pwm.h"
#include "nibo/i2cmaster.h"
#include "nibo/display.h"

#include "nibo/bot.h"
#include "nibo/leds.h"
#include "nibo/gfx.h"
#include "nibo/irco.h"
#include "nibo/motco.h"
#include "nibo/floor.h"

#define LINKS        0
#define VORNE_LINKS  1
#define VORNE        2
#define VORNE_RECHTS 3
#define RECHTS       4

void Init()
{
    sei(); // enable interrupts

    i2c_init();
	pwm_init();
	display_init();
	
	bot_init();
	leds_init();
	floor_init();
    gfx_init();
}

void float2string(float value, int decimal, char* valuestring);

float SupplyVoltage(void)
{
	bot_update();   	
	return(0.0166 * bot_supply - 1.19);
} 

void textout(int x, int y, char* str, int ft)
{
	gfx_move(x,y);
	gfx_print_text(str,ft);
}


int main()
{
	Init();

	// Kollisionsvermeidung vorbereiten
    uint16_t Vektor[5][2]; // Einheitsvektoren (*10) [0] ist x- und [1] ist y-Wert
    Vektor[0][0] = -10; // LINKS x
    Vektor[0][1] =   0; // LINKS y
    Vektor[1][0] =  -7; // VORNE_LINKS x
    Vektor[1][1] =   7; // VORNE_LINKS y
    Vektor[2][0] =   0; // VORNE x
    Vektor[2][1] =  10; // VORNE y
    Vektor[3][0] =   7; // VORNE_RECHTS x
    Vektor[3][1] =   7; // VORNE_RECHTS y
    Vektor[4][0] =  10; // RECHTS x
    Vektor[4][1] =   0; // RECHTS y

    uint16_t VektorMalSensor[5][2];   // Sensorwert * Einheitsvektor (*10)
 	uint16_t VektorMalSensorSumme[2]; // Sensorschwerpunkt (x,y) für Auswertung

	// Vorbereitungen
	leds_set_displaylight(1000);
	leds_set_headlights(512); 
	floor_enable_ir();
	motco_setPWM(600,600);
	motco_setSpeed(25,25);

	// fixe Display-Anzeigen
   	textout(35,0,"Volt",      0);
    textout(0, 8,"distance:", 0);
	textout(0,24,"floor:",    0);
	textout(0,40,"line:",     0);    

	// Hauptschleife
	while(1)
	{
	    // Akkuspannung anzeigen
	    float Ubatt = SupplyVoltage();
        char text[6];
        float2string(Ubatt,2,text);      
        textout(0,0,"     ",0); // 5 Zeichen löschen
		textout(0,0,text,   0); 

		// Abstandsmessung Raumgefühl
		irco_update();
		irco_startMeasure();
		irco_update();
		
		// Floor
		uint16_t floor_distance[2];
		uint16_t line_distance[2];

		// Abstandsmessung Floor		
		floor_update();
		floor_distance[0] = floor_l;
		floor_distance[1] = floor_r;
		line_distance[0]  = line_l;
		line_distance[1]  = line_r;

		//Strings für Display
		char irco_string[5][5];
		char floor_string[2][5];
		char line_string[2][5];
    	
		// Laufvariablen
		int i,j;
	
		/*
			IR-Abstandssensoren
		*/
		
		for(i=0; i<5; ++i)
     		textout(i*21,16,"      ",0); //löschen

		for(i=0; i<5; ++i)
    	{
     		itoa(irco_distance[i],irco_string[i],10);          
     		textout(i*21,16,irco_string[i],0);
	    }

		/*
			IR-Floorsensoren (Abgrunderkennung)
		*/
		
		for(i=0; i<2; ++i)
     		textout(i*28,32,"       ",0); //löschen

		for(i=0; i<2; ++i)
    	{
     		itoa(floor_distance[i],floor_string[i],10);          
     		textout(i*28,32,floor_string[i],0);
	    }

		/*
			IR-Liniensensoren 
		*/

		for(i=0; i<2; ++i)
     		textout(i*28,48,"       ",0); //löschen

		for(i=0; i<2; ++i)
    	{
     		itoa(line_distance[i],line_string[i],10);          
     		textout(i*28,48,line_string[i],0);
	    }
		
		/*
			MOTCO 
			
			Mathematische Methode "x/y-Schwerpunkt der Sensorvektoren bilden": 
			(Einheitsvektoren * 10) * Sensorwert (0-255), davon Summe bilden

			VektorMalSensorSumme[...] 0 ist x-Wert und 1 ist y-Wert
			Blockade: y kann maximal 6120 groß werden (vl, v, vr 255)
			Richtung: x kann maximal -4335 (Hindernis links) bzw. +4335 (H. rechts) werden (l, vl 255 bzw. r, vr 255)
		*/
		
        VektorMalSensorSumme[0] = 0; // x-Wert
        VektorMalSensorSumme[1] = 0; // y-Wert

	    for (i=0; i<5; ++i)
	    {
	        for (j=0; j<2; ++j)
	        {
	            VektorMalSensor[i][j] = Vektor[i][j] * irco_distance[i];
	            VektorMalSensorSumme[j] += VektorMalSensor[i][j];
	        }
	    }

		// Reaktion auf VektorMalSensorSumme[...] (x- und y-Wert) 		
		if(VektorMalSensorSumme[1] >= 4590)
		{
			motco_setSpeed(-25,-25); //rückwärts fahren	
		}
		else if( (VektorMalSensorSumme[1] < 4900) && (VektorMalSensorSumme[1] >= 3060) )
		{
			if(VektorMalSensorSumme[0] < -2500) // Hindernis links
				motco_setSpeed(25,-25);	
			else if ( (VektorMalSensorSumme[0] >= -2500) && (VektorMalSensorSumme[0] <= 2500) ) // kein Hindernis
				motco_setSpeed(25,25);	
			else // Hindernis rechts
				motco_setSpeed(-25,25);	
		}
		else
		{
				motco_setSpeed(30,30);	
		}

		motco_update();
	}

	while(1);
    return 0;
}


// Hilfsfunktionen

void float2string(float value, int decimal, char* valuestring)
{
 	int neg = 0; 	char tempstr[20];
	int i = 0;	int j = 0;	int c; 	long int val1, val2;
	char* tempstring;
	tempstring = valuestring;
	if (value < 0){	neg = 1; value = -value; }
  	for (j=0; j < decimal; j++)	{value = value * 10;}
 	val1 = (value * 2);
 	val2 = (val1 / 2) + (val1 % 2);
 	while (val2 !=0){
 		if ((decimal > 0) && (i == decimal)){
 			tempstr[i] = (char)(0x2E);
 			i++;
 		} 
 		else{
 			c = (val2 % 10);
 			tempstr[i] = (char) (c + 0x30);
 			val2 = val2 / 10;
 			i++;
 		} 
 	}
 	if (neg){
 		*tempstring = '-';
 		tempstring++;
 	}
 	i--;
 	for (;i > -1;i--){
 		*tempstring = tempstr[i];
 		tempstring++;
 	}
 	*tempstring = '\0';
}

[Lisbeth]

Hallo, ich habe mir auch einen Nibo gekauft und muss ihn nun erstmal zusammenlöten....
In einem anderen Faden
https://www.roboternetz.de/phpBB2/vi...=302266#302266
wird das MSRS diskutiert. Wäre es nicht gut, den Nibo als Hardwarebasis zu verwenden?
Gruß
Lisbeth

[ehenkes]

Wenn Du Fragen zum Zusammenbau hast, die versuche ich gerne zu beantworten. Kritisch ist das 10->2*5-Kabel der Odometrie und die Rückseite des 7805 muss man gut isolieren (2 Lagen Isolierband, Kurzschlussgefahr mit CNY70-Beinchen). Es gibt da schon einige Punkte zu beachten. Die Platine ist nicht ganz einfach gestrickt, also kein ASURO.

Bezüglich des MSRS bin ich mir noch nicht sicher. Es ist für den Nibo noch zu früh, da die Firmware/Software des Nibo noch in der Entwicklungsphase ist. Wenn hier Stabilität hergestellt ist, könnte man das Thema mal angehen. Auf jeden Fall können wir dann endlich Programme tauschen, etc.

[Lisbeth]

Ich dachte, gerade wenn die Plattform noch frisch ist und an der Firmware gearbeitet wird, ist MSRS ein Thema (parallel und nicht sequentiell arbeiten!).
Nibo ist mit 128k doch auch ein guter Kandidat für AI, oder?
Ansonsten verlief der Tag durchaus schlecht: Die Bestückung haben wir nach 10 eingelöteten Kondensatoren gefrustet abgebrochen, da der Lötzinn regelrecht abgestossen wurde!!
Keine Ahnung, warum. Mit dem gleichen Equipment haben wir den Asuro problemlos zusammengelötet!
Gruß
Lisbeth

[ehenkes]

Zu MSRS:
Stellungnahme des Entwicklers zu diesem Thema am 04.07.2007:
"In das Robotics Studio bin ich leider momentan nicht eingearbeitet, aber
ich würde es auch nicht ausschließen dafür eine Portierung zu
entwickeln. Ansonsten werden alle Quelltexte von mir unter Open-Source
Lizenzen bereit gestellt, sodass eine Anbindung an das Robotics Studio
auch durch andere erfolgen kann."

Zur Lötausrüstung:
Nibo ist kein ASURO. Die Platine ist deutlich filigraner und kann nur mit feiner Spitze und richtiger Temperatur mit gutem Lot gelötet werden. Ohne Löterfahrung geht da nichts! Ich habe ihn unter einer Leuchtlupe gelötet und war froh, als es geschafft war. Nur eine kalte Lötstelle am 10-Pin-Wannenstecker und ein Kurzschluss zwischen 7805 und CNY70.
Der ASURO ist ein Kinderspiel dagegen. Damit steht jetzt fest: Nibo ist definitiv kein Roboterbausatz für Anfänger! Ich dachte allerdings, dass er vom ASURO kommend als Upgrade tauglich sei. Ich habe allerdings recht viel Löterfahrung aus Serienfertigungen in den letzten Jahren.

[Lisbeth]

Leuchtlupe, feine Spitze und richtige Temperatur:
Nix davon steht in der Anleitung zum Zusammenbau!
Die (Löt-)Anleitung beim Asuro war dagegen gut!
Für Gelegenheitslöter wie uns (nach 20 Jahren mal wieder nach dem NDR-Computer (kennt den noch wer?)) ist Nibo wohl nicht zu stemmen? Oder?
Gruß
Lisbeth

[ehenkes]

Die ASURO-Platine ist grob gegen die des Nibo, das habe ich schon mehrfach hier geschrieben, also nichts für Lötanfänger!

Die Leuchtlupe brauche ich persönlich, weil ich 51 bin, trotz Brille, sonst sehe ich die feinen Bahnen der Nibo-Platine nicht und schmelze alles zusammen, also mein Problem. Die richtige Temperatur (regelbare Lötstation) und das richtige Lötzinn (fein) ist wichtig. Man sollte auch Entlötlitze greifbar haben.

Bitte nicht aufgeben! Das ist zu schaffen.

[Lisbeth]

Weller Lötstation WS50 ist regelbar
Lötzinn: Was ist "fein"? Ich habe HS10 mit Durchmesser 1,0mm von der Firma STANNOL.
Alles falsch?
Gruß
Lisbeth

[ehenkes]

1,0 mm ist meines Erachtens o.k. (Doku empfiehlt 0,5 mm). Daran liegt es sicher nicht, denn das habe ich auch verwendet (privat verwende ich noch bleihaltiges Lötzinn, Sn 60 Pb 38 Cu 2). Temperatur hatte ich eher hoch (350-370°C, bei Steckern 400°C) eingestellt, schnell mit wenig Lot gelötet. Weller ist doch auch ein Qualitätsname. Nur Mut! Das wird schon.

Der Schmelzpunkt von bleifreiem Lot ist 20 °C bis 45 °C höher als der Schmelzpunkt von bleihaltigen Lot , konsequenterweise muß die Temperatur der Lötspitze höher eingestellt werden. Es ist allgemein üblich und auch akzeptabel, daß die Temperatur der Lötspitzen um ca. 50 °C höher als der Schmelzpunkt des Lotes eingestellt wird. Allerdings werden vielfach Lötspitzentemperaturen gewählt, die 100 °C höher sind als die Schmelztemperatur, diese Unterschiede sind von der Wärmekapazität des zu lötenden Werkstückes , der Lötstellengröße, und der Masse der Lötspitze abhängig.
Die Lötspitzentemperaturen werden bei bleihaltigem Lötzinn Sn – Pb mit ca. 340 °C gewählt und bei bleifreiem Lötzinn Sn – 0.7Cu auf ca. 370 °C eingestellt.
Löttemperaturen über 350 °C stoßen an die Grenzen für Lötstationen. Der Verschleiß von Lötspitzen steigt rapide und der Arbeitsbereich der Flußmittel wird überschritten. Oberhalb dieser Temperaturen verkohlt das Flußmittel, die Aktivität des Flußmittels verringert sich und es kommt zur Trennung von Lot und Flußmittel.

Quelle: http://www.cologne-hardware.de/grund...n/bleifrei.htm