outdoor I

[Moppi]

Löten mit Zugentlastung (die auch das Abknicken des Kabels direkt an der Lötstelle verhindert), halte ich auch für besser. Bei Ministeckern ist das u.U. nicht möglich, bei zu dicken Kabeln auch nicht. Aber das mag jeder nach Erfahrung tun, wie er möchte. Ich verwende immer die fertigen Kabel mit diesen Dupont-Steckern. Leider leiern die Stecker meist schnell aus und sitzen wackelig.


MfG

[inka]

Kabel mit diesen Dupont-Steckern. Leider leiern die Stecker meist schnell aus und sitzen wackelig.

man kann die metalischen viereckigen hülsen auch mal vorsichtig (mit einer pinsette z.b.) etwas zudrücken - dann halten sie auf den stiften wieder besser. Habe ich eben wieder gemacht - den kontakt in die pinsette rein und an den spitzen zusammendrücken, so hat man mehr gefühl beim zusammendrücken...

[Moppi]

Ich hab den Dreh noch nicht raus, wie man die Hülsen runter bekommt.

MfG

- - - Aktualisiert - - -

Mit einem Stecker habe ich es nun hinbekommen, die feinen Nasen sind sehr instabil und nicht dafür gedacht, zurückgebogen zu werden.

[inka]

mit der spitze eines (kleinen!) teppichmessers seitlich eingreifen und sachte rausbiegen, dabei mit der dritten hand an der litze ziehen

[inka]

nach dem tausch des MEGA bin ich jetzt auf dem entwicklungsstand vor dem umbau auf die version mit der RAMPS-platine, das fahren mit IR-fernbedienung wie auch mit dem smartphone funktioniert soweit...
Mit der verdrahtung bin ich (fast) zufrieden, die motorzuleitungen muss ich noch ein bischen ordentlicher verlegen, da warte ich aber noch auf die crimpzange aus china...


was mir nicht gefält, ist das anfahren der schrittmotoren, ist mir zu rucklig, habe dazu ein kurzes video gedreht. Im ersten part startet der motor rückwärts, direkt, ohne irgendwelchen zusatcode. Da ruckelts wie immer. Nach dem stop starte ich den motor vorwärts, mit einer zusatzbeschleunigung funktion. Da wird ein array eingelesen an der stelle der statischen delays in der ansteurungsroutine für die stepper. Hab vieles über die S-funktion" gelesen, habe die arraytabelle in zwei teile zerlegt, eine für die anfahrt, eine fürs abbremsen. Ob ich die für's abbremsen brauche, weiss ich noch nicht...
Was mir nun noch kopfzerbrechen bereitet ist der ruckler zwischen den anfahrbeschleunigungsroutine (die wäre an sich ok) und dem übergang zur normalen vorwärtsbewegung.
Nun der code, der hauptteil, da sind gleich am anfang auch die arrays fürs anfahren und abbremsen:

//LCD
#include <LCD.h>
#include <LiquidCrystal_I2C.h>

LiquidCrystal_I2C lcd(0x3F, 2, 1, 0, 4, 5, 6, 7, 3, POSITIVE);

int sinus_rauf [] =
{   0,  0,  0,  0,  1,  1,  1,  2,  2,  3,  4,  5,  5,  6,  7,  9,
   10, 11, 12, 14, 15, 16, 18, 20, 21, 23, 25, 27, 29 ,31, 33, 35,
   37, 39, 42, 44, 46, 49, 51, 54, 56, 59, 62, 64, 67, 70, 73, 76,
   78, 81, 84, 87, 90, 93, 96, 99,102,105,108,111,115,118,121,124,

  127,130,133,136,139,143,146,149,152,155,158,161,164,167,170,173,
  176,178,181,184,187,190,192,195,198,200,203,205,208,210,212,215,
  217,219,221,223,225,227,229,231,233,234,236,238,239,240,242,243,
  244,245,247,248,249,249,250,251,252,252,253,253,253,254,254,254,
}; //128

int sinus_runter [] = 
{
  254,254,254,254,253,253,253,252,252,251,250,249,249,248,247,245,
  244,243,242,240,239,238,236,234,233,231,229,227,225,223,221,219,
  217,215,212,210,208,205,203,200,198,195,192,190,187,184,181,178,
  176,173,170,167,164,161,158,155,152,149,146,143,139,136,133,130,

  127,124,121,118,115,111,108,105,102, 99, 96, 93, 90, 87, 84, 81,
   78, 76, 73, 70, 67, 64, 62, 59, 56, 54, 51, 49, 46, 44, 42, 39,
   37, 35, 33, 31, 29, 27, 25, 23, 21, 20, 18, 16, 15, 14, 12, 11,
   10,  9,  7,  6,  5,  5,  4,  3,  2,  2,  1,  1,  1,  0,  0,  0
}; //128


//resett pin definieren
#define PIN2RESET 10

// DIR und STEP pins definieren
#define dirPin_VL 28
#define stepPin_VL 26
#define dirPin_HL 55
#define stepPin_HL 54
#define dirPin_VR 34
#define stepPin_VR 36
#define dirPin_HR 61
#define stepPin_HR 60

//definiere enable pins:
#define enbl_VL 24
#define enbl_HL 38
#define enbl_VR 30
#define enbl_HR 56


//steps pro umdrehung definieren:
#define stepsPerRevolution 200 //1600



uint8_t taste = 0;

uint8_t s_vor = 0;
uint8_t s_rueck = 0;
uint8_t s_links = 0;
uint8_t s_rechts = 0;
uint8_t s_stop = 0;
uint8_t s_parken = 0;

uint16_t step_delay = 2000;


void setup()
{

  //LCD
  lcd.begin(16, 2);
  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.setBacklight(HIGH);
  lcd.print("outdoor FB switch");
  lcd.setCursor(0, 1);
  lcd.print("smartphone 1");
  delay(2000);
  lcd.clear();

  //pins als output:
  pinMode(dirPin_VL, OUTPUT);
  pinMode(stepPin_VL, OUTPUT);
  pinMode(enbl_VL, OUTPUT);
  pinMode(dirPin_HL, OUTPUT);
  pinMode(stepPin_HL, OUTPUT);
  pinMode(enbl_HL, OUTPUT);
  pinMode(dirPin_VR, OUTPUT);
  pinMode(stepPin_VR, OUTPUT);
  pinMode(enbl_VR, OUTPUT);
  pinMode(dirPin_HR, OUTPUT);
  pinMode(stepPin_HR, OUTPUT);
  pinMode(enbl_HR, OUTPUT);

  // deaktiviere enable pins:
  digitalWrite(enbl_VL, HIGH);
  digitalWrite(enbl_HL, HIGH);
  digitalWrite(enbl_VR, HIGH);
  digitalWrite(enbl_HR, HIGH);


  Serial1.begin(115200);
  Serial.begin(115200);


  //resett pin zustand definieren
  pinMode(PIN2RESET, INPUT);


  //resett pin aktivieren
  digitalWrite(PIN2RESET, HIGH);

}


void loop()
{
  if (Serial1.available())
  {
    taste = Serial1.read();
    Serial.println(taste);
    //    taste_neu = taste;
    delay(50);
    tasten_abfrage();
  }


  richtung_abfrage();
}

/***********************************************************/
void richtung_abfrage(void)
{
  if (s_rechts == 1) rechts_drehen();
  if (s_links == 1) links_drehen();
  if (s_vor == 1) vorwaerts();
  if (s_rueck == 1) rueckwaerts();
  if (s_stop == 1) alle_stepper_stop();
  if (s_parken == 1) parken();
}

/***********************************************************/
void tasten_abfrage(void)
{
  switch (taste)
  {

    case 116:// fahre vor - FB smartphone "t"
      {
//        beschleunigen();
        vorwaerts();
        break;
      }

    case 115:// fahre rückwärts - FB smartphone "s"
      {

        rueckwaerts();
        break;
      }

    case 100:// rotate rechts - FB smartphone "d"
      {
        rechts_drehen();
        break;
      }

    case 97:// rotate links - FB smartphone "a"
      {

        links_drehen();
        break;
      }

    case 49: //alle Stepper stop - FB smartphone "1"
      {

        alle_stepper_stop();
        break;
      }

    case 51: //parken - FB smartphone "3"
      {

        parken();
        break;
      }

  }

}
/***********************************************************/
void reboot()
{
  pinMode(PIN2RESET, OUTPUT);
  digitalWrite(PIN2RESET, LOW);
  delay(100);
}
/************************************************************/

hier ist die funktion für vorwärtsfahren:

void vorwaerts(void)
{
  if (s_vor == 0)
  {
    // enable pins aktivieren:
    digitalWrite(enbl_VL, LOW);
    digitalWrite(enbl_HL, LOW);
    digitalWrite(enbl_VR, LOW);
    digitalWrite(enbl_HR, LOW);

    //richtung bestimmen
    digitalWrite(dirPin_VL, LOW);
    digitalWrite(dirPin_HL, LOW);
    digitalWrite(dirPin_VR, HIGH);
    digitalWrite(dirPin_HR, HIGH);

    for (int i = 0; i < 127; i++)
    {
      digitalWrite(stepPin_VL, HIGH);
      digitalWrite(stepPin_HL, HIGH);
      digitalWrite(stepPin_VR, HIGH);
      digitalWrite(stepPin_HR, HIGH);
      delayMicroseconds(1750 + sinus_rauf[i]);
      digitalWrite(stepPin_VL, LOW);
      digitalWrite(stepPin_HL, LOW);
      digitalWrite(stepPin_VR, LOW);
      digitalWrite(stepPin_HR, LOW);
      delayMicroseconds(1750 + sinus_rauf[i]);
    }
    digitalWrite(stepPin_VL, HIGH);
    digitalWrite(stepPin_HL, HIGH);
    digitalWrite(stepPin_VR, HIGH);
    digitalWrite(stepPin_HR, HIGH);
    delayMicroseconds(step_delay);
    digitalWrite(stepPin_VL, LOW);
    digitalWrite(stepPin_HL, LOW);
    digitalWrite(stepPin_VR, LOW);
    digitalWrite(stepPin_HR, LOW);
    delayMicroseconds(step_delay);

    s_vor = 1;
    s_rueck = 0;
    s_links = 0;
    s_rechts = 0;
    s_stop = 0;
    s_parken = 0;
  }
  else
  {
    digitalWrite(stepPin_VL, HIGH);
    digitalWrite(stepPin_HL, HIGH);
    digitalWrite(stepPin_VR, HIGH);
    digitalWrite(stepPin_HR, HIGH);
    delayMicroseconds(step_delay);
    digitalWrite(stepPin_VL, LOW);
    digitalWrite(stepPin_HL, LOW);
    digitalWrite(stepPin_VR, LOW);
    digitalWrite(stepPin_HR, LOW);
    delayMicroseconds(step_delay);
  }
}

wie bekomme ich den ruckler beim vorwärtsfahren weg? Hab schon alles mögliche versucht, bisher leider ohne erfolg

[inka]

die richtigen räder sind endlich da, die steuerung damit ist - hauptsächlich beim drehen - noch ungewohnt, das vor- und zurück unproblematisch, beim seitlichen schieben so, wie ich es schon kenne. Habe ein video hier hochgeladen. Bin selbst überrascht über die "lebendigkeit" der bewegungen. Hätte ich so nicht erwartet...
ein solarpanel ist - zumindest mechanisch - eingebaut, erstmal fest, unter der durchsichtigen abdeckung. Elektrisch habe ich es noch nicht angeschlossen, weil es als 12V beschrieben und verkauft wurde, aber 19V in der einbausituation liefert...

[Klebwax]

weil es als 12V beschrieben und verkauft wurde, aber 19V in der einbausituation liefert...

Nun 12V heißt, sie soll einen 12V Bleiakku laden. Dazu brauchts rund 14V. Und 19V ist die Leerlaufspannung. Zusammen mit der eingebauten Diode, die das Entladen des Akkus im Dunkeln verhindert, kommen dann beim Laden so die 14V zusammen. Belaste die Zelle mal und miss Spannung und Strom. Da ist's ganz schnell vorbei mit den 19V.

MfG Klebwax

[Rabenauge]

Die Bewegungen sehen ziemlich cool aus.
Wieviel Schub liefern diese Räder ?

Ich meine, Steigungen usw....kann der damit überhaupt ernsthafte Steigungen hoch fahren?

[inka]

bei 25° ist er am oberen ende der rampe nach dem stopp zurückgerutscht:

https://www.youtube.com/watch?v=u-sE3guYhXE

bei 20° normal rauf und runtergefahren:

https://www.youtube.com/watch?v=t8sk6ldp5fI

das waren noch andere räder, mit kunststoffrollen, die schwarzen räder haben gummirollen, müsste also noch ein bischen besser werden.

[inka]

hab es unüberlegter weise in ein bereits erledigtes thema gepostet, hier , wohin es eigentlich hingehört, noch einmal zusammengefasst...
----------------------------------------------------------------------------------------------------------------------------------------------------------------

Ich mach alles in Zeitscheiben: es läuft ein simpler Timer (nach dem Beispielprogramm BlinkWithoutDelay), der mir, beispielsweise, jede Sekunde einen Tick gibt. Diese Ticks werden gezählt, so lange, wie ich halt Aufgaben zu vergeben habe, und bei jeder Tick-Zahl wird eine Aufgabe erledigt.
Danach wird der Tick-Zähler zurückgesetzt, und der ganze Zyklus geht von vorne los.
Auf diese Weise schafft so ein kleiner Arduino erstaunlich viel.....es ist z.B. vollkommen unnötig, den Akku alle paar Millisekunden abzufragen, im XPlorer mache ich das nur alle 20 Sekunden, das genügt völlig, und ich hab 19 Sekunden, auf die ich andere Aufgaben verteilen kann.
Diesen Timer kann man beliebig langsam (oder schnell, der könnte auch Zehntelsekunden oder hundertstel) ticken lassen, so kann man z.B. auch sicherstellen, dass US-Sensoren sich nie gegenseitig in die Quere kommen (Echos abklingen lassen) usw.
Unglaublich einfach und unglaublich flexibel.
Da steht natürlich in Wirklichkeit noch bisschen Kleinkram drin (man sollte sicherstellen, dass der Arduino beim "Lies Akkustand-Tick" nicht 152x den Akku ausliest, usw. aber das Prinzip ist ganz einfach.

Hi Sly,
ich lerne neue sachen (auch simple timer ) gerne aus der kombination von beschreibung und beispiel und der "blink without delay" code ist nun ein zu simples beispiel. Würde Dir das was ausmachen hier Deinen code öffentlich zu machen? Eine PM geht natürlich auch, aber vielleicht gibt's noch andere die lernen wollen?

wäre super, dann könnte ich endlich meine loop für den outdoor fertigschreiben ohne ständig verzweifeln zu müssen...

antwort zusammengebastelt:
-----------------------------------------
Aber gern doch.
Hier mal ein paar Auszüge aus dem Code des XPlorer1, da wird das auch so gehandhabt.

Zuerst bauen wir und nen Timner zusammen, der anhand von den millis() bei Bedarf "Ticks" erzeugt:

void timer()               //***************** mehrere Sekundenticks erzeugen **********************************
{

unsigned long aktuelleMillis = millis();

  if (aktuelleMillis - vergangeneMillis >= interval)  // Sekunde um
  {
    vergangeneMillis = aktuelleMillis;
     halbeTick ++;                                // 500ms sind um
   if(halbeTick>2)                                // hier ist eine volle Sekunde vorbei
   {
    halbeTick=1;                                  // wechselt alle halbe Sekunde
    sekundenTick++;                               // wechselt jede volle Sekunde
    gemachtFlag=0;                                //  Aufgabe-erledigt-Flag zurücksetzen
   }
   if(sekundenTick==5)                            // mehr brauchen wir nicht
   {
    sekundenTick=0;
   }

  }
}

Der hier erzeugt jede halbe Sekunde nen Tick, und zusätzlich zählt er die Sekunden jedesmal bis fünf hoch.
Im Grunde ein umgeschriebenes "blink_without_delay"...
Im Hauptprogramm muss dieser Timer natürlich auch "hin und wieder" aufgerufen werden (immer, wenn Zeit ist), das Stück Code ist tatsächlich das _komplette_ Hauptprogramm:

 
void loop() 
{
 timer();
 manageLichter();
 sekundenAufgaben();                          // je nachdem, was der Timer grade hat...
 delay(2);                                           // Zeit lassen für Anfragen vom NodeMCU
}

Im Unterprogramm "sekundenAufgaben" wird nun aufgedröselt, je nachdem, welchen Wert der Timer gerade hat:

void sekundenAufgaben()
{
  if((sekundenTick==0)&&(gemachtFlag==0))     //wenns nicht schon erledigt wurde...
  {
    messeAkku();
  }

  if((sekundenTick==1)&&(gemachtFlag==0))
    {
      berechneLichtstaerke();
      gemachtFlag=1;
    }
}

Die gewünschten Intervalle (in denen der Timer halt "tickt") stellt man dann einfach mit passenden Konstanten ein:

          unsigned long vergangeneMillis = 0;  // hier der letzte Tick
const long interval = 500;           // Intervall, 500 Millisekunden

Die Variable "gemachtFlag" verhindert, dass die jeweilige Aufgabe innerhalb des einen Intervalls ...zigmal erledigt wird- nur wenn die auch 0 ist, wird die Aufgabe abgearbeitet, und nachdem sie erledigt wurde, wird das Flag auf 1 gesetzt.

Im Code zum XP2 hab ich inzwischen fünf oder sechs solche Flags-der hat einiges mehr zu tun, hehe.
Der zählt aber auch die Sekunden bis 20 hoch....das Beispiel ist in alle möglichen Richtungen anpassbar, man kann den Timer schneller oder langsamer ticken lassen, man kann ihn weiter oder weniger weit hochzählen lassen, ganz wie man es gerade braucht.
Das ist natürlich keine Atomuhr- da der nur abgefragt wird, wenn keine anderen Aufgaben zu erledigen sind (hier z.B. kommt noch das manageLichter() dazwischen), geht er nicht supergenau, aber wen jucken Abweichungen von nen paar Millisekunden denn- meistens ist das Wurst.

Falls du noch Fragen dazu hast- frag einfach.
---------------------------------------------------------------------

mache ich, muss es mir erstmal genauer anschauen....
gleich die erste frage:
und das ist jetzt wirklich so, dass die in der loop aufgerufenen task's laufen, unabhängig davon, wie lange sie dauern, während die loop weiter abgearbeitet wird?