"Gruppierung" von Pins

[Christoph B. (brandneraut)]

Hallo liebes µC-Forum,
ich bin gerade dabei, ein Lauflicht mit 10 LEDs auf einem Arduino mit C 
zu programmieren. Fü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.
Ich würde hierfür gerne eine Schleife verwenden, sodass ich die erste 
LED einschalte, 1 sek warte, zweite LED einschalte & erste LED 
ausschalte, 1 sek warte, dritte LED einschalte & zweite LED ausschalte, 
unsw. ...
Das Problem ist jedoch, dass sich die LEDs auf unterschiedlichen PORTS 
befinden (PORTD & PORTB). "Einfache" Bitmanipulationen (Bit setzen und 
zuvorgesetzes Bit rücksetzen) in Kombination mit einer Schleife, 
funktionieren wohl nicht (würden sich alle LEDs auf einem Port befinden 
hätte es geklappt).
Blöde Frage, aber kann man irgendwie, die Pins gruppieren? 
Möglicherweise in einem Array oder Ähnlichem? Wie würdet ihr dieses 
Problem lösen?

Mit freundlichen Grüßen
BrandnerAUT

[Veit D. (devil-elec)]

Hallo,

was du machst in unhöflich. Kümmere dich erstmal um deinen anderen 
Thread.
Beitrag "Kurzschreibweise"

Array wäre übrigens passend wenn man mit Schleifen handiert.

[Christoph B. (brandneraut)]

Veit D. schrieb:
> was du machst in unhöflich. Kümmere dich erstmal um deinen anderen
> Thread.
Bitte entschuldige mein Verhalten. Ich habe mich bereits mit der ersten 
Antwort dort zufriedengegeben.

> Array wäre übrigens passend wenn man mit Schleifen handiert.
Das Array klingt natürlich gut. Ich weiß jedoch nicht, wie ich die Pins 
in das Array bekommen kann. Ist das überhaupt möglich? Gibt es dafür 
vielleicht andere Strukturen?

[PittyJ (Gast)]

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.

[Port-Zersäger (Gast)]

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.

[Spess53 (Gast)]

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

[FOp (Gast)]

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. (brandneraut)]

FOp schrieb:
> 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.

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.

[Veit D. (devil-elec)]

Christoph B. schrieb:
> Veit D. schrieb:
>> was du machst in unhöflich. Kümmere dich erstmal um deinen anderen
>> Thread.
> Bitte entschuldige mein Verhalten. Ich habe mich bereits mit der ersten
> Antwort dort zufriedengegeben.

Schön das du dich zufrieden gibts. Nur wissen das die Threadteilnehmer 
nicht. Die haben sich alle viel Zeit genommen um dir zu helfen. Die 
wissen nicht ob dein Problem nun gelöst ist oder nicht. Du lässt die 
eiskalt im Regen stehen. Ein Danke und das alles gelöst ist wäre aus 
meiner Sicht das Mindeste. Das sagt mir zumindestens meine Erziehung. 
Weiß nicht ob das in Österreich unüblich ist.

Wegen Array, kurze Suche ergibt
Beitrag "[AVR] Pins über Array ansteuern"
und denk ans volatile.

[PittyJ (Gast)]

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.

[Peter D. (peda)]

Christoph B. schrieb:
> Fü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.

Und welche Portpins sind das?

[Stefan F. (Gast)]

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

[Christoph B. (brandneraut)]

Peter D. schrieb:
> Und welche Portpins sind das?
Die physikalischen Pins 2-7 des Arduinos sind die Portpins PD2-PD7; die 
Pins 8-11 sind PB0-PB3.

[FOp (Gast)]

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. (brandneraut)]

Veit D. schrieb:
> Wegen Array, kurze Suche ergibt
> Beitrag "[AVR] Pins über Array ansteuern"
> und denk ans volatile.
Vielen Dank für deine Bemühungen :)
Ich habe den Thread gestern schon gefunden. Doch leider komme ich auch 
damit auf keinen grünen Zweig. Das Problem ist ja, dass ich eine "smarte 
Schleife" verwenden wollte, die immer die zuvor eingeschaltete LED 
ausschaltet und die nächste LED einschaltet - das Array, des von dir 
empfohlenen Threads, hilft mir hier aber auch nicht weiter, da ich ja 
nach wie vor, den Ports einen Wert zuteilen muss.

Man kann keinen Pointer auf einen einzigen Pin zeigen lassen, korrekt? 
Nur auf das gesamte Port, oder?

[Peter D. (peda)]

Christoph B. schrieb:
> Ich würde hierfür gerne eine Schleife verwenden, sodass ich die erste
> LED einschalte, 1 sek warte, zweite LED einschalte & erste LED
> ausschalte, 1 sek warte, dritte LED einschalte & zweite LED ausschalte,
> unsw. ...

Das hört sich reichlich umständlich und unübersichtlich an und ist es 
wohl auch.
Um Bitmuster auszugeben, nimmt man ein Array und einen Zähler, der den 
Arrayindex hochzählt.
Das Array kann man schnell ändern bzw. mehrere Arrays (Muster) 
definieren.
Für 10 LEDs nimmt man 16Bit Werte, da es keine 10Bit-Typen gibt.
Man braucht dann nur noch eine Funktion, die die Bits auf beide Ports 
ausgibt, ohne die anderen Pins zu ändern.

void out16(uint16_t val)
{
  PORTD = PORTD & 0b00000011 | (val >> 8) & 0b11111100; // PD2-PD7
  PORTB = PORTB & 0b11110000 | val & 0b00001111;        // PB0-PB3
}

[Stefan F. (Gast)]

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

Das geht bei AVR Mikrocontrollern nicht.

[Phantomix X. (phantomix)]

#include <stdbool.h>
#include <stdint.h>

typedef struct {
    volatile void* port;
    uint8_t pinmask;
} portpin_t;

static portpin_t pins[] = {
    { &PORTB, 0x01 },
    { &PORTB, 0x02 },
    { &PORTB, 0x04 },
    { &PORTB, 0x08 },
    { &PORTB, 0x10 },
    { &PORTB, 0x20 },
    { &PORTB, 0x40 },
    { &PORTC, 0x02 },
    { &PORTC, 0x08 },
    { &PORTC, 0x80 }
};
#define PINS_COUNT (sizeof(pins) / sizeof(portpin_t))

static void pinout(portpin_t* pp, bool high)
{
    if(high) {
        *(pp->port) |=  pp->pinmask;
    } else {
        *(pp->port) &= ~pp->pinmask;
    }
}

void loop()
{
    static uint8_t last_index = 0;
    static uint8_t index = 0;
    pinout(&pins[last_index], false);
    pinout(&pins[index], true);
    delay(1000);
    last_index = index;
    index++;
    if(index >= (PINS_COUNT)) index = 0;
}

Nur mal schnell so runtergetippt. Fehler dürfen gern behalten und 
eingerahmt werden.

[fop (Gast)]

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.

[fop (Gast)]

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.

[Christoph B. (brandneraut)]

FOp schrieb:
> 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
Weißt du zufällig, ob diese Methode viel schneller/langsamer ist als die 
anderen Varianten?
> Switch-Case ist da schon die nächste Stufe. Einfach zu kapieren und auch
> wieder leicht zu lesen.
Switch-Case ist tatsächlich keine schlechte Idee. Ich bedanke mich an 
Stefanus.
> 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.
Zeiger und Arrays muss ich noch lernen. Ich setze mich dran :)

[Christoph B. (brandneraut)]

Peter D. schrieb:
> Für 10 LEDs nimmt man 16Bit Werte, da es keine 10Bit-Typen gibt.
> Man braucht dann nur noch eine Funktion, die die Bits auf beide Ports
> ausgibt, ohne die anderen Pins zu ändern.
>

> void out16(uint16_t val)
> {
>   PORTD = PORTD & 0b00000011 | (val >> 8) & 0b11111100; // PD2-PD7
>   PORTB = PORTB & 0b11110000 | val & 0b00001111;        // PB0-PB3
> }
>

Vielen Dank. Ich werde das mal ausprobieren :D

[PittyJ (Gast)]

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.

[Peter D. (peda)]

Hier mal ein Beispiel für mehrere Muster mit Array.
Beitrag "AVR Sleep Mode / Knight Rider"

[EAF (Gast)]

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. (peda)]

fop schrieb:
> 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.

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.

[fop (Gast)]

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.

[Peter D. (peda)]

fop schrieb:
> Mir fällt jetzt keine einfache Lösung ein, wie ich 2 Structs des Arrays
> auf einmal abarbeiten kann.

Hier werden doch keinerlei Structs gebraucht, wozu?
Ich verstehe nicht, warum man immer alles maximal kompliziert denken 
muß.
Man hat ein Array aus 16Bit Werten und eine Ausgabefunktion, die davon 
10 Bits auf 2 Ports ausgibt. Fertig.

Beitrag "Re: "Gruppierung" von Pins"

[fop (Gast)]

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.

[Stefan F. (Gast)]

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.

[Peter D. (peda)]

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

Was aber die Erstellung der Arrays komplizierter und unübersichtlicher 
macht.
In einen Arrayeintrag könnte man sogar bis zu 64 LEDs (uint64_t) packen.

[Christoph B. (brandneraut)]

Peter D. schrieb:
> Man hat ein Array aus 16Bit Werten und eine Ausgabefunktion, die davon
> 10 Bits auf 2 Ports ausgibt. Fertig.

Hallo Peter,
die Bitmuster hast du in deinem Beispiel im File "pattern.c" im Array 
"pattern "untergebracht, hab ich das richtig entziffert? Falls ja, 
verstehe ich da die Deklaration nicht so ganz (bitte nicht auslachen - 
schließlich bin ich noch ein blutiger Anfänger). Wofür steht zum 
Beispiel das B8(...) und die Zahlen, wie 16 oder 32, die du ab und an im 
Array angelegt hast?

 uint8_t pattern[] =   {
      16,    // number of following steps
      B8(00000000),
      B8(00000001),
      B8(00000011),
      .
      .
      16,    // number of following steps
      B8(00000000),
      B8(10000000),
      B8(11000000),
      .
      .
      .
      32,    // number of following steps
      .
      .
      .
      0    // mark end of table
      };

[EAF (Gast)]

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.

[Christoph B. (brandneraut)]

Peter D. schrieb:
> Man hat ein Array aus 16Bit Werten und eine Ausgabefunktion, die davon
> 10 Bits auf 2 Ports ausgibt. Fertig.

Hallo Peter,
hast du das mit dem Array so gemeint? Oder soll ich die Bitmuster lieber 
ausschreiben? Also zum Beispiel: 0b0000010000000000

 uint16_t bitpattern[] = {
    (1<<10),
    (1<<11),
    (1<<12),
    (1<<13),
    (1<<14),
    (1<<15),
    (1<<1),
    };

Übrigens hab ich nur noch eine LED am PORTB hängen.

[Peter D. (peda)]

Christoph B. schrieb:
> Oder soll ich die Bitmuster lieber
> ausschreiben? Also zum Beispiel: 0b0000010000000000

Natürlich. Dann ist doch sofort zu sehen, welches Muster erzeugt wird.

[Stefan F. (Gast)]

>> 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.

[Christoph B. (brandneraut)]

Vielen Dank Peter und Stefan!
Also für meine zukünftigen "Projekte": Bitmuster in Arrays hinterlegen 
und am besten, die Muster hinsichtlich besserer Lesbarkeit ausschreiben.

[Darth Moan (Gast)]

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.

[Stefan F. (Gast)]

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"?

[Darth Moan (Gast)]

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. (heiner1234)]

Darth Moan schrieb:
> 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…
> 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.

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

[Teo (Gast)]

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:

const unsigned char Bitmap_Big_Char[8][8] = {
    {
        0b00111,
        0b01111,
        0b11111,
        0b11111,
        0b11111,
        0b11111,
        0b11111,
        0b11111
    },

    {
        0b11111,
        0b11111,
        0b11111,
        0b00000,
        0b00000,
        0b00000,
        0b11111,
        0b11111
    },
    {
        0b11100,
        0b11110,
        0b11111,
        0b11111,
        0b11111,
        0b11111,
        0b11111,
        0b11111
    },

[Peter D. (peda)]

Darth Moan schrieb:
> Mir erscheint ein 0x0400 viel lesbarer als ein 0b0000010000000000.

Nur eine LED an, ist aber der Spezialfall. In meinem Beispiel sind ja 
verschiedene Muster definiert. Und dann sieht man mit der 
Hex-Darstellung alt aus, z.B. wenn 2 LEDs gegeneinander laufen sollen.
Stehen die Binärwerte untereinander, kann man sich auch nicht verzählen.

[Egonwalter M. (heiner1234)]

Peter D. schrieb:
> Darth Moan schrieb:
>> Mir erscheint ein 0x0400 viel lesbarer als ein 0b0000010000000000.
>
> Nur eine LED an, ist aber der Spezialfall. In meinem Beispiel sind ja
> verschiedene Muster definiert. Und dann sieht man mit der
> Hex-Darstellung alt aus, z.B. wenn 2 LEDs gegeneinander laufen sollen.
> Stehen die Binärwerte untereinander, kann man sich auch nicht verzählen.

Versteh' ich zwar nicht, weshalb man bei 2 gegeneinander laufende LEDs 
alt aussehen soll, wenn diese per Array in hex definiert sind, aber wenn 
Du meinst.

[Schlaumaier (Gast)]

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. ;)

[Thomas (kosmos)]

Als ich früher mit den Tinys gearbeitet habe die nur recht wenig Pins 
hatten habe ich einfach 8bit Latches genommen. Da kamen so Spielereien 
raus wie eine LED Gartenwegmarkierung/Beleuchtung/Lauflicht  mit 2 x 50 
LEDs oder 8 Bit LCD Ansteuerung und gleichzeitig Nutzung mehrerer ADC 
Kanäle.

Ich finde es viel pratkibabler die Daten von einem Port in ein Latch zu 
übergeben und den Port dann für andere Dinge frei zuhaben. Es kostet nur 
ein paar Steuerleitungen(Pins) aber man kann dieses Port vollständig 
weiterverwenden und auch von Ausgang auf Eingang umschalten.

[Stefan F. (Gast)]

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.

[Stefan F. (Gast)]

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.

[Schlaumaier (Gast)]

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.

[Stefan F. (Gast)]

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. (brandneraut)]

Schlaumaier schrieb:
> 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.
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.

[Schlaumaier (Gast)]

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.

[Schlaumaier (Gast)]

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.

[Stefan F. (Gast)]

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.

[Schlaumaier (Gast)]

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. (peda)]

Schlaumaier schrieb:
> Der TO belegt eine Menge Pins. Und die muss er auch noch alle einzeln
> ansteuern.

Sagt wer?
AND, OR und Schieben wurden schon erfunden. Man kann also ganz bequem 
sämtliche LEDs an einem Port in einem Rutsch ausgeben.
Die Einzelansteuerung kostet nur unnötig Code.

Und es gibt auch keinen Grund, nicht alle Pins zu benutzen, die der MC 
hat.
IO-Expander benutzt man nur, wenn man sich mit der Auswahl des MCs 
vertan hat oder wenn Steckverbinder zwischen MC und Last liegen.

[Schlaumaier (Gast)]

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.

[Peter D. (peda)]

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

Schieben in SW, d.h. das Bitmuster an die gewünschte Position im Port 
schieben. Da die Ports 8Bittig sind, mußt Du schieben, um 10 Bit auf 2 
Ports zu verteilen. Ginge natürlich auch über eine if/else Orgie.

[Schlaumaier (Gast)]

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. (phantomix)]

Schlaumaier schrieb:
> Aber ich bin mega Port-Geizig. Und deshalb ein Fan von Port-Expander für
> so ein LED-Zeug.

Naja die Pins am Arduino sind bezahlt und da. Genau wie der Flash und 
der RAM in der Kiste. Also, wenn man nicht noch mehr damit vor hat, 
warum nicht direkt für die LEDs benutzen?
Den PCF dagegen musst du extra kaufen und hast auch noch mehr 
Verdrahtungsaufwand

[Schlaumaier (Gast)]

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. ;)

[Phantomix X. (phantomix)]

Meistens mache ich mir erstmal eine Art von Diagramm mit allen 
Systemkomponenten, daraus ergibt sich dann bspw die Anzahl der 
benötigten Pins, die Rechenleistung, RAM-Bedarf usw. Der Punkt mit 
"nicht genügend I/O, brauche Expander" kommt eventuell und erst später, 
nämlich wenn man feststellt, dass bei der Konkretisierung/Bauteilauswahl 
sonst kein zufriedenstellender Kompromiss möglich ist.