2 Stellige 7 Segment Anzeige

[Robert I. (robert_i39)]

Hallo,

Ich würde gerne eine 2 stellige Anzeige mit 2 7 Segment Anzeigen 
programmien.

Sie soll von 00 - 99 hochzählen. Die Schaltung läuft im 
Multiplexbetrieb.

Wie kann ich die 100 Zahlen auf die codierung der Anzeige bringen ohne 
für jede einzelne zahl eine eigene Funktion zu schreiben ?

Programmiert wird auf einem MSP430G2553.


Danke euch schon mal

[Mike (Gast)]

Robert I. schrieb:
> Wie kann ich die 100 Zahlen auf die codierung der Anzeige bringen ohne
> für jede einzelne zahl eine eigene Funktion zu schreiben ?

Mach dir eine Tabelle für die Ziffern 0..9 und die liest du dann zwei 
mal, einmal für die Zehner und einmal für die Einer.

[MaWin (Gast)]

In dem du die 2 Ziffern einzeln behandelst.

char ziffer[]={0x7D,0x30,0x6D,0x79,0x33,0x5D,0x5F,0x70,0x7B,0x7B};

void main(void)
{
   DDRB=DDRD=0xFF;
   while(1) for(n=0;n<100;n++)
  {
    PORTB=ziffer[n%10];
    PORTD=ziffer[n/10];
    _delay_ms(1000);
  }
}

Ist also nicht wirklich schwer, aber der Lernweg bis dahin noch weit.

[Robert I. (robert_i39)]

Danke euch schon mal.

Hab das auch soweit erreicht, nur stehe ich vor dem Problem es Sinnvoll 
auf die Anzeige zu übertragen.

Wenn ich von 0-9 hochzähle , möchte ich dass auf der Zehnerstelle immer 
eine 0 steht , also 00, 01, 02,03, usw. Ich schaffe es nur nicht dass 
die Zehnerstelle, also die 0 steht und nur die Einerstelle aktualisiert 
wird.
Bei mir läuft es total schnell durch und man kann auch erkennen dass die 
Zahlen immer kurz ausgehen.

Also bleibt noch die Frage wie ich es umsetzen kann dass zb 9 Sekunden 
hoch gezählt werden ohne dass eine der Beiden stellen immer aus ist.


Gruß

[Easylife (Gast)]

Wenn du a mit 1 initialisierst funktionierts.

Show code.

[Max H. (hartl192)]

Robert I. schrieb:
> Bei mir läuft es total schnell durch und man kann auch erkennen dass die
> Zahlen immer kurz ausgehen.
Zeig mal den Code. Kann es sein, dass du mit irgendwelchen Delays das 
Multiplexen unterbrichst?

> Also bleibt noch die Frage wie ich es umsetzen kann dass zb 9 Sekunden
> hoch gezählt werden ohne dass eine der Beiden stellen immer aus ist.

PORTB=ziffer[n%10];
if(ziffer>9)
  PORTD=ziffer[n/10];
else
  PORTD=0x00;

[Dirk K. (dekoepi)]

Für ein 4-stelliges 7-Segment sieht es als Code für AVR so aus:

// cathode pins for digit selection
volatile static uint8_t digit[4]={
    0b00000100,
    0b00001000,
    0b00010000,
    0b00100000 };

// 'databse' of digits
volatile static uint8_t lightup[10]={
    0b00111111,  // 0
    0b00000110,  // 1
    0b01011011,  // 2
    0b01001111,  // 3
    0b01100110,  // 4
    0b01101101,  // 5
    0b01111101,  // 6
    0b00000111,  // 7
    0b01111111,  // 8
    0b01101111 };  // 9

  int tempdigit;  // dissect and show the number
  for (int8_t count=3; count>=0; count--) {
    tempdigit=temp % 10;
       PORTD &= ~(digit[count]);  // select digit
       PORTC |= (lightup[tempdigit] & numbitmaska);
       PORTD |= (lightup[tempdigit] & numbitmaskd);
       if (!(showyear) & !(showdate) & !(showvcc) & !(showtemp) & (count==1) & toggle) PORTD |= 0x80;  // set dot
       if (showdate & ((count==1)|(count==3))) PORTD |= 0x80;  // set dot
       if (showvcc & (count==0)) PORTD |= 0x80;  // set dot
       if (showtemp & (count==1)) PORTD |= 0x80;  // set dot
       temp /= 10;
    PORTC &= ~(numbitmaska);  // Set all pins A0-A5 HIGH
    PORTD &= ~(numbitmaskd);  // Set D2-D5 and D6+D7 HIGH
    PORTD |= digbitmask;  // deselect digit
  }

Die Schleife musst du auf zwei Durchläufe reduzieren, die if-Bedingungen 
zur Aktivierung des Dezimalpunkts kannst du löschen. Die Funktion unter 
den Arrays läuft bei mir im Timer-Interrupt, einmal pro Millisekunde.

[Robert I. (robert_i39)]

Bei mir funktionierts es jetzt.

Hab es geschafft dass die Anzeige von 00 bis 99 zählt. Vllt nicht sehr 
elegalnt und effektiv gelöst aber es geht.

Ist es normal dass ich immer einen leichten Schatten habe? Also wenn ich 
Zb die Zahl 19 ausgebe habe ich in der Anzeige für den 1er einen 
leichten Schatten vom 9er drinnen?

[Dirk K. (dekoepi)]

Nee, dann machst du es noch nicht richtig und die 9 wird gelegentlich 
auf der falschen Stelle ausgegeben.

[Robert I. (robert_i39)]

Ja das denke ich mir selber auch , nur ich wollte keinen Code aus dem 
Internet nehmen und den nur einfügen, ich will solche sachen selber 
lösen.

Ich weiss halt nicht ob man es auf dem Foto erkennen kann, da sollte 
eigentlich 16 stehen, mit dem Auge erkennt man es zwar besser aber ihr 
könnt euch sicher denken um was es geht.

[Dirk K. (dekoepi)]

Ohne deinen Code zu sehen, können wir nur noch mehr rätseln als du 
selber. Da scheinen die LEDs zwischendrin alle angeschaltet zu werden.

Also, Code posten, dann können andere helfen. So bleibt es ein 
"tu-du-was-ich-denke", also Mission Impossible.

[Peter D. (peda)]

Robert I. schrieb:
> Die Schaltung läuft im
> Multiplexbetrieb.

Multiplex benötigt zwingend einen Timerinterrupt, alles andere ist 
Quatsch.

Nur wenige Uneinsichtige versuchen es mit einem Delay im Main zu 
erzwingen, was nur doppelte Arbeit bedeutet.
Auch als Anfänger muß niemand in die Sackgasse hineinfahren, er darf 
auch gleich den richtigen Weg nehmen.

[Robert I. (robert_i39)]

Ja gut ich habs ohne Interrupt gemacht da ich da noch nicht so 
durchblicke.

Sieht so bei mir aus :

#include <msp430.h> 
/*
 * Developer : XXXXXXXXXXXXXX
 * Software : 2 Digit on 7 Segment Displays counting from 00 to 99
 * Version : v2
 * Date : 04.May.2014
 *
 */



#define Display  P1OUT
#define NULL  0x3F
#define ONE    0x0C
#define TWO    0x5B
#define THREE  0x5E
#define FOUR  0x6C
#define FIVE  0x76
#define SIX    0x77
#define SEVEN  0x1C
#define EIGHT  0xFF
#define NINE  0xFE

#define Digit1  P2OUT = 0x01
#define Digit2  P2OUT = 0x02




int InputNumber = 0;
int FirstNumber = 0;  //Unit Position
int SecondNumber = 0;  //Tens
int DelayCounter = 0;
int Digit1AcitveNumber = 0;
int Digit2AcitveNumber = 0;



int main(void)
{
    WDTCTL = WDTPW | WDTHOLD;  // Stop watchdog timer
  
    P1DIR = 0xFF;  //P1 --> Output
    P2DIR = 0x03;  //P2.0 + P2.1 --> Output
    P2OUT = 0;

    while(1)
    {
    for(InputNumber=InputNumber;InputNumber<100;InputNumber++)
    {
      FirstNumber = InputNumber % 10;
      SecondNumber = InputNumber / 10;
      switch(FirstNumber)
      {
        case 0:  Digit1AcitveNumber = NULL;
        break;
        case 1:  Digit1AcitveNumber = ONE;
        break;
        case 2:  Digit1AcitveNumber = TWO;
        break;
        case 3:  Digit1AcitveNumber = THREE;
        break;
        case 4:  Digit1AcitveNumber = FOUR;
        break;
        case 5:  Digit1AcitveNumber = FIVE;
        break;
        case 6:  Digit1AcitveNumber = SIX;
        break;
        case 7:  Digit1AcitveNumber = SEVEN;
        break;
        case 8:  Digit1AcitveNumber = EIGHT;
        break;
        case 9:  Digit1AcitveNumber = NINE;
        break;
      }
      switch(SecondNumber)
      {
        case 0:  Digit2AcitveNumber = NULL;
        break;
        case 1:  Digit2AcitveNumber = ONE;
        break;
        case 2:  Digit2AcitveNumber = TWO;
        break;
        case 3:  Digit2AcitveNumber = THREE;
        break;
        case 4:  Digit2AcitveNumber = FOUR;
        break;
        case 5:  Digit2AcitveNumber = FIVE;
        break;
        case 6:  Digit2AcitveNumber = SIX;
        break;
        case 7:  Digit2AcitveNumber = SEVEN;
        break;
        case 8:  Digit2AcitveNumber = EIGHT;
        break;
        case 9:  Digit2AcitveNumber = NINE;
        break;
      }
      DelayCounter = 0;
      while(DelayCounter<500)
      {
        Display = Digit1AcitveNumber;
        Digit1;
        _delay_cycles(1000);
        Display = Digit2AcitveNumber;
        Digit2;
        _delay_cycles(1000);
        DelayCounter++;
      }
    }
    int i = 0;
    for(i=0;i<1000;i++)
    {
      P2OUT = 0x03;
      P1OUT = 0xFF;

    }
    InputNumber = 0;


    }
}

Vllt kann mir ja mal jemand zeigen wie es effektiver und kürzer mithilfe 
von Interrupts wird.

Danke euch !!

[Telco (Gast)]

Robert I. schrieb:
> #define NULL  0x3F

So was macht man nicht! NULL ist in den C-Headern schon definiert!
Wenn, dann nimm den Namen ZERO oder was anderes passendes, aber nicht 
NULL!

[Dirk K. (dekoepi)]

Ui, echter Einsteiger-Code, schön :)

Du solltest vor dem Wechsel der Stellen Digit1 / Digit2 auch wieder 
ausmachen. So schreibt er den Wert der anderen Digit in die grad aktive 
und schaltet anschließend um. Dadurch hast du ein Glimmen der jeweils 
anderen Nummer.

[Robert I. (robert_i39)]

@Telco : Danke , genau das hab ich mir gedacht nachdem ich den Code 
hochgeladen habe.

@Dirk: Werde es mal versuchen und sehen was dabei rauskommt.

[Easylife (Gast)]

Robert I. schrieb:
> Vllt kann mir ja mal jemand zeigen wie es effektiver und kürzer mithilfe
> von Interrupts wird.

Der code wird auch deutlich kürzer, wenn du ein array statt der case 
structure für die digits nehmen würdest...

Ausserdem fände ich es logischer die Zehnerstelle "Digit1" und die 
Einerstelle "Digit2" zu nennen...

const unsigned char digit_port_data[10] = { 
  0x3F, // 0
  0x0C, // 1
  0x5B, // 2
  0x5E, // 3
  0x6C, // 4
  0x76, // 5
  0x77, // 6
  0x1C, // 7
  0xFF, // 8
  0xFE  // 9
};


(…)

Digit1AcitveNumber = digit_port_data[InputNumber / 10];
Digit2AcitveNumber = digit_port_data[InputNumber % 10];