Blinken wie ein Audi

#include <avr/io.h>
#include <util/delay.h>
 
int main(){
  DDRB=0x1F;    // PORTB als Ausgang
  PORTD = 0b01110000; // PullUps an
  while (1){
    if(~PIND&(1<<PD4)){ // PD4 gedrueckt?
      blinken(); // ein Blinkdurchlauf
    }
  }
}
 
void blinken(){
  while(PORTB<15){ // solange nicht alle
    PORTB = (PORTB<<1) +1; // eine weitere
    _delay_ms(150);
  }
  PORTB = 0; // LEDs aus
  _delay_ms(150);
}

#include <avr/io.h>
#include <avr/interrupt.h>
 
int main(){
  DDRB=0x1F; // PORTB als Ausgang
  PORTD = 0b01110000; // PullUps an
  TCCR0A |= 1<<WGM01; // CTC-Mode
  OCR0A = 145;        // 150 ms
  TIMSK |= 1<<OCIE0A; // Interrupt einstellen
  sei();              // Globale ISR-Freigabe
  while (1){
    if(~PIND&(1<<PD4)){ // T0 gedrueckt?
      TCCR0B |= 5;   // Timer starten
    }
  }
}
 
ISR(TIMER0_COMPA_vect){ 
  if(PORTB!=15){
    PORTB = (PORTB<<1) +1;  
  }
  else{
    PORTB = 0; // LEDs aus
    TCCR0B = 0; // Timer stopp
  }
}

#include <avr/io.h>
#include <avr/interrupt.h>
 
volatile unsigned char vram[] = {0,0,0,0}; // LED 4er Gruppen
volatile unsigned int ticks = 0; // Zaehler für 2ms Ticks
 
int main() {
  DDRB = 0xFF;          // PORTB als Ausgang
  PORTD = 0x70;         // PullUps an
  TCCR0A |= 1 << WGM01; // CTC-Mode
  TCCR0B |= 3;          // Vorteiler 64
  TIMSK |= 1 << OCIE0A; // Interrupt enable
  OCR0A = 124;          // 500 Hz
  sei();
  while (1) {
    if ((PIND&(1<<PD4))==0){
      blinken();
    }
  }
  return 0;
}
void incLeds(){ // eine weitere Led links einschalten
  unsigned char i;
  for (i=0;i<4;i++){
    if(vram[i]>=15){
      continue; // zur Bedingung in der For-Schleife springen
    }
    else{
      vram[i]=vram[i]*2+1;
      break; // die For-Schleife verlassen
    }
  }
}
void my_delay_ms(unsigned int n){ // delay ms mit Ticks
  ticks=0;
  while (ticks < n/2);
}
void clearLeds(){ // alle Led aus
  unsigned char i;
  for(i=0;i<4;i++){
    vram[i]=0;
  }
}
void blinken(){ // ein Blinkzyklus
  while(vram[3]<15){
    incLeds();
    my_delay_ms(40);
  }
  clearLeds();
  my_delay_ms(150);
}
ISR(TIMER0_COMPA_vect) { // jede 2ms
  static unsigned char i = 0;
  static const unsigned char vramEin[] = {0b11100000, 0b11010000, 0b10110000, 0b01110000};
  ticks++; // ein Tick weiter
  PORTB = vramEin[i] | vram[i];
  if (i < 3) i++; // vram durchgehen
  else i = 0;
}
 

/* ZylonMatrixBalken (c) Oliver Mezger 6.4.2020  */
 
#include <avr/io.h>
#include <util/delay.h>
 
unsigned char vram[] = {0,0}; // Videospeicher
unsigned char position=7; // Balkenposition
unsigned char balken[2][8]={{0xff,0xfe,0xfc,0xf8,0xf0,0xe0,0xc0,0x80},
                            {0x01,0x03,0x07,0x0f,0x1f,0x3f,0x7f,0xff}};
 
#define KEYREADER ~PIND & 0b01110000 // Einlesen, invertieren, maskieren zurecht schieben
 
unsigned char keyOld = 0;       // alter Tasten-zustand 
unsigned char keyEnter,keyExit; // gedrueckte und losgelassene Tasten 
void keyCheck(){                // Tastaturabfrage mit Flankendedektion  
  unsigned char keyTest,tmp; 
  keyEnter = 0, keyExit = 0; 
  keyTest = KEYREADER;          // Einlesen
  if (keyOld != keyTest){       // hat sich was getan 
    _delay_ms(10);              // Prellen abwarten 
    tmp = KEYREADER;            // noch mal Einlesen
    if (tmp == keyTest){        // ist es stabil? 
      keyEnter = (~keyOld) & keyTest; // steigende Flanke !alt und neu 
      keyExit = keyOld & (~keyTest);  // fallende Flanke alt und !neu 
      keyOld = keyTest; 
    } 
  } 
} 
 
void ausgebeBalken(){ // aus position vram bestimmen
  vram[1]=vram[0]=0;  // nix leuchtet
  if (position<=7){   // wenn kleiner 8
    vram[0]=balken[0][position];  // untere Muster
  }
  else {              // sonst obere Muster
    vram[0] = 0x80;   // dabei soll L7 leuchten
    vram[1]=balken[1][position-8];
  }
}
/* ISR 400 Hz bei 1Mhz Systemtakt: 1/400Hz = 2,5 ms = 2500 µs -> 2500 Takte
 *  2500 / 256 = 9,8 Vorteiler gewaehlt 64 - > 3
 *  2500 / 64 = 39 -> OCR0A = 38
 *  Probe: 39*64 = 2496
 */
int main(){
  DDRB=0xff;
  PORTD=0b01110000;   // PullUps an
  TCCR0A |= 1<<WGM01; // Timer im CTC-Mode
  TCCR0B |= 3;        // Vorteiler 1: /1; 2: /8; 3: /64; 4: /256; 5: /1024
  TIMSK |= 1<<OCIE0A; // Timer/Counter0 Output Compare Match A Interrupt Enable
  OCR0A = 38;         // Wert bei dem der Timer wieder auf 0 gesetzt wird
  sei();              // globale Interruptfreigabe
  ausgebeBalken();
  while(1){
    keyCheck();
    switch (keyEnter){  // Taste gedrueckt?
      case 1<<PD6: // Taste T2 nach oben
        if (position<15) position++;
        ausgebeBalken();
        break;
      case 1<<PD5: // Taste T1 = Start
        position=7;
        ausgebeBalken();
        break;
      case 1<<PD4: // Taste T0 nach unten
        if(position>0) position--;
        ausgebeBalken();
        break;
    }
  }
}
 
ISR(TIMER0_COMPA_vect){ // Interrupt Service Routine
  static unsigned char phase=0;
  switch (phase){  // Ausgabephasen fuer die 4 LED-Bloecke
    case 0:
      PORTB=0xe0 | (vram[0] & 0x0f); // Byte0 unteres Nibble
      phase++;
      break;
    case 1:
      PORTB=0xd0 | (vram[0]>>4);     // Byte0 oberes Nibble
      phase++;
      break;
    case 2:
      PORTB=0xb0 | (vram[1] & 0x0f); // Byte1 unteres Nibble
      phase++;
      break;
    case 3:
      PORTB=0x70 | (vram[1]>>4);     // Byte1 oberes Nibble
      phase=0; // wieder auf Anfang
      break;
  }
}