"Gruppierung" von Pins

In jeder guten Bücherei gibt es Bücher zum Programmieren-Lernen. Oftmals 
sogar für C/C++.
Darin werden Konzepte wie Arrays und Schleifen erklärt. Millionen von 
Programmierer haben es so erlernt.

Es gibt auch (in einer anderen Sprache) komfortablere Möglichkeiten:

Man nimmt sich ein Hilfsregister

Dim Himmel_hilf as Byte

Dort drin schiebt man sich seine Bits so hin, wie man sie an einen 
zusammenhängenden Port ausgeben würde.

Dann gehts los:

z.B.

Portb.0 = Himmel_hilf.0
Portb.1 = Himmel_hilf.1

Jetzt mal zur Freude der Umstehenden einen Pin an einem anderen Port.

Portd.0 = Himmel_hilf.3
Portd.5 = Himmel_hilf.4

Auf diese Weise kann man schön mit "normal breiten" selbst gefertigten 
Registern programmieren und dann in Frieden sonstwohin ausgeben.

Das ist übrigens Bascom. Mit dem C-artigen Zeug will ich nichts zu tun 
haben.

Hi

>Darin werden Konzepte wie Arrays und Schleifen erklärt. Millionen von
>Programmierer haben es so erlernt.

Und weit mehr lernen es nie.

MfG Spess

Dann nimm doch die vom Arduino bereitgestellte Funktion digitalWrite 
statt des direkten Portzugriffs. Der darfst Du eine Zahl von 2...11 für 
den entsprechenden Pin übergeben.

Christoph B. schrieb:
>
> Ich möchte ausschließlich mit C programmieren und nicht auf die
> Funktionen von Arduino zurückgreifen. Der Grund hierfür ist, dass ich
> irgendwann mal mit ATMEL-µCs zu tun haben werde und dann blöd aus der
> Wäsche gucke, sollten mal keine Arduino-Funktionen zur Verfügung stehen.

Hm...
Wenn du bereit bist, richtig auf den Teilen zu Programmieren, dann 
werden die Atmels wohl schon abgekündigt sein.

Und im richtigen Leben wirst du noch mehr begegnen. Ich habe hier mit 4 
verschiedenen Architekturen zu tun. Da muss man auch über den Tellerrand 
schauen können.


Aber beschäftige dich erst einmal mit den Grundlagen. So ein K&R dürfte 
erst einmal das richtige sein.

Christoph B. schrieb:
> Ich möchte ausschließlich mit C programmieren und nicht auf die
> Funktionen von Arduino zurückgreifen.

Dann schreibe dir halt eine Funktion, die genau das gleiche macht wie 
digitalWrite(). Das ist in diesem Fall definitiv die eleganteste Lösung. 
Du kannst das ja mit einem switch/case Konstrukt umsetzen.

Wenn du gar keine Idee hast, wie man das anstellen könnte, dann schau 
dir dieses Projekt an: http://stefanfrings.de/knightrider/index.html

Wenn Du nur das Lauflicht hast, kannst Du ja einfach per Copy&Paste die 
Anweisungen untereinander schreiben. Vor allem, wenn dazwischen noch ein 
delay() steht. Wenn einer fragt: das ist Loop-Unrolling, also 
hochoptimiert :-P

Switch-Case ist da schon die nächste Stufe. Einfach zu kapieren und auch 
wieder leicht zu lesen.

Wenn Du aber alle abziehen willst, mach mindestens 2 Arrays draus. Eins 
mit Zeigern auf die PORT-Register und ein eins mit Bitnummern oder 
Bitmasken.

Christoph B. schrieb:
> Man kann keinen Pointer auf einen einzigen Pin zeigen lassen, korrekt?

Das geht bei AVR Mikrocontrollern nicht.

Christoph B. schrieb:
> Das Problem ist ja, dass ich eine "smarte
> Schleife" verwenden wollte, die immer die zuvor eingeschaltete LED
> ausschaltet

Nö, "smart" musss Dein Programm schon selber sein. Kann ja nicht so 
schwer sein, sich die Nummer der eingeschalteten Led zu merken.
Bei fortgeschrittener Demenz kann man in diesem Fall auch einfach alle 
ausschalten bevor man die nächste einschaltet.

Zur allgemeinen Verwirrung wäre ich ja jetzt noch dafür, ein Makro zu 
schreiben, das aus einer Integerzahl einen Zugriff auf ein Bit eines 
Portregisters macht.
Tipp: wenn man über Pointer geht, kann man ?-Ausdrücke auch auf der 
linken Seite einer Zuweisung benutzen.

Da die Arduino Umgebung ja C++ ist (und nicht C, wie viele denken), 
könnte man wunderbar Klassen daraus machen. Das dann in 
Standardcontainer packen, und auch Iteratoren drüber laufen lassen.

PittyJ schrieb:
> Da die Arduino Umgebung ja C++ ist (und nicht C, wie viele
> denken),
> könnte man wunderbar Klassen daraus machen. Das dann in
> Standardcontainer packen, und auch Iteratoren drüber laufen lassen.

Könnte man!
Viele (zumindest die Arduino Erfahrenen), auch ich, würden gar nicht auf 
eine andere Idee kommen. Ob jetzt mit Arduino, oder auch neben dieser 
Welt, z.B. mit AS7.

Aber hier.....
Christoph B. schrieb:
> ich bin gerade dabei .... auf einem Arduino mit C
> zu programmieren.
Das grenzt die Wahl der Mittel natürlich stark ein.

Peter D. schrieb:
> Warum sollte man sich unnötig auf nur eine LED einschränken?
> Man könnte ja auch Muster aus mehreren LEDs anzeigen wollen.
> Ein Arrayeintrag, wo jedes Bit direkt einer LED entspricht, ist daher
> deutlich bequemer.

Mir fällt jetzt keine einfache Lösung ein, wie ich 2 Structs des Arrays 
auf einmal abarbeiten kann. Ich muss ja immer damit rechnen, dass port 
bei beiden unterschiedlich ist und ich pinmask nicht einfach 
zusammenfassen darf.
Wenn ich da erst eine Abfrage einbaue, stehe ich vermutlich nicht besser 
da als gleich 2 Zugriffe nacheinander zu machen.

Siehe den Beitrag von Phantomix X.

Du must natürlich keine Structs nehmen, aber irgendwie musst Du 
Led-Nummer umschlüsseln in Port und Bitposition. Bis 4 Ports kannst Du 
auch einen uint32_t als Bitmaske hernehmen.

Was natürlich einfach geht ist eine Funktion, die alle Leds ausschaltet, 
ausser einer, deren Nummer übergeben wird. Für den Fall, dass es bei 
Lauflichtern bleibt, bei denen immer genau eine Led leuchtet.

Peter D. schrieb:
> Man hat ein Array aus 16Bit Werten und eine Ausgabefunktion

Es wäre auch keine Schande, einfach zwei Arrays (mit je 8 Bit) für die 
beiden Ports zu erstellen.

Christoph B. schrieb:
> Wofür steht zum
> Beispiel das B8(...)
Ohne die Quelle gelesen zu haben.....

Das könnte ein Konstruktor sein.
Ein C++ Cast
Oder, am wahrscheinlichsten, ein Makro.

Wie auch immer, es wird sich im Quellcode finden lassen.

>> Oder soll ich die Bitmuster lieber
>> ausschreiben? Also zum Beispiel: 0b0000010000000000


Peter D. schrieb:
> Natürlich. Dann ist doch sofort zu sehen, welches Muster erzeugt wird.

Och würde es auch so machen. Und die Zahlen untereinander schreiben, 
damit sofort auffällt, wenn man eine 0 vergessen hat.

Moin,

Stefan ⛄ F. schrieb:
>>> Oder soll ich die Bitmuster lieber
>>> ausschreiben? Also zum Beispiel: 0b0000010000000000
>
> Peter D. schrieb:
>> Natürlich. Dann ist doch sofort zu sehen, welches Muster erzeugt wird.
>
> Och würde es auch so machen. Und die Zahlen untereinander schreiben,
> damit sofort auffällt, wenn man eine 0 vergessen hat.

Das hängt doch aber auch von der persönlichen Gewohnheit ab.
Mir erscheint ein 0x0400 viel lesbarer als ein 0b0000010000000000.
Und eine Verwechselung mit 0b0000001000000000 ist viel schneller
passiert als mit 0x0200. Aber das gilt für mich, weil ich Bitmuster
immer in hex schreibe und es eben so gewohnt bin. Gerade bei 16 oder
32 Bit ist mir die Zählerei zu fehleranfällig.

Darth Moan schrieb:
>> Ich würde es auch so machen.
> Das hängt doch aber auch von der persönlichen Gewohnheit ab.

Ach was! Was sonst bedeutet "Ich würde es auch so machen"?

Stefan ⛄ F. schrieb:
>>> Ich würde es auch so machen.
>> Das hängt doch aber auch von der persönlichen Gewohnheit ab.
>
> Ach was! Was sonst bedeutet "Ich würde es auch so machen"?

Das ist eine Interpretationsmöglichkeit. Aber ein explizites Benennen
als persönliche Gewohnheit scheinst Du jetzt als einen Angriff auf dich
zu verstehen. Das war aber nicht so gemeint. Ich wollte nur mal die Hex 
Variante einwerfen, weil ich die für lohnenewert halte, und zwar 
explizit ohne alle Anderen, die lieber binär schreiben, als verschroben 
oder so hinzustellen. Aber das ist hier wohl unüblich. Tut mir leid. 
Kommt nicht wieder vor.

Egonwalter M. schrieb:
> Also eine hex-Darstellung ist sicherlich einfacher zu lesen als die
> Bitaufdroeselung, insbesondere da man sich bei der zuletzt genannten
> sehr leicht “verzählt”.

Och, ich seh das anders:

1

const unsigned char Bitmap_Big_Char[8][8] = {

2

    {

3

        0b00111,

4

        0b01111,

5

        0b11111,

6

        0b11111,

7

        0b11111,

8

        0b11111,

9

        0b11111,

10

        0b11111

11

    },

12

13

    {

14

        0b11111,

15

        0b11111,

16

        0b11111,

17

        0b00000,

18

        0b00000,

19

        0b00000,

20

        0b11111,

21

        0b11111

22

    },

23

    {

24

        0b11100,

25

        0b11110,

26

        0b11111,

27

        0b11111,

28

        0b11111,

29

        0b11111,

30

        0b11111,

31

        0b11111

32

    },

1. Wenn man nur plöde LED's ansteuern will, braucht man den ganzen 
Aufwand nicht. Entweder man nimmt 2 x PCF8574 o. das 16 Bit-Modul. Ich 
persönlich finde die 8 Bit-Module chic'er.

Was die Programmierkenntnisse des TO angeht, kann ich ihn nur das

https://www.amazon.de/Arduino-Kompendium-Elektronik-Programmierung-Projekte/dp/3966450399

empfehlen. Da lernt er C auf Basis eines Arduino und darin auch den 
Umgang mit Bits + Array's.

Der Vorteil eines Port-Expander via i2c ist gerade für Anzeigen (LED / 
Displays / 7-Segment-Anzeigen) perfekt. Alles mit viel Pins und wenig 
Leistung pro Pin. Und man spart sich Pins am Arduino die man für andere 
wichtige Sachen braucht.

Ist jedenfalls meine Meinung. In meine Modellautos passt keine Arduino 
rein, aber 4 Dünne Drähte schon. Die werden dann NACKT an den SMD-Chip 
direkt angelötet und im Auto an die LED-Beleuchtung verteilt. So passt 
das dann. ;)

Darth Moan schrieb:
> Das ist eine Interpretationsmöglichkeit. Aber ein explizites Benennen
> als persönliche Gewohnheit scheinst Du jetzt als einen Angriff auf dich
> zu verstehen...Tut mir leid.

Nein keineswegs, du brauchst dich nicht zu entschuldigen. Wir sind doch 
keine Weicheier.

Ja, meine Empfehlung ist mein persönlicher Geschmack. Dafür schäme ich 
mich nicht. Wenn es jemand anders machen will: gerne, ich habe nichts 
dagegen.

> Ich wollte nur mal die Hex Variante einwerfen,
> weil ich die für lohnenswert halte

Gut, macht auch Sinn andere Vorschläge zu machen, die funktionieren.

Schlaumaier schrieb:
> Wenn man nur plöde LED's ansteuern will, braucht man den ganzen
> Aufwand nicht. Entweder man nimmt 2 x PCF8574 o. das 16 Bit-Modul. Ich
> persönlich finde die 8 Bit-Module chic'er.

Hä?

Du bist irgendwie auf dem falschen Gleis. Wir diskutieren hier nicht 
über Port Erweiterungen.

Stefan ⛄ F. schrieb:
> Du bist irgendwie auf dem falschen Gleis. Wir diskutieren hier nicht
> über Port Erweiterungen.

Was ein Fehler ist, deshalb habe ich es erwähnt.

Der TO belegt eine Menge Pins. Und die muss er auch noch alle einzeln 
ansteuern.  Wenn er eine Port-Erweiterung wie den besagten PCF-8574 
nutzt, kann er das BIT-Array mit 1 Befehl via Libs / I2C an den Chip 
senden. Das spart Code ohne Ende. Und Speicher ist Knapp in den Teilen.

Deshalb mein Vorschlag.

Schlaumaier schrieb:
> Das spart Code ohne Ende. Und Speicher ist Knapp in den Teilen.

Du missionierst hier mit einer vermeintlichen Lösung für ein nicht 
existentes Problem.

Christoph B. schrieb:
> Vielen Dank für den Vorschlag. Nur so weit bin ich noch nicht - ich
> wollte zu erst mal die Grundlagen von C erlernen und mit dem Equipment,
> welches ich gerade besitze, programmieren.

O.K.

Das Buch was ich dir oben empfohlen habe, bringt dir die gewünschten 
Kenntnisse perfekt bei. Ich habe es selbst gekauft, weil ich noch 
einiges Nachschlagen wollte. Davon abgesehen hat mir gefallen, das ich 
das Buch als dicken Wälzer und als PDF + EPUB GLEICHZEITIG bekomme für 
20 Euro.

Den Preis für so ein Wälzer finde ich mehr als fair. Einziger Nachteil 
wenn man so will. Das ganze PAPIER-Buch inkl. Fritzing-Bilder etc. ist 
in S/W. in der PDF + Co in Farbe. 4-Farben-druck ist teuer. ;)

Im Buch ist ein Code mit den du dich auf der HP des Verlages anmelden 
kannst für die Digitalen Dinge. z.b. auch die Codes in den Wälzer.

Und diese Danny Schreiber schreibt sehr gut. Und das sage ich wirklich 
nicht zu jeden.

Ach ja. Ich habe das vorher getestet, mit einen Kindle-Probe-Abo. ;) Da 
ist es auch drin. Es ist einfacher als sich jedes Zippelchen einzeln im 
Netz zu besorgen.

Davon abgesehen programmiere ich in Basic und der Compiler macht da C 
Code draus. Ich wollte einfach mal den Code auch besser lesen + 
manipulieren können. Weshalb ich mir das Buch gekauft habe.

Brennend Interessierter schrieb im Beitrag #6779765:
> Ja, wie heißt er denn, dieser Compiler?

www.b4x.com <- da kannst du dich schlau machen.

Das System wird in VB-Basic sehr ähnlichen Code programmiert. Danach 
wird der Code in den Code des Zielsystem umgewandelt. Ich benutzte ihn 
für Android (b4*A* ) und Arduino (b4*R*).  Es gibt aber auch eine 
Variante für Ei-Fons (B4*i*) + Irgendwas mit Java. Beide Varianten habe 
ich mir nie angeschaut, da kein Interesse.

Nach der Umwandlung liegt der Code in passenden Ordner und kann 
angesehen werden.

Dies ist auch wichtig weil ich auch mal mit eine Programmer arbeite.
Dann muss ich den Code in die Arduino-IDE laden und "Hochladen per 
Programmer" selbst ausführen.

Bei einen erkannten Arduino / Raspberry am USB-Port geht dieser Vorgang 
vollautomatisch.

Schlaumaier schrieb:
> www.b4x.com

Seltsames Konzept. Wie ein Adapter von Kreuzschraubendreher auf 
Schlitzschrauben.

Ich schätze, dass man sich dennoch mit den Plattform spezifischen 
Bibliotheken und (falls vorhanden) Betriebssystem beschäftigen muss.

Stefan ⛄ F. schrieb:
> Ich schätze, dass man sich dennoch mit den Plattform spezifischen
> Bibliotheken und (falls vorhanden) Betriebssystem beschäftigen muss.

Jein.

Solange man die Libs benutzt die dabei sind, geht es eigentlich ohne.

Problematisch wird das ganze, wenn du eine Libs nutzt die NICHT dabei 
ist.
Dann brauchst du einen "wrapper". Das ist eine Header-Datei die die Libs 
(von z.b. Github) in das System integriert.

Es gibt zwar von einigen Users eine Software die das mehr oder weniger 
brauchbar macht, aber hin + wieder musst du von Hand nachbessern.


Grundsätzlich sollte man aber wissen was die Libs machen. In meine Augen 
geht es hier nur um das Konzept :"Ich muss nicht für jedes Teil eine 
eigenen Syntax lernen".

Was der Grund ist, wieso ich das mag. Ich kann Basic im Schlaf. Damals 
im 20. Jahrhundert habe ich fast ein Dutzend Programmsprachen gekonnt. 
Von Dbase/Clipper über Cobol, Jede Menge Basic-Versionen etc. . 
Heutzutage ist es doch genau so, das du für jeden Mist eine eigenen 
Programmsprache brauchst.

Und erzähle mir bitte nicht das man das "neue" nicht mit ein paar Libs 
auch lösen kann. !!!

MS steuert da zwar mit den NET-Konzept gegen, aber das ist auch 
halbherzig.

Bei b4x ist es halt so. Du include'st die Libs und musst dann wissen 
welche Eigenschaften sie hat,  und was diese bewirken. Den Rest macht 
der Compiler.

Aber : for i = 1 to 10 : i = i + 1 : Next i
funktioniert genau SO auf allen genannten Systemen mit genau der 
gleichen Zeichenfolge. Nix Komische Klammern, Parameter falsch herum 
etc.

Ich spare mir also im Prinzip jede Menge Verwirrung wenn man wie ich 
mehre Systeme programmiert. Mich nervt schon das ich nach den Punkt die 
Auswahl mit Enter statt wie bei VB mit Leertaste bestätigen muss. Ich 
kann nicht zählen wie oft ich das 2 x machen musste.

Peter D. schrieb:
> Sagt wer?
> AND, OR und Schieben wurden schon erfunden. Man kann also ganz bequem
> sämtliche LEDs an einem Port in einem Rutsch ausgeben.

Christoph B. schrieb:
> ür die ersten 6 LEDs verwende ich die Ausänge 2-7 des
> Arduinos, die letzten 4 LEDs steuere ich über die Ausgänge 8-11 an.

Das sind 10 Pins auf einen Arduino die belegt sind. Wie du die ohne 
Register schieben willst ist mir ein Rätzel.

Und wenn du ein Schieberegister an EINEN Pin tust, was eine normale 
alternative Methode ist, musst du das auch kontrollieren.

Bei einen PCF-8574 würde ich aber den Zustand aller 8 Leds mit EINEN 
Befehl schicken. Und DAS ist einfach bequemer als zu schieben.

Schieben machen ich nur wenn ich keine Logik = 1/0 = an/aus habe. Weil 
ich schieben aufwändiger finde. Aber ich gebe zu, ich habe sogar in 
Lehrbüchern LED-Ansteuerung mit Schieberegister gesehen. Nur ich mag so 
Schaltungen halt nicht.


Problem an der Diskussion : Der TO möchte keine externen Chips 
ansteuern.

Und die Internen kann man meines Wissen nur kompliziert schieben.

O.K. ist ne Lösung.

Aber ich bin mega Port-Geizig. Und deshalb ein Fan von Port-Expander für 
so ein LED-Zeug. Passende Bits setzen und das in 1 Zeile via Libs zum 
PCF schicken. Einfach und praktisch.

Phantomix X. schrieb:
> Also, wenn man nicht noch mehr damit vor hat,

Hab ich aber i.d.R., weil in 90% aller Fälle muss da noch eine Tastatur, 
Display und oft eine IR-Diode dran. Und das alles OHNE das die wirkliche 
Funktion des Projekt überhaupt schon ne Bedeutung hat.

Und wenn man von vorne rein, lernt seine Pins sparsam zu benutzen, wird 
man schnell bei seinen Projekt neue Wünsche haben. Und dann muss man 
alles umstricken.

Weshalb ich z.b. schon ein Atiny-85 und ein PCF8574 beides SMD 
gegeneinander geklebt habe, und schon die komplette Schaltung fertig 
hatte. Das ist zwar nicht schön, normgerecht u.s. gewesen, aber es 
passte ins Auto. ;)