PORTB |= 1<<PB3;
Was bedeutet das?| 0 | 0 | 0 | 0 | 1 | 0 | 0 | 0 |
| PB7 | PB6 | PB5 | PB4 | PB3 | PB2 | PB1 | PB0 |
PORTB &= ~(1<<PB4);
1<<PB4 ist wieder unsere Bitmaske. Sie sieht nun so aus:
| 0 | 0 | 0 | 1 | 0 | 0 | 0 | 0 |
| PB7 | PB6 | PB5 | PB4 | PB3 | PB2 | PB1 | PB0 |
| 1 | 1 | 1 | 0 | 1 | 1 | 1 | 1 |
| PB7 | PB6 | PB5 | PB4 | PB3 | PB2 | PB1 | PB0 |
PORTB ^= 1<<PB0;
Hier kommt die Exklusiv-ODER-Funktion zum Einsatz, auch XOR genannt. Die Wahrheitstabelle einer XOR-Verknüpfung sieht so aus:
| A | B | A^B |
| 0 | 0 | 0 |
| 0 | 1 | 1 |
| 1 | 0 | 1 |
| 1 | 1 | 0 |
| Bitmaske | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 1 |
| PORTB vorher | 0 | 1 | 0 | 1 | 0 | 1 | 1 | 1 |
| PORTB nachher | 0 | 1 | 0 | 1 | 0 | 1 | 1 | 0 |
PORTB |= 1<<PB2;
#define F_CPU 1000000UL
#include <avr/io.h>
#include <util/delay.h>
#include <stdint.h>
uint16_t zeit;
void pause(uint16_t zeit)
{
for(uint16_t i=0; i<zeit; i++)
_delay_us(1);
}
int main(void)
{
DDRD |= 1<<PD6; //PD6 als Ausgang definieren
zeit=1;
while(1)
{
if (zeit < 1000)
{
zeit++;
PORTD |= 1<<PD6;
pause(zeit);
PORTD &= ~(1<<PD6);
pause(zeit);
}
else
zeit = 1;
}
}
#define F_CPU 1000000UL
#include <avr/io.h>
#include <util/delay.h>
#include <stdint.h>
int main(void)
{
DDRD |= 1<<PD6; //PD6 als Ausgang schalten,
//dort sitzt der Buzzer
ADCSRA |= 1<<ADEN; //enable ADC
ADCSRA |= (1<<ADPS1)|(1<<ADPS0); //Prescaler für Analog-Digital-Wandlung
uint16_t zahl=0;
void ton(uint16_t zahl)
{
for(uint16_t i=0; i<zahl; i++)
_delay_us(1);
PORTD |= 1<<PD6; //PD6 auf High schalten
for(uint16_t i=0; i<zahl; i++)
_delay_us(1);
PORTD &= ~(1<<PD6); //PD6 auf Low schalten
}
while(1)
{
ADCSRA |= 1<<ADSC; //AD-Wandlung auslösen
while(ADCSRA&(1<<ADSC)); //Warten auf Ende der Wandlung
zahl = ADCL + (ADCH<<8); //Ergebnis der Wandlung in zahl laden
ton(zahl); //Aufruf der Funktion ton
}
}
#define F_CPU 1000000UL
#include <avr/io.h>
#include <util/delay.h>
#include <stdint.h>
int main(void)
{
DDRB |= 1<<PB0;
ADCSRA |= 1<<ADEN; //enable ADC
ADCSRA |= (1<<ADPS1)|(1<<ADPS0); //Prescaler
uint16_t zahl=0;
while(1)
{
ADCSRA |= 1<<ADSC; //AD-Wandlung auslösen
while(ADCSRA&(1<<ADSC)); //Warten auf Ende der Wandlung
zahl = ADCL + (ADCH<<8);
if (zahl<600) //den Wert von zahl individuell probieren
{
for(int k=0; k<5; k++)
{
PORTB |= 1<<PB0; //schnelles Blinken
_delay_ms(200);
PORTB &= ~(1<<PB0);
_delay_ms(200);
}
}
else
{
PORTB |= 1<<PB0; //langsames Blinken
_delay_ms(1000);
PORTB &= ~(1<<PB0);
_delay_ms(1000);
}
}
}
// Die Spannungswerte beim Start werden in den EEPROM geschrieben.
// Es können 1024 Bytes in den EEPROM gespeichert werden.
#define F_CPU 1000000UL
#include <avr/io.h>
#include <util/delay.h>
#include <stdint.h>
unsigned char zahl, wert;
// Die folgende Funktion dient zum Schreiben des EEPROMs
// aus dem Datenblatt des ATmega32
void EEPROM_write(unsigned int uiAddress, unsigned char ucData)
{
/* Wait for completion of previous write */
while(EECR & (1<<EEWE))
;
/* Set up address and data registers */
EEAR = uiAddress;
EEDR = ucData;
/* Write logical one to EEMWE */
EECR |= (1<<EEMWE);
/* Start eeprom write by setting EEWE */
EECR |= (1<<EEWE);
}
int main(void)
{
DDRB |= 1<<PB0;
DDRD |= 1<<PD3;
PORTD |= 1<<PD3;
ADCSRA |= (1<<ADEN); //Enable ADC, d. h. die AD-Wandlung wird aktiviert
// Wir verwenden ADC0 als Eingang
ADMUX |= (1<<ADLAR); //wir wollen nur 255-Bit-Auflösung, daher left-adjusted
ADCSRA |= (1<<ADPS1)|(1<<ADPS0); //Einstellung des Prescalers für ADC
// Der Prescaler muss so gewählt werden, dass sich der Takt
// für den AD-Wandler zwischen 50 kHz und 200 kHz ergibt.
// Hier: 1 MHz/8 = 125 kHz --> OK!
for (unsigned int i = 0; i<1020; i++) //1020 Schleifendurchläufe für 1020 EEPROM-Bytes
{
zahl=wert=0;
ADCSRA |= (1<<ADSC); //Start der Wandlung
while(ADCSRA&(1<<ADSC)); //Warten auf Ende der Wandlung, sie dauert 13 Takte
wert = ADCH; //ADCL muss ebenfalls gelesen werden, da sonst keine
//neue Wandlung gestartet wird
EEPROM_write(i, wert); //wert in den EEPROM schreiben
}
while(1)
{
PORTB |= 1<<PB0; //Blinken zeigt Ende des Programms an
_delay_ms(1000);
PORTB &= ~(1<<PB0);
_delay_ms(1000);
}
}
//EEPROM-Lesen und Erzeugen einer csv-Datei mit avrdude (comma separated values)
//avrdude -c usbtiny -p m32 -U eeprom:r:datei.csv:d
//Es wird der EEPROM ausgelesen, read, in datei.csv, dezimal
/*
* ATmega32_Swap.c
* Das Programm arbeitet mit Zeigern.
* Die Funktion swap bewirkt das Hin- und Herschalten zwischen
* zwei Variablen.
*
* Created: 13.05.2017 20:31:31
* Author: Holger Freydank
*/
#define F_CPU 1000000UL
#include <avr/io.h>
#include <stdint.h>
#include <avr/interrupt.h>
int a=73, b=54; //Codierung der 7-Segment-Anzeige
//globale Variablen
void swap (int *px, int *py)
{
int tmp;
tmp = *px;
*px = *py;
*py = tmp;
}
ISR(INT2_vect)
{
swap(&a, &b);
}
int main(void)
{
PORTB |= 1<<PB2; //Pull-up Widerstand an PB2 einschalten
DDRC = 0xFF; //Port C als Ausgang definieren
GICR |= 1<<INT2; //Interrupt durch INT2 ermöglichen
//ISC2 im Register MCUCSR ist 0
// -> fallende Flanke von INT2 löst Interrupt aus
sei(); //Interrupt ermöglichen
while(1)
{
PORTC = a; //7-Segment-Anzeige
}
}
#define F_CPU 1000000UL
#include <avr/io.h>
#include <util/delay.h>
#include <stdint.h>
int anwert, auswert, zahl;
void alarm(void)
{
for(int i = 0; i<500; i++) //akustisches Signal
{
PORTB ^= 1<<PB0;
_delay_ms(5);
}
}
int getADC(void)
{
ADCSRA |= (1<<ADSC); //AD-Wandlung auslösen
while(ADCSRA&(1<<ADSC)); //Warten auf das Ergebnis der AD-Wandlung
zahl = ADCL + (ADCH<<8); //Ergebnis der Wandlung in zahl laden
return zahl;
}
int main(void)
{
DDRB |= 1<<PB0; //Buzzer
DDRA |= 1<<PA2; //LED
ADCSRA |= (1<<ADEN); //Enable ADC, AD-Wandlung wird aktiviert
ADCSRA |= (1<<ADPS1)|(1<<ADPS0); //Einstellung des Prescalers für AD-Wandlung
while(1)
{
PORTA |= 1<<PA2; //LED einschalten
_delay_ms(100);
anwert = getADC();
_delay_ms(1000);
PORTA &= ~(1<<PA2); //LED ausschalten
_delay_ms(100);
auswert = getADC();
_delay_ms(1000);
if((auswert-anwert) < 20)
alarm();
}
}
#define rechts 0xDF //Ansteuerung der rechten 7-Segment-Anzeige (Einer)
#define links 0xBF //Ansteuerung der linken 7-Segment-Anzeige (Zehner)
#define F_CPU 1000000UL
#include <avr/io.h>
#include <util/delay.h>
#include <stdint.h>
int main(void)
{
int pc[10]={63,6,91,79,102,109,125,7,127,111}; //Codierung der 7-Segment-Anzeigen
//pc bedeutet Port C
DDRC = 0xFF; //Port C als Ausgang definieren für die 7-Segment-Anzeige
DDRD = 0x60; //Port D schaltet zwischen den beiden 7-Segment-Anzeigen um
ADCSRA |= (1<<ADEN); //Enable ADC, AD-Wandlung wird aktiviert
ADCSRA |= (1<<ADPS1)|(1<<ADPS0); //Einstellung des Prescalers für AD-Wandlung
uint32_t zahl = 0; //Zahl muss groß genug sein, um den Wert 1024 * 99 aufzunehmen!
uint32_t l=0, r=0, wert;
while(1)
{
wert=0;
for(int i=0; i<8; i++)
{
ADCSRA |= (1<<ADSC); //AD-Wandlung auslösen
while(ADCSRA&(1<<ADSC)); //Warten auf das Ergebnis der AD-Wandlung
zahl = ADCL + (ADCH<<8); //Ergebnis der Wandlung in zahl laden
zahl = 99 * zahl;
zahl >>= 10; //zahl durch 1024 teilen
wert += zahl;
}
wert >>= 3; //Division durch 8
l= wert / 10; //linke Anzeige
r= wert % 10; //rechte Anzeige
for(int k=0; k<5; k++)
{
PORTD = rechts; //rechte Anzeige wird angesteuert
PORTC = pc[r];
_delay_ms(10); //10 ms Verzögerung ist ausreichend
//für flackerfreie Anzeige
PORTD = links; //linke Anzeige wird angesteuert
PORTC = pc[l];
_delay_ms(10);
}
}
}
Mithilfe eines Photowiderstandes wird die Lichtstärke gemessen und über die beiden Siebensegmentanzeigen angezeigt. Je dunkler es ist, umso größer ist die angezeigte Zahl. Bei Tageslicht wird etwa 5 bis 10 angezeigt. Bei Dunkelheit wird ein Wert bis 99 angezeigt. 
#define rechts 0xDF //Ansteuerung der rechten 7-Segment-Anzeige (Einer)
#define links 0xBF //Ansteuerung der linken 7-Segment-Anzeige (Zehner)
#define F_CPU 1000000UL
#include <avr/io.h>
#include <util/delay.h>
#include <stdint.h>
#include <avr/interrupt.h>
uint8_t zahl = 0; //die darzustellende Zahl
int pc[10]={63,6,91,79,102,109,125,7,127,111}; //Codierung der 7-Segment-Anzeigen
ISR(INT2_vect)
{
zahl++;
}
ISR(INT1_vect)
{
zahl=0;
}
int main(void)
{
DDRC = 0xFF; //Port C als Ausgang definieren für die 7-Segment-Anzeige
DDRD = 0x60; //Port D schaltet zwischen den beiden 7-Segment-Anzeigen um
//und ermöglicht INT1.
uint8_t l=0, r=0;
PORTB |= 1<<PB2; //Pull-Up-Widerstand an PB2 (INT2) einschalten
PORTD |= 1<<PD3; //Pull-Up-Widerstand an PD3 (INT1) einschalten
GICR |= 1<<INT2; //Interrupt durch INT2 ermöglichen
//ISC2 im Register MCUCSR ist 0 --> fallende Flanke von INT2
//löst Interrupt aus
GICR |= 1<<INT1; //Interrupt durch INT1 ermöglichen
MCUCR |= 1<<ISC11; //fallende Flanke von INT1 löst Interrupt aus
sei(); //Interrupts freigeben
while(1)
{
l= zahl / 10; //linke Anzeige
r= zahl % 10; //rechte Anzeige
for(int k=0; k<5; k++)
{
PORTD = rechts; //rechte Anzeige wird angesteuert
PORTC = pc[r];
_delay_ms(10); //10 ms Verzögerung ist ausreichend
//für flackerfreie Anzeige
if(l==0)
PORTD = 0xff; //wenn zahl < 10 bleibt die linke Anzeige dunkel
else
PORTD = links; //linke Anzeige wird angesteuert
PORTC = pc[l];
_delay_ms(10);
}
}
}
#define F_CPU 1000000UL
#include <avr/io.h>
#include <avr/interrupt.h>
#include <util/delay.h>
#include <stdint.h>
#include <setjmp.h>
jmp_buf lied1,lied2;
volatile int dst = 1;
ISR(INT2_vect)
{
if(dst==1) //Sprung zum jeweils anderen Codeabschnitt ("Lied")
longjmp(lied2, 2);
if(dst==2)
longjmp(lied1, 1);
}
int main(void)
{
cli();
DDRA = 0xFF; //Port A als Ausgang definieren
PORTB |= (1<<PB2); //Pull-up-Widerstand einschalten an PB2
GICR |= (1<<INT2); // General Interrupt Control register
MCUCSR &= ~(1<<ISC2); // fallende Flanke von INT2 löst Interrupt aus
sei();
while(1)
{
//Lied1
setjmp(lied1); //schnelles Blinken, die LED hängt an PA6
dst = 1;
for (int i=0; i<8; i++)
{
PORTA |= (1<<PA6);
_delay_ms(200);
PORTA &= ~(1<<PA6);
_delay_ms(200);
}
//Lied2
setjmp(lied2); //langsames Blinken
dst = 2;
for(int i=0;i<8;i++)
{
PORTA |= (1<<PA6);
_delay_ms(1000);
PORTA &= ~(1<<PA6);
_delay_ms(1000);
}
}
}
#define rechts 0xDF
#define links 0xBF
#define F_CPU 1000000UL
#include <avr/io.h>
#include <avr/interrupt.h>
#include <util/delay.h>
#include <stdint.h>
volatile uint8_t run = 0;
ISR(INT2_vect)
{
run++;
if (run == 3) run = 0;
}
int main(void)
{
cli();
int pc[10]={63,6,91,79,102,109,125,7,127,111}; //Codierung der 7-Segment-Anzeigen
int wertlinks = 0;
int wertrechts = 0;
//pc bedeutet Port C
DDRC = 0xFF; //Port C als Ausgang definieren für die 7-Segment-Anzeige
DDRD = 0x60; //Port D schaltet zwischen den beiden 7-Segment-Anzeigen um
PORTB |= (1<<PB2); //Pull-up-Widerstand einschalten
GICR |= (1<<INT2); // General Interrupt Control register
MCUCSR &= ~(1<<ISC2); // fallende Flanke von INT2 löst Interrupt aus
sei();
while(1)
{
if(run == 0)
{
wertlinks = 0;
wertrechts = 0;
PORTD = rechts; //rechte Anzeige
PORTC = pc[wertrechts];
_delay_ms(5);
PORTD = links; //linke Anzeige
PORTC = pc[wertlinks];
_delay_ms(5);
}
//if (!(PINB &(1<<PB2))) //Taster gedrückt
else if(run == 1)
{
for(int j=0; j<10; j++)
{
if(run != 1) break;
for(int i=0; i<10; i++)
{
if(run != 1) break;
for(int k=0; k<100; k++)
{
PORTD = rechts; //rechte Anzeige
PORTC = pc[i];
_delay_ms(5);
PORTD = links; //linke Anzeige
PORTC = pc[j];
_delay_ms(5);
wertrechts = i;
wertlinks = j;
}
}
}
}
else
{
PORTD = rechts; //rechte Anzeige
PORTC = pc[wertrechts];
_delay_ms(5);
PORTD = links; //linke Anzeige
PORTC = pc[wertlinks];
_delay_ms(5);
}
}
}
//Das Programm spielt das Lied "Auf, auf zum fröhlichen Jagen".
//Die Töne werden mit dem Timer0 erzeugt.
//Die Töne werden mit einer 7-Segment-Anzeige angezeigt.
#define F_CPU 1000000UL
#define notec 239 //dies sind die Werte des Output Compare Registers
#define noted 213 //für die einzelnen Noten
#define notee 190
#define notef 179
#define noteg 159
#define notea 142
#define noteb 134
#define noteC 119
#include <avr/io.h>
#include <util/delay.h>
#include <stdint.h>
void ton(uint16_t periode, uint8_t dauer) //Funktion spielt einen Ton
{
TCCR0 &= ~(1<<CS01); //Timer kurz abschalten
_delay_ms(10); //wegen zweier benachbarter Töne mit gleicher Tonhöhe
TCCR0 |= 1<<CS01; //Timer einschalten
OCR0 = periode;
if (periode==239) PORTC = 88; //Codierung der 7-Segment-Anzeige
if (periode==213) PORTC = 94;
if (periode==190) PORTC = 121;
if (periode==179) PORTC = 113;
if (periode==159) PORTC = 125;
if (periode==142) PORTC = 119;
if (periode==134) PORTC = 124;
if (periode==119) PORTC = 57;
for(int i=0; i<dauer; i++)
_delay_ms(100); //_delay_ms braucht als Argument eine Konstante
//deswegen die for-Schleife
}
void pause(uint8_t dauer) //Funktion macht eine Pause
{
TCCR0 &= ~(1<<CS01); //Timer abschalten
PORTC = 0;
for(int i=0; i<dauer; i++) //siehe oben
_delay_ms(100);
}
int main(void)
{
DDRC = 0xFF; //Port C als Ausgang schalten
DDRB |= 1<<PB3; //OC0 als Ausgang schalten
TCCR0 |= 1<<COM00; //toggle OC0 on compare match
TCCR0 |= 1<<CS01; //prescaler 8
TCCR0 |= 1<<WGM01; //clear timer on compare match
while(1)
{
//gegliedert nach Takten
//1 Zeile ist jeweils 1 Takt
//notec,1 bedeutet z. B. die Note c als Sechzehntelnote gespielt
//noteb,2 bedeutet z. B. die Note b als Achtelnote gespielt
ton(notec,4);
ton(notef,6); ton(notec,2); ton(notef,4); ton(notea,2);ton(notea,2);
ton(notef,8); ton(notec,4); ton(notef,2); ton(notea,2);
ton(noteg,4); ton(notec,4); ton(notec,4); ton(noted,2);ton(notee,2);
ton(notef,8); pause(4); ton(notec,4);
ton(notef,6); ton(notec,2); ton(notef,4); ton(notea,2);ton(notea,2);
ton(notef,8); ton(notec,4); ton(notef,2); ton(notea,2);
ton(noteg,4); ton(notec,4); ton(notec,4); ton(noted,2);ton(notee,2);
ton(notef,8); pause(4); ton(notee,3); ton(notef,1);
ton(noteg,4); ton(notec,4); ton(notec,4); ton(notef,2);ton(noteg,2);
ton(notea,8); ton(notef,4); ton(notea,4);
ton(noteb,4); ton(notea,4); ton(noteg,4); ton(notef,4);
ton(noteg,12); ton(notec,4);
ton(notef,6); ton(notec,2); ton(notef,4); ton(notea,4);
ton(notef,8); ton(notec,4); ton(notef,2); ton(notea,2);
ton(noteg,4); ton(notec,4); ton(notec,4); ton(noted,2); ton(notee,2);
ton(notef,8); pause(4); ton(notee,3); ton(notef,1);
ton(noteg,8); ton(notec,4); ton(noteC,4);
ton(notea,8); ton(notef,4); ton(notea,4);
ton(noteg,4); ton(noteC,4); ton(noteg,4); ton(noteC,4);
ton(notef,4); ton(notef,3); ton(notea,1); ton(noteg,8);
ton(notef,8); ton(notec,4); ton(notea,4);
ton(notef,8); ton(notec,4); ton(notea,4);
ton(noteg,4); ton(noteC,4); ton(noteg,4); ton(notea,3); ton(noteg,1);
ton(notef,12);
}
}
#define F_CPU 1000000UL
#define notec 239 //dies sind die Werte des Output Compare Registers
#define noted 213 //für die einzelnen Noten
#define notee 190
#define notef 179
#define noteg 159
#define notea 142
#define noteb 134
#define noteC 119
#include <avr/io.h>
#include <util/delay.h>
#include <stdint.h>
void ton(uint16_t periode, uint8_t dauer) //Funktion spielt einen Ton
{
TCCR0 &= ~(1<<CS01); //Timer kurz abschalten
_delay_ms(10); //wegen zweier benachbarter Töne mit gleicher Tonhöhe
TCCR0 |= 1<<CS01; //Timer einschalten
OCR0 = periode;
for(int i=0; i<dauer; i++)
_delay_ms(100); //_delay_ms braucht als Argument eine Konstante
//deswegen die for-Schleife
}
void pause(uint8_t dauer) //Funktion macht eine Pause
{
TCCR0 &= ~(1<<CS01); //Timer abschalten
for(int i=0; i<dauer; i++) //siehe oben
_delay_ms(100);
}
int main(void)
{
DDRB |= 1<<PB3; //OC0 als Ausgang schalten
TCCR0 |= 1<<COM00; //toggle OC0 on compare match
TCCR0 |= 1<<CS01; //prescaler 8
TCCR0 |= 1<<WGM01; //clear timer on compare match
while(1)
{
//gegliedert nach Takten
//1 Zeile ist jeweils 1 Takt
//notec,1 bedeutet z. B. die Note c als Sechzehntelnote gespielt
//noteb,2 bedeutet z. B. die Note b als Achtelnote gespielt
ton(notec,4);
ton(notef,6); ton(notec,2); ton(notef,4); ton(notea,2);ton(notea,2);
ton(notef,8); ton(notec,4); ton(notef,2); ton(notea,2);
ton(noteg,4); ton(notec,4); ton(notec,4); ton(noted,2);ton(notee,2);
ton(notef,8); pause(4); ton(notec,4);
ton(notef,6); ton(notec,2); ton(notef,4); ton(notea,2);ton(notea,2);
ton(notef,8); ton(notec,4); ton(notef,2); ton(notea,2);
ton(noteg,4); ton(notec,4); ton(notec,4); ton(noted,2);ton(notee,2);
ton(notef,8); pause(4); ton(notee,3); ton(notef,1);
ton(noteg,4); ton(notec,4); ton(notec,4); ton(notef,2);ton(noteg,2);
ton(notea,8); ton(notef,4); ton(notea,4);
ton(noteb,4); ton(notea,4); ton(noteg,4); ton(notef,4);
ton(noteg,12); ton(notec,4);
ton(notef,6); ton(notec,2); ton(notef,4); ton(notea,4);
ton(notef,8); ton(notec,4); ton(notef,2); ton(notea,2);
ton(noteg,4); ton(notec,4); ton(notec,4); ton(noted,2); ton(notee,2);
ton(notef,8); pause(4); ton(notee,3); ton(notef,1);
ton(noteg,8); ton(notec,4); ton(noteC,4);
ton(notea,8); ton(notef,4); ton(notea,4);
ton(noteg,4); ton(noteC,4); ton(noteg,4); ton(noteC,4);
ton(notef,4); ton(notef,3); ton(notea,1); ton(noteg,8);
ton(notef,8); ton(notec,4); ton(notea,4);
ton(notef,8); ton(notec,4); ton(notea,4);
ton(noteg,4); ton(noteC,4); ton(noteg,4); ton(notea,3); ton(noteg,1);
ton(notef,12);
}
}
#define F_CPU 1000000UL
#include <avr/io.h>
#include <util/delay.h>
int main(void)
{
DDRB |= 1<<PB3; //OC0 als Ausgang schalten
TCCR0 |= 1<<COM00; //Toggle OC0 on compare match
TCCR0 |= 1<<CS01; //Prescaler 8
TCCR0 |= 1<<WGM01; //Clear Timer on Compare Match (CTC)
while(1)
{
OCR0 = 239;
_delay_ms(1000);
OCR0 = 213;
_delay_ms(1000);
OCR0 = 190;
_delay_ms(1000);
OCR0 = 179;
_delay_ms(1000);
OCR0 = 159;
_delay_ms(1000);
OCR0 = 142;
_delay_ms(1000);
OCR0 = 126;
_delay_ms(1000);
OCR0 = 119;
_delay_ms(1000);
}
}
#define rechts 0xDF //Ansteuerung der rechten 7-Segment-Anzeige (Einer)
#define links 0xBF //Ansteuerung der linken 7-Segment-Anzeige (Zehner)
#define F_CPU 1000000UL
#include <avr/io.h>
#include <util/delay.h>
#include <stdint.h>
int main(void)
{
int pc[10]={63,6,91,79,102,109,125,7,127,111}; //Codierung der 7-Segment-Anzeigen
//pc bedeutet Port C
DDRC = 0xFF; //Port C als Ausgang definieren für die 7-Segment-Anzeige
DDRD = 0x60; //Port D schaltet zwischen den beiden 7-Segment-Anzeigen um
ADCSRA |= (1<<ADEN); //Enable ADC, AD-Wandlung wird aktiviert
ADCSRA |= (1<<ADPS1)|(1<<ADPS0); //Einstellung des Prescalers für AD-Wandlung
uint32_t zahl = 0; //Zahl muss groß genug sein, um den Wert 1024 * 99 aufzunehmen!
uint32_t l=0, r=0;
while(1)
{
ADCSRA |= (1<<ADSC); //AD-Wandlung auslösen
while(ADCSRA&(1<<ADSC)); //Warten auf das Ergebnis der AD-Wandlung
zahl = ADCL + (ADCH<<8); //Ergebnis der Wandlung in zahl laden
zahl = 99 * zahl / 1023;
l= zahl / 10; //linke Anzeige
r= zahl % 10; //rechte Anzeige
for(int k=0; k<5; k++)
{
PORTD = rechts; //rechte Anzeige wird angesteuert
PORTC = pc[r];
_delay_ms(10); //10 ms Verzögerung ist ausreichend
//für flackerfreie Anzeige
PORTD = links; //linke Anzeige wird angesteuert
PORTC = pc[l];
_delay_ms(10);
}
}
}
#define rechts 0xDF
#define links 0xBF
#define F_CPU 1000000UL
#include <avr/io.h>
#include <util/delay.h>
#include <stdint.h>
int main(void)
{
int pc[10]={63,6,91,79,102,109,125,7,127,111}; //Codierung der 7-Segment-Anzeigen
//pc bedeutet Port C
DDRC = 0xFF; //Port C als Ausgang definieren für die 7-Segment-Anzeige
DDRD = 0x60; //Port D schaltet zwischen den beiden 7-Segment-Anzeigen um
while(1)
{
for(int j=0; j<10; j++)
for(int i=0; i<10; i++)
{
for(int k=0; k<10; k++)
{
PORTD = rechts; //rechte Anzeige
PORTC = pc[i];
_delay_ms(10); //10 ms Verzögerung ist ausreichend
//für flackerfreie Anzeige
PORTD = links; //linke Anzeige
PORTC = pc[j];
_delay_ms(10);
}
}
}
}
#define F_CPU 1000000UL
#include <avr/io.h>
#include <util/delay.h>
#include <stdint.h>
//Das Programm steuert eine 7-Segment-Anzeige an und
//zeigt die Zahlen von 0 bis 9
int main(void)
{
DDRC = 0xFF; //Port C als Ausgang definieren für die 7Segment-Anzeige
while(1)
{
PORTC=63;
_delay_ms(500);
PORTC=6;
_delay_ms(500);
PORTC=91;
_delay_ms(500);
PORTC=79;
_delay_ms(500);
PORTC=102;
_delay_ms(500);
PORTC=109;
_delay_ms(500);
PORTC=125;
_delay_ms(500);
PORTC=7;
_delay_ms(500);
PORTC=127;
_delay_ms(500);
PORTC=111;
_delay_ms(500);
}
}
#define F_CPU 1000000UL
#include <avr/io.h>
#include <stdint.h>
#include <util/delay.h>
int main(void)
{
DDRC = 0xFF; //Port C als Ausgang definieren für die 7Segment-Anzeige
while(1)
{ //Taster an PA0 gegen Masse
PORTA |= (1<<PA0); // Pull-up-Widerstand einschalten
if (PINA & (1<<PA0))
{ //Normalzustand: Taster ist offen
PORTC = 0x01;
_delay_ms(50);
for(uint8_t i=0; i<7; i++)
{
PORTC <<= 1; //Reihenfolge a,b,c,...
_delay_ms(50);
}
}
else
{ //Taster ist geschlossen
PORTC = 0x80;
_delay_ms(50);
for(uint8_t i=0; i<7; i++)
{
PORTC >>= 1; //umgekehrte Reihenfolge: h,g,...
_delay_ms(50);
}
}
}
}
#define F_CPU 1000000UL
#include <avr/io.h>
#include <stdint.h>
#include <util/delay.h>
int main(void)
{
DDRB |= 1<<PB3; // PB3 als Ausgang schalten
while(1)
{
PORTB ^= 1<<PB3; //Toggeln von PB0
_delay_us(500);
}
}
#define F_CPU 1000000UL
#include <avr/io.h>
#include <stdint.h>
int main(void)
{
DDRB |= 1<<PB3; //OC0 als Ausgang schalten
TCCR0 |= 1<<WGM01; //Clear Timer on Compare Mode des Timers 0
TCCR0 |= 1<<COM00; //Toggle OC0 on Compare Match
TCCR0 |= 1<<CS00; //no prescaling
OCR0 = 255; // heraus kommt etwa eine Frequenz von 1953 Hz
while(1)
{
}
}
#define F_CPU 1000000UL
#include <avr/io.h>
#include <stdint.h>
#include <util/delay.h>
int main(void)
{
DDRB |= 1<<PB3; //OC0 als Ausgang
TCCR0 |= 1<<WGM01; //Clear Timer on Compare Mode des Timers 0
TCCR0 |= 1<<COM00; //Toggle OC0 on Compare Match
TCCR0 |= 1<<CS00; //no Prescaling
while(1)
{
OCR0=255;
while(OCR0>0)
{
_delay_ms(200);
OCR0--;
}
}
}
