-         

Seite 1 von 2 12 LetzteLetzte
Ergebnis 1 bis 10 von 11

Thema: Kann mir jemand auf die Sprünge helfen RC- Kanalschalter mit Nano

  1. #1
    Neuer Benutzer Öfters hier
    Registriert seit
    18.07.2015
    Ort
    Bayern
    Beiträge
    17

    Kann mir jemand auf die Sprünge helfen RC- Kanalschalter mit Nano

    Anzeige

    Hallo liebe Gemeinde,
    ich würde mich sehr freuen wenn mir jemand auf die Sprünge hilft. Bin Neuling auf dem Gebiet und versuche mich am Programmieren.(Leider auch mit Hilfe)
    Ich habe einen Kanalschalter im Netz gefunden den ich für mein Projekt umgewandelt hab.
    Er soll mit einem Schalter der Fernbedienung funktionieren, dabei zählt er die Schalterbetätigungen und addiert sie bis 7. Hat er 7 Schaltzustände erreicht setzt er alle Ausgänge auf 0.
    Der Aufbau funktioniert bei mir leider nur an Kanal 1, ich komm nicht drauf warum der nächste Kanal nicht geschaltet wird.

    Danke für eure Hilfe

    Hier noch der Sketch den ich verwende

    Code:
    //Bibliotheken laden
    //#include "Servo.h"
    #include "makros.h"
    #include "debug.h"
    //#define USE_TIMER_5
    #include "RCReceive.h"
      
    //Globale-Variablen Deklarieren  
    const int AusgabePin[]={7,8,9,10,11,12}; //die 6 Ausgabepins festlegen für die Schaltkanäle
    boolean Anaus[]={LOW,LOW,LOW,LOW,LOW,LOW,LOW}; //Variablen zum Schaltstatus der Kanäle auf LOW deklarieren
      
    int i=0;//Zählervariable für schleifen
    
    //Zeitmanagemant
    unsigned long StartZeit=millis();//Zeitsteuerungsvariable zum Schaltintervall berechnen
    unsigned long VergleichZeit=0;//Zeitsteuerungsvariable zum vergleichen mit SartZeit
    //unsigned long StartZeitKopf=millis();//Zeitsteuerungsvariable zum Schaltintervall berechnen
    //unsigned long VergleichZeitKopf=0;//Zeitsteuerungsvariable zum vergleichen mit StartZeitKopf
      
    unsigned long zaehlerZeit=millis();//Zeitsteuerungsvariable zum zurücksetzen fals die Timeout Zeit errecht wird
    unsigned long Vergleichzaehler=0;//Zeitsteuerungsvariable zum vergleichen mit zaehlerZeit
    boolean w=LOW;//Schaltvariable zum Timeout
    
    //Pinbelegung RC-Kanäle
    const byte PIN_RC = 3;//Variable Empfängerkanal Pin festlegen Kanal 1 Taster
    
    byte rcSignal;// Variable für das Empfängersignal 1 Steuert den Multiswitch
    
    int Kanalzaehler = 0;// Zähler für den zu schaltenden Kanal
    int Schaltwert = 210;// wert ab dem der Zähler erhöht wird. Vergleicht den rcSignal wert ist der Signalwert höhe...
    int schaltzeitk = 80;//kurze schaltzeit ca. eine 10.tel sec zum entprellen
    int schaltzeitl =550;//Lange schaltzeit dreiviertel Sec. zum schalten eines ausganges
    int timeout = 10000;// Timer zum zurücksetzen des Schaltbildes
    int Schaltwertver=0;
      
    int t=0;//Schleifen Zählervariable
    int a=0;//
    int Langeschaltzeit=0;//Prüfvariable ob die Schaltzeit über schaltzeitl gewesen ist
    
    // Der Empfänger
    RCReceive rcKanal1;//Objekt Kanal 1 festlegen Taster
    
    void setup()
    {
      rcKanal1.attachInt(PIN_RC);//Objekt Kanal 1 an Pin binden Switch
      
      pinMode(AusgabePin[0],OUTPUT);//Ausgabepins für die Schaltfunktionen deklarieren
      pinMode(AusgabePin[1],OUTPUT);
      pinMode(AusgabePin[2],OUTPUT);
      pinMode(AusgabePin[3],OUTPUT);
      pinMode(AusgabePin[4],OUTPUT);
      pinMode(AusgabePin[5],OUTPUT);
      //randomSeed(analogRead(0));
      Serial.begin(9600);//Serielle Übertragung durch Kommentar ausgeblendete ist nur zu Kontrollzwecken
    }
      
    void loop()
    {
    //Empfänger überwachen
    if (!rcKanal1.hasError())
      {
       doWork(); // aurufen der "Arbeits-Routine"
      }
      else if (rcKanal1.hasError())  // bei Empfangsproblemen dagegen
      { 
       failSave(); // wird die Failsave-Routine gestartet
      }
    }
    //-------------------------------------------------------------------------------
    //      01 Funktion Arbeit
    //-------------------------------------------------------------------------------
    void doWork()
    {
      rcSignal = rcKanal1.getValue(); // den Empfänger auslesen
      
      Serial.println("anfang:");//Serielle übertragung ausgeblendet
      Serial.println(rcSignal);
      
      //-------------------------------------------------------------------------------
      //      Timeout
      //-------------------------------------------------------------------------------
      if (w==HIGH)//wenn der Timout bereits gstartet ist wird Die Schaltsequenz zurück gesetzt, sofern die Bedingungen erfüllt sind
      {
        Vergleichzaehler=millis()-zaehlerZeit;//Laufzeit des Timout vergleichen
        if (Vergleichzaehler>timeout)
        {
         Kanalzaehler=0;
         a=0;//Kurze schaltzeit für den Kanalzähler zurücksetzen
         Langeschaltzeit=0;//Kanal Schalten zurücksetzen
         StartZeit=millis();// Startzeit neu setzen
         w=LOW;
        }
      }
      //-------------------------------------------------------------------------------
      //      Empfangsignal1 auswerten
      //-------------------------------------------------------------------------------
      if (rcSignal < Schaltwert)//wenn das ausgelesene Empfängersignal kleiner als der schaltwert ist
      {
       if (w==LOW)//ist es der erste schaltvorgang?
       {
         w=!w;//w HIGH setzen
         zaehlerZeit=millis();//Timeout Zeit starten
       }
    
    
       multiswitch();//aufrufen der multiswitch-Routine
       if (Langeschaltzeit==1)//wenn der Schaltimpuls lang war...
       {
         Kanalschalten();}//aufrufen der Kanalschalten-Routine
       }
       else//Werte zurücksetzen wenn das RC-Signal1 nicht in schaltposition ist
       {
        a=0;//Kurze schaltzeit für den Kanalzähler auf null setzen
        Langeschaltzeit=0;//Kanal Schalten auf null setzen
        StartZeit=millis();// Startzeit neu setzen
       }
    }
    //-------------------------------------------------------------------------------
    //      02 Funktion multiswitch zum auslesen des Schaltbildes
    //-------------------------------------------------------------------------------
    void multiswitch()
    {
      VergleichZeit=millis()-StartZeit;//wieviel zeit ist seit dem letzten zurücksetzen der Werte vergangen
      if (VergleichZeit > schaltzeitk)//ist die schaltzeit über der kurzen Schaltzeit??
      {
       if (a==0)// Wird diese schleife zum ersten mal durchlaufen ??
       {
         a=1;//wird auf 1 gesetzt damit der Kanalzäler nur einmal pro Schalterbewegung erhöht wird
         Kanalzaehler++;//den Kanalzähler (Ausgang) um 1 erhöhen
         if (Kanalzaehler>7)//Wenn der Kanalzäler größer als 7...
         {
           Kanalzaehler=0;}// ...ist wird er auf 0 zurückgesetzt
         }
         if (VergleichZeit > schaltzeitl)//Wenn die Schaltzeit lang war
         {
           Langeschaltzeit=1;//wird auf eins gesetzt damit ein Kanal geschaltet wird
           Anaus[Kanalzaehler-1]=!Anaus[Kanalzaehler-1];//Schaltzustand toggeln
         }
       }
    Serial.println(Langeschaltzeit);
    Serial.println(Kanalzaehler);
    }
    //-------------------------------------------------------------------------------
    //      03 Funktion Ausgabekanal schalten
    //-------------------------------------------------------------------------------
    void Kanalschalten()
    {
      //Schaltet einen Kanal an bzw. aus
      switch(Kanalzaehler)
      {
      case 1:// Schaltet Kanal 1
        digitalWrite (AusgabePin[0],Anaus[0]);
      break;
      case 2:// Schaltet Kanal 2
        digitalWrite (AusgabePin[1],Anaus[1]);
      break;
      case 3:// Schaltet Kanal 3
        digitalWrite (AusgabePin[2],Anaus[2]);
      break;
      case 4:// Schaltet Kanal 4
        digitalWrite (AusgabePin[3],Anaus[3]);
      break;
      case 5:// Schaltet Kanal 5
        digitalWrite (AusgabePin[4],Anaus[4]);
      break;
      case 6:// Schaltet Kanal 6
        digitalWrite (AusgabePin[5],Anaus[5]);
      break;
      case 7:// Wenn der Kanalzähler auf 7 steht werden alle Kanäle ausgeschaltet
       digitalWrite (AusgabePin[0],LOW);
       digitalWrite (AusgabePin[1],LOW);
       digitalWrite (AusgabePin[2],LOW);
       digitalWrite (AusgabePin[3],LOW);
       digitalWrite (AusgabePin[4],LOW);
       digitalWrite (AusgabePin[5],LOW);
       //Anaus[0]=LOW;
       
      break;
    }
    
    Kanalzaehler=0;//setzt den Kanalzähler nach dem Schalten eines Kanals zurück
    w=LOW;//Timeout zurücksetzen
    }
    //--------------------------------------------------------------------------------------
    // 08 Funktion FailSave Kanal 1 wird eigentlich nicht gebraucht sieht aber wichtig aus
    //--------------------------------------------------------------------------------------
    void failSave()
    {
    //Blinksignal des Scheinwerfer zur Erkennung das ein Fehler mit dem Empfänger vorliegt
      for (int i=0; i<5; i++)
      {
        digitalWrite(13,HIGH);
        delay(50);
        digitalWrite(13,LOW);
        delay(50);
      }
    }
    Geändert von radbruch (13.01.2016 um 12:19 Uhr) Grund: Code-Tag eingefügt

  2. #2
    Erfahrener Benutzer Roboter Genie Avatar von Rabenauge
    Registriert seit
    13.10.2007
    Ort
    Osterzgebirge
    Alter
    49
    Beiträge
    1.241
    Ich denke, ich hab es:

    if (a==0)// NUR dann!
    {
    a=1;//wird auf 1 gesetzt , UND wo wird a jemals zurück gesetzt?
    Kanalzaehler++;//den Kanalzähler (Ausgang) um 1 erhöhen
    if (Kanalzaehler>7)//Wenn der Kanalzäler größer als 7...
    {Kanalzaehler=0;}// ...ist wird er auf 0 zurückgesetzt
    }

    Ich habe nichts gefunden, wo a jemals wieder zurückgesetzt wird.
    Damit ist a nach dem allerersten Durchlauf für _immer_ 1, und somit wird nichts mehr getan in dem Teil.
    Unabhängig davon, dass ich den Sinn von a nicht wirklich verstehe (hab das ganze Programm allerdings auch nur überflogen), solltest du dann weiter unten in dem switch/case-Teil zumindest jedes mal (oder einmal, am Schluss) a auch wieder auf 0 setzen.

    Nebenbei bemerkt: Die Failsave-Routine ist "unfein" gelöst- delay() sollte man nur benutzen, wenn es gar nich anders geht.
    Zum blinken gibt es ein wunderschönes Beispielprogramm namens BlinkWituotDelay- schau dir mal an, wie man sowas _richtig_ macht.
    Und: ich glaub, insgesamt ist dein Progrämmchen nicht soo clever gelöst- oder willst du, dass die Schaltfunktionen, wenn du den Schalter längere Zeit AN lässt, der Reihe nach eingeschalten werden?
    Ich würds anders lösen: bei jedem Mal EINschalten wird eine Stelle weiter gerückt. Dabei wird alles verriegelt, bis wieder AUSgeschalten wurde.
    So kannst du ohne jede Zeitverzögerung (naje, minimale) jeden Schaltzustand einzeln aufrufen, in dem du einfach oft genug den Schalter betätigst.
    Aber ist natürlich Ansichtssache-würde jedoch das ganze Getüdele mit den Zeiten völlig ersparen.
    Grüssle, Sly
    ..dem Inschenör ist nix zu schwör..

  3. #3
    Neuer Benutzer Öfters hier
    Registriert seit
    18.07.2015
    Ort
    Bayern
    Beiträge
    17
    Hallo Sly,

    Danke für deine Antwort. Ich hab es auch bemerkt das der Kanalzaehler nicht zurück gesetzt wird. Ich hab das "Kanalzaehler=0;//setzt den Kanalzähler nach dem Schalten des letzten Kanals zurück" vor das "break" gesetzt. Hab den Sketch jetzt am laufen.
    Mit dem Failsafe muss ich dir recht geben, da bin ich noch dran.
    Wie meinst du das mit dem verriegeln und weiterschalten?
    So wie es jetzt läuft schalten nacheinander die einzelnen Schalter .
    Bin noch am probieren wie ich es so schalten kann das wenn der nächste Kanal geschalten wird der vorhergehende ausgeschaltet wird.
    Die beste Lösung wäre, einmal kurz schalten Kanal ein und beim nächsten Kanal aus. Oder einmal lang schalten und der Kanal geht an und bleibt auch beim weiterschalten an.
    Das ist mir aber nicht klar wie ich das mit der Zeitabfrage lösen kann.

  4. #4
    Erfahrener Benutzer Roboter Genie Avatar von Rabenauge
    Registriert seit
    13.10.2007
    Ort
    Osterzgebirge
    Alter
    49
    Beiträge
    1.241
    Was du möchtest, ist relativ einfach zu lösen:

    Du setzt einfach in die case-Anweisungen sowas:

    case 1: schalte1An;
    schalte 2,3,4,5,6,7,aus;
    break;
    case 2: schalte2An;
    schalte 1,3,4,5,6,7, aus
    break;

    ODER du setzt bei jedem Aufruf von KanalSchalten zuerst alle Ausgänge zurück und aktivierst dann nur den gewünschten.
    Hierbei würde ich dafür sorgen, dass die Routine überhaupt nur aufgerufen wird, wenn sich ein neuer Zustand ergibt, also den aktuell gewälten Kanal speichern:

    if (geschaltenerKanal!=geschaltenerKanalAlt)
    {kanalSchalten;}

    und am Ende von kanalSchalten setzt du kanalAlt auf den aktuellen Wert:
    geschaltenerKanalAlt=geschaltenerKanal

    Die Geschichte, dass du einzelne Kanäle dauerhaft an lassen kannst (indem du den Schalter länger an lässt) ist etwas schwieriger so hin zu bekommen, dass man sie auch wirklich ohne Nachdenken bedienen kann.
    Ich würd dafür nen zweiten Kanal dazu nehmen (wenn das vom Modell her _irgendwie_ geht):
    if (RcKanal1 an && RCKanal2 an)
    {setze BleibtAnFlag;}

    Das geht, indem du statt Boolean-Variablen einfach Integer benutzt.
    Dann können die Kanalvariablen beispielsweise 0, 1 und 2 annehmen, wobei die 2 dann der Marker ist: der bleibt an.

    Ich nehme an, du willst Beleuchtungen schalten?
    Das hab ich beim Seeteufel völlig automatisiert.
    Es gibt nen Helligkeitssensor an Bord. Wenn es "dunkel genug" wird, wird die Lichterführung aktiviert, und zwar (es ist nen Schlepper) je nachdem, ob vorher Leinen aus- oder abgeworfen wurden. Ansonsten eben nur normale Positionslichter nach Vorschrift.
    Darum brauch ich mich überhaupt nicht mehr kümmern.
    Will ich mal, zum angeben, auch im Hellen mit Beleuchtung fahren, stülp ich einfach nen Käppchen über den Lichtsensor, dann glaubt er, es ist dunkel.
    Geändert von Rabenauge (14.01.2016 um 11:59 Uhr)
    Grüssle, Sly
    ..dem Inschenör ist nix zu schwör..

  5. #5
    Neuer Benutzer Öfters hier
    Registriert seit
    18.07.2015
    Ort
    Bayern
    Beiträge
    17
    Hallo Sly
    Danke für dein Tip. Ich hab es mal in den Sketch reingeschrieben und probiert.
    "case 2:// Schaltet Kanal 2 ein, Kanal 1 aus
    digitalWrite (AusgabePin[1],Anaus[1]);
    digitalWrite (AusgabePin[0],LOW);
    break;"
    Funktioniert! Ich denke ich brauche nur immer den vorherigen Kanal ausschalten denn die anderen sind ja aus.
    Das blinken im Failsafe hab ich geändert nach deiner Anregung.
    Wieviel Case Schalter kann ich eigentlich mit dem Nano nutzen? Gibt es da eine Begrenzung? Ich habe noch ein 8 fach Relaismodul daliegen und würde das gern nutzen. Hab schon probiert den Max des Kanalzaehlers hochzusetzen aber es funktionierte nicht ( AusgabePins hatte ich angepasst).

    Die Idee mit dem 2 RC Signal ist mir auch schon gekommen, aber ich hab nur eine 6 Kanalanlage und da will ich das beste daraus machen. Ich hab jetzt 2 dieser Nano's geplant um jeweils 6 Kanäle extra zu schalten, ich weiss es ist nicht die beste Lösung aber so kann ich meine beiden Schalter am besten nutzen. Da hab ich dann 12 Kanäle zum schalten von Licht, Sound und Rauch bzw. Startsignal für meinen Kran. Ich baue die Calypso und hab dort den Kran für die Tauchtasse funktionsfähig gemacht. Die Tauchtasse schaltet die Beleuchtung erst ein wenn sie von ihrem Platz an Bord weggehoben wird. Desweiteren gibt es ja einiges an Beleuchtung wenn zB. die Tauchtasse im Wasser ist (Manovrierunfähig-Taucher im Wasser usw.). Ankerwinde ist noch in der Planung. Soundmodul wird auch von einem Nano gesteuert. Aber immer eins nach dem anderen abarbeiten dann hat man immer etwas zum basteln. Irgendwie kriege ich meine Schiffe nie fertig, mir fällt immer wieder was zum nachrüsten ein. Meine Kenntnisse im programmieren sind leider begrenzt, bin Schlosse von Beruf mit elektrischen Verständniss, so würde ich es beschreiben.
    Danke nochmal und freue mich auf weitere Tips

  6. #6
    Benutzer Stammmitglied
    Registriert seit
    19.05.2015
    Beiträge
    69
    Hallo,

    eigentlich sollte doch ein Nano ausreichen.
    Du kannst die Pins 4-13 und A0-A5 als digitale Ausgänge verwenden, also 16. Allerdings müßtest Du bei Pin 13 wegen der Stromstärke aufpassen, weil da bereits ein LED dranhängt und dann mit Strom zieht.
    Auch wenn Du mehrere Sachen an schaltest, solltest Du gucken, daß Du die zulässige Gesamtstromstärke des Chips nicht überschreitest, die weiß ich leider nicht aus dem Kopf.

    Vielleicht noch ein anderes mögliches Bedienkonzept: Nachdem Du Deine Anlage und den Nano eingeschaltest hast, prüft er ob beide Schalter in einer bestimmten Ausgangposition sind. Wenn nicht, macht er solange "Radau" bis beide z.B. unten stehen.
    Mit einem schaltest Du dann den Kanal mit jedem Toggle einen weiter und mit dem anderem toggelst Du dessen Zustand. Wenn ich die Lib richtig verstehe, solltest du den anderen RC-Kanal an Pin zwei mit einer zweiten RCReceive Variable hängen und verarbeiten können. Nur so als Idee...

    Gruß

    Chris

  7. #7
    Erfahrener Benutzer Robotik Visionär Avatar von oberallgeier
    Registriert seit
    01.09.2007
    Ort
    Oberallgäu
    Beiträge
    7.551
    .. eigentlich .. Nano ausreichen .. bei Pin 13 wegen der Stromstärke aufpassen, weil da bereits ein LED dranhängt und dann mit Strom zieht ..
    Hmmm. Ich finde solche allgemeine Aussagen nicht immer hilfreich, ne Messung wäre besser: mein nano-Clone als board-alone zieht am Labornetzteil bei 8,9 V VIN mit LED/PB5 on 23 mA und mit LED/PB5 off 19 mA. Mangels anderer Anschlüsse bei der Messkonfiguration lässt sich nun der Bedarf der LED im on-Zustand recht genau nennen.

    .. zulässige Gesamtstromstärke des Chips nicht überschreitest, die weiß ich leider nicht aus dem Kopf ..
    Ooch, die ist kein Geheimnis, steht im Datenblatt unter Absolute Maximum Ratings (und sogar in meinem Kopf)x:
    DC Current per I/O Pin . . . . . . . . . . . . . 40.0mA
    DC Current VCC and GND Pins. . . . . . . . 200.0mA
    Geändert von oberallgeier (15.01.2016 um 10:16 Uhr) Grund: Datenblattlink zugefügt
    Ciao sagt der JoeamBerg

  8. #8
    Erfahrener Benutzer Roboter Genie Avatar von Rabenauge
    Registriert seit
    13.10.2007
    Ort
    Osterzgebirge
    Alter
    49
    Beiträge
    1.241
    Bodo, du kannst ohne weiteres die 12 Kanäle mit _einem_ Nano schalten. Auch 64, wenn du willst.
    Dazu nimmt man einfach ein Schieberegister (auch: Portexpander), dann brauchst du drei Pins, hast aber schonmal acht Ausgänge daraus gemacht. Das wirklich tolle ist: man kann die Dinger kaskadieren, d.h. einfach hinter einander schalten. So sind selbst 32 Ausgänge mit den drei Pins kein Problem.
    http://fritzing.org/projects/cat-leds
    Hier wird das recht anschaulich dargestellt.
    Im Seeteufel habe ich das auch so gemacht (allerdings mit zusätzlichen Treiber-Transistoren hinter den Ausgängen, da das im Bild gezeigte nur noch mit LOW-Current-LED's gemacht werden sollte wegen der Stromaufnahme), dort steuert letztendlich ein solcher Baustein den gesamten Christbaum an den Masten, und das Radar auch noch.
    Die Portexpander kosten Pfennige, die Transistoren und Widerstände auch...
    Auch die Ansteuerung ist nicht weiter kompliziert:
    https://www.arduino.cc/en/Reference/ShiftOut
    Man erzeugt einfach das passende Bitmuster (z.B. 00010000 wenn Kanal 4 an sein soll oder 11000000 für Kanäle 1 und 2), und schickt es raus, wie im Link beschrieben.
    Durch diese Vorgehensweise kann man das so aufbauen, dass jedes Licht (Lämpchen, LED, was auch immer) an einem Ausgang des Portexpanders hängt. Nun kann man ganz beliebige Lichtmuster erzeugen, indem man einfach für die Ausgänge, die man gerade braucht, ne 1 raus schickt. Auch mal den ganzen Christbaum als Lauflicht nehmen, geht damit, oder irgendwelche Lampen blinken lassen, wenn der Akku leer wird.
    Einziger Nachteil: die Lichter dimmen geht nur, wenn man alle zusammen dimmt.

    Was switch/case angeht: ich weiss nicht, was der Compiler sagt, aber in der Arduino-Referenz find ich nix über irgendwelche Limits. Ich selbst hab da bestimmt schon mehr als 10 Auswahlmöglichkeiten benutzt, kein Problem.
    Wahrscheinlich ist das Limit der verfügbare Speicher.

    Was deine sechs Kanäle angeht: ich hab auch nicht mehr auf der MX. Das einzige, echte Problem isses immer, das Ganze so zu entwerfen, dass es "bedienbar" bleibt, d.h. man nach nem Jahr auch noch weiss, "wie das denn ging".
    Daher hab ich mir z.B. eben die Bleuchtungssteuerung komplett vom Hals geschafft- es gibt keinerlei Grund, sowas von Hand zu steuern.
    Es wird immer irgend ein Fahrzustand dargestellt. Du könntest z.B., wenn das Miniuboot am Haken hängt (dann ist der Kran in Betrieb, das kann der Arduino leicht detektieren) automatisch die Lichter für "manövrierbehindert" setzen oder so.
    Gerade bei nem Schiff mit recht vielen Funktionen hat man auch so genug zu tun....
    Beim Seeteufel zum Beispiel gehen automatisch die Schlepplichter an, so wie eine der Leinen ins Wasser geworfen wird. Und auch wieder aus, wenn ich die Leine abwerfe.
    Für den ganzen Sermon brauche ich- überhaupt keinen Kanal.
    Aber man kann noch mehr machen- zum Beispiel wird es kaum Sinn machen, einen Kran zu drehen, wenn er den Arm nicht zumindest minimal angehoben hat (oder wenigstens den Haken), so kann man einiges an Kanälen sparen. Ich bediene vier Servos (und damit vier Funktionen) mit "nem Rest von zwei Kanälen"- so, dass mir die Kanäle trotzdem noch für andere Funktionen zur Verfügung stehen.

    Mein Bordrechner (ist allerdings ein Mega 2560) erledigt noch andere Dinge- er überwacht z.B. die Akkus und auch den Rumpf auf Wassereinbrüche. Wenn ich mal Lust haben werd, bau ich das noch weiter aus, ich will ne echte Drive-by-wire-Steuerung haben, bei der der Rechner meine Steuerkommandos lediglich richtig interpretiert und passend umsetzt. Das bietet dann z.B. Möglichkeiten wie nen Kreisel einzubauen, damit das Ding bei Steuerkommando "Ruder geradeaus" auch wirklich ganz gerade fährt.
    Oder auch präzises Manövrieren rückwärts- das ist per Hand beim Seeteufel sehr schwierig.
    Grüssle, Sly
    ..dem Inschenör ist nix zu schwör..

  9. #9
    Erfahrener Benutzer Robotik Einstein
    Registriert seit
    09.10.2014
    Beiträge
    2.431
    man kann an einen Nano auch einfach einen 2. Nano (oder auch Mega) per I2C dran hängen, schon kann man mit 2 pins (A4+A5 für i2c, IIRC) sämtliche Pins des 2. Arduinos ebenfalls abfragen. Da man I2C kaskadieren kann und Arduinos ihre Slave-addr-ID selber festlegen können, kann man sogar über 100 zusätzliche Arduinos mit allen ihren Pins alle mit diesen 2 Nano-Master-Pins abfragen. Was will man mehr? (Das finde ich auch sogar noch viel einfacher als die Schieberegister!)
    ·±≠≡≈³αγελΔΣΩ∞ Schachroboter:www.youtube.com/watch?v=Cv-yzuebC7E Rasenmäher-Robot:www.youtube.com/watch?v=z7mqnaU_9A8

  10. #10
    Erfahrener Benutzer Roboter Genie Avatar von Rabenauge
    Registriert seit
    13.10.2007
    Ort
    Osterzgebirge
    Alter
    49
    Beiträge
    1.241
    Das ist keineswegs einfacher.
    Du musst nämlich auf jeden einzelnen eine eigene Software aufspielen.
    Hier (wo es lediglich darum geht, ein paar Ausgänge mehr zu schalten) wäre das mit Kanonen auf Spatzen geschossen.
    Bodo bezeichnet sich selbst als Anfänger!
    Nen Schieberegister beschreiben ist dagegen weit simpler- das einzig komplizierte ist es da, die richtigen Bitmuster zu bilden, wenn man denn auch kompliziertere braucht.
    Ähnliche Daten musst du auch nem zweiten Board schicken, aber nebenbei die Adressierung im Auge behalten und- du brauchst ne Bibliothek, die bei Schieberegistern nicht nötig ist.
    Insofern die einfachere und sparsamere Methode, in jeder Hinsicht.
    Einzige Ausnahme: jemand lötet nich gerne...aber Bodo ist Modellbauer, die machen das.
    Grüssle, Sly
    ..dem Inschenör ist nix zu schwör..

Seite 1 von 2 12 LetzteLetzte

Ähnliche Themen

  1. Kann mir jemand helfen???
    Von Nasume2 im Forum Allgemeines zum Thema Roboter / Modellbau
    Antworten: 4
    Letzter Beitrag: 02.01.2012, 22:15
  2. Kann mir jemand helfen
    Von Stinker196 im Forum Allgemeines zum Thema Roboter / Modellbau
    Antworten: 1
    Letzter Beitrag: 23.11.2008, 19:26
  3. kann mir jemand helfen???
    Von xbgamer im Forum Basic-Programmierung (Bascom-Compiler)
    Antworten: 7
    Letzter Beitrag: 22.10.2006, 16:07
  4. kann mir da mal jemand helfen ??
    Von LC-HC im Forum C - Programmierung (GCC u.a.)
    Antworten: 8
    Letzter Beitrag: 10.02.2006, 01:04
  5. [ERLEDIGT] Kann jemand Helfen ????
    Von im Forum Controller- und Roboterboards von Conrad.de
    Antworten: 4
    Letzter Beitrag: 27.02.2004, 20:41

Berechtigungen

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