C - Ersatz von switch case.

[C-Anfänger (Gast)]

Hallo zusammen,

ich bin noch dabei, C zu lernen.

Aktuell benötige ich eine Funktion, die die Nummer eines Kanals und die 
dorthin zu schreibenden Daten als Parameter erhält und dann mittels 
einfachem bitbanging des latch enable eines 74HC573 die Daten in diesen 
reinschreibt. Die clk_regx_oben/clk_regx_unten sind Symbole für 
Bitpositionen in den Ausgangsregistern der Ports, die an die jeweiligen 
LEs angeschlossen sind, latch ist ein Symbol für den Ausgangsport=Bus zu 
den 74HC573.

Im Prinzip sind es in allen case-Fällen die gleichen Abläufe, nur eben 
mit unterschiedlichen Bits(=latch enable) verschiedener Portregister.

Ausdrücklich sei erwähnt: es funktioniert gut, ich suche also keine 
Fehler.

Die Umsetzung in Assembler (siehe Anhang) ist sehr schnell, hat aber 
recht großen Platzbedarf. Im aktuellen Projekt stört das auch überhaupt 
nicht, aber geht es in C nicht noch irgendwie besser?

(Wie ich es in Assembler besser löse, weiß ich und das ist auch nicht 
die Frage)

Compiler ist der IAR, Optimierung auf Platzbedarf, Prozessor der 
STM8S105.

Auszug aus meiner bisherigen Lösung:

#define clk_reg1_oben PC_ODR_ODR3
#define clk_reg2_oben PC_ODR_ODR2
#define clk_reg3_oben PC_ODR_ODR1
#define clk_reg1_unten PA_ODR_ODR6
#define clk_reg2_unten PA_ODR_ODR5
#define clk_reg3_unten PA_ODR_ODR4
#define latch PB_ODR

...

void latching_data(int channel, int data)
{

  // Daten auf den Bus legen
  
  latch = data;

  // LE des Registers 1 auf low setzen (sollte ohnehin low sein)
  //    clk_reg1_oben = OFF;
  // LE für mindestens 10 Takte auf high setzen    
  //    clk_reg1_oben = ON;
  //    shortwait();
  // LE wieder auf low setzen, mit diesem Pegelwechsel
  // geschieht die Datenübernahme ins latch
  //    clk_reg1_oben = OFF;


  switch(channel) {
      case 1 :
         clk_reg1_oben = OFF;
         clk_reg1_oben = ON;
         shortwait();
         clk_reg1_oben = OFF;
         break;
      case 2 :
         clk_reg2_oben = OFF;
         clk_reg2_oben = ON;
         shortwait();
         clk_reg2_oben = OFF;
         break;        
      case 3 :
         clk_reg3_oben = OFF;
         clk_reg3_oben = ON;
         shortwait();
         clk_reg3_oben = OFF;
         break;
      case 4 :
         clk_reg1_unten = OFF;
         clk_reg1_unten = ON;
         shortwait();
         clk_reg1_unten = OFF;
         break;
      case 5 :
         clk_reg2_unten = OFF;
         clk_reg2_unten = ON;
         shortwait();
         clk_reg2_unten = OFF;
         break;
      case 6 :
         clk_reg3_unten = OFF;
         clk_reg3_unten = ON;
         shortwait();
         clk_reg3_unten = OFF;
         break;
      default :
         ;
   }
  return;
}

[NJ (Gast)]

Hi!

Warum nimmst Du nicht clk_regx, statt "channel" als Parameter der 
Funktion?

[C-Anfänger (Gast)]

Ich bin da noch nicht 100% sattelfest, die Bits der Register sind wohl 
als bitfield (?) definiert:

Auszug aus iostm8s105s4.h:

typedef struct
{
  unsigned char ODR0        : 1;
  unsigned char ODR1        : 1;
  unsigned char ODR2        : 1;
  unsigned char ODR3        : 1;
  unsigned char ODR4        : 1;
  unsigned char ODR5        : 1;
  unsigned char ODR6        : 1;
  unsigned char ODR7        : 1;
} __BITS_PB_ODR;

Heißt das dann also, ich müßte die Funktion so:

void latching_data(__BITS_PB_ODR channel, int data)

definieren?

Aber wie verwende ich das dann weiter in der Funktion? Setze ich dann 
einfach channel an die Stelle von clk_reg1_oben in meiner Funktion?

(große Fragezeichen über dem Kopf)

[C-Anfänger (Gast)]

Hab das mal schnell ausprobiert.

Hmm, das geht nur, wenn ich mein restliches Programm umschreibe, weil 
ich dort natürlich überall channel als int einsetze, (ich seh gerade, 
char bzw. besser uint8_t würde reichen) wenn ich die Funktion aufrufe. 
Das macht natürlich die weitere Nutzung dieser Funktion schwieriger.

[C-Anfänger (Gast)]

Mir wäre jetzt doch eine Lösung lieber, die als Parameter die Nummer des 
Channels und das zu schreibende Byte übernimmt. Das kommt meiner 
Denkweise im restlichen Programm mehr entgegen als die Übergabe der 
Bitbezeichnung.

[NJ (Gast)]

Falls ich nichts übersehen habe und OFF=0 und ON=1...

Lesbarer ist switch-case ;)

uint8_t *temp;
uint8_t offset = 0;

temp = (uint8_t*)__BITS_PB_ODR;

if (channel > 3) offset = 6;


*temp &= ~(1 << (offset + 4 - channel));
*temp |= (1 << (offset + 4 - channel));
shortwait();
*temp &= ~(1 << (offset + 4 - channel));

[Bitschubsen (Gast)]

>   clk_reg1_oben = OFF;
>   clk_reg1_oben = ON;
>   shortwait();
>   clk_reg1_oben = OFF;


Die erste Zeile ist überflüssig. Der Normalzustand ist ja wohl off.

So bleibt nur eine Funktion, die etwas "on" setzt, wartet und es dann 
wieder "off" setzt.

Ich würd das Port auf on setzen.
Warten.
Alle auf off setzen.

[Falk B. (falk)]

@C-Anfänger (Gast)

>Im Prinzip sind es in allen case-Fällen die gleichen Abläufe, nur eben
>mit unterschiedlichen Bits(=latch enable) verschiedener Portregister.

>Ausdrücklich sei erwähnt: es funktioniert gut, ich suche also keine
>Fehler.

>Die Umsetzung in Assembler (siehe Anhang) ist sehr schnell, hat aber
>recht großen Platzbedarf.

Wie groß? die paar Bytes können kaum ins gewicht fallen. Eine generische 
Funktion mit den Portnummern als Parameter wird auch nicht kleiner, denn 
die muss das alles ausrechnen.

> Im aktuellen Projekt stört das auch überhaupt
>nicht, aber geht es in C nicht noch irgendwie besser?

Was ist daran nicht gut? Klar kann man die Portnummern als Adresse oder 
Index übergeben, aber das macht es nicht notwenigerweise besser oder 
kleiner.

Besonders als Anfänger und C-Einsteiger sollte man seine Zeit und 
Energie nicht mit Pseudo-Optimierungen verschwenden. Als 
fortgeschittener und Profi auch nicht.

https://www.mikrocontroller.net/articles/AVR-GCC-Codeoptimierung#Prinzipien_der_Optimierung

[NJ (Gast)]

Manchmal hilft es aber beim Verständnis (evtl. auch für spätere 
Projekte) sich mehrere Möglichkeiten anzuschauen oder zu überlegen.

Deswegen ist der Gedanke "gehts auch anders oder sogar besser" gar nicht 
schlecht.

[Michael S. (schiko)]

Das veranschaulicht schön, warum ich Bitfelder nicht mag.

uint8_t Channel_2_PB_ODR_BitNr( ChannelType channel )
{
  switch( channel )
  {
  case 0: return 3; //kein offsetof möglich bei bitfields...
  case 1: return 2; 
  case 2: return 1; 
  case 3: return 6; 
  case 4: return 5; 
  case 5: return 4; 
  default: return 0; 
  }
}
//alternativ
uint8_t arChannelBitNr[6] =  {3,2,1,6,5,4}

void latching_data(ChannelType channel, int data)
{
  latch = data;
  uint8_t bitNr  = Channel_2_PB_ODR_BitNr( channel ); 
//oder 
  uint8_t bitNr  = arChannelBitNr[channel];
//wenn sowieso nur ein Bit gleichzeitig gesetzt wird
  __BITS_PB_ODR  = 1 << bitNr;
  shortwait(..)
  __BITS_PB_ODR  = 0;
//ansonsten
  __BITS_PB_ODR  |= 1 << bitNr;
  shortwait(..)
  __BITS_PB_ODR  &= ~(1 << bitNr);
  
}

[C-Anfänger (Gast)]

Vorab vielen Dank für die Antworten und freundlichen Anregungen.

@NJ
> OFF=0 und ON=1...

Ja, hab ich vergessen zu kopieren.

Vielen Dank für Deine pfiffige Lösung, die allerdings bei anderer 
Verteilung der Portbits nicht mehr funktioniert. :-)

@bitschubser
> Die erste Zeile ist überflüssig. Der Normalzustand ist ja wohl off.

Ja, das ist eine Angstzeile, die von den ersten Versuchen noch übrig 
ist. Ist tatsächlich überflüssig.

@Falk: Ja, Du hast recht, das Codegrößenargument/der Optimierungsgedanke 
ist dumm. Ich komme ursprünglich eher von Seiten der Hochsprachen. (hab 
viel Turbopascal programmiert früher) Da stößt man sich daran, dass man 
sechsmal praktisch das Gleiche im Quelltext hinschreibt. Der Gedanke, 
dass das vielleicht irgendwie eleganter geht und man selbst nur 
Scheuklappen vor den Augen hat, drängt sich förmlich auf. Deswegen 
fragte ich hier. Mein Gedanke war, dass es doch irgendwie möglich sein 
muss, die sechs Bitbezeichnungen zu strukturieren und in eine 
durchzählbare arrayähnliche Aufzählung zu fassen, sowas wie Enumeration 
oder eben ein Array.

@Michael:
Deine Lösung habe ich noch nicht ganz verstanden, geht aber, glaub ich 
zumindest verstehen zu können, in meine gedankliche Richtung. Vielen 
Dank dafür. Damit beschäftige ich noch mal intensiver.

Leider muss ich jetzt erst familiären und gesellschaftlichen overhead 
abarbeiten, bevor ich wieder ans Hobby darf. ;-)

[Falk B. (falk)]

@ C-Anfänger (Gast)

>fragte ich hier. Mein Gedanke war, dass es doch irgendwie möglich sein
>muss, die sechs Bitbezeichnungen zu strukturieren und in eine
>durchzählbare arrayähnliche Aufzählung zu fassen, sowas wie Enumeration
>oder eben ein Array.

Das ist machbar, läuft aber auch wieder auf eine mehr oder minder 
manuelle Unterscheidung in einer untergeordneten Funktion hinaus. So 
macht es der Arduino. Das ist aber weder kleiner noch schneller. Die 
C-Freaks machen das mit bösen Macros. Das willst du aber nicht wirklich.

Arrayzugriffe auf IO-Register oder gar IO-Bits sind und bleiben eher 
exotisch und anstrengend. Da sollte man lieber die Schreibarbeit 
investieren und es gut sein lassen. Es gibt wichtiger Dinge in der 
Programmierung.

Hier mal ein Beispiel für eine Macrolösung, wenn gleich das Problem 
etwas anders lag. Siehe Anhang.

[NJ (Gast)]

C-Anfänger schrieb:
> @NJ
>> OFF=0 und ON=1...
>
> Ja, hab ich vergessen zu kopieren.
>
> Vielen Dank für Deine pfiffige Lösung, die allerdings bei anderer
> Verteilung der Portbits nicht mehr funktioniert. :-)

Ja, sollte nur eine Möglichkeit für den speziellen Fall zeigen ;)

Ansonsten hat Falk schon recht, um die manuelle Unterscheidung kommst Du 
nicht herum und da lohnt sich i.d.R. der Aufwand nicht.

Ist aber doch immerhin eine Erkenntnis :D

[C-Anfänger (Gast)]

NJ schrieb:
> Ist aber doch immerhin eine Erkenntnis :D

Auf jeden Fall, vielen Dank dafür. :-)

Das Gefühl für die Möglichkeiten und Grenzen von C, die Vertrautheit mit 
der Sprache muss sich bei mir noch bilden.

Falk B. schrieb:
> Hier mal ein Beispiel für eine Macrolösung, wenn gleich das Problem
> etwas anders lag. Siehe Anhang.

Du meinst diesen Teil hier?

// clever bit generator macro

#define PAT(port, bit) ((port==&PORTA) ? (1L<<(bit+24)) : ( \
                        (port==&PORTB) ? (1L<<(bit+16)) : ( \
                        (port==&PORTC) ? (1L<<(bit+8))  : ( \
                        (port==&PORTD) ? (1L<<(bit+0))  : 0))))

Das schaue ich mir mal in Ruhe an, vielen Dank.