closed

Loginbox

Please enter your username and password into the following fields to log in.


  • Username:
  • Password:
  •  
  • Auto log in on every visit.


  •  

Bitweiser Zugriff

Bitweiser indizierter Zugriff auf indiziertes Array

grech offline
Benutzer
Avatar
Gender: male
Location: GERMANY  Saarland
Age: 61
Posts: 15
Registered: 10 / 2015
Private message
Subject: Bitweiser Zugriff  -  Posted: 30.04.2019 - 17:46   -  
Hallo zusammen,
ich bin zwar neu bei AVRCO, programmiere aber schon einige Jahre in Pascal/Delphi...
Neuerdings mache ich was mit Microcontrollern (XMega u.s.),

Dabei habe ich eine Problem:
Ich möchte Taster einlesen( 8 * 128 ) und
möchte Leds (8 * 128) über Schieberegister ein- und ausschalten.
Die Ein- und Ausgabe funktionieren schön. Dabei verwende ich Port A in ganzer Breite zum einlesen
der Taster und Port B zum ansteuern der LED.
An jedem Ausgang der Ports hängen dann bis zu 16 Schieberegister (LS595 bzw LS165).
Das ergibt zusammen also etwa ziemlich genau 1024 bit.
Damit ich mit den Daten (Taster) geschickter hantieren kann,
muss ich zu Beginn meiner Manipulationen etwas umsortieren.
Da fangen mit AVRCO die Probleme an. (oder ich nicht weiß wie es geht)
Ich finde keine elegante Möglichkeit der bitweisen Bearbeitung der Tasten/LED-Daten

Bisher hatte ich das ganze in BASCOM-AVR gelöst.
Wenn man aber mal mit Pascal gearbeitet hat will man sich ja nicht mit Basic ärgern.
Aber da gibt's eine elegante Möglichkeit.

Da gibt's Formulierungen wie:
LEDDAT[Index].pinnr := 1 or 0;
oder
LEDDAT[Index].pinnr := LEDDAT[Index+1].pinnr+1;

Hat jemand eine Idee wie solche Zuweisungen in AVRCO geschickt formuliert werden können?
Bisher helfe ich mir mit einer Procedure die aber bestimmt einiges an Zeit und Speicher frisst.

procedure setb( var abyte: byte; aBit : byte; value : boolean);
var m : byte;
begin
if value then
m := %00000001;
if abit > 0 then
m := m rol abit;
endif;
abyte := abyte or m;
else
m := %11111110;
if abit > 0 then
m := m rol abit;
endif;
abyte := abyte and m;
endif;
end;


eine ähnliche Prozedur gibt es dann auch noch für Word.
Wenn jemand eine geschickten Ansatz für dieses Problem könnte er mir sehr helfen.

Gruß grech
This post has been edited 2-times. Last edit: 30.04.2019 - 17:53 by grech.
go down go up
Merlin offline
Schreiberling
Avatar
Gender: male
Location: UNITED KINGDOM 
Age:
Posts: 877
Registered: 03 / 2005
Private message
Subject: Re: Bitweiser Zugriff  -  Posted: 30.04.2019 - 18:07   -  
for
Code
LEDDAT [Index] .pinnr: = 1 or 0; 


use

Code
SetBit(LEDDAT [Index], pinnr,  1{ or 0}); 


That is equivalent to your function.
Merlin.

:magic:

Software is a black art.
This post has been edited 1-times. Last edit: 30.04.2019 - 18:07 by Merlin.
go down go up
grech offline
Benutzer
Avatar
Gender: male
Location: GERMANY  Saarland
Age: 61
Posts: 15
Registered: 10 / 2015
Private message
Subject: Re: Bitweiser Zugriff  -  Posted: 30.04.2019 - 18:23   -  
OK,
Ich bin zwar sicher, dass ich das ausprobiert hatte und einen Compiler-Fehler bekam.
Aber es funzt.
Und auch die Variante
SetBit(LEDDAT [Index], pinnr, Bit(LEDDAT [Index+1], pinnr-1) );
wird ohne Fehler übersetzt.
Ich nehme an, dass das Programm dann auch das richtige tut.
Muss noch probieren wie es mit WORD aussieht.

Vielen Dank
Grech
go down go up
Merlin offline
Schreiberling
Avatar
Gender: male
Location: UNITED KINGDOM 
Age:
Posts: 877
Registered: 03 / 2005
Private message
Subject: Re: Bitweiser Zugriff  -  Posted: 30.04.2019 - 18:32   -  
It does indeed do the right thing. AVRCo is very strong on bit manipulation.
Merlin.

:magic:

Software is a black art.
This post has been edited 2-times. Last edit: 30.04.2019 - 18:32 by Merlin.
go down go up
grech offline
Benutzer
Avatar
Gender: male
Location: GERMANY  Saarland
Age: 61
Posts: 15
Registered: 10 / 2015
Private message
Subject: Re: Bitweiser Zugriff  -  Posted: 30.04.2019 - 21:39   -  
Das nächste Problem:
ich möchte auf bestimmte bits mit einem Namen zugreifen.
z.B. auf die Tasten eines num. Tastenfeldes. (Num-Pad)
Diese möchte ich als bit deklarieren.
Geht leider nicht!

//=====================================================
const
anz_reg_io : byte = 128;

var
Reg_tasten, //Einlesen über port B
Reg_tasten_old, //zum Vergleich mit aktuellen t:ten
Reg_filter : array[1..anz_Reg_IO] of Byte; //Filter über IO//S

Const
Num16 : byte = 7;

F16_start : Byte = 1;
Adr_s16_7 : Byte = F16_start + 2;
Adr_s16_8 : Byte = F16_start + 1;
Adr_s16_9 : Byte = F16_start + 0;
Adr_s16_s : Byte = F16_start + 15;
Adr_s16_4 : Byte = F16_start + 14;
Adr_s16_5 : Byte = F16_start + 13;
Adr_s16_6 : Byte = F16_start + 12;
Adr_s16_1 : Byte = F16_start + 10;
Adr_s16_2 : Byte = F16_start + 9;
Adr_s16_3 : Byte = F16_start + 8;

var
Num_0[@Reg_tasten[adr_s16_0],num16] : bit;
Num_1[@Reg_tasten[adr_s16_1],num16] : bit;
Num_2[@Reg_tasten[adr_s16_2],num16] : bit;
Num_3[@Reg_tasten[adr_s16_3],num16] : bit;
Num_4[@Reg_tasten[adr_s16_4],num16] : bit;
Num_5[@Reg_tasten[adr_s16_5],num16] : bit;
Num_6[@Reg_tasten[adr_s16_6],num16] : bit;
Num_7[@Reg_tasten[adr_s16_7],num16] : bit;
Num_8[@Reg_tasten[adr_s16_8],num16] : bit;
Num_9[@Reg_tasten[adr_s16_9],num16] : bit;
//===================================================

Könnte aber gehen weil,
Typ der Variable und Adresse schon zur Compilezeit bekannt sind;

Gruß grech
go down go up
pvs-deck offline
PowerUser
Avatar
Gender: male
Location: GERMANY 
Age: 48
Posts: 1030
Registered: 02 / 2009
Homepage Private message
Subject: Re: Bitweiser Zugriff  -  Posted: 30.04.2019 - 22:57   -  
Quote by grech

Das nächste Problem:
....
Könnte aber gehen weil,
Typ der Variable und Adresse schon zur Compilezeit bekannt sind;

Gruß grech


Hallo grech,

hmm...
ich bin mir da nicht ganz sicher ob es so mit einem ARRAY funktioniert.
Evtl. musst Du über eine Schleife "for" das zu prüfende Byte in das definierte Byte übertragen.
Bei Deinem Aufbau könnte der Compiler Probleme haben.

in etwa so (ungetestet)

...
Code
VAR
 bBuffer : Byte;
 Flag1[@bBuffer,num16]  : bit;

procedure CheckByte; var
var
 xi : byte;
 
begin
   for xi:= 1 to anz_Reg_IO do
     bBuffer:= Reg_filter[ xi ]; 
   
   // Hier kannst Du dann Flag1 prüfen und was tun....     

   endfor;
end CheckByte;


Ist einer der möglichen Lösungswege, da ich aber nicht genau weiß was Du mit diesem Construct vor hast, ist es schwer was passendes raus zu suchen.

Thorsten
---------------------------------------------------------
Nichts ist unmöglich in der Elektronik und der Software, die Grenzen
setzt nur das Budget, Zeit und der Entwickler! ( P V S - D E C K )
go down go up
Merlin offline
Schreiberling
Avatar
Gender: male
Location: UNITED KINGDOM 
Age:
Posts: 877
Registered: 03 / 2005
Private message
Subject: Re: Bitweiser Zugriff  -  Posted: 01.05.2019 - 10:31   -  
You can't do it in a single go - the dereferencing is too complex for the compiler, but you can do it in 2 stages, like this (I omitted 0 because adr_s16_0 is missing in the original)

Code
//=====================================================
const
anz_reg_io : byte = 128;

var
Reg_tasten, //Einlesen über port B
Reg_tasten_old, //zum Vergleich mit aktuellen t:ten
Reg_filter : array[1..anz_Reg_IO] of Byte; //Filter über IO//S

Const
Num16 : byte = 7;

F16_start : Byte = 1;
Adr_s16_7 : Byte = F16_start + 2;
Adr_s16_8 : Byte = F16_start + 1;
Adr_s16_9 : Byte = F16_start + 0;
Adr_s16_s : Byte = F16_start + 15;
Adr_s16_4 : Byte = F16_start + 14;
Adr_s16_5 : Byte = F16_start + 13;
Adr_s16_6 : Byte = F16_start + 12;
Adr_s16_1 : Byte = F16_start + 10;
Adr_s16_2 : Byte = F16_start + 9;
Adr_s16_3 : Byte = F16_start + 8;

var
Reg_tasten1[@Reg_tasten[adr_s16_1]] : byte;
Reg_tasten2[@Reg_tasten[adr_s16_2]] : byte;
Reg_tasten3[@Reg_tasten[adr_s16_3]] : byte;
Reg_tasten4[@Reg_tasten[adr_s16_4]] : byte;
Reg_tasten5[@Reg_tasten[adr_s16_5]] : byte;
Reg_tasten6[@Reg_tasten[adr_s16_6]] : byte;
Reg_tasten7[@Reg_tasten[adr_s16_7]] : byte;
Reg_tasten8[@Reg_tasten[adr_s16_8]] : byte;
Reg_tasten9[@Reg_tasten[adr_s16_9]] : byte;

//Num_0[@Reg_tasten[adr_s16_0],num16] : bit;
Num_1[@Reg_tasten1,num16] : bit;
Num_2[@Reg_tasten2,num16] : bit;
Num_3[@Reg_tasten3,num16] : bit;
Num_4[@Reg_tasten4,num16] : bit;
Num_5[@Reg_tasten5,num16] : bit;
Num_6[@Reg_tasten6,num16] : bit;
Num_7[@Reg_tasten7,num16] : bit;
Num_8[@Reg_tasten8,num16] : bit;
Num_9[@Reg_tasten8,num16] : bit;
//===================================================
Merlin.

:magic:

Software is a black art.
go down go up
Harry offline
PowerUser
Avatar
Gender: male
Location: GERMANY  zwischen Augsburg und Ulm
Age: 54
Posts: 1538
Registered: 03 / 2003
Private message
Subject: Re: Bitweiser Zugriff  -  Posted: 01.05.2019 - 12:40   -  
Hallo Grech,

erst mal 2 Fragen:
Welchen Compiler benutzt du (Standard, Profi, Mega8/88, XMegaE5)?
Die LEDs sind einfarbig (kein RGB)?

Du könntest ein Array verwenden:
LED : Array[0..7,0..15] of Byte;

Der erste Wert entspricht dem Pin deines Ports B. Auf einem anderen, nicht verendeten Port definierst du eine SPI-Schnittstelle und schliesst diese an alle Eingänge deiner Schieberegister an. Die Pins des Ports B sind die /CS der 8 Ketten. Du mußt also nur für z.B. Schieberegister-Kette 4, den PortB,3 (es geht ja bei 0 los) auf Low ziehen und via SPI LED[3,0-15] raus schreiben. Der Zugriff auf die 16 Bytes jeder LED-Kette dürfte ja kein Problem sein.

Ich habe sowas ähnliches, nur kleiner mit 32 LEDs eindimensional, mal gemacht. Ich konnte mit einem Mega32 @ 16MHz meine LEDs via SoftSPI ca. 25000x/sek. updaten. topic.php?t=2828

Genau so könntest du auch die Schieberegister deiner Tasten einlesen.

Wenn du die Profi-Version hast, könntest du deine LED-Matrix als Grafik-Array definieren und mit dem GraphIOS immer alle LEDs updaten. Kommt drauf an, was du damit vor hast .... lohnt sich das?

Gruss
Harry

[Edit] Du bräuchtest sowas wie eine Word128-Variable (gibt nur 64):
Quote

4.1.20 WORD64
64bit, 8 Bytes, 0..18446744073709551615 Word64 sind ganze Zahlen. Sie sind auf einen Bereich von 0 bis 18446744073709551615 beschränkt. Word64 benötigen acht Byte Speicher.
var w64 : word64;
Achtung: 64bit Typen wie Word64, Int64 und Fix64 stehen nicht standardmässig zur Verfügung. Der entsprechende Typ muss explizit importiert werden.
from System Import Word64;
Elektronik arbeitet mit Rauch - wenn man den Rauch raus läßt, funktioniert es nicht mehr.
Electronics works with smoke - if you let the smoke out, it works no longer.
This post has been edited 1-times. Last edit: 01.05.2019 - 12:45 by Harry.
go down go up
grech offline
Benutzer
Avatar
Gender: male
Location: GERMANY  Saarland
Age: 61
Posts: 15
Registered: 10 / 2015
Private message
Subject: Re: Bitweiser Zugriff  -  Posted: 01.05.2019 - 15:13   -  
Hallo Harry,
danke für deine Ideen.
Das Ausgeben der 1024 LEDs (16 Schieber mit je 8 Ein/Ausgänge hintereinander,
das ganze 8 bit breit) und Einlesen der Taster sind nicht das Problem.
Das Problem ist, dass ich namentliche Adressierung.
Die allermeisten Taster und parallel dazu die LED haben nur Ein/Ausschaltfunktionen.
Daneben gibt es aber auch Tasten mit sehr mächtigen Funktionen.
Die auch an vielen Stellen im Programm gehandelt werden.
Diese Tasten liegen bei jedem Projekt an anderer Stelle sollen aber immer das gleiche bewirken.
Also wird ein Alias benötigt oder die Benennung eine bit-Variable.

Zu meiner Hardware und Software.
XMega256A3U und Profiversion des Compilers.
In BASCOM schreibt man einfach z.B.
Transposer_M1 ALIAS Reg_taste(11).tab_mitte

Dabei ist Reg_Taste das array[1..128] of byte und Tab_Mitte eine Byte-Variable oder Konstante.
rh hatte noch eine Idee es mit Bit-Sets zu probieren.
Das schau ich mir mal an.
Weiß nur von Pascal/Delphi,
dass sets, je nachdem was man damit macht, sehr teuer werden können.

Gruß grech
You must be logged in or your permissions are to low to see this Attachment(s).
go down go up
grech offline
Benutzer
Avatar
Gender: male
Location: GERMANY  Saarland
Age: 61
Posts: 15
Registered: 10 / 2015
Private message
Subject: Re: Bitweiser Zugriff  -  Posted: 01.05.2019 - 15:27   -  
Hallo Merlin,
deine Idee müsste eigentlich funktionieren.
Ohne dass sie Speicher kostet;
und ohne Rechenzeit, weil die Adressen kann der Compiler ja schon berechnen.
(Anm. Die Berechnung der Adressen nach meiner Schreibweise ist auch nicht komplexer)

Danke.

Ich hatte schon daran gedacht mir für bestimmte Tasten einen Getter zu schreiben.
Wäre nicht aufwendiger in Source-Code aber braucht Rechenzeit und Speicher.

Gruß grech
go down go up
Merlin offline
Schreiberling
Avatar
Gender: male
Location: UNITED KINGDOM 
Age:
Posts: 877
Registered: 03 / 2005
Private message
Subject: Re: Bitweiser Zugriff  -  Posted: 01.05.2019 - 16:09   -  
Talking of getters (and setters) you can also use properties, although, as you say, it is computationally more expensive, but potentially more powerful, and you can always start one way and change to the other way later:

Code
property
  Num_1 : boolean
    read GetNum_1
    write SetNum_1;

//===================================================
{--------------------------------------------------------------}
{ functions }
function GetNum_1 : boolean;
begin
  return( Bit( Reg_tasten[adr_s16_1], num16));
end;

procedure SetNum_1( NewVal : boolean );
begin
  SetBit( Reg_tasten[adr_s16_1], num16, NewVal );
end;

Merlin.

:magic:

Software is a black art.
go down go up
 


Registered users in this topic
Currently no registered users in this section

Delete cookies of this forum  •  FAQ / Help  •  Team page  •  Imprint   |  Local time: 17.08.2019 - 15:37