Zahl in Ziffern zerlegen

[Felix G. (geerkins)]

Hallo
ich bastle gerade an nem Programm für ne 7Segment anzeige
Um deine Zahl in ihre Ziffern zu zerlegen.
Dazu hab ich Dei ZAhl in nen char Aray geschrieben und lese jetzt die 
enstsprechende stelle wieder aus. Aber wie wandel ich die jetzt gelesene 
ZAhl wieder in en int wert um um sie dan anzuzeigen??
Danke
Felix

[Peter II (Gast)]

Felix Geerkens schrieb:
> Dazu hab ich Dei ZAhl in nen char Aray geschrieben und lese jetzt die
> enstsprechende stelle wieder aus.

und warum?

 456 / 100       = 4
(456 % 100) / 10 = 5
(456 % 10 )      = 6

[Michael (Gast)]

Felix Geerkens schrieb:
> Aber wie wandel ich die jetzt gelesene
> ZAhl wieder in en int wert um um sie dan anzuzeigen??

Für eine Siebensegmentanzeige brauchst du die Segmentcodes und die 
passen in ein Byte rein.

[Felix G. (geerkins)]

Tag danke für die schnellen antworten.
@Peter geht des Wirklich kommt da dann nicht 4,56 raus??
@Michael danke für den Hinweis ich hatte oben blos int gschreiben um 
nicht weiter zu verwirren
Vielen Danke Felix

[Peter II (Gast)]

Felix Geerkens schrieb:
> @Peter geht des Wirklich kommt da dann nicht 4,56 raus??

ja, weil es ja int's sind, dort kann kein Komma rauskommen.

[Felix G. (geerkins)]

des heist bei unsigned char auch??

[Peter II (Gast)]

Felix Geerkens schrieb:
> des heist bei unsigned char auch??

klar.

Aber das sind wirklich Grundlagen von C.

[Felix G. (geerkins)]

Jep ich weis danke für die Hilfe
es ist peinlich das ich nicht selbst auf diese lösung gekommen bin und 
die frage mit char war auch nur zur absicherung

[Felix G. (geerkins)]

So AHbs jetzt Reingeschrieben es geht soweit einziges Problem ist wenn 
ich eine zahl größer 10 anzeige kommt am der einser Stelle nurnoch sch.. 
raus
woran könte das liegen hier mal mein code:

#include   <avr/io.h>      //Grundfunktionen
#ifndef   F_CPU        //Vordefinieren für delay.h
#define   F_CPU 8000000UL    //Definition von F_CPU in Herz
#endif
#include   <util/delay.h>    //Warteschleifen
#include    <avr/interrupt.h>  //Interruptheader

typedef unsigned char byte;

//Hier kann man den Code an seine Siebensegment Anzeige anpassen
const byte Zahl[10] = {0b10000001, 0b11111001, 0b01000011, 0b01100001, 0b00111001, 0b00100101, 0b00000101, 0b11110001, 0b00000001, 0b00100001};
#define  Segm0_E 0
#define  Segm0_Z 1



int Berechnung(byte Stelle, byte Var)
{
byte y;              //y Rückgabewert
y = Var / Stelle;
return y;
}


void Anzeige(byte Stelle, byte Var,byte Segm)
{

  PORTD |= (1<<Segm);              //Jeweilige Anzeige Anschlaten
  PORTB=Zahl[Berechnung(Stelle, Var)];    //Zahl ausgeben
  _delay_ms(3);
  PORTD &= ~(1<<Segm);            //Anzeige weider Ausschalten
}

int main (void)
{
  //Registerinitialisierung
  //TCCR1A = 0b00000000;                      //Timer im CTC-Mode; Prescaler 256; CPU-Clock
  //TCCR1B = 0b00001100;                      //Timer im CTC-Mode; Prescaler 256; CPU-Cloc//k
  //TCCR1C = 0b00000000;                      //Timer im CTC-Mode; Prescaler 256; CPU-Cl//ock
  //TIMSK  = 0b01000000;                      //Interrupt bei Compare Match
  //OCR1A  = 31249;                        //genau eine Sekunde; Comparematch-Register
  DDRB   = 0b11111111;                      //Alles Ausgang; Siebensegmentanzeige
  DDRD   = 0b11111111;                      //PD4 und PD5 sind Eingänge
  //sei();                          //Interrupts an
  unsigned char Var = 0;
  int c = 0;

  PORTD = 0b11111111;

  //Hauptschleife
  while(1)
  {
    Anzeige(1, Var, Segm0_E);
    Anzeige(10, Var, Segm0_Z);
    c++;
    if (c == 10)
  {
    Var++;
      c = 0;
  }
  }
}

[Michael (Gast)]

int Berechnung(byte Stelle, byte Var)
{
byte y;              //y Rückgabewert
y = Var / Stelle;
return y;
}

Das ist jetzt aber nicht die Funktion mit der du die Stelle berechnen 
willst oder?

Spielen wir das mal durch mit 213 und Stelle 1

213 / 1 = 213

mit Stelle 2

213 / 2 = 106 (die ,5 wird abgeschnitten)

mit Stelle 3

213 / 3 = auch falsch.

Denk doch mal nach. Du kannst die Stelle ja nicht einfach so berechnen. 
Wenndann muss du alle stellen berechnen.

Also 213 / 100 = 2 = hunderter
213 - (2(hunderter)*100) = 13
13 / 10 = 1 = zehner
13 - (1(zehner)*10) = 3
3 = einer

so geht das. Alternativ sind itoa oder sprinft: 
http://www.mikrocontroller.net/articles/FAQ#itoa.28.29_.28utoa.28.29.2C_ltoa.28.29.2C_ultoa.28.29.2C_ftoa.28.29_.29


Klar ?

[Felix G. (geerkins)]

ops daran hab ich garnicht gedacht
dei sache ist die das ich die zentrale berechnung wenn möglich vrmeiden 
will und auch nicht wissen muss wie vile stellen meien anzeige bzw meien 
zahl hat ich. ich werde also nochmal darüber nachdenken müssen
felix
fals ihr ne ide habt wie ich des lösen kann schreibt es

[Felix G. (geerkins)]

So jetzt die überarbeiter version mit atoi

#include   <avr/io.h>      //Grundfunktionen
#ifndef   F_CPU        //Vordefinieren für delay.h
#define   F_CPU 8000000UL    //Definition von F_CPU in Herz
#endif
#include   <util/delay.h>    //Warteschleifen
#include    <avr/interrupt.h>  //Interruptheader
#include  <stdlib.h>
typedef unsigned char byte;

//Hier kann man den Code an seine Siebensegment Anzeige anpassen
const byte Zahl[10] = {0b10000001, 0b11111001, 0b01000011, 0b01100001, 0b00111001, 0b00100101, 0b00000101, 0b11110001, 0b00000001, 0b00100001};
#define  Segm0_E 0
#define  Segm0_Z 1


/*char intToChar (int integer)
{
  return (char)integer+48;
}*/


int Berechnung(byte Stelle, int Var)
{
int y;              //y Rückgabewert
char Buffer [3];
itoa (Var, Buffer,10);
y = atoi(Buffer[Stelle]);
byte x = y;
return x;
}


void Anzeige(byte Stelle, byte Var,byte Segm)
{

  PORTD |= (1<<Segm);              //Jeweilige Anzeige Anschlaten
  PORTB=Zahl[Berechnung(Stelle, Var)];    //Zahl ausgeben
  _delay_ms(3);
  PORTD &= ~(1<<Segm);            //Anzeige weider Ausschalten
}

int main (void)
{
  //Registerinitialisierung
  //TCCR1A = 0b00000000;                      //Timer im CTC-Mode; Prescaler 256; CPU-Clock
  //TCCR1B = 0b00001100;                      //Timer im CTC-Mode; Prescaler 256; CPU-Cloc//k
  //TCCR1C = 0b00000000;                      //Timer im CTC-Mode; Prescaler 256; CPU-Cl//ock
  //TIMSK  = 0b01000000;                      //Interrupt bei Compare Match
  //OCR1A  = 31249;                        //genau eine Sekunde; Comparematch-Register
  DDRB   = 0b11111111;                      //Alles Ausgang; Siebensegmentanzeige
  DDRD   = 0b11111111;                      //PD4 und PD5 sind Eingänge
  //sei();                          //Interrupts an
  unsigned char Var = 0;
  int c = 0;

  PORTD = 0b11111111;

  //Hauptschleife
  while(1)
  {
    Anzeige(1, Var, Segm0_E);
    Anzeige(2, Var, Segm0_Z);
    c++;
    if (c == 10)
  {
    Var++;
      c = 0;
  }
  }
}

}

leider zeigt meine 7segm nur noch 0 an was mache ich falsch

[Michael (Gast)]

Ja sagmal klickst du das Zeug nur zusammen? Lies mal ein C Buch oder 
zumindest die Referenz zu atoi und itao

int Berechnung(byte Stelle, int Var)
{
int y;              //y Rückgabewert
char Buffer [3];
itoa (Var, Buffer,10);
y = atoi(Buffer[Stelle]);
byte x = y;
return x;
}

Was soll das sein? Zuerst machst du aus dem Integer einen String und 
dann wieder einen Integer?

itoa ist richtig, macht dir aus dem Integer einen String aber der steht 
natürlich im ASCII Format in dem Array: 
http://www.asciitable.com/index/asciifull.gif

213 = 2,1,3,0 (binäre Null (\0) am Schluss immer bei Strings!)
abgelegt wird es also:
50,49,51,0
Diese Werte findest du in der Tabelle s.o. 49='1', 50='2', 51='3', ...

Wie kommt man von 49 auf 1? -> 48 Abziehen
Wie kommt man von 50 auf 2? -> 48 Abziehen
Wie kommt man von 51 auf 3? -> 48 Abziehen
....

blüht dir was ?

Zahl = ASCII Char - 48




Buffer[3] ist natürlich zu klein weil die binäre Null immer mit muss. 
Also Buffer[4] ist richtig. Mach mal ein C Tutorial - das sind absolute 
Basics.

itoa und atoi sind brutalst Speicher- und Geschwindigkeitsfressend. 
Darum realisiere lieber die Umrechnung wie ich sie dir oben 
vorgeschlagen habe. Die Divisionen brauchen schon lange genug.

[Wilhelm F. (Gast)]

Felix Geerkens schrieb:

> leider zeigt meine 7segm nur noch 0 an was mache ich falsch

Geh das Programm mal manuell mit Papier und Stift schrittweise durch. 
Dann kommst du bestimmt drauf.

[Garden (Gast)]

Zum Thema Modulo einVIDEO:

http://et-tutorials.de/1218/variablenzuweisung-und-modulo-funktion/

[Wilhelm F. (Gast)]

Hier mal ein Programmbeispiel, wo eine größere Hexadezimalzahl 
ausgegeben wird:

/*******************************************************************************
DOES:    Print Dezimal (aus Kernighan/Ritchie: Programmieren in C)
         Rekursives Beispiel
         Könnte zur dezimalen Wandlung von Binärzahlen verwendet werden.
GLOBALS: none
RETURNS: none
*******************************************************************************/
void printd (unsigned long n)
{
/*
  if (n < 0)
  {
    putchar ('-');
    n = -n;
  }
*/
  if (n / 10)
  {
    printd (n / 10);
  }
  putchar (n % 10 + '0');
}
/******************************************************************************/

Einfach zur Ansicht.

[Fabian O. (xfr)]

Das Programmbeispiel ist nur dafür gedacht, Rekursion zu erklären. In 
einer realen Mikrocontroller-Anwendung will man sich den Stack nicht so 
vollmüllen ...

[Michael (Gast)]

Wer nicht iterativ programmieren kann kann es rekursiv schon gleich 
dreimal nicht :-D


Also jetzt mal im Ernst - jetzt kann ich echt nicht mehr zuschauen.

int Berechnung(unsigned byte digit, int inp_var)
{
 char buffer [4];                  // Buffer for itoa
 itoa (inp_var, buffer, 10);       // convert inp_var to char, dec
 return (Buffer[digit] - 48);     // convert char to number
}

[Wilhelm F. (Gast)]

Fabian O. schrieb:
> Das Programmbeispiel ist nur dafür gedacht, Rekursion zu erklären. In
> einer realen Mikrocontroller-Anwendung will man sich den Stack nicht so
> vollmüllen ...

Da hast du Recht, wenn der Stack nur klein ist.

[Walter S. (avatar)]

Michael schrieb:
> Also jetzt mal im Ernst - jetzt kann ich echt nicht mehr zuschauen.

das mag ja vielleicht funktionieren, schön ist aber was anderes

[Karl H. (kbuchegg)]

Walter S. schrieb:
> Michael schrieb:
>> Also jetzt mal im Ernst - jetzt kann ich echt nicht mehr zuschauen.
>
> das mag ja vielleicht funktionieren, schön ist aber was anderes

Ausserdem ziemlich sicher nicht das was er will. Denn die fehlenden 
führenden 0-en machen ihm zu schaffen. Das ist bei LCD schon 'ein 
Problem', bei 7-Segment Anzeigen will man aber üblicherweise haben, dass 
die Einerstelle immer an derselben Stelle steht.

Allerdings stellt Felix sich auch wirklich an.
Man zerlegt nicht die Zahl während der eigentlichen Ausgabe. Die Ausgabe 
(in einer ISR) zeigt vorgefertigte Bitmuster an. Wo immer die auch 
herkommen. Zb. aus einer Funktion, die eine Zahl in die 3 Stellen 
zerlegt und die entsprechend anzuzeigenden Bitmuster in den globalen 
Variablen hinterlässt, auf dass die Anzeige-ISR sie regelmässig an die 
7-Segment ausgibt.

[Michael (Gast)]

Karl Heinz Buchegger schrieb:
> Das ist bei LCD schon 'ein
> Problem', bei 7-Segment Anzeigen will man aber üblicherweise haben, dass
> die Einerstelle immer an derselben Stelle steht.

Dann muss er sprintf nehmen oder programmieren lernen ...

[Karl H. (kbuchegg)]

Michael schrieb:
> Karl Heinz Buchegger schrieb:
>> Das ist bei LCD schon 'ein
>> Problem', bei 7-Segment Anzeigen will man aber üblicherweise haben, dass
>> die Einerstelle immer an derselben Stelle steht.
>
> Dann muss er sprintf nehmen oder programmieren lernen ...

:-)
Er muss nur durch 10 dividieren lernen und lernen was es mit Modulo auf 
sich hat.

[Axel G. (axelg)]

Karl Heinz Buchegger schrieb:
> Er muss nur durch 10 dividieren lernen und lernen was es mit Modulo auf
> sich hat.

*Mathe lernen
*C lernen
*Und Rechtschreibung wären auch noch schön

Da hat er ja noch was zu tun.

[Michael (Gast)]

Karl Heinz Buchegger schrieb:
> Michael schrieb:
>> Karl Heinz Buchegger schrieb:
>>> Das ist bei LCD schon 'ein
>>> Problem', bei 7-Segment Anzeigen will man aber üblicherweise haben, dass
>>> die Einerstelle immer an derselben Stelle steht.
>>
>> Dann muss er sprintf nehmen oder programmieren lernen ...
>
> :-)
> Er muss nur durch 10 dividieren lernen und lernen was es mit Modulo auf
> sich hat.

Das hab ich ihm oben auch schon vorgekaut aber das nimmt er ja auch 
nicht an.

Michael schrieb:
> Also 213 / 100 = 2 = hunderter
> 213 - (2(hunderter)*100) = 13
> 13 / 10 = 1 = zehner
> 13 - (1(zehner)*10) = 3
> 3 = einer

Ich weiß echt nicht was daran so schwer ist. Modulo braucht man da ja 
nicht mal. Und mit ein paar schnellen if-Abfragen kann man sich die 
führenden Nullen oder Vorzeichen spielend holen.

[Karl H. (kbuchegg)]

Michael schrieb:

> Ich weiß echt nicht was daran so schwer ist.

Na ja..
Er hat sich da in eine dämliche Funktion "Anzeige" verrannt.

Das ist
a) schon mal der grundsätzlich falsche Weg
b) bringt ihn das bei der Zerlegung nicht weiter.
   (Man kann schon so eine Funktion benutzen. Aber eigentlich braucht
    die kein Mensch.)

Erst mal muss er verstehen, dass er eine Zahl als ganzes auf seine 7_Seg 
ausgibt. Dann wird alles ganz einfach. Sein eigentliches Problem ist das 
Multiplexen. Wenn er das richtig ansetzt ist der Rest nur noch Pipifax.