Liste der Anhänge anzeigen (Anzahl: 5)
Techniker Miniprojekt 2011 Modell Kuka Roboterarm
Hallo,
mein Name ist André und mache zurzeit meinen Staatlich geprüften Techniker (2te von 2 Jahren). Zum Unterricht gehört neben ein 10 wöchiges Projekt in einem Unternehmen auch ein Miniprojekt, welches ich mit ein Schulkollegen zusammen mache.
Wir haben vor ein Kuka Roboterarm- Modell mit RC Servos auszustatten, so dass dieser nachher z.B. Würfel übereinander stapeln kann.
Hier mal ein Bild von den Modell
Anhang 20133
Der Roboter sollen nachher über 6 Achsen und ein Greif-Arm verfügen. Also insgesamt werden 7 Servos verbaut.
Über ein C# Programm sollen dann einmal manuell die Positionen der Servos angegeben werden und danach soll er diese automatisch abfahren können.
Also das C# Programm schickt die Daten an ein uC, welcher die Servos ansteuert.
So könnte das C# Programm nachher aussehen
Bild hier
Verwirklichen wollen wir das ganze mit ein atmega 644 den man bei reichelt in DIL-Gehäuse bestellen kann. Wir nehmen diesen, da dieser 6 PWM- Channels besitzt
Im ersten Schuljahr haben wir die Grundkentnissein von C# gelernt. Und unser Problem ist es momentan das wir noch nicht viel mit uC gemacht haben. Bzw. dieses Thema erst in zweiten Schuljahr durchnehmen. Das Miniprojekt muss bis zu den Winterferien fertig gestellt werden.
In Assembler haben wir leichte Kenntnisse. Wollen unsern uC aber in C programmieren. Zur Zeit arbeiten wir das Tutorial auf mikrocontroller.net durch.
Geschafft haben wir bereits Daten von C# Programm zum uC zu schicken. Wissen aber noch nicht wie wir diese bearbeiten können.
Wir hoffen bei Fragen ein wenig Hilfestellung von Euch zu bekommen.
Aber zurück zum Projekt
Momentan sind wir dabei den Roboter-Arm mit Servos auszustatten.
Verbaut werden 3 digital Servos mit 13 kg/cm und 4 digital Servos mit 1,6 kg/cm
Mit ein Dremel fräsen wir den Roboterarm zurecht. Was bis jetzt ganz gut klappt
Anhang 20134
Anhang 20135
Anhang 20136
Anhang 20137
So war unser erster Servo schnell untergebracht.
Und der erste Funktionstest ging auch gut
http://www.youtube.com/watch?v=SR5WZ...eature=related
schnell folgten weitere Servos
http://www.youtube.com/watch?v=1aw0pOjACMg&feature=related
In den ersten beiden Videos haben wir noch eine einfache Platine von Conrad verwendet um die Servos anzusteuern. Da die Ansteuerung aber nicht so genau war kam schnell der uC zum Einsatz. Jetzt ist auch das Brummen in Ruhestand weg
http://www.youtube.com/watch?v=Le3eztl9Hzk&feature=related
Und hier der aktuelle Stand. Momentan haben wir 4 Servos verbaut. Das uC Programm ist natürlich bis jetzt nur zum Testen da.
Bild hier
http://www.youtube.com/watch?v=Gbc_7tyJPNQ
Wenn man bedenkt, dass wir erst am Samstag angefangen sind mit den Projekt sind wir bis jetzt sehr zufrieden damit.
Wir hoffen euch gefällt es auch.
Liste der Anhänge anzeigen (Anzahl: 3)
Hallo,
haben jetzt 5 Servos verbaut. Die Datenübertragung von C# auf den Mikrocontroller haben wir auch hinbekommen, auch so dass er diese verarbeiten kann.
Momentan versuchen wir den Greifarm zu realisieren
Hier nochmal 2-3 Bilder
Anhang 20147
Anhang 20148
Anhang 20149
Zum Schluss noch ein kleines Video :p
http://www.youtube.com/watch?v=guNsNSw-16o
Liste der Anhänge anzeigen (Anzahl: 2)
Hey, danke für die Antwort.
hätte ich auch selber darauf kommen können :-)
Habe hier mal diesen Widerstand rausgesucht. Damit müsste es doch realisierbar sein oder?
http://www.conrad.de/ce/de/product/4...&WT.mc_id=epro
Den Spannungsabfall würden wir dann noch mit einer OP-Schaltung verstärken.
Und hier dann noch zwei Bilder, wo nachher der Roboterarm darauf geschraubt wird.
Einmal hier betriebsbereit: Die blauen Streifen sind Plexiglas-Platten und werden halt blau beleuchtet. Dies soll über PWM geschehen, sprich es soll langsam blau pulsieren
Anhang 20176
Hier im Störungsfall, wenn z.B. der Not-Aus gedrückt wird. Dabei pulsiert es schnell und in rot.
Anhang 20178
Der runde Kreis der unten links zu sehen ist wird ein Not-Aus und rechts daneben kommt ein Display was den aktuellen Zustand/ Störmeldungen anzeigt.
Liste der Anhänge anzeigen (Anzahl: 1)
Danke für die Antworten. Werden es aber erst mal ohne Analogmultiplexer versuchen, müssten genug analoge Eingänge zur Verfügung haben. Wir werden die Schaltung eh erst mal auf ein Steckbrett zusammenstecken bevor wir eine Platine ätzen.
Heute haben wir die Grundplatte fertig gesägt. Sieht alles schon ganz gut aus. Haben zum Testen eine Ecke schon mal bezogen. Klappt ganz gut.
Hier mal ein Bild:
Anhang 20185
Liste der Anhänge anzeigen (Anzahl: 1)
So schnell noch ein Bild von C# Programm, bzw. vom Layout
Anhang 20190
Liste der Anhänge anzeigen (Anzahl: 1)
Hallo,
haben uns noch mal ein wenig Gedanken über die Spannungsversorgung gemacht. Wollten das jetzt so machen: 6V über ein Schaltnetzteil (5-12V / 4000mA) für die Servos und die Leds.
Haben nochmal genau die Ströme gemessen. Also die großen Servos (insgesamt 3) verbrauchen unter Last je 300-700mA@5V, die kleinen (insgesamt 4) je 150-300m@5V und Leds würden wir insgesamt 28 berbauen (wobei 2 immer in Riehe geschaltet werden)
Kommen wir im schlimmsten Fall auf
3X 700mA = 2100mA
4X300mA = 1200mA
14x20mA = 280mA
Gesamt = 3580mA
Denke aber, dass es niemals vorkommen wird das alle Servos maximal Last haben und dass die Servos bei 6 V weniger Strom verbrauchen.
Und für den Mikrocontroller wollten wir die 5 V von dem USB-Port nehmen.
Haben dieses Modul für die UART Schnittstelle gefunden
http://www.elv.de/output/controller....l2=28776&flv=1
Hier die Pin-Belegung
Anhang 20203
Damit könnten wir doch den Mikrocontroller versorgen, oder? Müssen wir dabei noch irgendetwas beachten?
Danke schon mal für die Antworten :-)
Liste der Anhänge anzeigen (Anzahl: 3)
so es hat sich mal wíeder einiges getan ;-)
einmal haben wir die letzten Holzstücke mit der passenden Plexiglas Platte fertig gesägt. Das eine Holzstück wurde auch schon mit Folie bezogen.
Anhang 20211
Dann ging es auch weiter an den Roboterarm. Dort haben wir angefangen ein Greifer zu entwerfen. Sieht jetzt irgendwie aus als ob der Arm ein Gesicht hätte :p.
Anhang 20212
und zum Schluss wurde noch etwas an den Layout des C# Programms gemacht
Anhang 20213
Wir hoffen, dass die Tage noch das bestellte Kabel ankommt, damit wir endlich diesen Kabelsalat entsorgen können...
Liste der Anhänge anzeigen (Anzahl: 4)
Zitat:
Zitat von
Richard
Wenn nicht nehmt ihr einfach einen USB Switch mit eigenem Netzteil, der liefert 500 mA an jeden seiner Ports. :-) Bei (mir) läuft ALLES über so ein Teil, so zerstöre ich nicht gleich den ganzen PC wenn (ich) Pfusch baue. :-)
Gruß Richard
Danke Richard genau so haben wir es auch bis jetzt gemacht :-)
So heute hat sich mal wieder einiges getan:-)
Zum einen haben wir die Operationsverstärker-Schaltung für die Strommessung der Servos erstellt und getestet und zum anderen ist das Kabel (12 x 0,35 mm²) angekommen.
In C# Programm soll nachher von jeden Motor über ein Diagramm der Stromwert angezeigt werden. Desweiteren brauchen wir die Stromwerte um Blockierungen der Servos festzustellen um so ein eventuelles durchbrennen der Motoren durch abschalten zu verhindern.
Hier ein paar Fotos von der Verdrahtung:
Anhang 20222
Anhang 20223
Anhang 20224
Anhang 20225
Liste der Anhänge anzeigen (Anzahl: 2)
Zitat:
Zitat von
Geistesblitz
Echt cooles Projekt habt ihr euch da ausgesucht :)
Als ich zum ersten Mal dieses Modell in der Vorlesung gesehen hab, dachte ich nur "Kann der sich auch bewegen oder ist das nur ein Modell?". Als sich letzteres bestätigt hatte, begann ich zu überlegen, wie man den denn motorisieren könnte. Und ihr macht das hier einfach mal, und das sogar richtig gut :)
Ich bin wirklich gespannt, was ihr aus diesem Modell noch herausholt. Das Nonplusultra wäre ja eine schöne CP-Bewegung, wobei aber PTP-Bewegungen schon was Nettes wären. Kann man denn das Programm nur über PC-schreiben und läd es dann auf den µC oder kann man den Roboter auch über den PC steuern?
Hey schön das es dir gefällt! Naja leicht ist es nicht die Servos anzupassen, aber mit ein bissen Geduld klappt es eigentlich ganz gut.
Also der Roboterarm wird nachher schon eine CP-Bewegung haben (Hoffen wir zumindest). Er wird nur über den PC steuerbar sein. Also ein PC wird immer benötigt. Man kann ihn dann entweder manuell fahren oder einmal manuell fahren und die Positionen speichern, so dass dieser nachher per Knopfdruck (alle abspielen) diese automatisch abfährt. Diese Abfahrten soll man dann auch speichern können und nachher wieder laden.
So Heutet haben wir die letzten Kabel am Roboterarm verlegt. Hier mal schnell zwei Bilder.
Läuft natürlich auch alles :-)
Anhang 20229
Anhang 20230
Liste der Anhänge anzeigen (Anzahl: 5)
Ja haben die Teile über die Servohörner befestigt. Und ja die Teile Wackeln auch wenn man dran rüttelt. Es ist halt immernoch ein Arm aus Plastik aber er soll ja auch keine schweren Teile bewegen. Denke mal er könnte so Sachen bis ca 100-150g heben. Aber für uns reicht es, wenn er Würfel heben kann.
Hier noch ein paar Bilder
Anhang 20236
Anhang 20237
Anhang 20238
Anhang 20239
Anhang 20240
Liste der Anhänge anzeigen (Anzahl: 2)
heute haben wir uns an den Greifer gewagt. Sieht eigentlich ganz gut aus, nur leider ist uns beim bohren ein Teil von Greifer abgebrochen. Wir die Tage also nochmal neu gemacht. Für ein Foto reicht es trozdem :-)
Anhang 20254
Anhang 20255
Liste der Anhänge anzeigen (Anzahl: 3)
Hey,
meinen Sie? Wir meinen der ist so schon ziemlich klein. Klar ist das kein Vergleich zu Ihrer Lösung, aber bei uns sind vorne im Greifelement zwei Servos, einen zum Greifen und einen, der den Greifkopf nochmal um 180° drehen kann nach dem Gelenk. Somit kann man jede Stellung einehmen.
Hier sieht man die zwei Servos (naja man kann es erahnen)
Anhang 20256
Um kleine sachen zu Greifen kann man also den Kopf um 180° drehen
Anhang 20257
So soll es nacher aussehen
Anhang 20258
Vorne am Greifer kommt noch ca 3mm dicker Mosgummi, damit er mehr Grip hat
Liste der Anhänge anzeigen (Anzahl: 2)
Hallo,
haben leider die letzte Woche nicht so viel geschafft.
Naja der aktuelle Stand ist das alle 6 Achsen sowie den Greifarm realisiert sind.
Viel kam nicht dazu, weil a) wir uns um das richtige Abschluss-Projekt kümmern mussten, welches super mit diesem Thema zusammen passt. Müssen nämlich für einen Unternehmen einen richtigen Roboterarm (Adept Cobra 600) programmieren.
Anhang 20307
Wird auf jeden Fall spannend. Anderseits schreiben wir jetzt kurz vor den Ferien noch ein paar Klausuren und müssen dafür lernen.
Zum Glück fangen nächste Woche die Ferien an, so können wir uns ganz auf das Mini-Projekt konzentrieren.
Ganz ohne Bilder wollten wir den Beitrag aber nicht schreiben :-) Haben die ersten Leds in der Grundplatte verlötet.
Anhang 20306
Liste der Anhänge anzeigen (Anzahl: 4)
Hallo,
Der aktuelle Stand ist so lala. Mein Kollege der muss ab Morgen für 1 Wochen ins Krankenhaus und ich habe zwar 2Wochen Ferien, in den ich hoffentlich viel schaffen werde aber irgendwie komme ich momentan nicht weiter.
Vorher lief ja alles mit ein Atmega8. Gestern Abend und Heute den ganzen Tag versuche ich den Atmega644 über UART anzusteuern und das klappt nicht so gut wie beim Atmega8...
Anfangs hatten wir Probleme Daten in den EEPROM des Atmega664 reinzuschreiben. Dabei haben wir das mySmartUSB Board MK2 Programmer benutzt. Es hat auch nicht geklappt. Liegt wohl an den Programmer. Haben dann über Ebay ein günstiges STK500 ersteigert und damit klappt es.
Habe heute geschafft das LCD Display anzusteuern und den Wert den ich über UART sende über das Display ausgeben lassen, aber dieses Funktioniert nicht. Ich Sende zwar über das C# Programm Daten zum uC, es kommen auch welche an, aber nicht die die ich gesendet habe.
Am C# Programm wird es wohl nicht liegen, da dieses mit den Atmega8 funktioniert hat.
Hoffe Ihr könnt uns ein paar Tipps geben.
Hier mal das uC Programm
Code:
#include <avr/io.h>
#include <inttypes.h>
#include "lcd-routines.h"
#define BAUD 9600UL
#define UBRR_BAUD ((F_CPU/(16UL*BAUD))-1)
// USART initialisieren
void
uart_init(void)
{
// Baudrate einstellen (Normaler Modus)
UBRR0H = (uint8_t) (UBRR_BAUD>>8);
UBRR0L = (uint8_t) (UBRR_BAUD & 0x0ff);
// Aktivieren von receiver und transmitter
UCSR0B = (1<<RXEN0)|(1<<TXEN0);
// Einstellen des Datenformats: 8 Datenbits, 1 Stoppbit
UCSR0C = (1<<UCSZ01)|(3<<UCSZ00);
}
main(void)
{
//-------------------------------------------------------------------------------------------
// Initialisierung
//-------------------------------------------------------------------------------------------
uart_init();
lcd_init();
// Variablen
uint8_t buffer= 00;
//TCCR1A = (1<<WGM11) | (1<<WGM10) | (1<<COM1A1);
//TCCR1B = (0<<WGM13) | (1<<WGM12) | (1<<CS10) | (0<<CS11) | (0<<CS12);
//-------------------------------------------------------------------------------------------
// Schleife
//-------------------------------------------------------------------------------------------
//Zeile 1
lcd_setcursor( 0, 1) ;
lcd_string("Hallo");
//Zeile 2
lcd_setcursor( 0, 2 );
lcd_string("Bitte um Hilfe!");
//Zeile 3
lcd_setcursor( 20, 1 );
lcd_string("UART funkt. nicht!");
//Zeile 4
lcd_setcursor( 20, 2 );
lcd_data(UDR0);
while (1)
{
// Wenn Daten empfangen wurden dann...
if ( (UCSR0A & (1<<RXC0)) )
{
lcd_setcursor( 20, 2 );
lcd_data(UDR0);
}
//sonst....
else
{
}
}
return 0; // never reached
}
Ich weiß dass er in der vierten Zeile nicht den Wert z. B. 102 schreibt, sondern diesen in ASCII Zeichen angibt, aber die könnte man ja vergleichen z.B. hier:
http://www.code-knacker.de/ascii.htm
Hier mal ein Bild:
Anhang 20367
Das STK500 benutze ich zum Programmieren und das mySmartUSB Board MK2 wird ist in den UART-USB-Bridge Modus. Angeschlossen ist ein 16MHz Quarzoszillator.
Momentan sieht es folgenermaßen aus:
Wenn ich das Programm darauf gespielt habe dann erscheint folgendes auf den Display
Anhang 20368
das Zeichen in der 4ten Zeile ist denk ich mal normal weil ja noch nichts wirkliches in UDR0 drinsteht.
Sende ich jetzt irgendeine Zahl (Byte)
dann sieht es so aus:
Anhang 20369
Folgende FuseBits sind gesetzt
Anhang 20370
hoffe Ihr könnt uns ein paar Tips geben!
Gruß André
