LCD Anzeige spinnt

[netwurm (Gast)]

Hi,

Ich habe ein kleines "Problemchen" mit meiner Anzeigenausgabe

Angezeigt soll werden

1234

raus kommt

7239


Danke vom Netwurm



hier der Quelltext :

#include <msp430x44x.h>

/*  
############################################
## Display Treiber Alarmanlage MSP430F449 ##   
############################################


     __a__  
    |     |
    f     b
    |__g__|    sieben segment display
    |     |
    e     c
    |__d__|
    
    .db  0b11000000     ; 0: a, b, c, d, e, f
    .db  0b11111001     ; 1: b, c
    .db  0b10100100     ; 2: a, b, d, e, g     
    .db  0b10110000     ; 3: a, b, c, d, g
    .db  0b10011001     ; 4: b, c, f, g
    .db  0b10010010     ; 5: a, c, d, f, g
    .db  0b10000010     ; 6: a, c, d, e, f, g
    .db  0b11111000     ; 7: a, b, c
    .db  0b10000000     ; 8: a, b, c, d, e, f, g
    .db  0b10010000     ; 9: a, b, c, d, f, g 


Bitzahlen von rechts nach links gelesen 
Beispiel für Dezimalzahl 0
<-------
11000000 

     __a__      ___on___    a = 0 = on   bit O
    |     |    |        |   b = 0 = on   bit 1    
    f     b    on      on   c = 0 = on   bit 2
    |__g__|    |___off__|   d = 0 = on   bit 3
    |     |    |        |   e = 0 = on   bit 4
    e     c    on      on   f = 0 = on   bit 5
    |__d__|    |__off___|   g = 1 = off  bit 6 
     
siehe: http://www.mikrocontroller.net/articles/AVR-Tutorial:_7-Segment-Anzeige
*/

#define   LCD_PORT_DIR P2DIR         //  
#define   LCD_PORT_OUT P2OUT         //  
#define   LCD_1_LOW     P3OUT&=~BIT4 //  
#define   LCD_1_HIGH    P3OUT|=BIT4  //
#define   LCD_2_LOW     P3OUT&=~BIT5 //
#define   LCD_2_HIGH    P3OUT|=BIT5  //
#define   LCD_3_LOW     P3OUT&=~BIT6 //
#define   LCD_3_HIGH    P3OUT|=BIT6  //
#define   LCD_4_LOW     P3OUT&=~BIT7 //
#define   LCD_4_HIGH    P3OUT|=BIT7  //


unsigned int dez_anzeig;            // Dezimalzahl zum anzeigen 0....9999    
void wait(unsigned int i);          // prototypen

unsigned char digit[10] = {0xC0, 0xF9, 0xA4, 0xB0, 0x99, 0x92, 0x82, 0xF8, 0x80, 0x90};

void int_lcd()
{
  LCD_PORT_DIR|=0XFF;           //  
  P3DIR|=BIT7+BIT4+BIT5+BIT6;
  P3DIR|=BIT3;                  //
  P3OUT&=~BIT3;                 //
}

void wait(unsigned int i)    // delay function
{
  unsigned int j;
  for(j=0;j<i;j++);
}

void display(int num)
{
   unsigned char LCD_1,LCD_2,LCD_3,LCD_4;
   unsigned char w=220;  
   unsigned char i=0; 
   /* 
   LCD_1=num/1000;
   LCD_2=num%1000/100;
   LCD_3=num%100/10;
   LCD_4=num%10;
  */
  for(i = 0; num >= 1000; i++, num -= 1000);
  LCD_1 = i;
  for(i = 0; num >= 100; i++, num -= 100);
  LCD_2 = i;
  for(i = 0; num >= 10; i++, num -= 10);
  LCD_3= i;
  LCD_4 = num;
   
  LCD_PORT_OUT=digit[LCD_1];
  LCD_1_LOW;
  wait(w);
  LCD_1_HIGH;
  LCD_PORT_OUT=digit[LCD_2];
  LCD_2_LOW;
  wait(w);
  LCD_2_HIGH;
  LCD_PORT_OUT=digit[LCD_3];
  LCD_3_LOW;
  wait(w);
  LCD_3_HIGH;
  LCD_PORT_OUT=digit[LCD_4];
  LCD_4_LOW;
  wait(w);
  LCD_4_HIGH;
}

void main(void)
{
  WDTCTL = WDTPW+WDTHOLD;           // watchdog aus
  int_lcd();                        // Intalisierung 
  dez_anzeig = 1234;                // Dezimal Zahl Ausgabe
  
  while (1)
  {
  display(dez_anzeig);
  }
}

[DirkB (Gast)]

Dein Segment a leuchtet immer.
(Kurzschluß in der Schaltung?)

[Lord Z. (lordziu)]

Schmeiß doch erstmal

  for(i = 0; num >= 1000; i++, num -= 1000);
  LCD_1 = i;
  for(i = 0; num >= 100; i++, num -= 100);
  LCD_2 = i;
  for(i = 0; num >= 10; i++, num -= 10);
  LCD_3= i;
  LCD_4 = num;


raus. Und weise LCD_1 - _4 explizit Werte zu. Dann siehst du erstmal ob 
deine Ausgabe funktioniert.

Das hier ist der weitaus schönere Ansatz:

   /*
   LCD_1=num/1000;
   LCD_2=num%1000/100;
   LCD_3=num%100/10;
   LCD_4=num%10;
  */

[netwurm (Gast)]

hi,

Danke!!!!!

Ja die Ausgabe funktioniert jedoch werden falsche Zahlen angezeigt ;o)

Ich habe auch schon eine Schleife (0 bis 9999) laufen lassen ... mit dem 
Ergebnis das jeweils bei den Ziffern 1 bzw 4 die Anzeige in allen 4 LCD 
7 bzw. 9 anzeigt.

als aus 1 wird 7
und aus 4 wird 9

ist schon irgendwie seltsam ;o)

Netwurm

[netwurm (Gast)]

Nochmal getestet

Die Null hat auch ein Ding weg

sieht so aus
++++
+  +
+    <- da fehlt es
++++

  while (1)
  {
  
    for(dez_anzeig = 0; dez_anzeig < 10000; dez_anzeig++)
     { 
    display(dez_anzeig);
    wait(5000);
    
     }
  dez_anzeig = 0;
  }

[Karl H. (kbuchegg)]

Stell doch erst mal fest, ob diese Zuordnungstabelle überhaupt mit 
deiner Verschaltung übereinstimmt

Beispiel für Dezimalzahl 0
<-------
11000000 

     __a__      ___on___    a = 0 = on   bit O
    |     |    |        |   b = 0 = on   bit 1    
    f     b    on      on   c = 0 = on   bit 2
    |__g__|    |___off__|   d = 0 = on   bit 3
    |     |    |        |   e = 0 = on   bit 4
    e     c    on      on   f = 0 = on   bit 5
    |__d__|    |__off___|   g = 1 = off  bit 6 
     
siehe: http://www.mikrocontroller.net/articles/AVR-Tutorial:_7-Segment-Anzeige
*/

....

unsigned char digit[10] = {0xC0, 0xF9, 0xA4, 0xB0, 0x99, 0x92, 0x82, 0xF8, 0x80, 0x90};

Schmeiss dein Programm weg und gib einfach nur
   0x01
aus und sieh nach welches Segment leuchtet
Danach 0x02, 0x04, 0x08 etc.
bist du von jedem Bit weißt, zu welchem Segment es gehört.
Und dann baust du deine Tabelle erneut auf.

....

int main()
{
   ...

  while( 1 )
  {
    LCD_PORT_OUT = 0x01;
    LCD_1_LOW;
  }
}

[netwurm (Gast)]

Hi,

erstmal danke ;o)

LCD_PORT_OUT = 0x01;

leuchtet alles ...


werde ich jetzt mal versuchen

unsigned char digit[10] = {0xC0, 0xF9, 0xA4, 0xB0, 0x99, 0x92, 0x82, 
0xF8, 0x80, 0x90};

so wie ich es bis jetzt verstanden habe ist das doch ein standard

Der Controller kann mit hex Zahlenformat umgehen und hat eine 
Zuordnungstabelle für ASCII-Darstellung

na da bin ich ja mal gespannt


Netwurm

[DirkB (Gast)]

netwurm schrieb:
> LCD_PORT_OUT = 0x01;
>
> leuchtet alles ...

Aber der Punkt ist aus.
Das wird invertiert dargestellt. Und die 1 ist für den Punkt da.

Bevor du jetzt das Inverse von 0x01 selber ausrechnest, nimm den ~ 
Operator.

LCD_PORT_OUT = ~0x01;

[DirkB (Gast)]

Oder wenn die Bezeichnung oben stimmt ist 0x01 für Segment a da. Und das 
leuchtet halt immer.

Gib doch mal 0x00 aus.

[Karl H. (kbuchegg)]

netwurm schrieb:

> so wie ich es bis jetzt verstanden habe ist das doch ein standard

Standard ist das, wie du die Drähte vom µC zur Anzeige gezogen hast.Und 
ich bin jetzt zu faul mir das aus deinem Schaltplan rauszulesen, wenn du 
das in einem 1/4 der Zeit durch pures ausprobieren selbst feststellen 
kannst.
Vertausch 2 Drähte und anstelle des Punktes leuchtet eben irgendein ein 
anderes Segment. Ist doch wurscht welches, solange man nur weiß welches. 
Und genau das stellst du jetzt einfach mit einem Testprogramm fest.

[netwurm (Gast)]

Hi,

Hab die ganze Sache mal getestet
scheinbar ist irgendwas kaputt ....

Die obere LED (a) bleibt immer an bzw. blink nur ganz kurz geht aber 
nicht aus

Hier nochmal der Code kann ja sein das Jemand auch so ein Problemchen 
hat

......
......
unsigned char segment[255] = {

/*0*/ 0x0,
/*1*/ 0x1,
/*2*/ 0x2,
/*3*/ 0x3,
/*4*/ 0x4,
/*5*/ 0x5,
/*6*/ 0x6,
/*7*/ 0x7,
/*8*/ 0x8,
/*9*/ 0x9,
/*10*/ 0xa,
/*11*/ 0xb,
/*12*/ 0xc,
/*13*/ 0xd,
/*14*/ 0xe,
/*15*/ 0xf,
/*16*/ 0x10,
/*17*/ 0x11,
/*18*/ 0x12,
/*19*/ 0x13,
/*20*/ 0x14,
/*21*/ 0x15,
/*22*/ 0x16,
/*23*/ 0x17,
/*24*/ 0x18,
/*25*/ 0x19,
/*26*/ 0x1a,
/*27*/ 0x1b,
/*28*/ 0x1c,
/*29*/ 0x1d,
/*30*/ 0x1e,
/*31*/ 0x1f,
/*32*/ 0x20,
/*33*/ 0x21,
/*34*/ 0x22,
/*35*/ 0x23,
/*36*/ 0x24,
/*37*/ 0x25,
/*38*/ 0x26,
/*39*/ 0x27,
/*40*/ 0x28,
/*41*/ 0x29,
/*42*/ 0x2a,
/*43*/ 0x2b,
/*44*/ 0x2c,
/*45*/ 0x2d,
/*46*/ 0x2e,
/*47*/ 0x2f,
/*48*/ 0x30,
/*49*/ 0x31,
/*50*/ 0x32,
/*51*/ 0x33,
/*52*/ 0x34,
/*53*/ 0x35,
/*54*/ 0x36,
/*55*/ 0x37,
/*56*/ 0x38,
/*57*/ 0x39,
/*58*/ 0x3a,
/*59*/ 0x3b,
/*60*/ 0x3c,
/*61*/ 0x3d,
/*62*/ 0x3e,
/*63*/ 0x3f,
/*64*/ 0x40,
/*65*/ 0x41,
/*66*/ 0x42,
/*67*/ 0x43,
/*68*/ 0x44,
/*69*/ 0x45,
/*70*/ 0x46,
/*71*/ 0x47,
/*72*/ 0x48,
/*73*/ 0x49,
/*74*/ 0x4a,
/*75*/ 0x4b,
/*76*/ 0x4c,
/*77*/ 0x4d,
/*78*/ 0x4e,
/*79*/ 0x4f,
/*80*/ 0x50,
/*81*/ 0x51,
/*82*/ 0x52,
/*83*/ 0x53,
/*84*/ 0x54,
/*85*/ 0x55,
/*86*/ 0x56,
/*87*/ 0x57,
/*88*/ 0x58,
/*89*/ 0x59,
/*90*/ 0x5a,
/*91*/ 0x5b,
/*92*/ 0x5c,
/*93*/ 0x5d,
/*94*/ 0x5e,
/*95*/ 0x5f,
/*96*/ 0x60,
/*97*/ 0x61,
/*98*/ 0x62,
/*99*/ 0x63,
/*100*/ 0x64,
/*101*/ 0x65,
/*102*/ 0x66,
/*103*/ 0x67,
/*104*/ 0x68,
/*105*/ 0x69,
/*106*/ 0x6a,
/*107*/ 0x6b,
/*108*/ 0x6c,
/*109*/ 0x6d,
/*110*/ 0x6e,
/*111*/ 0x6f,
/*112*/ 0x70,
/*113*/ 0x71,
/*114*/ 0x72,
/*115*/ 0x73,
/*116*/ 0x74,
/*117*/ 0x75,
/*118*/ 0x76,
/*119*/ 0x77,
/*120*/ 0x78,
/*121*/ 0x79,
/*122*/ 0x7a,
/*123*/ 0x7b,
/*124*/ 0x7c,
/*125*/ 0x7d,
/*126*/ 0x7e,
/*127*/ 0x7f,
/*128*/ 0x80,
/*129*/ 0x81,
/*130*/ 0x82,
/*131*/ 0x83,
/*132*/ 0x84,
/*133*/ 0x85,
/*134*/ 0x86,
/*135*/ 0x87,
/*136*/ 0x88,
/*137*/ 0x89,
/*138*/ 0x8a,
/*139*/ 0x8b,
/*140*/ 0x8c,
/*141*/ 0x8d,
/*142*/ 0x8e,
/*143*/ 0x8f,
/*144*/ 0x90,
/*145*/ 0x91,
/*146*/ 0x92,
/*147*/ 0x93,
/*148*/ 0x94,
/*149*/ 0x95,
/*150*/ 0x96,
/*151*/ 0x97,
/*152*/ 0x98,
/*153*/ 0x99,
/*154*/ 0x9a,
/*155*/ 0x9b,
/*156*/ 0x9c,
/*157*/ 0x9d,
/*158*/ 0x9e,
/*159*/ 0x9f,
/*160*/ 0xa0,
/*161*/ 0xa1,
/*162*/ 0xa2,
/*163*/ 0xa3,
/*164*/ 0xa4,
/*165*/ 0xa5,
/*166*/ 0xa6,
/*167*/ 0xa7,
/*168*/ 0xa8,
/*169*/ 0xa9,
/*170*/ 0xaa,
/*171*/ 0xab,
/*172*/ 0xac,
/*173*/ 0xad,
/*174*/ 0xae,
/*175*/ 0xaf,
/*176*/ 0xb0,
/*177*/ 0xb1,
/*178*/ 0xb2,
/*179*/ 0xb3,
/*180*/ 0xb4,
/*181*/ 0xb5,
/*182*/ 0xb6,
/*183*/ 0xb7,
/*184*/ 0xb8,
/*185*/ 0xb9,
/*186*/ 0xba,
/*187*/ 0xbb,
/*188*/ 0xbc,
/*189*/ 0xbd,
/*190*/ 0xbe,
/*191*/ 0xbf,
/*192*/ 0xc0,
/*193*/ 0xc1,
/*194*/ 0xc2,
/*195*/ 0xc3,
/*196*/ 0xc4,
/*197*/ 0xc5,
/*198*/ 0xc6,
/*199*/ 0xc7,
/*200*/ 0xc8,
/*201*/ 0xc9,
/*202*/ 0xca,
/*203*/ 0xcb,
/*204*/ 0xcc,
/*205*/ 0xcd,
/*206*/ 0xce,
/*207*/ 0xcf,
/*208*/ 0xd0,
/*209*/ 0xd1,
/*210*/ 0xd2,
/*211*/ 0xd3,
/*212*/ 0xd4,
/*213*/ 0xd5,
/*214*/ 0xd6,
/*215*/ 0xd7,
/*216*/ 0xd8,
/*217*/ 0xd9,
/*218*/ 0xda,
/*219*/ 0xdb,
/*220*/ 0xdc,
/*221*/ 0xdd,
/*222*/ 0xde,
/*223*/ 0xdf,
/*224*/ 0xe0,
/*225*/ 0xe1,
/*226*/ 0xe2,
/*227*/ 0xe3,
/*228*/ 0xe4,
/*229*/ 0xe5,
/*230*/ 0xe6,
/*231*/ 0xe7,
/*232*/ 0xe8,
/*233*/ 0xe9,
/*234*/ 0xea,
/*235*/ 0xeb,
/*236*/ 0xec,
/*237*/ 0xed,
/*238*/ 0xee,
/*239*/ 0xef,
/*240*/ 0xf0,
/*241*/ 0xf1,
/*242*/ 0xf2,
/*243*/ 0xf3,
/*244*/ 0xf4,
/*245*/ 0xf5,
/*246*/ 0xf6,
/*247*/ 0xf7,
/*248*/ 0xf8,
/*249*/ 0xf9,
/*250*/ 0xfa,
/*251*/ 0xfb,
/*252*/ 0xfc,
/*253*/ 0xfd,
/*254*/ 0xfe

};

void main(void)
{
  WDTCTL = WDTPW+WDTHOLD;           // watchdog aus
  int_lcd();                        // Intalisierung 
  dez_anzeig = 0;                // Dezimal Zahl Ausgabe
   unsigned char LCD_1,LCD_2,LCD_3,LCD_4;
   unsigned char w=220;  
   unsigned int j;
   while (1)
  {
    for(dez_anzeig = 0; dez_anzeig < 256; dez_anzeig++)
     { 
         LCD_2=dez_anzeig%1000/100;
         LCD_3=dez_anzeig%100/10;
         LCD_4=dez_anzeig%10;     
         for(j=0;j<10;j++)
         {
            LCD_PORT_OUT = segment[dez_anzeig];
            LCD_1_LOW;
            wait(w);
            LCD_1_HIGH;
            LCD_PORT_OUT=digit[LCD_2];
            LCD_2_LOW;
            wait(w);
            LCD_2_HIGH;
            LCD_PORT_OUT=digit[LCD_3];
            LCD_3_LOW;
            wait(w);
            LCD_3_HIGH;
            LCD_PORT_OUT=digit[LCD_4];
            LCD_4_LOW;
            wait(w);
            LCD_4_HIGH;        
            wait(5000);      
         }   
      }
  }
}

[mr. mo (Gast)]

hast du das array von hand getippt? ^^

falls ja:
hättest auch in einer schleife das array füllen können
 z.b
for(i=0,i<=255,i++) {
segment[i} = i;
}

[J.-u. G. (juwe)]

mr. mo schrieb:
> hättest auch in einer schleife das array füllen können

Welchen Sinn hat ein Array, wenn alle Elemente den gleichen Wert haben, 
wie ihr Index?

[netwurm (Gast)]

LCD_PORT_OUT = ~0x01;
LCD_1_LOW;

es leuchtet Segment a darf es das ???

Danke Netwurm

[netwurm (Gast)]

hast du das array von hand getippt? ^^

neee,

Ich habe heute die erste .exe gemacht ;o)
fange mit c an sorry

int i=0;

char hex[256];

for(i = 0; i < 256; i++)
{
sprintf(hex, "%x", i);
printf("/*%d*/ 0x%s,\n", i,hex);
}      


system("PAUSE");

[Karl H. (kbuchegg)]

netwurm schrieb:
>

> LCD_PORT_OUT = ~0x01;
> LCD_1_LOW;
>

>
> es leuchtet Segment a darf es das ???

Ist es das einzige Segment, welches leuchtet?
Wenn ja, dann darf es das.

Also


     ++++++
    +      +
    +      +
     ++++++
    +      +
    +      +
     ++++++

welches Segment leuchtet? (Tausch die + gegen eine 0 aus)

(Jetzt gehen wir beide das ganze mal systematisch an. Das hat doch 
keinen Sinn, wenn du da ohne System an die Sache rangehst. Wenn du 
hardwaremässig keinen Kurzschluss hast, dann ist das eine Sache auf 10 
Minuten und du hast deine Zahlen dann korrekt auf der Anzeige. Und nein, 
es ist mir völlig wurscht, welchen Buchstaben das Segment da weiter oben 
hat. Wir brauchen eine zusammenstellung, welches Segment mit welchem Bit 
gesteuert wird. Und am besten diese Zusammenstellung in graphischer 
Form. Denn dann muss man nicht um die Ecke denken, sondern hat alles 
direkt vor Augen)

Wenn du das hast, dann probierst du
  LCD_PORT_OUT = ~0x02;
und tauscht wieder die entsprechenden + für das Segment diesmal gegen 
eine 1 aus.

Danach
 LCD_PORT_OUT = ~0x04;
+ austauschen gegen 2

 LCD_PORT_OUT = ~0x08;       // austauschen gegen 3

 LCD_PORT_OUT = ~0x10;       //                   4

 LCD_PORT_OUT = ~0x20;       //                   5

 LCD_PORT_OUT = ~0x40;       //                   6

 LCD_PORT_OUT = ~0x80;       //                   7


Hast du die alle einzeln durchpobiert, dann musst du eine Zeichnung 
haben, in der für jedes Segment der 8 das Segment gegen die jeweilige 
Bitnummer ersetzt ist.
Und wenn du das hast, dann gehts weiter.

[netwurm (Gast)]

Hi,

Es ist ein Hardwarefehler der Platine. Ich konnte den Fehler etwas 
eingrenzen. Offenbar ist irgendwas nicht richtig abgeschirmt sobald ich 
über den LCD Treiber mit meiner Hand gehe (ohne Berührung!) fangen die 
defekten Segmente (a) an zu flackern... die anderen sind jedoch stabil!

Ist schon ärgerlich...Aber für mein Verständnis des MSP430 (bin ja noch 
blutiger Anfänger)ist es gut ;o) habe mich mit dem LCD richtig 
auseinandergesetzt. Werde heute noch Deinen Vorschlag (Isolierung der 
einzelnen Segmente) durchtesten.

Danke Dir ;o)

Netwurm

[DirkB (Gast)]

Evtl. hast du auch eine kalte Lötstelle oder der JP1 hat nicht richtig 
Kontakt.

[netwurm (Gast)]

Hi,

Jetzt gehts!!! Das Bord hatte Pins für die P20 - P37

Habe diese ersetzt durch andere ... da muss man erstmal drauf kommen ;o)
Jetzt ist die Anzeige stabil. Habe noch ein wenig rumprobiert

~0x01 = 1
~0x02 = 2
~0x04 = 4
~0x08 = 8
~0x10 = 16
~0x20 = 32
~0x40 = 64
~0x80 = 128
~0x00 = off

Buchstaben
P[.] wie Programm
P = ~(0x01+0x20+0x02+0x40+0x10) + 0x80
A[.] wie Arlarm
A = ~(0x01+0x20+0x02+0x40+0x10+0x04) + 0x80

    ++~0x01++
    +       +
  ~0x20    ~0x02
    +       +
    ++~0x40++
    +       +
  ~0x10  ~0x04
    +       +
    ++~0x08++  [+] ~0x80 = Punkt


Danke nochmal an Alle

Netwurm