Hallo holde Gemeinde!
Vorab: Ich beneide Menschen, welche sich im Binärsystem und Assembler
zuhause fühlen- ich schaffe sowas einfach partout nicht, Mathe und Logik
sind nicht wirklich meine Welt.
Schlimm genug dass ich versuche, via Bascom und einer Porterweiterung
via Schieberegister meine µC-Ausgänge erweitern zu wollen. :)
Die Anforderung mag für viele hier absolut banal und simpel sein, ich
versuche seit Tagen, eine Lösung zu finden.
Ein Atmega16 soll mit wenigen Ausgängen in Summe 26 Relais ansteuern.
Das Einbinden eines Schieberegisters via händischer Programmierung (also
ohne SPI(?)) bekomme ich gebacken- man schiebt quasi immer Nullen und
Einsen in diese Register (es sind in Summer 4 Stk., also 32 Bit?), und
lässt die Ausgänge danach schalten.
Nun aber das Problem:
Ich möchte meinetwegen Relais 1 + 5 ansteuern, dann umschalten auf 1+7,
dann meinetwegen auf 4+3, etc...
WIE zum Henker muss ich das meinem Programmcode mitteilen?
Wenn ich die Relais direkt am µC hängen habe, ist es soweit kein Ding,
ich gebe den Pins Namen:
Config PortA.0=Output
Name as Porta.0
Config PortA.1=Output
Test as Porta.1
Wenn ich nun "Name" schalten will, sage ich:
Name=1
Bei Test wäre es eben Test=1 usw...
Dies kann man im Progamm super verwenden.
Will ich nun aber mittels Drehencoder (die Routinen gibt es
dankenswerterweise ja zum abkopieren ;)) diese 26 Relais schalten,
müsste ich quasi irgendeine Art Zähler haben, welcher den ermittelten
Wert dem Schieberegister so reinschiebt, dass was Brauchbares rauskommt.
In einer ersten Programmroutine wähle ich die Relais 1-8, dann betätige
ich den Taster im Drehencoder und soll dann meinetwegen Relais 9-16
zusätzlich auswählen können.
Nur wie gestalte ich dieses Thema in Bascom (andere Sprachen sind keine
Option für mich, ehrlich)?
Den richtigen Ausgang des Registers bekomme ich zwar bestimmt einmalig
geschalten, aber wie mache ich einen zweiten Schaltvorgang an einem
anderen Ausgang, so dass der erste bestehen bleibt?
Ist jetzt etwas verwirrend beschrieben, aber mir fällt keine
vernünftigere Problembeschreibung ein... :/
Hat jemand Rat für mich?
VIELEN Dank schonmal an alle, die sich hier erbarmen mögen...
Grüsse,
Matthias
Mal ein Vorschlag ins blaue:
Wie wäre es damit ein Array aus Boolean einzurichten,
den einzelnen Werten kannst du mit #define array[x] Name
(oder wie immer das auch in Bascom geht) einen Namen geben
und mit z.B. Name=1 die passende Stelle im Array ändern.
Danach musst du nur noch das ganze Array auf das Schieberegister takten
und valide schalten.
Hi,
Du könntest auch eine Long Variable nutzen und dann die Bits 0 - 25 für
die Relais setzen und diese dann Byteweise an die Schieberegister
senden.
Gruß JackFrost
snowfly schrieb:> Mal ein Vorschlag ins blaue:>> Wie wäre es damit ein Array aus Boolean einzurichten,> den einzelnen Werten kannst du mit #define array[x] Name> (oder wie immer das auch in Bascom geht) einen Namen geben> und mit z.B. Name=1 die passende Stelle im Array ändern.> Danach musst du nur noch das ganze Array auf das Schieberegister takten> und valide schalten.
Hi und schonmal vielen Dank für deinen Ratschlag!
Ich weiß ja nichtmal, was ein Array aus Boolean ist... :/
Im Prinzip wäre es super, wenn ich jedem Relais eine Nummer zuteilen
könnte.
Der Encoder zählt dann meinetwegen eine Variable hoch/runter.
Ich betätige den Taster, und kann einen zweiten Wert übergeben, welcher
dann ein zweites Relais NEBEN dem ersten schaltet.
Kurzum: Irgendeine Routine/Befehle/Befehlskette, welche es mir
ermöglicht, die Ausgänge der Schieberegister beliebig ein/auszuschalten-
wie die Ausgänge des µC selbst.
Ich sag ja: Mathe war schon immer die Hölle- bin wohl mehr der
"kreative" Künstlertyp. :D
µC-Technik ist echt was für Matheasse, bzw. Menschen, welchen logisches
Denken einfach fällt.
JackFrost schrieb:> Hi,>> Du könntest auch eine Long Variable nutzen und dann die Bits 0 - 25 für> die Relais setzen und diese dann Byteweise an die Schieberegister> senden.>> Gruß JackFrost
Hi und natürlich ebenfalls vielen Dank!
Hmm, klingt plausibel, aber ich wüsste nicht, wie ich dies in
Programmcode umsetzen kann.
Dazu fehlt mir einfach das logische Denken in diesen Belangen.
Einfach hingegen ist es, mit den vorhandenen Ausgängen zu arbeiten- nur
komme ich in meiner Anwendung nicht um den Einsatz von Schieberegistern
herum.... :/
Hallo,
nochmals zur einfacheren Erläuterung:
Gut wäre, wenn ich eine Routine hätte, welcher ich sagen könnte:
Relais1 =1
Relais5= 1
Relais4= 0
usw, usf...
Also quasi so tun, als ob ich anstelle der vorhandenen
Controller-Ausgänge eben zusätzliche weitere 26 habe, welche eben in den
Schieberegistern sitzen.
Entweder ist die Lösung so einfach, dass ich nicht draufkomme- oder
aber, und dass ist weitaus wahrscheinlicher: Ich raffe die Verwendung
von minimal komplexeren Variablensystemen in Bascom einfach nicht. :)
Viele Grüsse,
Matthias
Hallo,
die Idee von JackFrost mit einer "long" Variablen (32 Bit) könnte man zB
auf die folgende Art umsetzen:
Zunächst definiert man alle Relais als eine Zahl entsprechend ihrer
Wertigkeit in der Variablen. D.h., wir haben das:
Relais_1 = 1
Relais_2 = 2
Relais_3 = 4
Relais_4 = 8
Relais_5 = 16
...
Relais_25 = 16.777.216
Dann errechnest du deine Long Variable als:
LongVar = Relais_1 | Relais_3 | Relais_4 | Relais_6 usw.
(Die vertikalen Striche sollen ein bitweises OR darstellen. Ich weiß
grad nicht, ob das in Bascom auch so geschrieben wird, aber die
Bascom-Hilfe weiß, was gemeint ist)
Und zuletzt schiebst du deine LongVar Stück für Stück in die
Schieberegister.
Hi, nehme einfach 4 bytes, zB 'A', 'B', 'C' und 'D', lege dir alias an
wie zB Rel_1 alias A.0, Rel_2 alias A.1... erkennst du schon die
Systematik? Und diese 4 bytes schiebst du bei jedem Wechsel eines
Relaisstatus in dein Schieberegister. Unveränderte Relaiszustände
ergeben unveränderte bits.
Um Relais zu schalten, schreibst du Rel_1=1 und alle 4 bytes wieder in
die Schieberegister. Du musst aber immer alle 4 bytes in gleicher
Reihenfolge in die Schieberegister schreiben, am bessten in einer sub.
> Das Einbinden eines Schieberegisters via händischer Programmierung> (also ohne SPI(?)) bekomme ich gebacken- man schiebt quasi immer Nullen> und Einsen in diese Register (es sind in Summer 4 Stk., also 32 Bit?),> und lässt die Ausgänge danach schalten.
Wo liegt dann das Problem?
Du schiebst IMMER die Zustände ALLER Relais raus. Für jedes Relais hast
du eine Variable, die zb 0 ist, wenn das Relais nicht geschaltet sein
soll und 1 wenn das Relais geschaltet sein soll.
Trenn dich von der Vorstellung, du könntest im Schieberegister einzelne
Bits wahlfrei setzen. Statt dessen besteht ein Ausgabezyklus immer
darin, dass du alle Bits hinausschiebst. Ob im Endeffekt ein Pin auf 0
oder auf 1 sein soll, dafür hast du Variablen (im einfachsten Fall
einfach ein Array). Wenn du 1 Relais änderst (oder mehrere) dann setzt
du in der betreffenden Variablen eine 0 oder eine 1 (je nachdem) und
taktest ALLE Variablen erneut auf das Schieberegister raus. Mach dir
keine Sorgen, das geht schnell genug und deinem µC ist es egal, wenn er
mal schnell 32 Bits in Schieberegistern neu ausgeben soll.
Man kann natürlich vorher alles bitmässig in einer Long Variablen
zurechtlegen. Man muss aber nicht. Zur einfach Bearbeitung reicht es
auch ein Array zu benutzen. Also musst du dich mal damit beschäftigen,
wie man in Bascom mit Arrays arbeitet. Das bleibt dir so und so nicht
erspart. Vorteil: du brauchst dich dann nicht mit Bitpfriemelei beim
Aufbau und der Zerlegung zur Übertragung rumschlagen.
Stefan schrieb:> DIM Relais als dword> ..> Relais.5 = 1> ..> Relais.12 = 0> ...>> 'Dann rausschieben
Hallo!
VIELEN HERZLICHEN DANK! So wird es klappen- zumindest im Simulator in
Bascom sieht alles schonmal ganz gut aus.
Die Kette aus den Variablen Relais.1 - Relais.26 schiebe ich mittels
For-Next-Schleife in die Schieberegister und schalte die Dinger danach
ein.
Und die Einzelwerte bekomme ich ganz einfach, indem ich mit dem
Drehencoder eine Variable (z.B. "x") hoch/runterzählen lasse, und diese
dann via Knopfdruck entweder als "0" oder "1" in Relais.x ablege.
Sag ja: Es wäre so einfach, wenn man ein wenig mehr Logik im
Oberstübchen unterbringen könnte. :)
Vielen Dank nochmals an Alle!
Matthias
