C Programmierung Schleife

[IWANN (Gast)]

Hallo, habe ein Problemm beim programmieren, bin auch anfänger :-)

Habe ein atmega8 mit 10 LEDs jeweils eine an einem Ausgang. Jetzt will 
ich mit einer schleife die Leds in reihenfolge nach einander 
einschalten, wenn alle leuchten, dann wieder nacheinander ausschalten. 
Folgendes Programm:

#include <inttypes.h>
#include <avr/io.h>
#include <avr/delay.h>    // definiert _delay_ms()



void delay_ms(int ms)
{
  int t;
  for(t=0; t<=ms; t++)
  _delay_ms(1);
}


int8_t array[10] ={PB7, PD5, PD6, PD7, PB0, PB1, PB2, PB3, PB4, PB5};


void main()
{
  //Port C auf Ausgang schalten (Auswahl)
  DDRB = 0xFF;
  //Port A auf Ausgang schalten (Daten)
  //DDRC = 0xFF;
  DDRD = 0xFF;
  DDRC = 0b00000000;

while(1){

unsigned char i=0;

  while(i<10){

    i |= (1 << array[i]);   // unsicher ob die schreibweise
          //möglich ist
    i++;
    _delay_ms(50);
        }


    while(i>0){

      i |= (1 << array[i]);
      i++;
      _delay_ms(50);
        }

    }



}




Problem ist halt dass die Leds nich in einer sinnvollen reihenfolge 
angelötet sind. IChhab jetzt keine ahnung wie ich mittels einer schleife 
die Leds nacheinander ein bzw ausschalten kann. Hab gedacht dass es mit 
einem array klappen könnte. Mit meinem Programm passiert aber nix :-)
für jede hilfe dankbar :-)

[Sven P. (Gast)]

IWANN wrote:
> int8_t array[10] ={PB7, PD5, PD6, PD7, PB0, PB1, PB2, PB3, PB4, PB5};
Speicher direkt die Bitmasken ab.

>     i |= (1 << array[i]);   // unsicher ob die schreibweise
>           //möglich ist
Möglich ja, aber auf dem AVR arschlahm, denn der kann immer nur um 1 
schieben.

Die Idee mit dem Array ist übrigens ordentlich :-)

[IWANN (Gast)]

>>Speicher direkt die Bitmasken ab.

was bedeutet das ? :-)  voll anfänger ^^

[Walter (Gast)]

unter anderen Fehlern:
wenn du was an den Ausgängen sehen willst,
musst du schon auch mal was auf PORTB schreiben

[der mechatroniker (Gast)]

Er meinte so:

int8_t bitmask[10] ={0x80, 0x20, 0x40, 0x10, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20};

volatile unsigned char * ledport[10] = {&PORTB, &PORTD, &PORTD, &PORTD,
                   &PORTD, &PORTB, &PORTB, &PORTB, &PORTB, &PORTB }

int main()
{
    unsigned char i;
    // DDRs setzen überlaß ich dem Leser als Übung

    for(i=0; 1 ; i = (i+1) % 10; ) {
        *(ledport[i]) |= bitmask[i];
        _delay_ms(50);
        *(ledport[i]) &= ~bitmask[i];
    }
    // Abwechselndes Vor- und Rückwärtslaufen überlaß ich dem Leser
}

[IWANN (Gast)]

ahhh :-)  die idee ist gut :-)  das probier ich mal aus :-)  dankee :-)

[IWANN (Gast)]

Ich habs jetzt so gemacht


#include <inttypes.h>
#include <avr/io.h>
#include <avr/delay.h>    // definiert _delay_ms()



void delay_ms(int ms)
{
  int t;
  for(t=0; t<=ms; t++)
  _delay_ms(1);
}


int8_t array[10] ={PB7, PD5, PD6, PD7, PB0, PB1, PB2, PB3, PB4, PB5};

volatile unsigned char * ledport[10] = {&PORTB, &PORTD, &PORTD, &PORTD,
                   &PORTB, &PORTB, &PORTB, &PORTB, &PORTB, &PORTB };

//int8_t bitmask[10] ={0x80, 0x20, 0x40, 0x10, 0x01, 0x02, 0x04, 0x08, 
0x10, 0x20};



void main()
{
  DDRB = 0xFF;
  DDRD = 0xFF;
  DDRC = 0b00000000;

unsigned short speed=50;


while(1){
lable:


if((PINC & 0x08) !=0) {

while(1) {

if((PINC & 0x04) !=0) {
  goto lable;       }

unsigned char i=0;

  while(i<10){

  *(ledport[i]) |= (1 << array[i]);

    i++;
    if ( (speed>4 && ( PINC & 0x20 ) != 0 ) ) {

          speed = speed-5;
            }

          if((PINC & 0x10) !=0) {
            speed = speed +1;
              }
      _delay_ms(speed);
          }
    i=0;

    while(i<10){

      *(ledport[i]) &= ~(1 << array[i]);
      i++;
      if ( (speed>4 && (PINC & 0x20 ) != 0 )) {
          speed = speed-5;
            }

          if((PINC & 0x10) !=0) {
            speed = speed +1;
              }
      _delay_ms(speed);
        }


}

}

    }



}


Läuft sehr gut :-)  verbraucht aber 50% des Speichers, ich hab da jetzt 
keine Erfahrung aber kann mir schon vorstellen, dass es garnicht optimal 
ist :-)

[der mechatroniker (Gast)]

Du hast vergessen in den Zeilen

_delay_ms(speed);

den führenden Unterstrich zu entfernen, um tatsächlich deine eigene 
delay_ms aufzurufen. Da wird der Speicherverbrauch herkommen.

[Mano W. (Firma: ---) (manow)]

Auf goto verzichtet man idR! In deinem Fall geht's sicher auch ohne.

Wieviele verschiedene Datentypen benützt Du eigentlich? Brauchst Du das 
wirklich?

[IWANN (Gast)]

>> Du hast vergessen in den Zeilen _delay_ms(speed); den führenden Unterstrich zu 
entfernen

WOW  da hab ich den strich weggemacht und jetzt verbrauche ich nur noch 
4,8% unglaublich, wie kommt denn das verstehe ich garnicht :-)


>>Wieviele verschiedene Datentypen benützt Du eigentlich? Brauchst Du das
wirklich?

Meinst du die variable deklaration oder den ganze rest auch ?  welchen 
Datentyp soll ich denn am besten nutzen ?

[Sven P. (Gast)]

IWANN wrote:
>>> Du hast vergessen in den Zeilen _delay_ms(speed); den führenden Unterstrich zu
> entfernen
>
> WOW  da hab ich den strich weggemacht und jetzt verbrauche ich nur noch
> 4,8% unglaublich, wie kommt denn das verstehe ich garnicht :-)
_delay_ms rechnet mit Fließkommazahlen; wenn du einen konstanten Wert 
als Argument mitgibst, fliegt das aber bei der Optimierung des Compilers 
alles wieder raus. Das geht aber logischerweise nur, wenns wirklich ein 
konstanter Wert ist :-)


>>>Wieviele verschiedene Datentypen benützt Du eigentlich? Brauchst Du das
> wirklich?
>
> Meinst du die variable deklaration oder den ganze rest auch ?  welchen
> Datentyp soll ich denn am besten nutzen ?
Ersetz inttypes.h durch stdint.h und ersetze den ganzen 'char', 'long', 
'int'-Kram durch die int_xx/uint_xx-Typen, dann stimmts wieder und ist 
auch sicher.