Der AVR-/ARDUINO-Faden

[jodurino]

Ich gehe davon aus, dass das Hochladen deshalb nicht geht, weil der auch schon irgendwas weg hat.

Hi
hast Du es denn mit beiden Bootloadern auch probiert ?

Also wie schon geschrieben hatte ich aus gleicher Lieferung vom "C" welche die mit altem und welche die mit neuen Bootloadern zu beschicken waren bekommen.

Gut ein paar Tage her das ganze.

cu
jodurino

[Später Gast]

sysconsols Frage, wie Du aus dem PC-Netzteil 7,5V rausholst interessiert mich auch noch brennend.

Ich vermute mal zwischen +12V und +5V. Ob der Schaltwandler das wirklich mag ist fraglich.

12-5 macht 7, fehlen 0,5.
Um zu vermeiden, dass die +5V als Stromsenke arbeiten müssen könnte man die auch mit der 5 Ohm Dummyload belasten. Ich vermute eher einen DCDC an 12V, aber Cubicany lässt sich die Infos ja nicht nur aus der Nase ziehen, er antwortet dann auch nicht.

Was tote Arduinos angeht bin ich ganz bei IPv6. Hab abgesehen von meinem Einstiegs-Uno ausschließlich Chinaware und noch keinen DOA gehabt, dafür aber schon einen stattlichen Friedhof an versehentlich gekillten Arduinoboards und Peripherie angehäuft. "Wie das tut nicht, kriegt das überhaupt Strom, mal eben mess.." -oh 12V auf den Pin gegeben.
*Wölkchen dampft dahin*

Alter Bootloader hatte ich auch schon bei Nanos, garnicht so lang her.

-> Von Boards, die ich verbaue habe ich immer mehrere auf Lager, dann muss ich nicht warten, falls mal einer den Heldentod stirbt. Wenn die Restmenge einer Sorte auf unter 2 fällt, fange ich an nervös zu werden.

[Cubicany]

Ich hatte mich da selber vertan, denn 7,5V bekommt man halt nicht aus der Differenz von 5 und 12.

Aber ja, das stimmt schon. Zwischen Rot und Gelb gehangen.

Ich habe übrigens noch mit anderen Steckdosennetzteilen getestet, aber irgendwie wird es nicht besser.

Bestelle mir noch ein zwei der günstigen Unos und probier die mal aus.

Und was das zerstören wegen unachtsamem Anschließen angeht, umgehe ich das da durch, dass ich den
beim Testen nur über den USB Mini versorge. und später an dem Vin Pin Drähte fest anschließe. Außerdem
nutze ich nur noch ein Netzgerät, was maximal 9V kann

[Später Gast]

Ich hatte mich da selber vertan, denn 7,5V bekommt man halt nicht aus der Differenz von 5 und 12.
Aber ja, das stimmt schon. Zwischen Rot und Gelb gehangen.

Gut zu wissen. Der 5V Ausgang vom Netzteil wird hier rückwärts betrieben, dafür ist er nicht ausgelegt. Der Arduino verbraucht zwar kaum Strom, aber es wäre wahrscheinlich trotzdem eine gute Idee, den Strom nicht im 5V Ausgang zu versenken, sondern von dort über nen 20 Ohm Widerstand nach Masse abzuleiten. Oder noch besser, mit nem einstellbaren DCDC- Wandler direkt die benötigte Spannung herstellen. Ist ja nicht so, als wär das Zeug teuer.

Ich habe übrigens noch mit anderen Steckdosennetzteilen getestet, aber irgendwie wird es nicht besser.
Bestelle mir noch ein zwei der günstigen Unos und probier die mal aus.

Elko haste getestet?
Wenn deine 7V von +12v-5v kommen funzt das mit "Relaisplatine aus den 5V vom Rechnernetzteil direkt versorgen" nicht, weil da dann 2 verschiedene Massen im Spiel sind. Dann sehen die I/O-Pins eine Masse die bei -5V liegt, das mögen die bestimmt nicht. Vom Kurzschluss der 5V leitung, wenn man die 2 Massen verbindet ganz zu schweigen.

Den Vin/Raw zu umgehen und mit 5V direkt an den 5V Pin vom Arduino rangehen (und andere 5V Verbraucher damit mitversorgen) ist auch noch ne Option, wenn man nur eine Spannung zur Verfügung hat, bzw der Strombedarf vom Arduino selbst nicht mehr geleistet werden kann. Die Spannung sollte dann aber sauber und frei von Spitzen sein.

Dass das Problem mit nem anderen Arduino verschwindet glaub ich eher nicht.

[Lukas_P]

Kurze frage:
Der Arduino hat ja 8Bit, die integer sind 2 Byte lang. Wenn ich jetzt einene 32 bit µC hab (ESP8266) sind dann die int aus nur 16Bit lang wenn ich den mit arduino bespaße, oder sind die länger ?

[Anse]

Hängt vom Compiler ab. Aber mindestens 16Bit.
Auf dem ESP müssten es aber 32Bit sein. Wenn es Dich interessiert einfach mal Printl(sizeoff(int)); machen

[jodurino]

Es kommt eben auf die Projektgröße an.
Bei meinem Heimzeuch nutze ich auch Notepad++ bzw gedit und makefile.

Auf Arbeit dann eine IDE, bei 20k Files+ biste sonst leicht verloren.
Leider ist der IAR von v7 auf v8 so richtig schlecht geworden in Richtung unbenutzbar, daher gucken wir grade nach Alternativen.
Scherze wie: Volltextsuche braucht auf 8 Kernen 4min30s. Grep braucht 4s auf einem Kern

Hallo nun ja wie soll ich es sagen
habe eben mit Notepad++ editiert und den makefile button gesucht.

Also beim Notepadd++ habe ich Arduino eingepflegt
code geschrieben
alles ok

wie bekomme ich den code zum Einen compiliert zum Testen?

und möglichst dann auch in den Arduino reingeschubst.

Habe mich eben damit beholfen den code zu kopieren und in der Arduino IDE zu compilieren.


**EDIT MEINT ich brauche Urlaub
hatte vergessen den Haken bei der Arduino IDE externer Editor zu machen.

cu
jodurino

[ch_ris]

das ist die pragmatischste idee, lass es dabei. bzw. du kannst die gleiche datei in beiden Editoren parallel bearbeiten, glaub ich.

[Fritzler]

Ich hab mir "make all" beim Notepad++ auf F5 gelegt
Dann sucht make das makefile im Projektverzeichnis und führt den Inhalt aus.
Unter Linux is eh immer ne Konsole offen.

Bei Blödduino? ka.

[jodurino]

hi
ja es funktioniert
ist vielleicht nicht die eleganteste Lösung aber es geht

Arduino IDE => Dteiname vergeben
Notepad++ => editieren und mit CTRL S abspeichern
wieder zur Arduino IDE dort dann compilieren oder direkt mit compilieren Hochladen

cu
jodurino

[Finger]

Ich hab da jetzt auch mal ne Fragestellung.... Ich hab n Schnipsel Software, der läuft auf einem MEGA2560. Ich hab mehrere PCINT (PinChangeInterrupts) die ich selber auswerte, die hängen in einer eigenen
ISR:

Code: Alles auswählen

ISR (PCINT1_vect)
{
  // Hier werden Ereignisse zusammengetüdelt
}

Jetzt brauche ich aber noch einen fünften UART, das Ding hat aber nur 4. Denk ich mir: da nimmste SoftSerial, da haste alles was du brauchst. Dummerweise arbeiten die ja auch mit nem PCI, der hängt auf dem selben Vektor (10), und zwei ISR auf dem selben Vektor will der Linker natürlich nicht zusammenbauen. Wie auch? Ich würde jetzt ungerne die Bibliothek zerpflücken, sondern eher irgendwas in der Art von "Ich klinke meinen Kram mit in die ISR ein oder so".... Hm.... Gibts da einen Ansatz für?

Ich bin was Änderungen an der Hardware angeht leider etwas eingeschränkt, eine elegante Softwarelösung ohne (oder möglichst wenig) in die mitgelieferten Bibliotheken einzugreifen wäre schon toll...

Finger

[Sir_Death]

kannst du am I2C einen UART-Bridge anschließen? - dann hättest du deinen 5. - frag mich aber nicht, wie der mit Interrupts ansprechbar wäre.
http://sandboxelectronics.com/?product= ... dge-module

[virtexultra]

Eine Lösung ohne Eingriff fällt mir nicht ein.

a) Attribut weak (__attribute__((weak));) zur Funktion ISR(PCINT1_vect) innerhalb der SoftSerial.cpp hinzufügen. Dann kann die eigene ISR(PCINT1_vect) irgendwo definiert werden und überschreibt die von SoftSerial.cpp zur Verfügung gestellte.
b) #undef PCINT1_vect nach den Headern innerhalb der SoftSerial.cpp. Dann wird der ISR gar nicht erst definiert. Leider ist mir kein Weg bekannt das per CLI an den Compiler weiterzugeben.

Überall muss dann aber SoftwareSerial::handle_interrupt(); aufgerufen werden.

[Sven]

Wir haben das Problem jetzt auf die elegante Art gelöst und einfach die Lib an der Stelle ihres ISRs beraubt.

In der Interrupt Routine wird jetzt einfach ein Wrapper für das handle Interrupt der SoftSerial Klasse aufgerufen.
Eine Wrapper Funktion war nötig, weil die Lib Funktionen mit Inlining hat. Ist zwar schnell, verhindert aber zuverlässig einfache Aufrufe von außerhalb.

[Sir_Death]

Well... And now in German please - only understand Bahnhof
Macht nix - würde ich auch anders nicht verstehen. Ich bin immer froh, wenn ich in Arduino ein wenig zusammenklicken kann und meine einfachst-Projekte halbwegs tun was sie sollen.

[Finger]

Und das funktioniert auch noch! Vielen Dank nochmal. Man muss aber auch echt dazu sagen: das ist nichts für normalen Anwender, sondern für den, der ganz unten drin herumwühlt. Was wurde gemacht? Die Bibliothek aus der Entwicklungsumgebung herausgelöst und als Kopie mit ins Projekt gepackt. Dann dort die ISR vom Interruptvektor abgekoppelt und den Aufruf mit in meine ISR hineingepackt. ZackPengBonjour -> Der Linker hat nur noch eine ISR und baut brav das Programm zusammen.

[jodurino]

Hallo



nicht sehr spektakulär, aber es funktioniert erst mal so weit.

Aber was mich ein bisschen nervt ist, wenn ich zur Kontrolle den seriellen Monitor starte dann macht der Arduino erst mal ein Reset bzw. ich befürchte er schaltet wild alle Relais/Mosfet auf ein.

Kann man das umgehen?

cu
jodurino

[Bastelbruder]

Seit dem 4004 starten alle Kleinhirne mit FF an den Ausgängen. Und vor ungefähr 50 Jahren hat man sich geeinigt daß Low der Aktivpegel ist. Wenn diese Kleinigkeit mißachtet wird, ist mit beliebigen Ergebnissen zu rechnen.

[Später Gast]

...
Aber was mich ein bisschen nervt ist, wenn ich zur Kontrolle den seriellen Monitor starte dann macht der Arduino erst mal ein Reset bzw. ich befürchte er schaltet wild alle Relais/Mosfet auf ein.

Kann man das umgehen?
cu
jodurino

In der original Arduino IDE wohl nicht und die Funktion an sich braucht das Board, damit man komfortabel Sketches hochladen kann.

-> im Code dafür sorgen, dass keine unwillkommenen Zustände direkt nach Reset möglich sind, wenns ganz kritisch ist, ggf extern PullUp/Down Widerstände einplanen, um zufällige Schaltspielchen zu verhindern.

Hier wird vorgeschlagen einen 10µF Elko zwischen den Resetpin und Gnd zu schalten, schätze aber mal, dann geht upload auch nicht mehr.

[jodurino]

Ja es ist die original IDE

Also ich editiere im wordpad++
Dann lade ich den Sketch auf den Arduino Nano
Da ist ein Reset normal.

Dann starte ich den Arduino IDE Seriellen Monitor, bei den Werkzeugen den.
Schon kommt gefühlt ein halbreset es macht nicht mehr ganz was es soll das Programm.
Ebenso beim Schließen vom Monitor.

Aber nur bei den Nano s der letzten Lieferung mit USB Mini, die Nano s aus der Lieferung davor mit USB Micro machen das nicht.

cu
jodurino

[Später Gast]

Aber nur bei den Nano s der letzten Lieferung mit USB Mini, die Nano s aus der Lieferung davor mit USB Micro machen das nicht.

letztere (mit USB Micro) sind wahrscheinlich keine Nano(V3), sondern Pro Micro (leonardo). Nicht so lang, dafür ne Idee breiter, anderes Pinout. Da hab ich grad vorhin was beim googeln gelesen, dass das bei denen anders ist mit den Reboots.(die das Problem nicht haben) Kenn mich da selber nicht großartig mit aus.

Bei mir wars heute ganz praktisch, weil ich damit nen leicht zugänglichen Reset-Button hatte, mit dem ich schnell überprüfen konnte, ob meine neue shuffle-Funktion auch wirklich shuffelt. (Spoiler: Ja, aber sie braucht mehrere Aufrufe ohne Reboot dazwischen, bis der "Zufall" auch so genannt werden darf.)

[ch_ris]

vermutlich der gelbe an der stirnseite

[Tobi]

Die gelben sind Tantalkondensatoren die die Versorgungsspannung stützen. Der 100n wird einer der beiden kleineren Keramikkondensatoren sein.
Klick doch mal auf den link "here" aus dem Screenshot.

[ch_ris]

der, bzw beide, zeigt nach hier:
http://actrl.cz/blog/index.php/2016/ard ... d-details/

sacht mir nix

[jodurino]

Hallo
um das mal zu umgehen denke ich ganz schlau an einen arduino mega 2560 mit einem tft shield 480*320 Treiber ILI9486
so wie der Kollege im Video:
https://www.youtube.com/watch?v=R_V_lzAbnb8

habe die library herunter geladen

https://github.com/lcdwiki/LCDWIKI_gui

https://github.com/lcdwiki/LCDWIKI_kbv

beide.
dann noch die Beispiele
https://drive.google.com/file/d/1eEeecf ... 3wCpU/view

Geguckt wie ich im code den ILI9486 eintragen kann

hm aber nix ist
was natürlich wieder blöd ist.
Gibts da was einfachres für mich?

cu
jodurino

[Später Gast]

Gibts da was einfachres für mich?

Was willste denn anzeigen?

Sehr einfach einzubinden find ich die verschiedenen siebensegment anzeigen, also max7219, tm1637, tm1638, ht16k33, ...

Die mehrzeiligen lcd ( zB. 4x20 character) fand ich auch noch gut machbar. Da geht's dann aber auch schon los, dass man kucken muss, wo im Display man was schreibt und wieviel/wie oft, sonst gibt's Probleme.

Alles, was GFX will ist für mich raus. A) bekomm ich das nicht auf die Pfanne und B) sind Arduinos dafür ne Nummer zu klein. Gut mit dem Mega2560 vllt schon, aber da scheitere ich dann wieder an A).

Grüße
Moritz

[jodurino]

Gibts da was einfachres für mich?

Was willste denn anzeigen?

Sehr einfach einzubinden find ich die verschiedenen siebensegment anzeigen, also max7219, tm1637, tm1638, ht16k33, ...

Die mehrzeiligen lcd ( zB. 4x20 character) fand ich auch noch gut machbar. Da geht's dann aber auch schon los, dass man kucken muss, wo im Display man was schreibt und wieviel/wie oft, sonst gibt's Probleme.

Alles, was GFX will ist für mich raus. A) bekomm ich das nicht auf die Pfanne und B) sind Arduinos dafür ne Nummer zu klein. Gut mit dem Mega2560 vllt schon, aber da scheitere ich dann wieder an A).

Grüße
Moritz

Hi
bin da blauäugig an die Sache heran gegangen, dachte wenn ich schon so ein tft und Mega in der Bastelkiste habe, schnell vertüdeln
Software aufspielen und dann mit dem anderen Arduino Nano über txd rxd verbinden und sich die Daten anzeigen lassen wo der IDE Monitor immer den Reset macht beim Aufrufen.
Das wollte ich eben umgehen.
Soll nix dauerhaftes werden nur jetzt für die Entwicklung der Software mal die Statüssers der Ein und Ausgänge abfragen.
Wenn alles zusammen gechraubt ist komme ich nur noch über USB an den Nano, oder halt über TXD/RXD direkt.
Muss halt eine gewisse Reienfolge bei den Ausgängen einhalten und das möchte ich überwachen bevor ich alles "Scharf" verbinde.

cu
jodurino

[Später Gast]

Ah ok, also für so Development- und Debug - Zwecke. Da hab ich für meinen Wecker so'n 4x20 lcd hergenommen und fand das sehr praktisch. Irgendwann ist mir der Speicher knappgeworden, da isses dann rausgeflogen. war aber auch nur n Nano mit ATmega168, da is wenig Platz drauf.

[Lukas_P]

Hatte von euch schonmal jemand ein Problem das bei Arduino (also ESP8266) das negiern einer Variable 0 zurück gibt ?

ich weis mir absolut keinen helfer mehr :

Code: Alles auswählen

int a = 500;
Serial.println(a); // <-- gibt mir 500 aus (oder auch -500 wenn man das als a definiert)
a = -a; //  ooder a=0-a; 0der a*= -1; funktioniert alles nicht nichtmal wennman a einer ausweichvariable zuweist und die dann invertiert
Serial.println(a); <-- gibt dann immer 0 aus wenn a eigentlich negativ sein sollte

seit dem ich das in nem git hab fuckt der scheiss manchmal echt unerklärlich rum

[andreas6]

Überschreitest Du den Wertebereich von int? Probiere mal einen kleineren Wert, etwa 100.

MfG. Andreas

[ch_ris]

da wird int wohl auf uint...,zeigen.
nimm doch mal int16t.
oder wie heist das?

[IPv6]

Der Wertebereich von int sollte mit -2147483648 bis 2147483647 eigentlich mehr als ausreichend sein.
Auch wäre es komisch, wenn da irgendwie aus einer int eine uint wird. Selbst bei einem Überlauf sollte da auch keine 0 rauskommen.
Sehr merkwürdig...

[Lukas_P]

da wird int wohl auf uint...,zeigen.
nimm doch mal int16t.
oder wie heist das?

warum sollte mein int Array auf uints zeigen ? ... vor Allem weil vorm negieren die negativen werte tadellos gespeichert werden

[virtexultra]

Negiere die Variable doch einmal doppelt und lasse sie dann ausgeben. So kann man den Fehler auf die serielle Lib oder die Rechenoperationen eingrenzen.

Die Variable muss dafür aber mit volatile definiert werden, ansonsten wird wegoptimiert.

[Sir_Death]

Ich finde zwar die Seite nicht mehr, habe aber im Kopf dass der Compiler für die Arduinos int als signed integer interpretiert, für den ESP aber anders.
probiere mal "word" statt "int"

Hintergrund war glaube ich mich erinnern zu können das Thema hier: https://www.esp8266.com/viewtopic.php?f ... 954#p55810

[Fritzler]

habe aber im Kopf dass der Compiler für die Arduinos int als signed integer interpretiert

WTF?
Sind die geistig behindert?!

[Jannyboy]

habe aber im Kopf dass der Compiler für die Arduinos int als signed integer interpretiert

WTF?
Sind die geistig behindert?!

Nö das tun mittlerweile alle GCC-Compiler neuer Version, der Standard-Typ ist int32_t.
Für einen 8 bit Wert muss explizit nach uint8_t gecastet werden bevor gerechnet wird.
Sonst rechnet der Compiler intern mit int32_t und kürzt nachher auf uint8_t.
Wenn man den binären Überlauf mit einkalkuliert ergibt es einen Rechenfehler.

Grüße Jan

[Fritzler]

Das ist mir bisher nicht aufgefallen, weil ich sowieso IMMER cstdint nutze.
Was ich auch jedem hier nur empfehlen kann, dann passiert sowas erst garnicht.

[virtexultra]

Also meine Compiler machen das schon etwas länger so. Das sieht zumindest der erste C Standard (89) auch so vor - ich zitiere mal:

"int , signed , signed int , or no type specifiers [...] designates the same type, except that for bit-field declarations" aus http://port70.net/~nsz/c/c89/c89-draft.txt (3.5.2)

Dieser Thema im ESP8266 Forum resultiert für mich daraus das der Compiler zwischen den Variablen Padding einfügt um einen schnellen Datenzugriff zu ermöglichen.

Nur bei char gibt es keine eindeutige Definition - hierzu hat GCC die Flags -funsigned-char und -fsigned-char bereitgestellt um das Verhalten zu definieren.

Bei mir macht die Toolchain Xtensa in Version 4.8.2 aus der Negierung den neg asm Befehl. Für den ESP8266 gibt es nur Negierungsbefehle für 32 Bit und single prec. - weiterhin werden für das Codeschnipsel alles als l32i.n bzw s32i.n ausgeführt. Somit sollte ein Under- oder Overflow ausgeschlossen sein.

Der Compiler optimiert bei mir ohne das volatile aber etwas lustig. Er hält sowohl die 500 als auch die -500 im Flash vor und lädt diese mit dem movi Befehl als 12 bit signed constant in ein Arbeitsregister.

Also für mich ist das Problem nicht beim Compiler oder dem gezeigten Code zu suchen sondern irgendwo anders. Wenn du den Debug Build deines Programms aber mal rüber schickst kann man sich die Befehle ja anschauen. Vielleicht täusche ich mich mit meinen Gedankengängen ja auch

Die Datentypen intX_t und uintX_t sind auf jeden Fall immer eine gute Idee. Evtl. auch int_fastX_t bzw. uint_fastX_t falls es auf Geschwindigkeit ankommt.

[Hightech]

Wie mache ich das generell eigentlich korrekt, wenn ich mit dem AVR rechne mit den "Kommazahlen", besonders wenn ich Zahlen teile?
Zum Beispiel 10/3. Da hab ich ja 3.333333, das kann ich für spätere Berechnungen ja nicht einfach abschneiden. Oder alles in float?

[Fritzler]

Fixkomma, du rechnest mit einer festen Anzahl an Nachkommastellen.
Oder statt in Ampere in mA/µA.
Um da Überläufe zu vermeiden braucht man aber ab und zu mal ne 64Bit Variable.
Das wird aufm AVR dann auch groß im Code und langsam.
(Vor allem bei Mul und Div).
float auf AVRs ist aber noch schlimmer.

Es empfiehlt sich eine modernere CPU Architektur wie ARM

[nero]

Was sehr lange dauert ist die Umwandlung integer - float - double
Das an zeitkritischen Stellen vermeiden.
Dabei auch aufpassen: 1.23 ist double. Wenn man float will 1.23f schreiben.

Der Compiler wandelt (castet) automatisch immer alles in die "hochwertigste" Einheit. Das ist problemtisch vor allem da unsigned "höherwertig" als signed ist. Steht also eine unsigned int in der Berechung wird die Berechnung und das Ergebnis unsigned. (klassischer Fehler der schon zu vielen Sicherheitslücken geführt hat - unsigned index -> Indexberechung -> check auf kleiner 0 -> ist eh klar da Ergebnis unsigned war -> Index ist riesig und greift auf falschen speicher zu).
Steht ein float in der Berechnung wirds float. Bei einem Double wird alles double.
Worst case ist für die Berechnungsdauer und Speicherbedarf ist also sowas: y = 77 * x1 + 333 * x2 + 1.1;
Braucht vier mal Umwandlungen von int in double.
Besser so schreiben:
y = (770 * x1 + 3330 * x2 + 11) / 10;
oder mit verbessertem Rundungsfehler:
y = (770 * x1 + 3330 * x2 + 11) + 5 / 10;
oder wenns die Genauigkeit braucht:
y_10fach = 770 * x1 + 3330 * x2 + 11;

Bei ARM (Cortex) etc ist zwar eine (also Eine) float Operation immer noch recht langsam (verglichen mit int). Das Gleitkommarechenwerk hat aber eine Pipline. dh das Ergebnis der Gesamt Rechnung kommt 7 (glaub ich aus Stegreif) Takte verspätet. Egal ob dort steht y = 7.77f * x; oder y1 = 1.11 x1; y2 = 2.22f x2; y3 = 3.33f * x3; ...

Bei 8bit wie AVR dauert das einfach alles "ewig". Also an einer Stelle machen wo Zeit keine Rolle spielt ist die beste Lösung.

[nero]

doppelt

[Fritzler]

Auch das Rechnen dauert lange.
Eine Floatzahl wird bei jedem rechnen erstmal ausgepackt.
Dann wird gerechnet, am Ende wird gerundet und wieder eingepackt.
Bei einer Addition wird vorm Rechnen noch die Mantisse angefasst und auf 128Bit aufgeblasen!
Sonst wäre jede Addition ein Würfelspiel.

Einpacken und auspacken ist quasi ein:

Was sehr lange dauert ist die Umwandlung integer - float [..]

Das Dauert, vor allem auf nem 8Bitter.
Daher hat der AVR GCC erst garkein double.
Auf einem ARM ist softfloat etwas schneller, aber auch lahm.
Zum Glück haben Cortex-M4 Aufwärts ne FPU

Es ist natürlich imemr vom Anwendungsfall abhängig obs sich lohnt, wer viel rechnet sollte was mit FPU nehmen.
Für meine E-Last war ein AVR schon zu lahm, der konnte keine 100Hz nach einem Gleichrichter mehr mit konstant 1A belasten.

Das Gleitkommarechenwerk hat aber eine Pipline. dh das Ergebnis der Gesamt Rechnung kommt 7 (glaub ich aus Stegreif) Takte verspätet.

Japp, das weis der Compiler aber und versucht da andere Befehle reinzustreuen.
Ein zu früher Zugriff in Eigenbau ASM stallt dann einfach die CPU selbst bis die FPU fertig hat.

[Später Gast]

Wie mache ich das generell eigentlich korrekt, wenn ich mit dem AVR rechne mit den "Kommazahlen", besonders wenn ich Zahlen teile?
Zum Beispiel 10/3. Da hab ich ja 3.333333, das kann ich für spätere Berechnungen ja nicht einfach abschneiden. Oder alles in float?

Ich mache das so, dass ich intern die Variable so weit aufmultipliziere, wie es die Größe der Variable halt zulässt und es nur für die Anzeige/Ausgabe durch den entsprechenden Faktor teile. Es muss dann nix mit Kommas gerechnet werden und Trunkierung führt zu vernachlässigbaren Ungenauigkeiten. In deinem Fall könnte man 30/3 rechnen und das Ergebnis der späteren Weiterverarbeitung nach der Weiterverarbeitung nochmal durch 3 teilen.Wenn man bei der Ausgabe Nachkommastellen braucht, halt vorher mit entsprechenden Zehnerpotenzen multiplizieren.

[Lukas_P]

oke ich hab es rausgefunden :

ich hatte bei einem if in einem ganz anderen Teil meines Codes (der lange nachher abgearbeitet wird) das 2. = vergessen ... nur warum das so viel weiter vorn im Programm scheisse baut ist mir nicht klar...

[IPv6]

Ich habe in eine Schaltung einen Arduino Nano (läuft klassisch mit 5 V) reingefrickelt.
In der Schaltung sitzt ein IC und ein Display, die über I²C mit dem Arduino sprechen sollen.
Das Display und das IC werden mit 3,3 V versorgt, zumindest das Display ist an seinen I²C Pins nicht 5 V tolerant.

Kann ich nun auf Levelshifter verzichten, indem ich die Pullups von I²C einfach auf 3,3 V lege, also mein ganzer I²C Bus einfach mit 3,3 V läuft?
Die ganzen Busteilnehmer ziehen die Leitungen ja bloß auf GND, der Arduino dürfte da keine 5 V drauf geben.
Auch wenn es etwas knapp ist aber in der Regel werden die 3,3 V ja noch als Highpegel erkannt.

Könnte gehen, oder?

[Anse]

Könnte gehen, oder?

ja. Aber warum probierst Du es nicht einfach aus?
Das ist aber halt auch noch ein Nachteil des Arduino Ökosystems. Keine frei Wahl der Spannungsebene.

[IPv6]

Weil ausprobieren sehr viel Fädeldrahtgefädel bedeutet, das würde ich gerne ein einziges Mal so machen, dass es dann möglichst auf Anhieb läuft

[Finger]

Dat funzt, hab ich schon erfolgreich gemacht .