Druckbare Version
Nach vielen vergeblichen Versuchen (von denen das hier übriggeblieben ist:
Bild hier
)
läuft der Ultraschallsensor nun!
Bild hier
Die Front sieht jetzt noch so aus:
Bild hier
Aber ich werd noch versuchen, wieder etwas davon zu entfernen...
Das Ding ist sogar recht genau, ich komme so auf 1 bis 2cm maximale Abweichung bei einer glatten Wand...
Hey super, vielen Dank für die ausführliche Tabelle.
Arexx such nicht noch zufällig einen Tester oder kommt jemand nicht dazu den Bausatz zu testen? :-b
Wie lange halten wärend des Betriebs mit Display und Sensoren ca. die Akkus?
Viele Grüße, und macht weiter so!
Mehto
Zur Akkulaufzeit kann ich nciht so richtig was sagen. Ich arbeite immer mal wieder am Yeti, und hab ihn für die Sensortests meist nur auf dem Tsich stehen, ohne dass er läuft, und zwischendurch lass ich ihn auch mal nen paar Meter laufen. Dann muss ich die Akkus (1900mAh) so alle 1 bis 2 Wochen laden.
Ich plane derzeit an einer neuen Erweiterungplatine, da meine alte wegen dem Display nicht mehr passt. Leider gibt es keine Bohrlöcher, um Platinen zu stapeln. Daher versuche ich es nun mit dem Stiftleisten (13er und drei 2er), die die Signale vom Flachbandkabel auf der Displayplatine verteilen. Dort will ich jetzt mit Buchsenleisten eine kleine Platine aufsetzen, so wie es auch beim Asuro gemacht wird. Dabei liegt die Platine dann über dem IC und lässt die Displays frei.
Dabei ist extrem nervig, dass die Stfitleisten in nem 25mil-Raster verteilt sind. Ich hab lange gebraucht, bis ich alle Positionen korrekt gemessen und in Eagle gezeichnet hatte...
Erster Entwurf:
Bild hier
Da die Stiftleisten von unten kommt, ich aber nur ein einseitige Platine machen will, hab ich Vias neben die Pins gesetzt, die ich dann mit Draht anschließen werde.
Bis jetzt plaziert: zwei Eingabe- und ein Resettaster, sowie Anschlüsse für zwei Sharps.
Der Mega8 dient nur als Größenvergleich, man könnte aber problemlos eienn Zweitcontroller unterbringen...
Heute hab ich mal wieder geätzt, hatte noch nen zweites Miniprojekt, für das ich auch Platinen brauchte. Da hab ich gleich die Platine für den Yeti fertiggemacht:
Bild hier
Ich habe das Layout inzwischen noch mal überarbeitet. Nun liegen alle drei freien Analogeingänge auf Steckern, um Sensoren anzuschließen. Außerdem weitere Stiftleisten, um noch ein Platine draufstapeln zu können, wo alle noch verfügbaren Signale ankommen, das UART, I2C und zwei digitale Portpins.
Ich habe auch einen Erweiterungssatz geschickt bekommen (ich bin gerade erst nach Hause gekommen).
Es schein das gleiche drin zu sein.
Mal sehen, ob ich noch etwas neues bringen kann.
Manfred
Hier mal nen paar Hinweise zum Ulttraschallsensor:
- In die Seitenwand nen Loch bohren, um das Poti von außen einstellen zu können.
- Das Innere des YETIs gut mit Dämmmaterial ausfüllen. Ich habe die Seitenwände mit Moosgummi beklebt, zwischen Sensorplatine und Deckel ein Taschentuch, oben auf der Hauptplatine noch ein Taschentuch und dann Watte.
- In der Software den Wert für die minimale Hindenisdistanz erhöhen. Dann reagiert der Sensor erst nach einer entsprechenden Verzögerung auf Echos, und störende Reflexionen werden ignoriert. ICh ahbs auf 20cm gesetzt.
- evtl. Mehrmals messen und Mittelwert bilden
- Im Stand funktioniert der Sensor bei mir mittlerweile einigermaßen zufriedenstellend. Bei harten Wänden misst er die ersten 50cm auf einen Zentimeter genau. Bei weichen Hindernissen ist er kaum zu gebrauchen. aber das liegt ja in der Natur der Sache...
Wenn der Yeti läuft, misst er öfters mal falsch. Störungen in der Stromversorgung duch die Servos?? Ich warte derzeit jach jeden Schritt ne halbe Sekunde, bis ich messe. Dann gehts besser
- Wenn der Sensor frei in den leeren Raum zeigt, also innerhalb der eingestellen maximalen Reichweite nichts ist, liefert er teilweise Fehlmessungen.
- Manchmal liefert er Werte, die um eins unterhalb der minmalen Entfernung liegen. Keine Ahnung wieso...
- Beim Einstellen erhielt ich bei minimaler Empfindlichkeit nur Messfehler. Komischerweise ging es bei mittlerer Empfindlichkeit auf einmal. Derzeit hab ich das Poti etwa auf die Mittelposition gestellt.
PS: die 570 Mehrkilometer haben sich aber ganz schön in der Lieferzeit bemerkbar gemacht...
Hallo,
Die Yeti lasst sich einfach Preparieren fur die Ultraschall.
1. Füllmaterial im Kopf
2. Ein extra stuck Schaumgummigummi IN Yeti's Kopf an die vorder seite zwischen die Sender und Empfanger
3. Ein gleiches stuck Schaumgummigummi am aussenseite zwischen Yeti's augen.
Und es funktioniert Tadellos.
[img]
Gruss
Henk
@Arexx-Henk:
Mit welcher Poti-Einstellung klappt es bei dir am besten?
ICh hab jetzt auch mal mein Dämmung etwas reduziert. Geht auch noch. Ich hatte nur so viel an die Außenseite gepackt, weil es erst überhaupt nicht ging und immer wenige Zentimeter angezeigt wurden.
Bild hier
Material: ein Stück Taschentuch, innen befestigt und unter dem Deckel festgeklemmt, unten am Servo angeklebt, mit Watte ausgestopft.
Hallo,
ich hatte ein loch im zeitenwand gebohrt und die Poti so gefuhlsmassig im Mitten positioniert.
Ich hab vieles an die Ultraschall untersucht und da ist die Gummi am innenseite der kopf (zwischen sender und empfanger) ser wichtig.
Am aussenseite hab ich vom papier ein viereckige form gemacht und von eine Kerze voll tropfen lassen. Funktioniert auch gut.
Gruss
Henk
Ich hab mal an meiner Funktionsbibliothek für den Yeti weiterprogrammiert.
Features:
- senden von Daten per Infrarotschnittstelle (ohne Angabe der Zeichenanzahl, direktes Senden von Zahlen)
- Messen von analogen Spannungen
- Überwachung der Akkuspannung
- Auslesen von zwei Eingabetastern
- Blinken der Frontleds, unabhängig vom Hauptprogramm
- Aktivierung eines Timer-Interrupts im Intervall von 33ms, um regelmäßig auszuführende Vorgänge unabhängig vom Hauptprogramm zu starten
Hier mal die derzeitige Version:
(speichern als yeti_extended.c)Code:/*/////////////////////////////////////
// weitere Funktionen für den Yeti //
// (c) Uwe Große-Wortmann (uwegw) //
// Version 0.1 09.07.06 //
///////////////////////////////////////
Diese Datei enthält weitere Funktionen für den YETI:
- senden von Daten per Infrarotschnittstelle
- Messen von analogen Spannungen
- Überwachung der Akkuspannung
- Auslesen von zwei Eingabetastern
- Blinken der Frontleds, unabhängig vom Hauptprogramm
- Aktivierung eines Timer-Interrupts im Intervall von 33ms, um regelmäßig
auszuführende Vorgänge unabhängig vom Hauptprogramm auszuführen
Integration dieser Datei in eigene Programme (siehe auch test.c):
In der Haupt-c-Datei am Anfang:
#include "yeti_extended.c"
Im Programm folgende Funktion einfügen:
ISR(TIMER0_OVF_vect) //systick, alle 33ms
{
blinkmodus();
TastenPollen();
//an dieser Stelle können noch weitere Befehle stehen, die regelmäßig erledigt werden müssen!
} //end.systick
//Diese Funktion wird ausgeführt, sobald die linke Taste gedrückt wurde:
void Aktion_Taste_L(void)
{
}
//Diese Funktion wird ausgeführt, sobald die rechte Taste gedrückt wurde:
void Aktion_Taste_R(void)
{
}
//Beim Programmstart in der Funktion main:
initExtended();
*/
//######################################################
// I. benötigte Funktionsbibliotheken
//######################################################
#include <stdlib.h>
#include <string.h>
#ifndef YETI_H
#include "yeti.h" //yeti.h muss vor yeti_extended.c bekannt sein.
#endif
//######################################################
// II. Vom Benutzer zu ändernde Werte
//######################################################
/* Es können zwei Tasten ausgewertet werden, die an beliebigen Eingängen angeschlossen
sein können. Portnummer und Portname werden mit den folgenden Konstanten festgelegt.*/
//wenn keine Tasten angeschlossen sind, die folgende Zeile auskommentieren:
#define Tasten
//Voreinstellung ist linke Taste an PD7 und rechte Taste an PB4
#ifdef Tasten
#define Taste_L_Pin 7
#define Taste_L_Port PORTD
#define Taste_R_Pin 4
#define Taste_R_Port PORTB
#endif
//######################################################
// III. Übersicht der enthaltenen Funktionen
//######################################################
// a) Funktionen, die vom Benutzer aufgerufen werden können
//Initialisierung, nötig für die folgenden Funktionen
void initExtended(void);
//String über RS232 ausgeben
void vPrint(unsigned char* pucUsrTmtDat);
//Zahl (16bit) über RS232 ausgeben
void vPrint_int(uint16_t zahl);
//Einen Kanal des Analog-digital-Wandlers auslesen
uint16_t ReadChannel(uint8_t mux);
//Die Akkuspannung messen und ausgeben
uint16_t akkutest(void);
//Die Tasten einlesen (per Timer regelmäßig aufrufen)
#ifdef Tasten
void TastenPollen(void);
#endif
//Die Front-LEDs blinken lassen (per Timer regelmäßig aufrufen)
void blinkmodus(void);
// b) Funktionen, die nur intern innerhalb dieser Datei benötigt werden
//Den Timer0 für den Interrupt im 33ms-Rhytmus einstellen
void initsystick(void);
// c) Funktionen, die im Hauptprogramm vorhanden sein müssen
//Timer-Interrupt, wird alle 33ms aufgerufen
ISR(TIMER0_OVF_vect);
#ifdef Tasten
void Aktion_Taste_L(void);
void Aktion_Taste_R(void);
#endif
//######################################################
// IV. Vom Benutzer benötigte (globale) Variablen
//######################################################
//Status Laufmodus
//0 heißt nicht Laufen, ungleich 0 heißt Laufen.
volatile uint8_t Laufmodus=0;
//Status Beeper
//0 heißt nicht piepen, ungleich 0 heißt piepen.
volatile uint8_t Beepmodus=0;
//Variablen für die Blinkfunktionen der Front-LEDs
//blink_x: Blink-Impulslänge in 33ms-Schritten, 0 deaktiviert das Blinken
volatile uint8_t blink_L= 0;
volatile uint8_t blink_R= 0;
////Ab hier müssen normalerweise kein Änderungen vom Benutzer vorgenommen werden////
//######################################################
// V. interne Variablen
//######################################################
#define PIN(x) (*(&x - 2))
#define DDR(x) (*(&x - 1))
//Variablen für die Blinkfunktionen der Front-LEDs
//blink_count_x: Zähler für die Blinkschleife
volatile uint8_t blink_count_L = 0;
volatile uint8_t blink_count_R = 0;
//######################################################
// VI. Die einzelnen Funktionen
//######################################################
void initsystick(void) //Timer0 für den Systick initialisieren und starten, alle 33ms ein Interrupt
{
//Timer 0 auf Prescaler 1024 setzen => alle 33ms ein Int
TCCR0 |= (1<<CS02)|(1<<CS00);
//Overflow-Interrupt aktiv
TIMSK |= (1<<TOIE0);
}
#ifdef Tasten
//Bitfeld für die Tasten
volatile struct {
uint8_t L:1; //Status der Tasten, 1 wenn
uint8_t R:1; //gedrückt, 0 wenn offen
uint8_t L_cnt:1; //vorheriger Zustand der Tasten,
uint8_t R_cnt:1; //zur Erkennung von Schaltflanken
}Taste;
void TastenPollen(void)
{
////////////Linke Taste //////////////
//schaltet Laufmodus um
if (bit_is_clear(PIN(Taste_L_Port),Taste_L_Pin)) //momentan gedrückt
{
if (Taste.L_cnt==0) //Flanke erkannt; Taste wurde gerade gedrückt
{
Taste.L = 1;
Aktion_Taste_L();
}
Taste.L_cnt=1;
}
else //momentan offen
{
if (Taste.L_cnt==1) //Flanke erkannt; Taste wurde gerade losgelassen
{
Taste.L = 0;
}
Taste.L_cnt=0;
}
///////////Rechte Taste/////////////
if(bit_is_clear(PIN(Taste_R_Port),Taste_R_Pin)) //momentan gedrückt
{
if (Taste.R_cnt==0) //Flanke erkannt; Taste wurde gerade gedrückt
{
Taste.R = 1;
Aktion_Taste_R();
}
Taste.R_cnt=1;
}
else //momentan offen
{
if (Taste.R_cnt==1) //Flanke erkannt; Taste wurde gerade losgelassen
{
Taste.R = 0;
}
Taste.R_cnt=0;
}
/////////////////////////////
}//end.TastenPollen
#endif
//Blinkmodus//
void blinkmodus(void)
{
if (blink_L!=0)
{
blink_count_L++;
if (blink_count_L>blink_L)
{
blink_count_L=1;
LEFT_FRONT_LED_TOGGLE;
}
}
if (blink_R!=0)
{
blink_count_R++;
if (blink_count_R>blink_R)
{
blink_count_R=1;
RIGHT_FRONT_LED_TOGGLE;
}
}
}//end.blinkmodus//
//######################################################
//Funktionen zur Ausgabe über die Infrarotschnittstelle
//######################################################
/* Gibt einen String über die Infrarotsschnittstelle aus, ohne dass die Anzahl der zu übetragenden Zeichen
übergeben werden muss. Dazu wird mit strlen der String durchgezählt und dann vRs232Write aufgerufen.*/
void vPrint(unsigned char* pucUsrTmtDat)
{
unsigned char ucNofTmtChr=strlen(pucUsrTmtDat);
vRs232Write(pucUsrTmtDat,ucNofTmtChr);
} //end.vPrint
/* Gibt eine 16bit-Zahl über die Infrarotsschnittstelle aus*/
void vPrint_int(uint16_t zahl)
{
unsigned char zahlstr[5];
itoa(zahl, zahlstr,10);
vPrint(zahlstr);
} //end.vPrint_int
//######################################################
//Funktionen für den Analog-digital-Wandler
//######################################################
/* Liest einen Kanal des Anaolg-Digital-Wandlers aus
Quelle: mikrocontroller.net AVR-GCC Tutorial
Übetrgabeparameter: mux ==> Kanal (0..5)
Rückgabe: Messwert vom ADC (16bit)
Der ADC wird vor jeder Messung aktiviert, da die Ultraschall-Routine ihn abgeschaltet haben könnte.
*/
uint16_t ReadChannel(uint8_t mux)
{
uint8_t i;
uint16_t result = 0;
ADCSR |= (1<<ADEN) | (1<<ADPS1) | (1<<ADPS2); // Frequenzvorteiler setzen auf 64 (125000Hz) und
//ADC aktivieren
ADMUX = mux; // Kanal waehlen
ADMUX |= (1<<REFS1) | (1<<REFS0); // interne Referenzspannung nutzen
//"Dummy-Readout"*/
ADCSR |= (1<<ADSC); // eine ADC-Wandlung
while ( ADCSR & (1<<ADSC) ); // auf Abschluss der Konvertierung warten
// Eigentliche Messung - Mittelwert aus 4 aufeinanderfolgenden Wandlungen
for(i=0;i<4;i++)
{
ADCSR |= (1<<ADSC); // eine Wandlung "single conversion"
while ( ADCSR & (1<<ADSC) ); // auf Abschluss der Konvertierung warten
result += ADCW; // Wandlungsergebnisse aufaddieren
}
result /= 4; // Summe durch vier teilen = arithm. Mittelwert
return result;
} //end.ReadChannel
//Der ADC-Kanal, an dem die Akkuspannung gemessen werden kann.
#define akkumess_port 5
/*Misst die Akkuspannung und gibt den ungefähren Ladezustand über die Infrarotschnittstelle aus.
Der Akku ist an Kanal5 angeschlossen (in akkumess_port definiert)
Die Grenzen für die einzelnen Bereiche sind im folgenden Quelltext angegeben.
Je nach interner Referenzspannung kann es nötig sein, die Werte zu korrigieren.
Rückgabe: Messwert vom ADC (16bit)*/
uint16_t akkutest(void)
{
uint16_t akkuspannung = 0;
akkuspannung = ReadChannel(akkumess_port); //messen
vPrint("\r\nAkkuwert: "); //Betexten
vPrint_int(akkuspannung); //Rohwert ausgeben
if (akkuspannung > 999) //ab 5,5V
vPrint(" Akku Überspannung!");
else if ((akkuspannung > 836)&(akkuspannung<1000)) //4,7 bis 5,4V
vPrint(" Akku voll");
else if ((akkuspannung > 764)&(akkuspannung<837)) //4,3 bis 4,6V
vPrint(" Akku halbvoll");
else if ((akkuspannung > 637)&(akkuspannung<765)) //3,8 bis 4,2V
//[der IR-Empfänger kann unter 4,5V schon Probleme bereiten!!!]
vPrint(" Akku fast leer");
else if (akkuspannung<638) //unter 3,8V
vPrint(" Akku leer!");
vPrint("\r\n");
return akkuspannung;
} //end.akkutest
//initialiserung der Funktioen in dieser Datei
//Die Front-LEDs beginnen zu blinken
void initExtended(void)
{
initsystick();
#ifdef Tasten
blink_L = 6;
blink_R = 2;
Taste_L_Port|= (1<<Taste_L_Pin); //Pullups an für Tasten
Taste_R_Port|= (1<<Taste_R_Pin);
DDR(Taste_L_Port) |= _BV(Taste_L_Pin); //Tasten als Eingänge
DDR(Taste_R_Port) |= _BV(Taste_R_Pin);
#endif
}
//ende von yeti_extended.c
Ein kleines Testprogramm, das den Gebrauch demonstriert:
(abspeichern als test.c)Code://Beispiel für die Nutzung der yeti_extended.c
#include "yeti_extended.c"
#include "yeti.h"
#include "yetimove.c"
ISR(TIMER0_OVF_vect) //systick, alle 33ms
{
blinkmodus();
TastenPollen();
//an dieser Stelle können noch weitere Befehle stehen, die regelmäßig erledigt werden müssen!
} //end.systick
//Diese Funktion wird ausgeführt, sobald die linke Taste gedrückt wurde:
void Aktion_Taste_L(void)
{
}
//Diese Funktion wird ausgeführt, sobald die rechte Taste gedrückt wurde:
void Aktion_Taste_R(void)
{
}
int main(void)
{
vInitYeti();//init micro controller unit to correctly control main pcb hardware
initExtended(); //erweiterte Funktionen initialisieren
//transmit yeti version
vPrint("\r\nYeti, V1.06\r\n");
vPrint("YETI sagt Hallo Welt\r\n");
vStandUpright();
//yeti ready sound
vBeep(400,80);
vBeep(520,80);
vBeep(360,80);
vBeep(580,80);
while(1) //hauptschleife
{
if (Beepmodus !=0)
{
vBeep(400,30);
}
vWaitMilliseconds(500);
vPrint(" Teste erweiterte Funktionen...\r\n");
vPrint("Zahlen ausgeben:\r\n");
for (uint8_t i=1;i<11;i++)
{ vPrint_int(i);
vPrint("\r\n"); //Zeilenumbruch im Terminal
}
if (Laufmodus !=0)
{
vPrint("Laufmodus aktiv... mache einen Schritt\r\n");
vMoveForwardXSteps(1);
}
else
{
vPrint("Laufmodus inaktiv... stehenbleiben\r\n");
}
}//end.hauptschleife
return 0;
} //end.main
//ende von test.c
[Thread ausgrab]
Hat irgendjemand schon den Yeti gekauft? Er ist ja seit einger Zeit in diversen Shops gelistet, bei Conrad im Shop ist er als sofort lieferbar eingetragen. Aber weder hier noch im arexx.Forum sind bisher Fragen dazu aufgetaucht. Ist das Teil doch noch nicht auf dem Markt, oder haben wir mit der Anleitung so gute Arbeit geleistet, dass keine Fragen mehr offen sind?
[/Thread ausgrab]
gibts eigentlich inzwischen die neue anleitung irgendwo? ich hab immernoch die erste version von arexx... wollte mal wissen was die da eigentlich geändert haben. verkauft wird er glaube ich schon im arexx forum ist einer mit einem problem aufgetaucht...
Hallo Antiich,
Wir haben mit der Post den neuesten YETI CD mit neuester Anleitung an Ihnen abgesandt.
Die Bemerkungen der YETI Tester haben sehr gut geholfen. Es sind bereits sehr viele YETIs verkauft. Im Vergleich mit ASURO bekommen wir sehr wenige Fragen über YETI. Wir gehen davon aus dass die Anleitung sehr gute Informationen enthält.
Verschiedene Studenten haben im diesem Moment YETI Projekte. Die meiste arbeiten an die YETI Beine und möchten eine neue mechanische Konstruktion für die Beine fertigen mit zusätzlichen Servos. Wir haben sehr viele Interesse an diesen Erfahrungen.
Wir möchten alle YETI Tester nochmals herzlich danken für alle Bemerkungen auf die YETI Bauanleitung.
Mit freundlichen Grüßen aus Zwolle,
AREXX
Fr. Marjon Roeten
Was kann man denn mit YETI so machen?
Hallo,
hab mal ne ganz andere frage: und zwar läuft das yeti bei mir immer auf der stelle. wiollte mal fragen ob jemand auch schon dieses problem hatte und ob jemand weiß wie amn das lösen könnte...??
mfg simi05
also ich hatte auch das Problem. Das liegt an der zu geringen Reibung von den Füßen. Ich habe mir da mit ein paar Neoprenecken (oder sonst was rutschresistenten) ausgeholfen. Siehe Bild.
Die müssen an der Innenseite der Füße sein da sonst nicht korrekt gelaufen wird.
[/img]
Hallo Flash2over
Danke für die schnelle Antwort! Jetzt läuft mein Yeti endlich auch normal!! :D
Mit freundlichen Grüßen
Simon
Mein Erfahrungsbericht:
Habe mir den YETI beim Conrad gekauft, bin mehr oder weniger zufällig drüber gestolpert und habe das Ding dann mitgenommen.
Ich finde, es macht unglaublich Spass den YETI zu bauen! Als absoluter Anfänger hätte ich mir an einigen Punkten eine detailliertere Anleitung gewünscht, so wie für den Infrarot Transceiver. Dann hätte ich nämlich auch die Augen-LEDs richtig verlötet und die Pins für die Servoanschlüsse hätte ich auch korrekt eingebaut.
Was mir nicht so gefallen hat: Das Gehäuse ist sehr eng dimensioniert, lässt sich kaum richtig schliessen. Ich habe auch keinen YETI aus schwarzem Plastik, sondern einen dunkelblauen. Um den unteren Servo überhaupt mit 4 Schrauben fixieren zu können, musste ich das Plastik mit einer Feile gefügig machen. Von den Schrauben die ganz oben auf dem Kopf angebracht werden sollen, hat eine ein kaputtes Gewinde. Diese Kugelgelenke (nennt man das so?) hätte ich alleine nicht montieren können, zum Glück war jemand da, der mir helfen konnte. Ausserdem musste ich rohe Gewalt anwenden.
Die Dateistruktur auf der CD ist hingeschlampt! Rechtschreibfehler noch und nöcher, Daten sind oft mehrfach abgelegt. Eine saubere Struktur wäre hier schöner. Das Handbuch hat offenbar auch nie eine Qualitätssicherung gesehen!
Über den beigelegten Source-Code kann ich als Software-Entwickler auch nur schimpfen! Ein Source-Code der funktioniert ist nicht zwangsläufig ein guter Source-Code. Was noch im Handbuch als Programmers Hint zur Funktionsbenennung verkauft wird, ist in Wirklichheit für die meisten Profis ein absolutes don't. Die Source ist wenig lese- und wartungsfreundlich, das könnte man besser machen.
Bei all dieser Kritik muss ich jedoch sagen, dass ich die Arbeit am Roboter wirklich geniese und mir demnächst bestimmt noch den Asuro und die anderen Kits von Arrexx kaufen werde. Vielleicht sind es gerade diese Unzulänglichkeiten durch die man sich kämpfen muss, wie das zu enge Gehäuse, um am Ende so stolz auf seinen Roboter sein zu können. Etwas weniger Schlamperei bei CD, Handbuch und Source wäre dennoch angebracht.
Dem kann ich nur zusimmen! Es sind echt etliche Fehler vor allem in der Anleitung...und stellenweise fehlen meiner Meinung nach auch Informationen: zum Beispiel hat man es als Anfänger schwer, den Ultraschall-Zusatz in Betrieb zu bekommen.. (wobei es da in der letzten Zeit auch Verbesserungen unter der Arexx-Seite gibt!:) aber ist trotzdem ein toller Roboter und macht Spaß damit zu experimentieren!:)
Es gibt jetzt eine Erneuerung für die "Plastikbeine" (http://www.conrad.de/ce/de/product/1...archDetail=005)
@simi05
Ich hab mir "gleich" die Aluminiumbeine zum Yeti bestellt
Leider ist die qualitaet saumaessig, und von der Masshaltigkeit will ich gar nicht erst sprechen....(von Fuss zu Fuss 3mm Unterschied)
Die Ungenauigkeit der Fussstangen konnte ich noch mit einer Feile beseitigen....aber das die Aufnahmeloecher 2mm unterschied hatten, ist nicht zu bereinigen.
Somit steht mein Yeti immer "schief"...oder wenn ich Kalibriere, kommt der Servo nie in Mittenstellung.
Warum unbedingt 2mm Mutter/Gewinde gewaehlt wurden wird mir wohl immer ein Geheimnis bleiben.
Mit 3mm-Material waere der auch nicht schwerer geworden, dagegen weitaus besser zu "Handwerken"
Denn trotz Kontermuttern etc. reissen hier alle Gewinde so langsam aus. Mein Yeti verliert beim laufen sozusagen seine Einzelteile.
Ich will nicht sagen, das er beim laufen eine Spur von Teilen hinterlaesst....aber weit weg ist das nicht gedacht.
aber Spass macht der "Kerl" schon....!!!
@uwegw
Ich habe Deine yeti_extended.c freudig angenommen und ausprobiert
prima sache das...
bloss da bleiben bei mir als Newcomer noch so viele Fragen offen
obwohl alles sauber kompiliert wird, habe ich doch nen halben Bildschirm als "Warning:"
Ich wollte das mit Drag&Drop kopieren...geht leider nich....
also schreib ich mal was online.....
zB.
warning: pointer targets in passing arguments 1 of 'strlen' differ in signedness
2 of 'itoa'
.
.
warning pointer targets in passing arguments 1 of 'vPrint' differ in signedness
...........jetzt meine Frage.......was bedeutet diese Warnung.....und ist nicht gerade 'strlen' wichtig ??
und dann noch, wenn ich die Akkuspannung messen moechte......Du schreibst von Port5
welcher Port5
der ADC-Port5 ist mit dem Spannungsteiler belegt (ich dachte eigentlich bis jetzt, der ist fuer die Referenzspannung zustaendig)
...und die zu messen waere ja bloedsinn...
oder PIN5....waere noch frei....hat aber nix mit ADC zu tun...
auch wenn der Tread schon ein bissel aelter ist, auf (hoffentlich) konstruktive Antworten wuerde ich mich freuen.
Gruss Asko.
Hallo
Zur Batteriespannungsmessung: Über den Spannungsteiler R2(120k)-R3(100k) wird die Akkuspannung auf einen Wert kleiner 2,5V gesenkt und an Pin 28 (PC5) angelegt. Gemessen wird die Spannung dann mit interner 2,56V-Referenz um bei der Messung unabhängig von der Akkuspannung zu sein. Als externe Referenz für andere ADC-Messungen bis zur Akkuspannung wird die externe Referenz an AVCC (geglättet über Spule über L1) verwendet. (Die angelegte Spannung am ADC-Pin darf nicht größer als die Referenzspannung sein!)
warning pointer targets: Bei neueren GCC-Versionen passt irgendetwas nicht mit dem Vorzeichen in den Parametern (wirklich kapiert habe ich es allerdings nicht). Beim einem Parameter für vPrint() muss man in der Definition signed gegen unsigned ändern (oder andersrum?). vPrint() ist vermutlich in yeti_extended.c
Zur Mechanik kann ich leider nichts sagen, weil ich den yeti nicht besitze.
Gruß
mic
@ radbruch
Du bestaetigst positiv meine Vermutungen.
Ich war aber etwas verwirrt....."Port5" gibts ja bein ATmega oefter....Port.a ......Port.b....usw
Wenn das aber ueber nen Spannungsteiler geht...wieviel "vertraegt" denn so ein eingang ?
Auch bin im Datenblatt bisher nicht so richtig schlau geworden, wieviel mA eim Pin-Ausgang gefahrlos treiben kann.
Ich muss dazu sagen das ich der englischen Sprache nicht besonder maechtg bin.
mehr raten als wissen...
...Und nichts ist gefaehrlicher als profundes Halbwissen...
gibts denn eigentlich irgendwo ne "deutsche" Befehlsuebersicht ? (also eine fuer mich gemachte)
Und danke nochmal fuer den hinweis auf den Prozessor, ich selber hab Ihn nicht gefunden.
Weil ich ja immer nach "YETI" suchte....
jetzt habe ich Ihn auch beim grossen C entdeckt, als Ersatzteil fuer den Asuro.
Weil ELV nicht schnell genug lieferte, hatte ich mir im Berliner Ladengeschaeft von C.... gleich nen ASURO Bausatz mitgenommen.
da hatte ich dann einen Prozessor....und gleich noch nen zweites Bastelobjekt obendrein.
Jetzt interessiert mich die portierung der IR-Kollisionserkennung vom Asuro auf den Yeti.
Aber bis dahin werden wohl noch einige Elektronen fliessen....
Gruss Asko.
Hallo
Die Batteriemessung ist an Pin 28 oder Port C Bit5 oder PC5 oder ADC5 angeschlossen.
Den Strom am Mega8-Pin findet man im Datenblatt unter "Electrical Characteristics". Der "DC Current per I/O Pin" wird dort mit 40.0 mA angegeben. Zusätzlich gibt es aber noch Einschränkungen bei der Summe der Portströme.
Gruß
mic