Wie effizienten Code schreiben?

do

loop until 1=2

Mal schnell gegoogelt:

Also Funktion:

 Rückgabetyp  Funktionsname(Parameterliste)
 {
    Anweisungen
 }


Dann müssen nur noch die passenden Namen, Parameter und Anweisungen 
rein.

Und gegen Spagetti hilft
#define goto /**/
ganz oben im Code.

while(1)
{
if( nach_unten && anschlag_unten !=1 )
{
fahre_nach_unten() ;
}

if(nach_oben && anschlag_oben !=1 )
{
fahre_nach_oben() ;
}
}


versuch damit ;--)))

Ich glaube ich habe mich nicht Deutlich ausgedrückt!
Ich möchte eine Funktion für alle Rollo! Ich möchte aber nicht 8 mal die 
Taten Abfragen und die passenden Ausgänge übergeben!
Geht es nicht einfacher und besser?

Danke

>Kirsche schrieb:
> Ich glaube ich habe mich nicht Deutlich ausgedrückt!
Ganz, ruhig,
> Ich möchte eine Funktion für alle Rollo! Ich möchte aber nicht 8 mal die
> Taten Abfragen und die passenden Ausgänge übergeben!
 Es ist schon klar das ein µC sequentiell arbeitet? :-)))
> Geht es nicht einfacher und besser?
>
> Danke

 was ist das für Platine? Ist da ein AVR drauf? die 16 digitale Eingänge 
liegen die an zwei PORT´s?

Was willst du dann?

also erstmal will er in der software eine gpio erweiterung / expander 
machen. er hat ja nur 16 dig. eingänge entprellt jedoch 18 in der 
software ... vlt. multiplexe ^^^

ducken und tüsch

>eingänge schrieb:
> also erstmal will er in der software eine gpio erweiterung / expander
> machen. er hat ja nur 16 dig. eingänge entprellt jedoch 18 in der
> software ... vlt. multiplexe ^^^
>
> ducken und tüsch

expander gehen über MUX wie du schon sagst, man kann aber auch GPIO 
Expander über SPI ansteuern, funkzioniert auch ganz gut ;-)))

Womit wir wieder beim guten C-Buch wären...

Sorry das ich mich erst jetzt wider melde aber habe es erst jetzt 
geschafft!

1

                if( get_key_short( 1<<IN_R1_Auf ) )

2

    {

3

      Rollo_kommpletAuf(O_Roll_1_Auf)

4

    }

5

    if ( get_key_long( 1<<IN_R1_Auf ))

6

    {

7

      RolloPort|=(1<<O_Roll_1_Auf)

8

    }

9

    else

10

    {

11

      RolloPort &=~(1<<O_Roll_1_Auf)

12

    }

13

    if( get_key_short( 1<<IN_R1_Zu ) )

14

    {

15

      Rollo_kommpletAuf(O_Roll_1_Zu)

16

    }

17

    if ( get_key_long( 1<<IN_R1_Zu ))

18

    {

19

      RolloPort|=(1<<O_Roll_1_Zu)

20

    }

21

    else

22

    {

23

      RolloPort &=~(1<<O_Roll_1_Zu)

24

    }

Mir gefäält es einfach nicht diese Wurst 8 mal hin zu schreiben!

Danke für Eure Hilfe

Wäre die frage besser unter Gcc aufgehoben?

for(int i=0;i<8;i++)
{
   -- hier kommt dein Code --
}

Funktioniert die Entprellung auch in einer for Schleife?

Ich sehe mehrere Antworten.

1. Effizienz im Sinne von kurzer Arbeitszeit. Du hast funktionierenden 
Code, jedes weitere Feilen daran wäre ineffizient (es sei denn, es 
leichtere Wartung oder Wiederverwendung spielen eine Rolle).


2. Effizienz im Sinne von geringer Sourcecode-Länge (siehe Wartbarkeit):

Voraussetzung: IN_R1_Auf ... IN_R8_Auf, O_Roll_1_Auf ... O_Roll_8_Auf, 
usw gehen jeweils in 1er-Schritten aufwärts, dann geht das so:

#define ROLLO_HIN_UND_HER(ROLLO) \
   if( get_key_short( 1<<(IN_R1_Auf+ROLLO) ) ) \
  { \
      Rollo_kommpletAuf(O_Roll_1_Auf+ROLLO) \
...
      RolloPort &=~(1<<O_Roll_1_Zu+ROLLO) \
    }

ROLLO_HIN_UND_HER(0)
ROLLO_HIN_UND_HER(1)
...
ROLLO_HIN_UND_HER(8)


3. Effizienz im Sinne von geringer Objectcode-Länge (Flash sparen) 
(wobei ich mir nicht ganz sicher bin, dass der Overhead von der Loop und 
der Parametrisierung nicht die Ersparnis kaputtmacht)

void rollo_hin_und_her_1(int rollo)
  if( get_key_short( 1<<(IN_R1_Auf+rollo) ) )
  {
      Rollo_kommpletAuf(O_Roll_1_Auf+rollo)
...
      RolloPort &=~(1<<O_Roll_1_Zu+rollo)
    }

void rollo_hin_und_her_alle(void)
{
  for (int i=0; i<8; i++)
    rollo_hin_und_her_1(i);
}


4. Effizienz im Sinne von geringem Ram/Registerverbrauch

void rollo_hin_und_her_1(int rollo)
  if( get_key_short( 1<<(IN_R1_Auf+rollo) ) )
  {
      Rollo_kommpletAuf(O_Roll_1_Auf+rollo)
...
      RolloPort &=~(1<<O_Roll_1_Zu+rollo)
    }

rollo_hin_und_her_1(1);
rollo_hin_und_her_1(2);
...
rollo_hin_und_her_1(8);


Die Effizienzkriterien können, müssen aber nicht, einander 
widersprechen.


/***
Rein typographische Anmerkung: Viele Techniker machen das und Du wurdest 
offenbar infiziert, aber Rufzeichen! braucht man nur, wenn es wirklich 
um Ausrufe oder Schreie geht, nicht für normale Aussagen oder 
Fehlermeldungen.

"Kein Artikel mit der Nummer 3829 in der Datenbank."
"Domain mikkrokkontroller.net exisitiert nicht."

aber:

"Du Trottel hast schon wieder das Passwort flasch eingegeben!"

mit mehr Schmackes:

"Du hast den Mistkübel schon wieder nicht hinuntergetragen!!11!"
***/

Welche Entprellung.
Ist da etwa noch mehr Code?
Woher sollen wir das wissen, was da alles noch ist.

Achja, heute ist Samstag. Die Buchhandlungen haben noch auf. Meistens 
gibt es da auch gute C-Bücher. Mit Erlärungen zu Array und Schleifen.

PittyJ schrieb:
> Welche Entprellung.
> Ist da etwa noch mehr Code?

Ich möchte auf den ersten Beitrag in diesem Faden verweißen!

Kirsche schrieb:
> Nun habe ich die 18 Eingänge mit der Danegger
> Entprellung entprellt!

Ich kenne Array und schleifen bin mir aber vom Konzept nicht sicher!

LG

COBOL-Hasser schrieb:
> . Effizienz im Sinne von geringer Sourcecode-Länge (siehe Wartbarkeit):


Ich glaube dieser Weg wäre der meine
Danke!

Off by one, zwei Mal. Ich korrigiere:

ROLLO_HIN_UND_HER(0)
ROLLO_HIN_UND_HER(1)
...
ROLLO_HIN_UND_HER(7) /* nicht 8 */


rollo_hin_und_her_1(0);  /* nicht 1..8, sondern 0..7 */
rollo_hin_und_her_1(1);
...
rollo_hin_und_her_1(7);

Complexity kills :-)

PittyJ schrieb:
> Welche Entprellung.
> Ist da etwa noch mehr Code?
> Woher sollen wir das wissen, was da alles noch ist.
>
> Achja, heute ist Samstag. Die Buchhandlungen haben noch auf. Meistens
> gibt es da auch gute C-Bücher. Mit Erlärungen zu Array und Schleifen.

Diese herablassende Art bringt niemanden weiter.

Welches gute C-Buch würdest Du empfehlen, wenn Du schon so gscheit bist?

Was aber wahrscheinlich nicht der Fall ist: Es fehlt je ein Fragezeichen 
hinter "Entprellung" und "noch ist". Wer nicht einmal die einfachsten 
Grundregeln von Kommunikation und Satzzeichen versteht, kann auch keine 
guten Programme schreiben und schon gar nicht gut im Geschäft sein.

Hey, die Flamerei macht ja richtig Spaß!

PittyJ schrieb:
> Und gegen Spagetti hilft
> #define goto /**/
> ganz oben im Code.

Quatsch, goto kann man oft genug sinnvoll verwenden.

Spaghetticode produzieren die Leute, die einfach los programmieren ohne 
nachzudenken was sie eigentlich machen wollen.

Diese herablassende Art bringt niemanden weiter.
>
> Welches gute C-Buch würdest Du empfehlen, wenn Du schon so gscheit bist?
>
> Was aber wahrscheinlich nicht der Fall ist: Es fehlt je ein Fragezeichen
> hinter "Entprellung" und "noch ist". Wer nicht einmal die einfachsten
> Grundregeln von Kommunikation und Satzzeichen versteht, kann auch keine
> guten Programme schreiben und schon gar nicht gut im Geschäft sein.

gscheit

Glashaus

Also Leute,
in diesem Fall tut es doch auch der ineffizienteste Spagetticode.

Letztendlich kann man gutes Softwaredesign nur auf einem Weg lernen - 
erst mal Fehler machen und dann darüber nachdenken, warum das System im 
Chaos versunken ist. Und dafür ist das Projekt zu klein.