Home



Stand 07.07.2014
Link zu : Bitmanipulation   

Bitte die vielen kleinen Rechtschreibfehlr verzeihen..

Programmierung
Stile und Konzepte:

WARUM ?
Bei der Programmierung  in C kann man ohne großen Aufwand allein durch die Schreibweise für professionelle Strukturen sorgen.
Es gibt einen anfänglich, auch von Microsoft Windowsentwicklern, eingeführten Programmierstil.
Ich selbst bin vor vielen Jahren beim studieren der Windows 3.1 Programmierung  auf dieses Konzept gestossen.
Und schon bald, als ich die ersten größeren Programme geschrieben habe, wurde mir klar, wie klasse das Konzept ist.

WIE ?
Ein simpler Buchstaben-Code in der Benennung von Variablen
oder
bewußte Groß-Keinschreibung  unterscheiden Variablen von  Konstanten oder #defines (in einer Headerdatei).
Das sorgt  somit für einen übersichtlichen, lesbaren Code und einem einheitlichen Programmierstil.
Dieser Stil hilft sehr dabei  Fehler und passende Zusamenhänge uinmittelbar/sofort, allein an der evtl. unpassenden Scheibweise, zu erkennen.

* es sorgt für Übersicht.
* gute verständliche Lesbarkeit der Bedeutung von Variablen und Konstanten.
* gibt dabei Auskunft über wichtige Eigenschaften von Variablen.
    Datentyp: Ganzzahl, Zeichen, oder  Pointer
    Datenbreite: char, short, Byte, Word,   etc....
    unsigend oder signed oder float
* gibt Auskunft über Lokaler oder  Gloaber  Geltungsbereich....

das ist doch schon mal recht hilfreich, und es kostet eben keine Mühe.
Die Regeln sind leicht zu merken und passen auf einen Bierdeckel.
(Copy - Paste)...Schützt auch vor der allseits beliebten Tippfehlerfalle.

Zuerst ein Vergleich:

Ich kann nur hoffen, daß ich euch mit folgender Dartsllung überzeugen kann "niemals wieder" die beliebten "Ein-Buchstaben Variablen" zu benutzen!
for( i = 0; i < 20.......)  = Bäääääh   =  Anfänger-max. Basic Programmierstil.

Beispiel: Zwei Programme, die das gleiche tun,
nur, das ein ist unverständlich, -->das andere lesbar:

for( i = 0, i<20, i++ )
{ v  = s * z[i] :    }:  // Was  tut das Programm warum ?   Keine Ahnung
keiner weis, istVariable  "i" evtl  int oder float  ?? ,  loakal oder global verwendet ?? ´..
Nichts ist so klar !!

BESSER:
for( u8NN = 0, u8NN<20, u8NN++  ) { fSensor_Volt = fSensor *  u16Kalibrierung[ u8NN ]:     }:
Man erkennt nun :
a)
Wir haben eine "u8=unsigned Byte ( 8=8Bit)" als Zählvariable.
b)
fSensor ist ein  Float Sensorwert (erkennbar am kleinen f )
c) fSensor
wird  mit einer "unsigned integer"-Kalibrier-Tabelle
(erkennbar am u16) verrechnet. d)
Das Ergebnis ist mit der Tabelle korrigiert,  und heißt auch lesbar "
fSensor_Volt" und ist damit  eine floatVariable ( kleines f am Anfang), die das Ergebnis in Volt anzeigt.
Also alles gut versteh und lesbar ! Und das alles nur durch die Schreibweise.


Es ist nur eine Handvoll kleiner Regeln zu beachten, an die man sich schnell gewöhnt.
Der Sinn!
* Lesbarkeit des Codes erhöhen,
* Jederzeit kann der Datentyp einer Variable  in seiner Verwendung erkannt werden ( und damit auch evtl. fehlerhafte Anwendung!)
* Wildes Verteilen von festen Zahlenwerten im Code ist unprofessionel. Viel vernünfitger ist die Verwendung von "Lesbaren" Platzhaltern, auch zur Progrmmmpflege.
Das ist der Unterschied zwischen einem Anfänger-hauruck-Programm und gutem pflegbaren Code.
.
Konventionen:

Mit Großbuchstaben geschrieben sind:
  kurz gesagt, alles was in Headerdateien gehört.
In gutem C-Code sollten keine Konstanten als feste Zahlen geschrieben werden, auch wenn man das vom Compiler aus darf.
#define Platzhalter erhöhen die Lese und Pfelgbarkeit des Codes enorm.
Großbuchstaben:                                        Beispiele:  
Konstanten #define VOLTAGE_REFERENCE  2.56
#define SOLLWERT 1234.56
Makros #define MIN ((A) <(B))
Selbstdefinierte Daten-Typen typedef struct NMEA_STRUCT
   {
    ..
   }NMEA_STRUCT_TYPE;
Alle anderen "#define"
wie z.B. FlagBit-Definitionen´
( die in einer Flagbyte Varibale gesetzt,gelöscht werden, typisch für µController Programme )
#define KEY_PRESSED_EVENT   0x01
#define KEY_PRESSED                 0x02
#define KEY_RELEASE_EVENT  0x04
#define KEY_RELEASED              0x08
#define KEY_VALID                     0x10

Anwendung:
im Headerfile "main.h" wird zuerst  z.B. eine Arraygröße definiert:
#define STRMAX 80
eine Variable aus Char.Array  wird so geschrieben
char caVariablenName[ STRMAX + 1 ];


Regeln zur  Scheibweise von Variablennamen.
Schreibweise mit vorangestelltem Kleinbuchstaben, die den Datentyp anzeigen.

Allein an der trickreichen Schreibweise kann viel Information über eine Variable verpackt werden:
1. ob die Variable global oder lokal definiert ist...
2. welchen Datentyp die Variable hat.
    a) ob die Variable ein Array ist,
    b) ob die Variable ein Pointer ist,
3. welche Bedeutung/Funktion die Variable hat.
oder noch mehr..

Wie das geht? ganz einfach
1. JEDE“ Variable hat einen sehr minimalen "Präfix-Code" aus kleinen Buchstaben an Variablen-Namensanfang stehen
 stehen.

2
. Variablen in C-Code sollten ausführlich und lesbar ausgeschrieben sein.
3. Variablen erkennt man an gemischter Gross-Klein Schreibung. also daran, daß
„JEDE“ Silbe einen Großbuchstaben hat
  Bsp: u16DiesIstEineVariableVomTypUnsignedInteger_mit16Bit


Eine Handvoll Bezeichner sind sinnvoll, die fast  selbsterklärend sind:
g = Global
p = Pointer
c = char
b = BYTE = unsigned char
ca = charArrray
i = Integer
u = unsigned
w = WORD = unsigned int
     (das ganze vtl ergänzt durch die Zahl der Bitbreite der Variable ) :  "u16VariablenName"   )
l = long
f = float
d = double
z = ist Zeroed Array = STRING  
            (wird so gern vom Mikrosoft Programmierern verwendet)

Geschrieben wird in der Reihenvolge nach Priorität...
gpcVariablenName;   Lese:  Global Pointer auf Char VariablenName
Beispiele
czMessage = „Borschaft\0“
.z.B.   caDiesIstEinArrayAusChar
 pcaStrField      //Pointer auf Char-array

Beispiele:
eine Variable aus char mit 8 Bit wird so Geschrieben eine Variable aus Char.Array  wird so Geschrieben
char     caVariablenName     // Lese char array <Name>    Bsp: caLCDText;

eine Variable aus unsigned char mit 8 Bit wird so Geschrieben:
uint8_t    u8VariablenName;   // Lese char array unsigend 8 Bit <Name>    Bsp: u8KeyFlag;

eine Variable aus unsigned char mit 16 Bit wird so Geschrieben  
uint16_t    u16VariablenName;         // Lese: unsigned integer,16Bit...<VariablenName>

eine Variable aus pointer auf char wird so Geschrieben
char*    pcVariablenName;    //Lese: Pointer auf char <VariablenName>

eine Variable aus Char Array wird so Geschrieben
char     caVariablenName[ STRMAX ];    //Lese: char array <VariablenName>

eine Pointer auf  ein CharArray wird so Geschrieben
char *  pcaVariablenName;    // Lese: pointer auf char array <VariablenName>


UND NOCH ETWAS... wie schon erwähnt,
Es gibt KEINE EIN-Buchstaben Variablen , auch wenn man das immer wieder sieht
zummindest nicht im professionellen Code.


Funktionen werden wie Variable geschrieben, nur ohne Typkenzeicher!
void CatLastCharOfString(char* pczInStr)

Block und Klammerebenen mit Einrückungen kennzeichen

Gut ist es jeden Block mit einem Bereichsoperator {}  einzuleiten.
WIE ?
Jeder Block/Bereichsoperator   { }  rückt eine Tabulatorstelle ein

Richtige Verwendung:   Klammern mit TAB einrücken!
Jede  öffnende Klammer  {
                                            steht immer  über einer schließenden Klammer 
                                           }
;
auch wenn man das woanders anders sieht !... man muss nicht nachmachen was Andere machen.
Vorteil:
So sieht man gleich, ob man die Klammerebennen stimmen und richtig im Zusammenhang stehen.
Bsp:
void Funktion(void)
{
char cXX =0;
for(cXX=0; cXX<10; cXX++)
        {
        for(cYY=0; cYY<10; cYY++)
            {
            code.......
            };
        code..........
        };
};  // ende der Funktion



Programmierkonzepte für bitweise Methoden:

Es gibt immer mehrere Wege.. davon doch nur einige 'Gute'.

Thema: wie definiere ich Bit-Positionen ?
Gezählt werden Bits von NULL bis SIEBEN, --> 0..7,      nicht von 1 bis 8 !
( Binäre Zahlen werden von rechts nach links, aufwärts zählend, geschrieben )also:
BIT 7 BIT 6 BIT 5 BIT 4 BIT 3 Bit 2 Bit 1 Bit 0

Bin    Hex
0000    0
0001    1
0010    2
0011    3
0100    4
0101    5
0110    6
0111    7
1000    8
1001    9
1010    A-10
1011    B-11
1100    C-12
1101    D-13
1110    E-14
1111    F-15
 
Wer aufmerksam ist, erkennt einen 01 Wechselrythmus,der je Stelle nach links gesehen, sich halbiert.

C-konforme definitionen....  // = Komentar
#define BIT_0    0x01    // = 0000 0001    0 #define BIT_1    0x02    // = 0000 0010    1 #define BIT_2    0x04    // = 0000 0100    2 #define BIT_3    0x08    // = 0000 1000    3 #define BIT_4    0x10    // = 0001 0000    4 #define BIT_5    0x20    // = 0010 0000    5 #define BIT_6    0x40    // = 0100 0000    6 #define BIT_7    0x80    // = 1000 0000     7

So "wandert" die EINS schrittweise nach links......

Methoden  zum gezielten SETZEN und LÖSCHEN von Bits...




Bits setzen:

Dazu wird das Zielbyte verodert mit den zu setzenden Bitpositionen:
ZIEL |=  Binaerposition ;     Bsp: u8KeyFlag |= 0x08;



Bits Löschen:
zum Löschen wird mit der Bitumkehrung ( Komplement = ~ ) verundet
ZIEL &= ~(Binaerposition);     u8KeyFlag &= ~0x08;

alternatives Verfahren zum Löschen von Bits mit EXOR ( dafür ohne Komplementbildung  )
Bits Loeschen: 
ZIEL  ^= (Binaerposition);    Bsp:  1101 ^= 0001   ergibt   1100


Was bedeutet das !! 
Syntaktische Erklärung und Theorie
(  In Bytes, in Registern, in StatusBytes etc..
Sehr sehr wichtig...  Schreibweise in Ansi-C:   0bnn = Binär 0xnn= hexadezimal.
Ein Byte = 8 Bit , wird mit 2 Hexzahlen dargesellt: BSP: 0b00101010 ist das selbe wir  0x2A


Berechnen der Bitposition mit einer Aufzählung:
Wenn man für die Position des Bites das man  setzen möchte nur als Aufzähklung kennt ( z.B. 0..7 ) dann kann man die BitPosition mit dem Trick: "Schieben eine  EINS" genau ermitteln
Position =  ( 1 << BitNummer )
So sind die Bits oft im  Headerfile zum µC definiert:

Bsp: unter  PORTA ist das 3. Bit so definiert:  #define PA3 3
Um nun dieses Bit zu setzen geht man so vor, wen man die #define verwenden will: setzen:   PORTA |= (1<< PA3 ); löschen: PORTA &= ~(1<< PA3 );

TIP:  In WINAVR gibt es eine fertige Hilfe: _BV( BitNummer )  =   ( 1<< BitNummer )