7-Segment Anzeige ansteuern (Gray-Code und ATmega32)

[Ingemar F. (dementius)]

Hallo,

ich möchte eine 7-Segment Anzeige per ATmega32 ansteuern wobei die 
Eingangssignale als Gray-Code definiert sind:

000 = A
001 = U
011 = E
010 = 1
110 = 2
111 = 3
101 = 4

Wenn die entsprechenden Signale an den jeweiligen Bits (PA0 - PA2) 
anliegen sollen die entsprechenden Bits am PORT D auf High geschaltet 
werden.
Ich hab mir das Tutorial durchgelesen und auch andere Beispiele 
angeschaut und mal probiert ein Programm dazu zu schreiben.
Für Hilfe und Ratschläge wäre ich sehr dankbar.

mfg

#define F_CPU 8000000UL
#include <util/delay.h>
#include <avr/io.h>



int main(void)
{
  //Setzen der Eingänge
  DDRA = 0x00;
  DDRA &= ~((1<<PA0) | (1<<PA1) | (1<<PA2));

  // Ausgänge definieren
  DDRD = 0xff;

    while (1) 
    {
    // für Anzeige "U"
    if (PINA &= (1<<PA0))
    {
      PORTD |= ((1<<PD1) | (1<<PD2) | (1<<PD3) | (1<<PD4) | (1<<PD5));
      _delay_ms(250);
    } 
    else
    {
      PORTD = 0x00;
    }
    
    // für Anzeige "E"
    if(PINA &= ((1<<PA0) & (1<<PA1)));
    {
      PORTD |= (1<<PD0) | (1<<PD3) | (1<<PD4) | (1<<PD5) | (1<<PD6);
      _delay_ms(250);
    }
    else
    {
      PORTD = 0x00;
    }

    //für Anzeige "1"
    if(PINA &= (1<<PA1))
    {
      PORTD |= (1<<PD1) | (1<<PD2);
      _delay_ms(250);
    }
    else
    {
      PORTD = 0x00;
    }

    //für Anzeige "2"
    if(PINA &= (1<<PA1) & (1<<PA2))
    {
      PORTD |= (1<<PD0) | (1<<PD1) | (1<<PD3) | (1<<PD4) | (1<<PD6);
      _delay_ms(250);
    }
    else
    {
      PORTD = 0x00;
    }

    // für Anzeige "3"
    if (PINA &= (1<<PA0) & (1<<PA1) & (1<<PA2))
    {
      PORTD |= (1 << PD0) | (1 << PD1) | (1 << PD2) | (1 << PD3) | (1 << PD6);
      _delay_ms(250);
    } 
    else
    {
      PORTD = 0x00;
    }
    
    // für Anzeige "4"
    if (PINA &= (1<<PA0) & (1<<PA2))
    {
      PORTD |= (1 << PD1) | (1 << PD2) | (1 << PD5) | (1 << PD6);
      _delay_ms(250);
    } 
    else
    {
      PORTD = 0x00;
    }
    
    }
}

[Max D. (max_d)]

Mach dir eine code Tabelle und benutze deinen Code als Zeiger da rein.

[Witkatz :. (wit)]

Ingemar F. schrieb:
> if (PINA &= (1<<PA0))

&= ist ein Zuweisungsoperator

[Karl M. (Gast)]

Hallo,

hier ist eine komplette Lösung mit LunaAVR für unterschiedliche LED mit 
gemeinsamer Kathode oder Anode.

'---------------------------------------
' LunaAVR Version 2017.r1 build 9156 (beta)
' 2017-01-30
'---------------------------------------
' System Settings

const F_CPU = 8000000
avr.device   = atmega32
avr.clock  = avr.F_CPU
avr.stack  = 64

'---------------------------------------
' define I/O Portpins

#define INPUT0 as portA.0
#define INPUT1 as portA.1
#define INPUT2 as portA.2

#define LED_OUT as portd

'---------------------------------------
' setup I/O Portpins

INPUT0.mode = input, nopullup
INPUT1.mode = input, nopullup
INPUT2.mode = input, nopullup

'---------------------------------------
' Belegung der LED Segmente
' Wahl des LED Typs
#define LED_COMMON_ANODE   as 0
#define LED_COMMON_KATHODE as 1
#define LED_COMMON_TYPE    as LED_COMMON_KATHODE

' Belegung der LED Segmente am Port LED_OUT
' LED_SEG_DP = Bit7 wird nicht bedient.
const LED_SEG_A  = (1<<0)
const LED_SEG_B  = (1<<1)
const LED_SEG_C  = (1<<2)
const LED_SEG_D  = (1<<3)
const LED_SEG_E  = (1<<4)
const LED_SEG_F  = (1<<5)
const LED_SEG_G  = (1<<6)
const LED_SEG_DP = (1<<7)

#if LED_COMMON_TYPE
LED_OUT.mode = output, low
#else
LED_OUT.mode = output, high
#endif

'---------------------------------------
' main loop

dim bInput as byte
dim bInput_old as byte

bInput_old = ReadInput()
LED_OUT.value = ReadLEDChar( bInput_old )

do
bInput = ReadInput()

if (bInput <> bInput_old) then
bInput_old = bInput
LED_OUT.value = ReadLEDChar( bInput )
endif

' waitms(100) ' just debug
loop

'---------------------------------------
'
function ReadInput() as byte
 dim result as byte
 result = 0

 when (INPUT0) do result or= 0b001
 when (INPUT1) do result or= 0b010
 when (INPUT2) do result or= 0b100

 return result
endfunc

'---------------------------------------
'
function ReadLEDChar( value as byte ) as byte
 #if LED_COMMON_TYPE
  return LED_character.ByteValue( value and 0b111 )
 #else
  return not LED_character.ByteValue( value and 0b111 )
 #endif
endfunc

'---------------------------------------
' LED Zeichensatz
data LED_character
' 0b000
.db 0b01110111
' 0b001
.db 0b00111110
' 0b010
.db 0b00000110
' 0b011
.db 0b01111001
' 0b100
.db 0b0
' 0b101
.db 0b01100110
' 0b110
.db 0b01011011
' 0b111
.db 0b01001111
enddata

[fop (Gast)]

if (PINA &= (1<<PA0))

Uff ! So vergleicht man eigentlich nicht. Das ist eine Zuweisung in 
einem if.
Also wird hier PINA der Wert von PINA mit 1 und-verknüpft zugewiesen. 
Weil aber in C jede Zuweisung auch einen Wert hat, gibt's dafür keinen 
Mecker vom Compiler, sondern die Bedingung ist wahr, sobald PINA und 1 
einen Wert ungleich null hat.
Du schreibst also auf PINA, das ist bei AVRs wie ein Schreiben auf 
PORTA. Da die Pins wohl Eingänge sind, schaltest Du damit munter die 
Pullups, falls sie global aktiviert sind. War vermutlich so nie gedacht.
Punkt 2 ist noch witziger, sobald das Bit 0 in PINA eins ist, ist die 
Bedingung erfüllt. Also immer, wenn PA0 auf high ist.
Laut Deiner Tabelle also bei U, E, 3 und 4. Nicht wie geplant nur bei U.
Warum Du die Anzeige löschst, wenn der aktuell abgetestete Wert nicht 
stimmt, bleibt wohl Dein Geheimnis. Würdest Du Dir das verkneifen, 
könntest Du die delay auch einfach weg lassen.
Also normalerweise würdest Du ja auch sagen
- wenn U, zeige U an
- wenn E, zeige E an
... usw.
- wenn nix von alledem, lösche Anzeige

So was kann man als witzige if...else if...else if...else if...else 
Kaskade schreiben. Oder man kann das wie dafür gemachte switch/case 
benutzen.

Wenn Du es so umsetzt kannst Du auch volle Geschwindigkeit geben. Es 
flackert dann nur, wenn der Eingangswert wackelt.

[Ingemar F. (dementius)]

Max D. schrieb:
> Mach dir eine code Tabelle und benutze deinen Code als Zeiger da rein.

So in etwa?

const unsigned char GrayCode[7] = {0x7E, //U 
0x79, // E
0x06, //1
0x5B, //2
0x4F, //3
0x66, //4
0x77 //A 
};

Das wären die Zustände für die Pins an der 7-Segment Anzeige.

Abgefragt sollen folgende Zustände an den Eingangspins:

U = 0x01
E = 0x03
1 = 0x02
2 = 0x06
3 = 0x07
4 = 0x05
A = 0x00

Edit:

Ist das korrekt?

//Setzen der Eingänge
  DDRA &= ~((1 << DDA0) | (1 << DDA1) | (1<<DDA2));
  
  // Ausgänge definieren
  DDRD |= (1 << DDD0) | (1 << DDD1) | (1 << DDD2) | (1 << DDD3) | (1 << DDD4) | (1 << DDD5) | (1 << DDD6);

[Max D. (max_d)]

Du musst vorher den graycode in binär "umdenken".
Das erste Element ist das mit der Adresse 0 0=0x00="A"
Das nächste ist 1
1=0x01="U"

usw....

[Georg (Gast)]

Max D. schrieb:
> Du musst vorher den graycode in binär "umdenken"

denken vielleicht, programmieren muss man das nicht - es genügt ja eine 
Tabelle Gray -> 7Segment.

Georg

[Ingemar F. (dementius)]

Georg schrieb:
> Max D. schrieb:
>> Du musst vorher den graycode in binär "umdenken"
>
> denken vielleicht, programmieren muss man das nicht - es genügt ja eine
> Tabelle Gray -> 7Segment.
>
> Georg

Soll so sein wie im Anhang dargestellt. Das ganze mit gemeinsamer 
Kathode der 7-Segment Anzeige

[Max D. (max_d)]

Du baust dir erstmal eine Tabelle die für deine 8 Zustände die Werte 
enthält:

uint8_t konverterTabelle[] = {
0x77 //A
0x7E //U
0x06 //1
0x79 //E
//hier noch die restlichen Codes
};

(größere Tabellen kann man auch in den flash legen (pgmspace.h) um Platz 
im RAM zu sparen, bei 8 Einträgen lohnts aber ned)
Du kannst die dann ansprechen fast wie eine Funktion:

PORTD = konverterTabelle[PINA&0b00000111];

Wenn auf PORTD noch andere Funktionen liegen, dann musst du halt die 
bits maskieren.

[fop (Gast)]

Ich würde es nicht umdenken nennen. Es ist eher ein Umsortieren. Du 
brauchst aber 8 Plätze im Array, nicht 7, da es einen ungültigen Zustand 
gibt.

0 = 000 = A
1 = 001 = U
2 = 010 = 1
3 = 011 = E
4 = 100 = -
5 = 101 = 4
6 = 110 = 2
7 = 111 = 3

[fop (Gast)]

#define SEG_A PD0
#define SEG_B PD1
#define SEG_C PD2
#define SEG_D PD3
#define SEG_E PD4
#define SEG_F PD5
#define SEG_G PD6

#define CHR__ (0U)
#define CHR_1 ((1U<<SEG_B)|(1U<<SEG_C))
#define CHR_2 ((1U<<SEG_A)|(1U<<SEG_B)|(1U<<SEG_G)|(1U<<SEG_E)|(1U<<SEG_D))

...
#define CHR_8 ((1U<<SEG_A)|(1U<<SEG_B)|(1U<<SEG_C)|(1U<<SEG_D)|(1U<<SEG_E)|(1U<<SEG_F)|(1U<<SEG_G))

const unsigned char Gray2SevenCode[8] = {
#ifndef NEGATIVE_LOGIC
    CHR_A,
    CHR_U,
    CHR_1,
    CHR_E,
    CHR__,
    CHR_4,
    CHR_2,
    CHR_3
#else
    ~CHR_A,
    ~CHR_U,
    ~CHR_1,
    ~CHR_E,
    ~CHR__,
    ~CHR_4,
    ~CHR_2,
    ~CHR_3
#endif
};

...
#ifndef NEGATIVE_LOGIC
    PORTD=(PORTD & ~CHR_8)|Gray2SevenCode[PINA & 7U];
#else
    PORTD=(PORTD | CHR_8)& Gray2SevenCode[PINA & 7U];
#endif

[Ingemar F. (dementius)]

fop schrieb:

> #ifndef NEGATIVE_LOGIC
>     PORTD=(PORTD & ~CHR_8)|Gray2SevenCode[PINA & 7U];
> #else
>     PORTD=(PORTD | CHR_8)& Gray2SevenCode[PINA & 7U];
> #endif
> [/c]
Vor dem ersten PORTD bekomm ich folgende Fehlermeldungen:

expected identifier or '(' before 'volatile'
expected ')' before '(' token

CHR_8 brauch ich ja nicht unbedingt

[fop (Gast)]

Jein, das CHR_8 nehme ich als Maske, für alle Bits, die zur Ausgabe an 
die Anzeige dazu gehören. Nur für den Fall, dass der 8. Pin mal eine 
andere Bedeutung bekommt.

Ich hatte das Beispiel getippt, ohne es durch den Compiler zu jagen. 
Sollte aber so ähnlich funktionieren. Die letzte Zeile gehört natürlich 
in die Schleife der main() Funktion.

Also nochmal probiert. Folgendes Compiliert durch :

#include <avr/io.h>
#include <stdint.h>

#define SEG_A PD0
#define SEG_B PD1
#define SEG_C PD2
#define SEG_D PD3
#define SEG_E PD4
#define SEG_F PD5
#define SEG_G PD6

#define CHR__ (0U)
#define CHR_1 ((1U<<SEG_B)|(1U<<SEG_C))
#define CHR_2 ((1U<<SEG_A)|(1U<<SEG_B)|(1U<<SEG_G)|(1U<<SEG_E)|(1U<<SEG_D))
#define CHR_3 ((1U<<SEG_A)|(1U<<SEG_B)|(1U<<SEG_C)|(1U<<SEG_D)|(1U<<SEG_G))
#define CHR_4 ((1U<<SEG_B)|(1U<<SEG_C)|(1U<<SEG_F)|(1U<<SEG_G))
#define CHR_8 ((1U<<SEG_A)|(1U<<SEG_B)|(1U<<SEG_C)|(1U<<SEG_D)|(1U<<SEG_E)|(1U<<SEG_F)|(1U<<SEG_G))
#define CHR_A ((1U<<SEG_A)|(1U<<SEG_B)|(1U<<SEG_C)|(1U<<SEG_E)|(1U<<SEG_F)|(1U<<SEG_G))
#define CHR_E ((1U<<SEG_A)|(1U<<SEG_D)|(1U<<SEG_E)|(1U<<SEG_F)|(1U<<SEG_G))
#define CHR_U ((1U<<SEG_B)|(1U<<SEG_C)|(1U<<SEG_D)|(1U<<SEG_E)|(1U<<SEG_F))

#define INLSB PA0
#define INMSK (7U)

const uint8_t Gray2SevenCode[8] =
{
#ifndef NEGATIVE_LOGIC
    CHR_A,
    CHR_U,
    CHR_1,
    CHR_E,
    CHR__,
    CHR_4,
    CHR_2,
    CHR_3
#else
    CHR_A ^ CHR_8,
    CHR_U ^ CHR_8,
    CHR_1 ^ CHR_8,
    CHR_E ^ CHR_8,
    CHR__ ^ CHR_8,
    CHR_4 ^ CHR_8,
    CHR_2 ^ CHR_8,
    CHR_3 ^ CHR_8
#endif
};


int main(void)
{
    /* Eingaenge definieren */
    DDRA &= ~(INMSK << INLSB); /* Datenrichtung */
    PORTA |= (INMSK << INLSB); /* PullUps */
    /* Ausgaenge definieren */
#ifndef NEGATIVE_LOGIC
    PORTD &= ~CHR_8;    /* Startwert */
#else
    PORTD |= CHR_8;     /* Startwert */
#endif
    DDRD |= CHR_8;      /* Datenrichtung */
    while (1)
    {
        PORTD = (PORTD & ~CHR_8) | Gray2SevenCode[(PINA >> INLSB) & INMSK];
    }
}

[Axel S. (a-za-z0-9)]

fop schrieb:
> Also nochmal probiert. Folgendes Compiliert durch

Zu umständlich. Ich würde den ganzen Schmonzes mit NEGATIVE_LOGIC 
weglassen. Das verwirrt doch unseren TE bloß. Eher so:

...

const uint8_t Gray2SevenCode[8] =
{ CHR_A, CHR_U, CHR_1, CHR_E,
  CHR__, CHR_4, CHR_2, CHR_3 };

int main(void)
{
    /* Eingaenge definieren */
    DDRA &= ~(INMSK << INLSB); /* Datenrichtung */
    PORTA |= (INMSK << INLSB); /* PullUps */

    /* Ausgaenge definieren */
    DDRD |= 0xFF;             /* Datenrichtung */

    while (1)
    {
        PORTD = Gray2SevenCode[(PINA >> INLSB) & INMSK];
    }
}

Falls er seine LED doch lieber mit L statt mit H einschalten will, dann 
genügt es, eine einzige Zeile zu ändern:

        PORTD = ~Gray2SevenCode[(PINA >> INLSB) & INMSK];

Außerdem noch ein paar Anmerkungen:

1. es ist ziemlich verwirrend, eine entweder-oder Codevariante als

#ifndef BEDINGUNG
#else
#endif

zu schreiben. So ziemlich jeder erwartet den if Zweig zuerst. Also 
einfach #ifdef BEDINGUNG und dann die beiden Blöcke tauschen.

2. wenn du ohnehin alle Bits setzen willst, dann brauchst du nicht mit 
logischen Operatoren rumzumachen, sondern kannst den Wert direkt 
zuweisen. Alle Anfänger, die deinen Code mal zu verstehen versuchen, 
werden es dir danken.

3. es ist ungeschickt, CHR_8 als Maske zu nehmen. Denn es ist zwar mit 
dieser Codierung gegeben, daß CHR_8 alle Bits gesetzt hat, aber das 
muß ja nicht so bleiben (genau deswegen verwendet man ja ein #define, 
damit man den Code verwenden kann ohne die Interna zu kennen). Wenn du 
also explizit alle Bits setzen willst, dann schreib das auch so hin und 
verlaß dich nicht auf Spezifika der gerade gewählten Codierung.

Stell dir dazu einfach vor, der TE wöllte das nächste Mal keine 
7-Segment-Anzeige verwenden, sondern 7 einzelne LED, je eine für jeden 
Zustand. Dann müßte er außer der Übersetzungstabelle noch eine ganz 
andere Stelle im Code ändern.

[Georg (Gast)]

Axel S. schrieb:
> der TE wöllte das nächste Mal keine
> 7-Segment-Anzeige verwenden, sondern 7 einzelne LED, je eine für jeden
> Zustand.

Dann kann man das ja als HAL aufeinander aufbauen. Es gibt eine Routine 
Setze_LED, und die Routine Setze_Display verwendet diese. Dann muss man 
auch kein 8bit-Port für das Display verwenden, sondern kann beliebige 
Pins nehmen. Die paar Befehle mehr sollten ja keine Rolle spielen.

Georg

[Axel S. (a-za-z0-9)]

Georg schrieb:
> Axel S. schrieb:
>> der TE wöllte das nächste Mal keine
>> 7-Segment-Anzeige verwenden, sondern 7 einzelne LED, je eine für jeden
>> Zustand.
>
> Dann kann man das ja als HAL aufeinander aufbauen.

Hast du eigentlich verstanden, worum es mir in Punkt 3 ging?
Kleiner Tip: das wesentliche hast du nicht zitiert.

[Ingemar F. (dementius)]

Axel S. schrieb:
> fop schrieb:
>> Also nochmal probiert. Folgendes Compiliert durch
>
> Zu umständlich. Ich würde den ganzen Schmonzes mit NEGATIVE_LOGIC
> weglassen. Das verwirrt doch unseren TE bloß. Eher so:
Ja, ist alles neu für mich in Sachen Mikrocontroller.

Im Grunde geht es um folgende Aufgabenstellung und Problem:

In einem Aufzug wird die Position über Initiatoren als Gray-Code 
erfasst. Dabei entspricht die unterste Position dem Signal "001" (also 
U). Es gibt 6 Etagen und wenn der Aufzug außer Betrieb ist wird die 
Position "000" gesetzt und es erscheint die Anzeige "A".

Deswegen das ganze mit 7-Segment Anzeige und keine einzelnen LED.

[Eric B. (beric)]

#define SEG_A PD0
#define SEG_B PD1
#define SEG_C PD2
#define SEG_D PD3
#define SEG_E PD4
#define SEG_F PD5
#define SEG_G PD6

#define CHR__ (0U)
#define CHR_1 ((1U<<SEG_B)|(1U<<SEG_C))
#define CHR_2 ((1U<<SEG_A)|(1U<<SEG_B)|(1U<<SEG_G)|(1U<<SEG_E)|(1U<<SEG_D))
#define CHR_3 ((1U<<SEG_A)|(1U<<SEG_B)|(1U<<SEG_C)|(1U<<SEG_D)|(1U<<SEG_G))
#define CHR_4 ((1U<<SEG_B)|(1U<<SEG_C)|(1U<<SEG_F)|(1U<<SEG_G))
#define CHR_8 ((1U<<SEG_A)|(1U<<SEG_B)|(1U<<SEG_C)|(1U<<SEG_D)|(1U<<SEG_E)|(1U<<SEG_F)|(1U<<SEG_G))
#define CHR_A ((1U<<SEG_A)|(1U<<SEG_B)|(1U<<SEG_C)|(1U<<SEG_E)|(1U<<SEG_F)|(1U<<SEG_G))
#define CHR_E ((1U<<SEG_A)|(1U<<SEG_D)|(1U<<SEG_E)|(1U<<SEG_F)|(1U<<SEG_G))
#define CHR_U ((1U<<SEG_B)|(1U<<SEG_C)|(1U<<SEG_D)|(1U<<SEG_E)|(1U<<SEG_F))

Dann doch eher so

#define _A (1U<<PD0)
#define _B (1U<<PD1)
#define _C (1U<<PD2)
#define _D (1U<<PD3)
#define _E (1U<<PD4)
#define _F (1U<<PD5)
#define _G (1U<<PD6)

#define CHR_1 (      _B | _C                     )
#define CHR_2 ( _A | _B |      _D | _E |      _G )
#define CHR_3 ( _A | _B | _C | _D |           _G )
#define CHR_4 (      _B | _C |           _F | _G )
#define CHR_8 ( _A | _B | _C | _D | _E | _F | _G )
#define CHR_A ( _A | _B | _C |      _E | _F | _G )
#define CHR_E ( _A |           _D | _E | _F | _G )
#define CHR_U (      _B | _C | _D | _E | _F      )

(mit oder ohne "SEG")