Anfänger - Universeller I²C-Greifarm + Steuerung

Hi,

wie bereits hier beschrieben:

https://www.roboternetz.de/phpBB2/vi...a38d34860b701d

habe ich vor, einen Greifarm zu bauen, der vorerst mal von einem Robby RP6 gesteuert werden soll.

Da ich das ganze auch über Jugend forscht machen will, benötige ich vorab eine Liste der benötigten Teile.

Nun meine ersten Fragen zu dem Thema sind:

-kann ich z.B. das Robby RP6-USB-Interface zum proggen eines anderen AVRs verwenden (wenn ja, Schaltung?)

-dann zum anderen, was für Mikrocontroller brauche ich dafür bzw. welche Teile brauche ich zu einem Mikrocontroller dazu, damit er Servos ansteuern kann?
er erhält Signale von einem anderen Controller und soll dann den Greifarm die richtigen Bewegungen machen lassen.

-welchen Mikrocontroller nehme ich am besten, um RC-Funk-Signale umzuwandeln?

Ich würde das alles wenn möglich mit AVRs machen und die RC-Funk-Signale später evtl. von USB-Joysticks senden lassen.

Wenn jemand nen Controller kennt, der 2 USB-Joysticks auswerten kann und dann die Signale an einen RC-Sender weitergibt (evtl. verändert) dann wäre das auch noch wichtig.

In dem Fall geht es erstmal um diese Elektronik-Bauteile, da ich diese alle beantragen muss und dann erst nach und nach bestelle (wenn ich sie dann wirklich brauche.

Danke für jede Hilfe!!

MfG Pr0gm4n

Hi nochmal,

hab endlich was für die Joysticks gefunden:
http://joystick.world3.net/

jetzt muss ich es nur noch verstehen und auf 2 Joysticks erweitern...


Kann das jemand von euch vielleicht nochmal verständlich erklären, wie ich den Joystick dann verwenden kann laut dem, der das geschrieben hat?


DANKE!!

MfG Pr0gm4n

Es gibt doch auch so ein Joypad wie aus ner PS2 nach RN-standart mit I2C schnittstelle. mir fällt der name nur net ein. warum nimmst du net den?

lol!!!


also, ich will per I²C einen Greifarm ansteuern...


Also nich mit Kabel dem Robby hinterherlaufen

oder meinst du, ich soll den Joypad dann über nen AVR auswerten und dann die Signale über RC-Funk senden, anstatt dafür 2 normale USB-Joysticks zu verwenden?

naja, ganz einfach:

ich will das Projekt später noch ausweiten, d.h., dass ich noch ein Steuerungsinterface am Computer proggen will...

darauf wird u.a. mehrere Kamerabilder und eine Simulation der momentanen Bewegung des Greifers zu segen sein.
das geht nur, wenn die Joysticks gleichzeitig an den PC angeschlossen sind.
während man einen bestimmten Knopf drückt, sollen die Joysticks gar nichts senden, sodass man also zuerst simulieren kann, was der Greifer machen wird. Ist der Robby ausgeschaltet, wird in dem Interface evtl. nur noch die Simulation des Greifarms angezeigt.

Später will ich dann auch den Robby RP6 dazu nichmehr brauchen und mache daraus einen komplett eigenen Bot, der nur irgendwie fahren kann und über I²C-RC-Funk Befehle empfängt oder sich mit Sensoren allein in der Umgebung zurechtfindet.

Ich hoffe, das ist jetzt klar, aber wenn ich die Joysticks selbst nich so ganz hinbekomme, dann überleg ich mir das mit dem Teil nochma...

MfG Pr0gm4n

nehm doch einen joystick, wie in einer rc funke, so mit potties unten dran, die kannst du dann ganz einfach ueber den adc in den controller einlesen..

den controller kannst du jeden nehmen der nen icp hat ( wegen den signalen von der funke ) das geht dann so :

Code:

---

Dim Puls(8) As Integer
Dim Kanal As Byte

'---------Timer----------------
Config Adc = Single , Prescaler = Auto , Reference = Avcc
Start Adc

'-----------Interupts----------
On Icp1 Get_empfaenger Nosave
On Ovf1 Kanal_reset Nosave

Config Timer1 = Timer , Prescale = 8 , Capture Edge = Falling

Enable Ovf1
Enable Icp1

Enable Interrupts

....
programm

....
'------------Interupts---------------
 Get_empfaenger:
      push r10
      push r11
      push r24
      push r25
      push r26
      push r27
      in r24,sreg
      push r24

      Puls(kanal) = Timer1
      Timer1 = 40000

      Incr Kanal

      pop r24
      !Out Sreg , R24
      pop r27
      pop r26
      pop r25
      pop r24
      pop r11
      pop r10



    Return


Kanal_reset:


    push r24
    in r24,sreg
    push r24

    Kanal = 1
    pop r24
    !Out sreg,r24
    pop r24
  Return

---

servos kannst du auch ganz einfach ansteuern:

Code:

---

Config Servos = 2 , Servo1 = Portb.1 , Servo2 = Portb.2 , Reload = 10
do
Servo(1) = 50
wait 1
servo(1) = 100
wait 1
loop
      Config Portb = Output

---

steht auch im wike.. falls du das in c machst musst jemand anders fragen ;)

Hi,

ja, ich mach das in C und folgendes:

ich kauf bei ebay ne gebrauchte Funke und 2 Joysticks mit gleichen Potis, dann werden die Joysticks leicht modifiziert und das ganze an die Funke angeschlossen.

Zum auslesen der Signale nehme ich die Beschreibung von radbruch im Robby RP6 Forum mit ISR.

Servos ansteuern kann ich glaub ich über PWM und dann muss das ganze erstmal gebaut werden.

Was ich im Moment brauche, ist bitte eine Empfehlung für AVRs, die ich für die einzelnen Aufgaben nehmen kann.

1. RC-Signale auswerten (ATMega8 ?)

2. Servoansteuerung 10 Stück (??)

3. Sensorik (????)

4. Hauptcontroller zum koordinieren (evtl. mit Servos und Sensoren gemeinsam?? möglich??)



Wenn mir das jemand schreiben könnte wäre ich euch echt sehr verbunden, da ich dann die Teile beantragen kann und anfangen kann zu bauen...


MfG Pr0gm4n

Also konkret empfehlen kann dir von meiner seite nur den atmega 8535 der kann so ziemlich alles.
Hat aber nur 2 PWM ausgänge wobei du auch eine Software pwm nehmen könntest.
I2C hat dieser auch und mit 16Mhz kommste auch rellativ weit ;P.

Aber an deiner Stelle wäre es schon zu überlegen einen 2. uC zu nehmen vll 20pins der über i2c die Servo werte bekommt und mit software eine PWM generiert. Einen Chip mit 10 hardware PWM ist mir nicht bekannt würd mich aber auch intressiern.


mfg

von funk hab ich keine ahnung
:-b

Hi,

Danke für diese Antwort!!

also, ich nehm den dann wohl als Hauptcontroller und für die Sensorik

Für die Funksignale reicht der ATMega8, sofern ich mit dem dann über I²C Slave quasi die Kanäle abfragen kann.

wenn der ATMega 8535 mit 3 Controllern gleichzeitig ne I²C-Verbindung haben kann iss der genau mein ding!!

als Servosteuerung kann ich dann eigentlich gleich ein reines I²C Servoboard kaufen, oder? (10 servos, empfehlung?)


Jetz die Frage: was kann ich dann für die µCs einrechnen?

also: (Reichelt)
-ATMega8: 1,85€
-ATMega8535: 2,70€


soweit so gut...

jetzt aber noch was für die servos, was am besten für 15€ geht...



MfG Pr0gm4n

EDIT: Servoansteuerung vielleicht wie hier: https://www.roboternetz.de/phpBB2/viewtopic.php?t=35643


wenn möglich will ich die Servoansteuerung auch mit nem AVR machen um Kosten zu sparen und da komplexe Sachen von mir aus geplant sind...


Ach ja, ich richte unter Pr0gm4n.roboterbastler.de (noch nicht hochgeladen) dann eine Seite ein, auf der ich auch Bilder etc. Posten werde, dazu dann aber auch wieder ein post.

laso fuer die funke brauchst du interrupst.. das signal was da rauskommt sieht so aus :
Bild hier  
(brauchst du nen empfänger bei dem du das summensignal rausbekommst ( oder wenn nen oszi hast messen an welchem pin es liet und rausführen )

da sollte es ein meag8 tun , ja...

servos ueber sowftware pwm , weil wie oben shcon erwähnt mit 10 net gibt.. is auch kein ding, braucht man nur n timer..

fragt sich jetz ob es sinnvoll ist da jeweils nen extra conteoller zu nehmen, wiel du brauchts im prinzip einen icp pin fuer die funke und 10 ausgänge fuer die servos.. ( das hat sogut wie jeder controller)
was kommen denn noch fuer sensoren dran ?? da muesstest du dann shcaun (falls analoge) wie viele adcs du brauchst.. aber im prinzip tuts da echt fast jeder kontroller... mega32 ... 8 ... egal..

Hi,

also die Funke muss mit nem extra Controller ausgelesen werden, da das ein Bauteil wird, das man nur schnell auf Distanzbolzen hinschraubt und den I²C-Stecker reinmacht und dann nurnoch den anderen Controller als Master einstellt


Ich weis zwar, wo das Summensignal rausgeleitet wird, aber sollte ich nich besser einfach die einzelnen Kanäle rausleiten? (GND, +5V, Signal)

Kann ich die Servos mit nem ATMega8535 ansteuern, während er nen Sharp und ein paar Bumper ausliest und alles koordiniert?

Sharp und Bumper sind auf Interrupt, die schlagen an, wenn der Greifer genau so weit von was weg ist, dass er nurnoch zumachen muss oder wenn er irgendwo ansteht, dammit die Servos nich kaputt gehen

das mit dem koordinieren heißt, er muss per I²C Befehle empfangen (abfragen bei Funke), Befehle per I²C an den Roboter senden, auf den das ganze draufgebaut wird, die Servos steuern

Isses möglich, dass ich an meiner Funke nen Knopf drücke und dann wird ein schon reingeladenes Programm in dem Roboter wos draufkommt abgespielt (autonome Steuerung des Greifers dann, also auf I²C Slave und nur überwachung auf gleichen Schalter an Funke zum rückgängig machen)



MfG Pr0gm4n

nee nehm das summensignal.. wenn du die einzelnen kanäle nimmst bracht du erstens viele pins, und 2. ist es auch gar nich so einfach die dann alle einzulesn, wuesst jetz nicht wie das machbar waere, brahct ja jedesmal nen interruptpin, und die quasseln sich dann alle gegenseitig rein..
am einfachsten ist summensignal und dann die ienzelnen kanäle hochzählen, habe ich auch so geamcht:
https://www.roboternetz.de/phpBB2/ze...143&highlight=
die servos ansteurn macht der controller "nebenher", da kannst du also ruig noch paar taster und sensoren dranhängen..

das mit dem knop ist kein problem, du kannst sogar mehrer knöpfe an die funke machen, die alle auf einem kanal laufen und jeweils einen anderen wert senden.. im programm dann einfach mit ner case schleife abfragen in welchem berecih der gesendet wert liegt und dementesprechend ein programm starten.. gehen locker 10 taster pro kanal,..

Ok,

da ich wie oben beschrieben ja eigentlich Joysticks als Funke verwende, kommt mir das mit den Tastern sehr recht...


Ich kann doch also auf insgesamt 2 Kanälen alle Taster meiner Joysticks laufen lassen, oder?

dann brauche ich nurnoch 6 Kanäle, um die x-, y- und z-Achsen der beiden abzufragen...

da ich eine gebrauchte Funke dafür bei ebay suche, muss ich also ne 7- oder 8-Kanal-Funke kaufen, oder?

könnte ich theoretisch auch die Taster irgendwie auf die anderen Kanäle zuschalten, denn ich hätte schon ne 6-Kanal-Funke im Auge, oder soll ich die 6-Kanal-Funke kaufen und zusätzlich noch so ne billige 2-Kanal-Funke für die Taster??


MfG Pr0gm4n

wofuer genau braucsht du denn 6 kanäle ?? 3 achsen und dann.... ??

ich habe oben (glaube ich) schon erwähnt, dass es sich um 2 Joysticks handelt, einer rechts und einer links. Das sind dann 6 Achsen (Kanäle) und alle Taster, die ich auf 2 Kanäle schalten will, da man sonst immer nur einen drücken könnte. Wenn ich 2 gleichzeitig drücken würde, dann würde nur der eine reagieren, der den niedrigeren Widerstand hat.


MfG Pr0gm4n

ok, dann brauchst du 6 + 1 oder 2 kanalele...

naja du kannst wenn du die widerstände sinnvollvoll anordnest an den tastern, auch mehrer gleichzeitig nutzen, zum beispiel wenn der erste 1 kohm hat der 2. zwei, dann ist 1 und 2 gedrückt 3 kohm, der nexte wert darf dann erst bei 4 leigen.. muss halt so sien, dass sich nichsts ueberschneidet..
aber mit 2 kanaälen ist es auf jedenfall einfacher,..

Ok,

ich muss jetzt das Geld beantragen und wenn ich es bewilligt kriege, dann wird bestellt und dann gebaut

MfG Pr0gm4n

PS: also reicht Controllermässig der Mega8 und der Mega8535, oder?

Also was die servos betrifft hätte ich ein vorschlag.
Hab hier noch ne Software PWM rumliegen die theoretisch 32 Servos steuern kann.
Problem dabei sie nur das die auf 8Mhz ausgelegt ist (ebenfalls der atmega8535). Ist zwar nicht ganz so stilvoll gehalten aber sie funktioniert ^^.
Um mehr Rechenleistung verwenden zu können müsstest du lediglich den umrechnungswert hochsetzen.
Funktioniert so das mit 50Hz ein Timer läuft und von einer mS aufwärts die Ports abgeschalten werden. In den maximal 2mS ist der Atmega in der Timer schleife drin und kann nix machen aber die restlichen 18mS reichen im grunde für alle berechnungen aus.
Wenn du mehr als 8 Servos brauchst musst du 2 Bytes einrechnen wobei du die anderen noch als input verwenden kannst.
8 Servos = 30% des speichers max 16Servos =49%.

Ich habe gerade noch eine wo ein String mit 8 Werten verarbeitet wird wobei es sich empfehlen würde einen 2. Atmega zu nehmen der über i2c einen String erhält bzw die einzelnen Positionen.

Bei jeder der beiden möglichkeiten muss ein 8Mhz Quarz verwendet werden (wie gesagt einstellen ist möglich)

Code:

---

'-------------------------------------------------------------------------------
'-------------------------------------------------------------------------------
'----------------------------- Software PWM ------------------------------------
'------------------------------ 16 Servo's -------------------------------------
'-------------------------------------------------------------------------------
'-------------------------------------------------------------------------------
'------- Voreinstellungen
'-------------------------------------------------------------------------------
$regfile = "m8535.dat"                                      'ATMega8535
$framesize = 32
$swstack = 32
$hwstack = 32
$crystal = 8000000                                          'Quarz: 8.0000 MHz
$baud = 9600
'-------------------------------------------------------------------------------
'------- Timer 0
'-------------------------------------------------------------------------------
Print "16 Servo Steuerung"
Print "2 Beiniger Roboter"
Print "by MC Gyver Games"
Print "Programm Start"
Config Timer1 = Timer , Prescale = 256                      'Konfiguriere Timer1
Enable Timer1                                              'schalte den Timer1 ein
On Timer1 Isr_von_timer_fuer_f                              'verzweige bei Timer1 überlauf zu  Isr_von_Timer1
Enable Interrupts
Load Timer1 , 625                                          '64911                                  'Timer1 soll schon von 625 wegzählen
Enable Interrupts                                          '50hz Schleife
'-------------------------------------------------------------------------------
'------- Output
'-------------------------------------------------------------------------------
Config Porta = Output
Config Portc = Output
Config Portb.1 = Output                                    'LED
Config Portb.2 = Output                                    'LED
Config Portb.3 = Output                                    'LED

'-------------------------------------------------------------------------------
'------- Servo Variablen
'-------------------------------------------------------------------------------
Dim Servos(8) As Word
Dim Servos_a(8) As Word
Dim Servos_b(8) As Word

'------- Umrechnungsvariablen 1...8 zu 2^1...8
Dim Input_aw As Byte
Dim Output_aw As Byte
Dim Rech_aw As Byte

'-------------------------------------------------------------------------------
'------- Wait Variablen
'-------------------------------------------------------------------------------

Dim Z As Word                                              'Zähl Variable als waitus ersatz ;P
Dim W_s(8) As Word                                          'Waitzeiten Save für übergabe vorgerechnet
Dim Wa(8) As Word
Dim Wb(8) As Word
Dim Wa_s(8) As Word
Dim Wb_s(8) As Word
'-------------------------------------------------------------------------------
'------- Berechnungsvariablen
'-------------------------------------------------------------------------------
Dim Rech(20) As Word                                        ' rechen Variable
Dim Nr_a(20) As Byte                                        'Port nummer
Dim Nr_b(20) As Byte                                        'Port nummer

Dim Index As Byte
Dim Wert As Word
Dim Index_plus As Byte
Dim Nr As Byte

Dim Durchgang As Byte                                      'gibt an welche stelle des bytes grade berechnet wird: 1 - 8
Dim Durchgang_plus As Byte                                  'durchgang + 1
Dim Durchgang_minus As Byte
Dim Save_rech(10) As Word

Dim Port_s(8) As Byte                                      'Port Save = Zwischenspeicher von port Byte's
Dim Port_s_a(8) As Byte                                    'Port Save = Zwischenspeicher von port Byte's
Dim Port_s_b(8) As Byte                                    'Port Save = Zwischenspeicher von port Byte's

Dim Akt_byte As Byte

Akt_byte = 0
'-------------------------------------------------------------------------------
'------- Variablen des Hauptprogramms
'-------------------------------------------------------------------------------
Dim A As Byte                                              'durchlauf Variable
Dim B As Word                                              '50Hz Schleifen Variable
Dim C As Word                                              '50Hz Schleifen Variable
A = 0
B = 0
C = 0
'-------------------------------------------------------------------------------
'------- Hauptprogramm
'-------------------------------------------------------------------------------
'-------------------------------------------------------------------------------
Servos_b(1) = 0
Servos_b(2) = 0
Servos_b(3) = 0
Servos_b(4) = 0
Servos_b(5) = 95
Servos_b(6) = 75
Servos_b(7) = 75                                            '83
Servos_b(8) = 0                                            '100

'-------------------- Byte A
Servos_a(1) = 60                                            '60
Servos_a(2) = 80                                            '80  'hoch nach links / runter nach rechts
Servos_a(3) = 130                                          '130
Servos_a(4) = 100                                          '100 'rechts = hoch  / Links = runter
Servos_a(5) = 35                                            '35  'rechts = hoch / links = runter
Servos_a(6) = 48                                            '48
Servos_a(7) = 83                                            '83
Servos_a(8) = 105                                          '110 'Pa7
'-------------------- Byte B


'Servos_a(4) = 10                                            '110 'rechts = hoch  / Links = runter
'Servos_a(6) = 10                                            '110 'rechts = hoch  / Links = runter
Do
'-------------------------------------------------------------------------------
If C = 1 Then
'-------------------------------------------------------------------------------
If B = 100 Then
Servos_b(5) = 180
End If

If B = 200 Then
Servos_b(5) = 10
End If

If B = 300 Then
Servos_a(3) = 180
Servos_a(4) = 140
Servos_a(7) = 55
Servos_a(8) = 110

End If



If B = 5000 Then B = 0
End If
Toggle Portb.2
Berechnung:
'-------------------------------------------------------------------------------
'------- Byte übergabe
'-------------------------------------------------------------------------------
Incr Akt_byte
If Akt_byte = 3 Then Akt_byte = 1
If Akt_byte = 1 Then
Servos(1) = Servos_a(1)
Servos(2) = Servos_a(2)
Servos(3) = Servos_a(3)
Servos(4) = Servos_a(4)
Servos(5) = Servos_a(5)
Servos(6) = Servos_a(6)
Servos(7) = Servos_a(7)
Servos(8) = Servos_a(8)
End If
If Akt_byte = 2 Then
Servos(1) = Servos_b(1)
Servos(2) = Servos_b(2)
Servos(3) = Servos_b(3)
Servos(4) = Servos_b(4)
Servos(5) = Servos_b(5)
Servos(6) = Servos_b(6)
Servos(7) = Servos_b(7)
Servos(8) = Servos_b(8)
End If
'-------------------------------------------------------------------------------
'------- Umrechnen der 0 - 180 werte auf 0 - 390  (390 = maximaler Schleifenwert)
'-------------------------------------------------------------------------------
'-------------------------------------------------------------------------------
'-------------------------------------------------------------------------------
For Nr = 1 To 8
Rech(nr) = Servos(nr) * 217
Rech(nr) = Rech(nr) / 100
Next Nr                                                    'Rechnung klappt perfekt
'-------------------------------------------------------------------------------
'-------------------------------------------------------------------------------
'------- Berechnen der Ausgangswerte
'-------------------------------------------------------------------------------
'-------------------------------------------------------------------------------
'Input = rech 1 - 8 des wars
'output = Die Byte werte der 50 HZ schleife
'Zu rechnen:
'1. kleinster Wert mit Index
'2. vergleich auf anderer index mit gleichen werten und auf 1000 setzen
'3. alle Werte mit 1000 vom Byte abziehen
'4. Nun muss die Schleife von vorne beginnen und besagte werte ignorieren
' Zu Beachten: Alle Werte müssen verstellbare Var's sein um eine große Schleife
' zu verwirklichen was weniger speicher braucht als ein Byte komplett zu
' scripten und den uC unnötig aufzuhalten.
'-------------------------------------------------------------------------------

'-------------------------------------------------------------------------------
'------- Übergabe von Rech auf Rech_save
'-------------------------------------------------------------------------------
For Save_rech(10) = 1 To 8
Save_rech(save_rech(10)) = Rech(save_rech(10))
W_s(save_rech(10)) = 0
Next Save_rech(10)
Save_rech(9) = 500
'-------------------------------------------------------------------------------
'-------------------------------------------------------------------------------
For Durchgang = 1 To 8                                      'Variable die angibt welche Stelle berechnet wird
'-------------------------------------------------------------------------------
Durchgang_plus = Durchgang + 1
Durchgang_minus = Durchgang - 1
Wert = 500
Rech(9) = 500
'-------------------------------------------------------------------------------
'------- Berechnen der niedrigsten Zahl und des Index
'------- Die namen erklären sich von selbst ^^
'-------------------------------------------------------------------------------
'Größenvergleich der aktuellen Zahl (nr) und der nachfolgenden Zahl (index_plus)
'Falls Rech(nr) unter der aktuellen niedrigsten zahl ist wird der niedrigste
'Wert aktualisiert. Der index ist einfach die NR des durchgangs
'Der WERT wird bei jedem neuen Durchgang (var: Durchgang) auf 500 gesetzt.
'Um damit den alten Wert zu löschen und die 2...7 niedrigste Zahl zu berechnen
For Nr = 1 To 8
Index_plus = Nr + 1

  If Rech(nr) < Rech(index_plus) Then

      If Rech(nr) < Wert Then


            Wert = Rech(nr)
            Index = Nr


      End If
  End If

Next Nr
'-------------------------------------------------------------------------------
'------- Erste Wait Zeit = Niedrigster Wert somit Rech(index)
'-------------------------------------------------------------------------------
'Da Rech(1...8) ja auf 1000 gesetz werden muss dessen eigentliche werte in
'Save_rech gespeichert werden
'-------------------------------------------------------------------------------
Save_rech(durchgang) = Rech(index)
If Durchgang = 1 Then
W_s(1) = Rech(index)
Else
If Save_rech(durchgang_minus) = Rech(index) Or Rech(index) = 1000 Then
W_s(durchgang) = 0
Else
W_s(durchgang) = Rech(index) - Save_rech(durchgang_minus)
End If
End If
'-------------------------------------------------------------------------------
'------- Auf gleiche Werte überprüfen und ggf auf 1000 setzen
'-------------------------------------------------------------------------------
Port_s(durchgang) = 255
'-------------------------------------------------------------------------------
For Nr = 1 To 8
'-------------------------------------------------------------------------------
'------- Auf gleiche Werte Testen
'Alle werte die mit rech(index) identisch sind auf 1000 setzen
'-------------------------------------------------------------------------------
If Rech(nr) = Rech(index) Then
If Nr <> Index Then
Rech(nr) = 1000
End If
End If
Next Nr
Rech(index) = 1000
'-------------------------------------------------------------------------------
'------- Ende Vergleich es folg Ausgangsbyte 1000er vergleich
'------- Alle Werte die 1000 sind vom byte abziehen
'-------------------------------------------------------------------------------
'Print "Ende Vergleich es folg Ausgangsbyte 1000er vergleich"
'-------------------------------------------------------------------------------
For Nr = 1 To 8
If Rech(nr) = 1000 Then
Input_aw = Nr
'-------------------------------------------------------------------------------
'-------------------------------------------------------------------------------
'Eingang: Input_aw  1 - 8
'Ausgang: Output_aw 1,2,4,8,16,32,64,128
'-------------------------------------------------------------------------------
'Werte umrechnen
Input_aw = Input_aw - 1
Output_aw = 1
'Berechnungsschleife
For Rech_aw = 1 To Input_aw
Output_aw = Output_aw * 2
Next Input_aw
'-------------------------------------------------------------------------------
Port_s(durchgang) = Port_s(durchgang) - Output_aw
'-------------------------------------------------------------------------------
End If
Next Nr
'-------------------------------------------------------------------------------
'------- Neuer Berechnungszyklus
'-------------------------------------------------------------------------------
Next Durchgang
'-------------------------------------------------------------------------------
'------- Berechnung Fertig => Wert Übergabe
'-------------------------------------------------------------------------------
'Print "Berechnungs Ende => Wertuebergabe"
'-------------------------------------------------------------------------------
'Erst fertig berechnete Werte schnellstmöglich übergeben

If Akt_byte = 2 Then
For Nr = 1 To 8
Wb_s(nr) = W_s(nr)
Port_s_b(nr) = Port_s(nr)
Next Nr
For Nr = 1 To 8
Wa(nr) = Wa_s(nr)
Wb(nr) = Wb_s(nr)
Nr_a(nr) = Port_s_a(nr)
Nr_b(nr) = Port_s_b(nr)
Next Nr
End If


If Akt_byte = 1 Then
For Nr = 1 To 8
Wa_s(nr) = W_s(nr)
Port_s_a(nr) = Port_s(nr)
Next Nr
End If
C = 1
'-------------------------------------------------------------------------------
'------- Schleifen Ende
'-------------------------------------------------------------------------------
Loop
'-------------------------------------------------------------------------------
'------- ENDE
'-------------------------------------------------------------------------------
Print "ENDE"
End
'-------------------------------------------------------------------------------
'------- ISR TImer 1 (theoretische 50Hz Schleife hab kein Oszi^^)
'-------------------------------------------------------------------------------
Isr_von_timer_fuer_f:
Enable Interrupts
Load Timer1 , 625                                          'Timer1 soll schon von 625 wegzählen
Incr B
Porta = 255
Waitus 520

'-------------------------------------------------------------------------------
'------- Byte A
'-------------------------------------------------------------------------------
For Z = 1 To Wa(1)
Next Z

Porta = Nr_a(1)

For Z = 1 To Wa(2)
Next Z

Porta = Nr_a(2)

For Z = 1 To Wa(3)
Next Z

Porta = Nr_a(3)

For Z = 1 To Wa(4)
Next Z

Porta = Nr_a(4)

For Z = 1 To Wa(5)
Next Z

Porta = Nr_a(5)

For Z = 1 To Wa(6)
Next Z

Porta = Nr_a(6)

For Z = 1 To Wa(7)
Next Z

Porta = Nr_a(7)

For Z = 1 To Wa(8)
Next Z

Porta = Nr_a(8)

'-------------------------------------------------------------------------------
'------- Byte C
'-------------------------------------------------------------------------------
Portc = 255
Waitus 520

For Z = 1 To Wb(1)
Next Z

Portc = Nr_b(1)

For Z = 1 To Wb(2)
Next Z

Portc = Nr_b(2)

For Z = 1 To Wb(3)
Next Z

Portc = Nr_b(3)

For Z = 1 To Wb(4)
Next Z

Portc = Nr_b(4)

For Z = 1 To Wb(5)
Next Z

Portc = Nr_b(5)

For Z = 1 To Wb(6)
Next Z

Portc = Nr_b(6)

For Z = 1 To Wb(7)
Next Z

Portc = Nr_b(7)

For Z = 1 To Wb(8)
Next Z

Portc = Nr_b(8)

Return
'-------------------------------------------------------------------------------
'------- ENDE
'-------------------------------------------------------------------------------
End

---

Jeder Servo um 1° einstellbar
Du kannst auch anstatt "0 ...180" => 0...217 benutzen. Aber 0..180 war mir lieber ;P

mfg

jipp die sontroller solltens tun..

also wie gesagt, ich bin ein richtiger Anfänger, was ich schon gemacht habe ist mit dem RP6 und seiner Library rumspielen...

Wenn ich jetz den gleichen µC wie beim RP6 verwende kann ich theoretisch glaube ich sogar die enthaltene Library verwenden

Ich werd das mit dem Software PWM dann mal durcharbeiten und hoffe, es zu verstehen...


MfG Pr0gm4n

hi,

für die Servoansteuerung kannst du auch nen SD20 http://www.roboter-teile.de/datasheets/sd20.pdf
nehmen. Das ist n vorprogrammierter PIC und den kann man auch über I²C ansteuern. Das ist, finde ich, das einfachste, denn die Beschaltung ist n Kinderspiel und du kannst bis zu 20 Servos steuern. Allerdings solltest du für die Servos und die Elektronik auf jeden fall getrennte Spannungsversorgungen einrichten.

Gruß
Jigger

Dazu eine Frage: Was kostet der und wo bekommt man den alleine, nicht auf einem Board?

Bisher hab ich ihn immer nur als Servoboard gesehen und da iss er mir etwas über dem Budget...


Da ich mir auch eigene RC-Fernsteuerungen bauen will, muss ich das mit dem PWM sowieso lernen...



MfG Pr0gm4n

ich habe den hier her http://www.roboter-teile.de/Shop/the...id=17&source=1

Ok, der ist mir ein kleines bisschen zu teuer, ich kann meine 10 Servos auch für 2,70€ und etwas programmierarbeit steuern...


MfG Pr0gm4n

jo mach das ohne so seltsame boards, die sind immer teuer, können viel was man nicht braucht und das was man brauct auch nich besser als ne kleine eigenbauschaltung

Jojo, meine Meinung!!

Ich hab da so eine Idee wo ich gerne wissen würde, was ihr davon haltet:

Ich will ein altes CD-Laufwerk umbauen, sodass dann eine Platine, die so ungefähr das kann, was das STK 500 von ATMEL kann (bisschen weniger), herausfährt und man nur noch den µC einstecken muss und losproggen kann...


wär doch ne geile Idee, oder?

Wenns klappt vielleicht noch eins, bei dem dann so Sachen wie Druckerport, Gameport und halt lauter so gut verwendbare Schnittstellen rausgeleitet werden

Wenn mein Mainboard die nich hat, kann ich mir die dann auch anders hinmachen, also quasi so aber dann selber irgendwie verbinden?


MfG Pr0gm4n


PS: Meine Teileliste wurde jetzt eingeschickt, jetzt muss ich auf positive Antwort warten...

das is sicher machbar, und sieht stilish aus :) musst du dann aber ne ic halternung nehmen, die man öffnen kann, so wie auf den programmern drauf... :)

jojo, kann man diese IC-Fassungen nichmehr aufmachen?

beim STK 500 sind doch auch welche drauf, oder?

Ich lass mir halt nen eigenen Programmer ätzen und kauf die Bauteile, mal schauen ob das hinhaut...

Glaubt ihr, da gibt es auch andere Interressenten? Ich könnte das dann so als Bausatz und auch fertig bei ebay oder im RN anbieten... (nur halt ganz kleiner zuschlag für das CADden der Platine)


naja egal, geht das mit den zusätzlichen Steckern auch? also ich will dann z.B. sowas wie den Druckerport direkt als RS-232 hinzumachen oder einzelne Pins, die man ansteuern kann rein und so halt alles

also auch so eine Art Missbrauch als Stromquelle



MfG Pr0gm4n

Hi,

ich hab heut erfahren dass meine be********* Lehrerin, die das Jugend forscht leitet das immernoch nicht abgeschickt hat und jetz hat sie auch noch die Teileliste verloren...


Ich muss sie jetz eh neu machen und bin jetzt auf das hier gestossen:

http://www.pollin.de/ (sucht mal nach FUNKMODUL)


Gehn die auch anstatt von den RN-Funk-boards? das wär nämlich super, das käme vieeeeeeel billiger

kann ich die genauso an das RN-Funk selber anschliessen?

kann man die auch so leicht an PC anschliessen?


Sorry, viele Fragen aber...


das mit dem Laufwerk muss vorerst warten, ich will bald eh neuen PC, dann hab ich 2 Laufwerke zur Verfügung zum basteln


MfG Pr0gm4n

also mit dem rn funk sind sie nich kompatibel aber wenn du die komplette funkstrecke mit den dingern aufbaust sollte das kein problem sein..

Ok, das iss dann schonmal sehr gut, da ich dringend billigeren Ersatz für RN-Funk mit Modul brauche

Wie siehts damit aus: (?)

Zitat:

---

kann man die auch so leicht an PC anschliessen?

---

Ich hoffe es, das wär echt super...

Antenne brauche ich da wohl keine dazu, oder?

Wie siehts bei denen mit programmieren über Funk aus? ich mein da steht doch was von wegen Reset-Pin und so, wäre echt das allerbeste dann


MfG Pr0gm4n

PS: goara ich hab deinen quadrocopter-Thread jetz auch schon die ganze Zeit im auge, glaubst du man könnte diese CFK-Platten von ner CNC Fräsen lassen?

hmm und sowas ?
http://www.rev-ed.co.uk/docs/axe031.pdf
https://www.roboternetz.de/phpBB2/viewtopic.php?t=36164