Arduino mit Lazarus: Nur für Nerds?

[theo]

af0815 hat recht. Dieser Thread ist schon lange nicht mehr beim Thema.
Deshalb geht es hier weiter.

So langsam bekomme ich etwas den Überblick und erkenne den "philosophischen" Unterschied zwischen Lazarus für AVR und der Arduino Idee.
Wiki meint zu Arduino: "Die Entwicklungsumgebung ... soll auch technisch weniger Versierten den Zugang zur Programmierung und zu Mikrocontrollern erleichtern. Die Programmierung selbst erfolgt in einer C- bzw. C++-ähnlichen Programmiersprache, wobei technische Details wie Header-Dateien vor den Anwendern weitgehend verborgen werden und umfangreiche Bibliotheken und Beispiele die Programmierung vereinfachen."

Das macht die IDE in meinen Augen gut.

Lazarus hingegen kümmert sich eigentlich nur um die "blanke" AVR Programmierung, mit einer steileren Lernkurve.
Von af0815 habe ich hier einen Versuch gefunden https://github.com/afriess/Laz_AVR_Lib eine Brücke zu bauen.
Das ist vielleicht für Umsteiger ganz hilfreich, da man so erst einmal einen Erfolg hat und anschließend in die Details gehen, verstehen und wegoptimieren kann.

Ich für meinen Teil, werde erst zu Lazarus AVR wechseln, wenn ich mit der Arduino IDE an Grenzen stoße.

Gestern habe ich z.B. ein 230V Relais mit einer IR-Fernbedienung geschaltet.
Das funktioniert einwandfrei, ist sinnvoll und benötigt nur ein paar leicht verständliche Zeilen.
Gehe ich richtig in der Annahme, dass das mit Lazarus ungleich schwieriger wäre?

Code: Alles auswählen

#include <IRremote.h>

const int RECV_PIN = 7;
const int RELAIS_PIN = 4;
IRrecv irrecv(RECV_PIN);
decode_results results;
unsigned long key_value = 0;

void setup(){
  irrecv.enableIRIn();
  irrecv.blink13(true);
  pinMode(RELAIS_PIN,OUTPUT);
}

void loop(){
  if (irrecv.decode(&results)){
        if (results.value == 0XFFFFFFFF)
          results.value = key_value;
        switch(results.value){
          case 0xFFA25D:
            digitalWrite(RELAIS_PIN,LOW);
          break;
          case 0xFF22DD:
            digitalWrite(RELAIS_PIN,HIGH);         
          break;
        }
        key_value = results.value;
        irrecv.resume(); 
  }
}

[pluto]

Gestern habe ich z.B. ein 230V Relais mit einer IR-Fernbedienung geschaltet.
Das funktioniert einwandfrei, ist sinnvoll und benötigt nur ein paar leicht verständliche Zeilen.
Gehe ich richtig in der Annahme, dass das mit Lazarus ungleich schwieriger wäre?

Soweit ich weiß, gibt es leider noch keine Einfache IR LIB/Klasse für Lazarus.
Wäre schön.... wenn es sowas gebe. Ich denke, aber die von Arduino könnte man leicht nach Pascal Portieren.

[Warf]

Zugegeben, seit dem ich mit arduinos gearbeitet habe ists schon ein bisschen her, aber hier mal mein Senf dazu:

Die Arduino IDE ist eine quick and dirty Lösung, die sich vor allem an Leute richtet die entweder nicht die Zeit, oder das Verständnis haben sich in die technichen docs einzulesen (zugegeben, techniche docs lesen ist verdammt anstrengend)

In etwa das Ikea prinzip. Z.b. wenn man einen LED cube zum leuchten bringen will, einfach nen schaltplan ausm internet suchen, die Arduino lib runterladen, ein paar zeilen glue code schreiben den man sich zu 90% von der website mit dem schaltplan hat und es funktioniert.

Das ist zwar eine funktionierende lösung aber vermutlich nicht die beste. Beispiel, wenn man beim arduino einen pin ansteuert, wird das über den namen gemacht. Der name wird dann über eine lookup table auf das register gemapt. Selbiges für die art der operation die gemacht wird.
Also während die eigentlich benötigte Operation ein simples setzen eines register bits ist, ist es über die arduino lib mindestens 3-4 mal so viel aufwand, und kostet auch entsprechend viel memory.
Und das hauptproblem, je nach Arduino Modell und register ist das nicht mal konsistent wie viel langsamer es ist. Präzise zugriffe, sowie auch hochfrequente änderungen für z.b. PWM, sind also schlicht weg nicht möglich.

Ich hatte auch damals mal ein bisschen weiter in den Arduino source geschaut, und es gibt ein paar ecken an denen ist der verwendete code echt grenzwertig bis müll (an anderer stelle aber auch gut, ist jetzt nicht einheitlich scheiße), und auch in diversen Foren gab es damals oftmals die Meinung das dem Arduino team quality control fehlt, und das die praktisch alles in ihre repos lassen was irgendwie funktioniert. Ob sich das mittlerweile geändert hat keine ahnung.

Langer rede kurzer Sinn, die Arduino IDE und lib sind eigentlich nur zum prototyping relevant und für Leute die grade erst anfangen. Ich würde massiv davon abraten sie für Production code zu verwenden.

Ich bin aber der Meinung das zum lernen wie so ein Microcontroller funktioniert das keine gute Idee. Das einzige was dir die Arduino IDE beibringt ist High level Code für Low Level hardware zu schreiben, ohne auf die implikationen der hardware zu achten. MMn. wer vorher schon programmieren konnte lernt hier nix neues.

Im gegensatz dazu hatte ich damals mal angefangen bare metal auf dem arduino zu arbeiten, mit purem C++ in Atmel Studio und später als ich auf meinem Mac entwickeln wollte MPLAB X.
Ich habe nicht mit Lazarus gearbeitet, aber ich denke mal das man da ähnlich drauf arbeitet, d.h. keine libs (außer der libc) und man muss alles per hand machen.
Die lernkurve hier ist natürlich deutlich steiler. Um auf das beispiel mit dem LED Cube zurückzukommen, jetzt muss man sich die Spezifikation des Cubes den man sich gekauft hat anschauen, verstehen wie sein interface funktioniert, eventuell sich in entsprechende protokolle wie i2c einlesen, und dieses wissen dann auf einem low level anwenden.
Klar dauert das länger und ist komplizierter, aber wenn man da einmal den bogen raus hat und weiß wo man in der Spec schauen muss, etc. dann kann man von da an jede komponente benutzen wie man lustig ist, selbst wenn es keine Arduino lib dafür gibt.

Und noch besser, für gewöhnlich sind nicht arduino kompatible komponenten (also komponenten die ne arduino lib bereitstellen) auch noch billiger

[Mathias]

Und das hauptproblem, je nach Arduino Modell und register ist das nicht mal konsistent wie viel langsamer es ist. Präzise zugriffe, sowie auch hochfrequente änderungen für z.b. PWM, sind also schlicht weg nicht möglich.

Du sprichst mir aus dem Herzen. digitalWrite ist etwa das traurigste, was ich von Arduino kenne. Hast du mal geachtet, wie der Speicherbedarf wächst, sobald man nur ein digitalWrite verwendet. 220Byte nur für ein Portzugriff
Man muss mal die sourcen angucken, das nur für eine Pinumschaltung.

Code: Alles auswählen

void digitalWrite(uint8_t pin, uint8_t val)
{
	uint8_t timer = digitalPinToTimer(pin);
	uint8_t bit = digitalPinToBitMask(pin);
	uint8_t port = digitalPinToPort(pin);
	volatile uint8_t *out;

	if (port == NOT_A_PIN) return;

	// If the pin that support PWM output, we need to turn it off
	// before doing a digital write.
	if (timer != NOT_ON_TIMER) turnOffPWM(timer);

	out = portOutputRegister(port);

	uint8_t oldSREG = SREG;
	cli();

	if (val == LOW) {
		*out &= ~bit;
	} else {
		*out |= bit;
	}

	SREG = oldSREG;
}

Wen ich doch mal mit Arduino-C was schreibe, dann wenigstens so auf die Pins schreiben:

Code: Alles auswählen

void dw(unsigned char pin, bool value) {
	if (value) {
		PORTD |= (1 << pin);
	} else {
		PORTD &= ~(1 << pin);
	}
}

Oder verende mal alle 3 Timer eines Atmega328p mit Arduino.

Code: Alles auswählen

Soweit ich weiß, gibt es leider noch keine Einfache IR LIB/Klasse für Lazarus.

Es ist nicht verboten, wen man selbst eine lib schreibt, wen man die für weitere Lazarianer veröffentlicht.

[theo]

Das mag alles richtig sein, aber es bleibt für mich die Frage, was ich tun soll, wenn ich z.B die Fernbedienung benutzen möchte.
Für meinen einfachen IR-Ein-Aus Schalter, ist mir auch die ressourcenfressende Pinumschaltung herzlich egal. Hauptsache es funktioniert.
Soll ich 2 Wochen lang Kopfstand üben, um mit einer eigenen, halbgaren Lösung zu kommen?
Dann ist mir die vielleicht hässliche, aber immerhin zig-fach getestete Arduino Library dann doch noch lieber.

Aber gut, ich verstehe, dass ihr dafür Lazarus favorisiert. Alles Andere wäre es ja auch traurig im Lazarusforum.

@Mathias: Bei deinem

Code: Alles auswählen

void dw(unsigned char pin, bool value)

Ist nicht der Arduino Pin gemeint, oder? Das Mapping muss man manuell machen?

[Timm Thaler]

Das einzige was dir die Arduino IDE beibringt ist High level Code für Low Level hardware zu schreiben, ohne auf die implikationen der hardware zu achten. MMn. wer vorher schon programmieren konnte lernt hier nix neues.

Wenn man schon vorher programmieren konnte, ist das sogar hinderlich: Da verwenden dann Leute massiv float, was auf einen AVR Mikrocontroller nur in Software geht und massiv Ressourcen frißt. Oder machen großzügig Stringoperationen, die den spärlichen RAM sprengen und dann kackt das wegen Stackpointer-Überläufen ab.

Andererseits hab ich schon Schulklassen gesehen (in Indien) die damit als Einsteiger einfache Projekte realisieren konnten, in ihrer begrenzten Zeit und ohne Vorkenntnisse. Das wäre weder in C noch in Pascal so möglich gewesen.

Es ist nicht verboten, wen man selbst eine lib schreibt, wen man die für weitere Lazarianer veröffentlicht.

Ui, dann würd ich aber nicht mit IR anfangen. Es gibt so unzählige verschiedene IR-Protokolle und Modifikationen...

Andererseits hab ich auch schon C-Libs auf Pascal portiert: Den Code in die Unit kopieren, und Schritt für Schritt auf Pascal umschreiben. So sind meine nRF24-Units entstanden.

Um allerdings eine Arduino-ähnliche Umgebung für Pascal zu erzeugen müßte man erstmal mit grundlegenden Funktionen anfangen: Timer-Management, Speicher-Management, Port-Management. Natürlich kann man die entsprechenden C-Libs auf Pascal umschreiben.

Allerdings handelt man sich damit die gleichen Schwächen und Probleme ein, die Arduino hat: Du willst eine schnelle PWM? Geht nicht, der Timer ist bereits belegt. Du willst eine Soft-RS232? Geht nicht, der Timer ist bereits belegt. Du willst ein Multitasking-System? Geht nicht, der ADC blockiert den Controller. Du willst eine schnelle Soft-PWM? Geht nicht, die Pin-Zugriffe sind zu langsam.

Ich könnte sowas nicht, ich würde mich nur über die Verschwendung an Ressourcen und die verschenkten Möglichkeiten ärgern.

[wp_xyz]

Ich bestreite nicht, dass man mit Lazarus viele Sachen effizienter machen kann als mit der Arduino-IDE.

Dennoch muss ich der Frage im Titel, "Arduino mi Lazarus: Nur für Nerds", zustimmen. Was mir fehlt, ist, wie Leo sagt, der einfache Zugang für Newcomer. Ein Freund von mir, der an der Volkshochschule Arduino-Kurse anbietet, erzählt mir, wie begeistert die jungen Leute sind, mit dem Arduino einen einfachen Zugang zur "echten" Computerei zu finden. Wenn wir hier statt der Arduino-IDE eine einfache "Lazuino-IDE" hätten, ergäbe sich eine einfache Möglichkeit, die Leute wieder zur Sprache Pascal zurückzugewinnen.

Mattias, deine Beispielsammlung ist hervorragend und ich habe sie gleich in meine Bookmarks aufgenommen. Aber wenn ich mir das Standard-Beispiel "blink" ansehe, wie bitte soll da mein Freund den Arduino-Anfängern erklären, was das "(1 shl BP5)" und der "asm"-Block und das "NOP" bedeuten? Den Original-Arduino-C-Quelltext (vereinfacht: loop - DigitalWrite(High) - Delay - DigitalWrite(Low) - Delay) kann man dagegen fast lesen wie ein Buch.

[Timm Thaler]

Für meinen einfachen IR-Ein-Aus Schalter, ist mir auch die ressourcenfressende Pinumschaltung herzlich egal. Hauptsache es funktioniert.

Nein, fü IR musst Du einen Pin schnell pollen. Dazu brauchst Du
1. einen Timer-Interrupt, der im µsec-Intervall angesprungen wird und
2. eine schnelle Pin-Abfrage in diesem Interrupt
3. schnelles Bit-Shifting, um die Werte einzulesen

Das alles nimmt Dir die IRremote-Lib ab. Die das dann mit C-Befehlen ausführt. Ein DigitalRead ist hier viel zu langsam.

Für das Schalten des Ausgabe-Pins selbst ist es wiederum egal.

Ist nicht der Arduino Pin gemeint, oder? Das Mapping muss man manuell machen?

Nicht nur das Pin-, sondern auch das Portmapping. Du musst also wissen, ob Dein Ausgang auf PORTA, PORTB, PORTC oder PORTD liegt.

Dass Arduino hier total andere Portbezeichnungen verwendet ist zwar total nutzerfreundlich - man muss sich nicht die Ports anschauen - aber total AVR-unfreundlich. Denn jedes Arduino-Pin muss auf seinen ARV-Pin und Port gemappt werden.

Andererseits weiß ich, an welchem Port und Pin meine Peripherie hängt. Es ist also eigentlich überflüssig, die Pins variabel zu machen. Ich definiere die einmal im Programm, und fertig.

[af0815]

Ich habe versucht für mich zu vereinfachen, siehe den Code auf github, den Theo schon gefunden hat. ist genaugenommen dadurch entstanden, das ich das Arduinosystem verstehen wollte und mal sehen ob man das auch mit Lazarus hinbekommt.

Theo kann ich verstehen und es ist klar das es mit Lazarus, was für Nerds mit dem Hang zu masochismus ist SCNR

Das Arduinokonzept ist einfach und durchgängig und man kann Skalieren. Das ist was, was die Leute zum Thema bringt. Mein kompletter 3D Drucker wird über Arduino programmiert. Der Hersteller hat den Source offengelegt und die Community. hat weiterentwickelt. Also so Resourcenfressen kann Arduino nicht sein.

[Warf]

Dennoch muss ich der Frage im Titel, "Arduino mi Lazarus: Nur für Nerds", zustimmen. Was mir fehlt, ist, wie Leo sagt, der einfache Zugang für Newcomer. Ein Freund von mir, der an der Volkshochschule Arduino-Kurse anbietet, erzählt mir, wie begeistert die jungen Leute sind, mit dem Arduino einen einfachen Zugang zur "echten" Computerei zu finden. Wenn wir hier statt der Arduino-IDE eine einfache "Lazuino-IDE" hätten, ergäbe sich eine einfache Möglichkeit, die Leute wieder zur Sprache Pascal zurückzugewinnen.

Das erinnert mich an diese ganzen Klicki Bunti Entwicklungs Umgebungen, bei denen man aufgaben bekommt und die mit einer grafischen programmiersprache lösen muss.
Toll um leute fürs programmieren zu begeistern, denn du hast direktes featback, und merkst das das ja alles keine magie ist. Dennoch würde niemand in nem echten projekt so ne klicki bunti sprache benutzen (außer Maschinenbauer, die programmieren immernoch mit bauklötzen ).

Das problem ist aber, das ist genau der sellingpoint von arduino. Das komplette unternehmen und die gesammte community ist darauf aus eine klicki bunti lösung zu bauen, sodass du in den nächsten Conrad fahren kannst, dir für 25€ nen arduino holen kannst und loslegen kannst.

Selbst wenn man sowas für Lazarus will, da fehlt die Manpower. Ich würde mal behaupten das die AVR community unter Lazarus entwicklern einen sehr kleinen Teil ausmacht, und selbst da ist ja nicht gegeben das jeder für so ein anfängerfreundliches konzept beitragen will oder kann.
Dann gibt es ja nicht nur das Arduino core Team, sondern z.b. die IRemote library die von theo im ursprungspost verwendet wird ist eine lib von drittanbietern.

Solang die Lazaurs-AVR-EInsteigercommunity nicht zumindest in einer ähnlichen größenordnung ist wird es einfach mehr und einfachere resourcen für arduino geben. Und grade bei einsteigern, die noch keine favoritensprache haben sehe ich das so: Du willst das benutzen was den besten job erfüllt, und das wird einfach arduino sein.

Im gegensatz dazu, außerhalb der anfängerszene, gibt es nur wenige gründe warum man C++ oder C statt Lazarus für nen AVR benutzen sollte. Wenn man eh bare metal arbeitet und alles von grund auf selbst macht, kann man da auch seine Lieblingssprache nehmen. Daher denke ich das es schlicht und ergreifend die bessere Idee ist, statt versuchen in eine Niche reinzukommen für die schlicht und ergreifend die Resourcen fehlen, lieber die Nichen auszubauen die Lazarus eh schon einnimmt.

Ich würde mich viel mehr darüber freuen wenn Lazarus support für In-Circuit-Debugger wie den Atmel ICE bekommen würde, und ich denke das würde das leben viel einfacher machen. Oder einen Lazarus basierten AVR Emulator mit dem man direkt aus der IDE interagieren kann

[Mathias]

Wer es noch nicht gesehen hat, ich habe eine Package, welches die Einstellungen in Lazarus übernimmt. Damit entfällt das Gewurschtel mit den Optionen und Parametern.

https://github.com/sechshelme/Lazarus-E ... UI_Package

[theo]

@Warf: Das ganze Thema ist doch "Klicki Bunti".

Diese ganzen Starter Kits haben die gleiche Ausstrahlung und Anziehungskraft, wie Mars Celebrations.

[Mathias]

Das wäre eine Herausforderung für jedes Sensörli eine Pascal lib zu schreiben.

[Timm Thaler]

Das erinnert mich an diese ganzen Klicki Bunti Entwicklungs Umgebungen, bei denen man aufgaben bekommt und die mit einer grafischen programmiersprache lösen muss.
Toll um leute fürs programmieren zu begeistern, denn du hast direktes featback, und merkst das das ja alles keine magie ist. Dennoch würde niemand in nem echten projekt so ne klicki bunti sprache benutzen

Ähem: LabView. da wurde schon im letzten Jahrhundert viel Geld für KlickiBunti bezahlt.

[pluto]

Ich denke, was der Lazarus-AVR Unterstützung fällt ist eigentlich klar: Beispiele. Viele viele Beispiele.

Nur so, kann man Anfänger zeigen wie etwas geht. Am Anfang muss man auch nicht alles verstehen. Es reicht, wenn du weiß, in etwa wie es Funktioniert.
Ein Beispiel:
Ich habe vor einer ganzen Zeit, ein Arduino Code gefunden, um "unbekannte" 433 mhz Empfänger auszuwerten z.b. Wetterstationen.
Ich verstehe den Kern Code nicht. Jedoch habe ich ihn erweitert und drumherum das gebaut was ich haben wollte.

Eine kleine Schaltung an der ein Uart angeschlossen ist, speist die Daten in einem PI4 ein, wo node-red drauf läuft.
Einfacher geht es nicht. Gut, es hat etwas gedauert. Aber ich stand auch nicht unter Zeitdruck.

Das ganze mit Pascal nach zu bauen, wäre vermutlich nicht viel aufwendiger. Der Kern Code, ist recht "einfach gehalten":

Code: Alles auswählen

void ReadData() {
  long lowtime, hitime;
  if (pbread != pbwrite) { 
    lowtime = pulsbuf[pbread];
    hitime = hibuf[pbread];
    cli(); 
    pbread++;
    if (pbread >= PBSIZE) pbread = 0;
    sei(); 
    if (lowtime>MINSTARTPULSE) { 
      if (counting) showBuffer();
      startBitDurationL=lowtime;
      startBitDurationH=hitime;
      counting=true;     
      counter=0;         
    }
    else {
      if (counting && (counter == 0)) {         
        shortBitDuration=lowtime / 2;
        if (shortBitDuration<MINBITPULSE+PULSEVARIANCE)
          shortBitDuration=MINBITPULSE;
        else  
          shortBitDuration -= PULSEVARIANCE;
        longBitDuration=lowtime * 2 + PULSEVARIANCE;
        validpulsbuf[counter]=lowtime;
        validhibuf[counter]=hitime;
        counter++;
      }
      else {
        if ( counting && (lowtime > shortBitDuration ) && ( lowtime < longBitDuration )) {
          validpulsbuf[counter] = lowtime;
          validhibuf[counter] = hitime;
          counter++;
          if ((counter == MAXPULSECOUNT) || (hitime < MINHITIME)) {
            showBuffer();
          }  
        }
        else { 
          if (counting) showBuffer();
          counting=false;
          counter=0;
        }  
      }
    }
  }      
} // ReadData

void rx433Handler() {
  static long rx433LineUp, rx433LineDown;
  long LowVal, HighVal;
  int rx433State = digitalRead(RX433DATAPIN);
  if (rx433State) { 
    rx433LineUp = micros(); 
    LowVal = rx433LineUp - rx433LineDown; 
    if (LowVal > MINBITPULSE) {
      if (LowVal > MINSTARTPULSE) LowVal = MINSTARTPULSE  + LowVal / 10;

      pulsbuf[pbwrite] = LowVal; 
      pbwrite++;  
      if (pbwrite >= PBSIZE) pbwrite = 0; 
    }  
  }
  else  {
    rx433LineDown=micros(); 
    HighVal=rx433LineDown - rx433LineUp; 
    if (HighVal>31999) HighVal=31999; 
    hibuf[pbwrite]=HighVal; 
  }
} // rx433Handler

Das ist der Kern Code davon.