C Kommastellen verwerfen

lvr · 7. August 2014

0,5 kannst Du nicht in einem int speichern, da gehen nur ganze Zahlen.
Sinn macht das ganze Thema ja nur, wenn Du mit Fließkommazahlen rechnest, die Du dann hinterher auf Ganzzahlen rundest, so war ja die Ausgangsfrage.

Also evtl. so:

Code

float val = 0.5;
int16_t valganz;
valganz = val / 4;

Jetzt wird 0.5 / 4 gerechnet, ergibt also 0.125. Das kannst Du nun mit einer der bereits genannten Methoden je nach Anforderung runden. Eine einfache Zuweisung an einen int (wie hier) schneidet einfach die Nachkommastellen ab, ergibt also in diesem Fall wieder 0.
5.0 / 4 als anderes Beispiel würde 1.25 ergeben, auf int zugewiesen ergibt 1 usw...

DerSchatten · 7. August 2014

ähm, ich glaub ich hab den Fehler gefunden.
Hab mir da irgendwie selbst ein Ei gelegt.

Jedenfalls ist die Zählung noch nicht so wie ich gerne hätte.
Vielleicht hat dazu jemand einen Tipp.

Diese Funktion hier zählt mir beim erreichen des Wertes 9999 wieder von vorne beginnend weiter, also 0:

Code

void Print(uint16_t num)
{
uint8_t i=0;
uint8_t j;
if (num>9999) return;
while (num)
{
digits[i]=num%10;
i++;
num=num/10;
}
for (j=i;j<4;j++) digits[j]=0;
}
Jetzt hätte ich aber gerne das beim Rückwärtszählen wieder von 9999 an gezählt wird.
Also beim erreichen von 0 soll als nächstes 9999 erscheinen und von dort rückwärts weiter gezählt werden.
Läßt sich diese Funktion diesbezüglich entsprechend anpassen? Wenn ja, wie muß das aussehen?

Alles anzeigen

lvr · 7. August 2014

Diese Funktion "zählt" doch gar nichts. Die wandelt die übergebenen Zahl "num", die max. 9999 groß sein darf in BCD-Code im Array digits[] um (das wohl global definiert ist). Praktisch um die Zahl irgendwie anzuzeigen, addiere z.B. ziffernweise jeweils 0x30 und Du hast ASCII-Zeichen.

EDIT:
Wenn Du also z.B. Print(1234) aufrufst, steht nachher in digits:
digits[0] = 4;
digits[1] = 3;
digits[2] = 2;
digits[3] = 1;
Print zerlegt also eine Zahl in ihre dezimalen Ziffern.

Wenn Du irgendwas hoch oder runterzählen willst, dann musst Du das außerhalb von Print() machen. Was genau soll denn das Programm machen?

Mac Bacon · 7. August 2014

Zitat von Zirias

ich weiß nicht, was du vorhast [...]
Erklär mal, was du erreichen willst

Zitat von Zirias

Bitte poste den kompletten Code und/oder erkläre, was genau du erreichen willst

+1

DerSchatten · 7. August 2014

Also:

C

#include <avr/io.h>
#include <avr/interrupt.h>
// CPU: ATtiny2313-20PU 8MHz
// =======================================================================
// Ein-/Ausgänge
// -----------------------------------------------------------------------
#define MOTOR_PORT PORTA
#define MOTOR_DDR DDRA
#define SEVEN_SEGMENT_PORT PORTB
#define SEVEN_SEGMENT_DDR DDRB
#define FOTODIODE_PORT PORTD
#define FOTODIODE_DDR DDRD
#define TASTER_PIN PIND
#define FOTODIODE_A (PIND & (1 << PD6))
#define FOTODIODE_B (PIND & (1 << PD5))
#define TASTER (1 << PD4)
#define MOTOR (1 << PA0)
#define DP_DIGIT 7 // Dezimalpunkt an Bit 7
//Schaltmuster
//--------------------------------------------------
#define ALL_LOW 0x00 // 0000 0000
#define ALL_HI 0xFF // 1111 1111
#define FOTO_EINGANG 0x0F // 0000 1111
#define FOTO_PULLUP 0xF0 // 1111 0000
#define MOTOR_AUSGANG 0x07 // 0000 0111
// .gfedcba
uint8_t digitPattern[] = {
0b00111111,
0b00000110,
0b01011011,
0b01001111,
0b01100110,
0b01101101,
0b01111101,
0b00000111,
0b01111111,
0b01101111,
};
// Tastendruck
// -----------------------------------------------------------------------
#define REPEAT_MASK (TASTER)
#define REPEAT_START 250
#define REPEAT_NEXT 100
volatile uint8_t key_state;
volatile uint8_t key_press;
volatile uint8_t key_rpt;
volatile uint8_t digits[4];
volatile int8_t enc_delta;
volatile int8_t dp_ein = 0;
volatile int8_t motor_aus = 0;
static int8_t last;
// Timer-Routine für 7-Segment
// -----------------------------------------------------------------------
ISR(TIMER0_OVF_vect)
{
static uint8_t i=0;
FOTODIODE_PORT &= FOTO_PULLUP;
if (i==3)
{
i=0;
}
else
{
i++;
}
SEVEN_SEGMENT_PORT = digitPattern[ digits[i] ];
FOTODIODE_PORT |= (1<<i);
if ((i == 0) & (dp_ein == 1))
SEVEN_SEGMENT_PORT |= (1 << DP_DIGIT);
}
// Timer-Routine für IR-Dioden und Tastendruck
// -----------------------------------------------------------------------
ISR(TIMER0_COMPA_vect)
{
int8_t neu, diff;
neu = 0;
if (FOTODIODE_A)
neu = 3;
if (FOTODIODE_B)
neu ^= 1;
diff = last - neu;
if (diff & 1)
{
last = neu;
enc_delta += (diff & 2) - 1;
}
uint8_t i;
static uint8_t ct0, ct1, rpt;
i = key_state ^ ~TASTER_PIN;
ct0 = ~(ct0 & i);
ct1 = ct0 ^ (ct1 & i);
i &= ct0 & ct1;
key_state ^= i;
key_press |= key_state & i;
if ((key_state & REPEAT_MASK) == 0)
rpt = REPEAT_START;
if (--rpt == 0)
{
rpt = REPEAT_NEXT;
key_rpt |= key_state & REPEAT_MASK;
}
}
// IR-Dioden auswerten
// -----------------------------------------------------------------------
int8_t encode_read(void)
{
int8_t val;
cli();
val = enc_delta;
enc_delta = val & 1;
sei();
return val >> 1;
}
// 7-Segment Anzeige darstellen
// -----------------------------------------------------------------------
void Print(uint16_t num)
{
uint8_t i=0;
uint8_t j;
if (num>9999) return;
while (num)
{
digits[i]=num%10;
i++;
num=num/10;
}
for (j=i;j<4;j++) digits[j]=0;
}
// Tastendruck auswerten
// -----------------------------------------------------------------------
uint8_t get_key_press(uint8_t key_mask)
{
cli();
key_mask &= key_press;
key_press ^= key_mask;
sei();
return key_mask;
}
uint8_t get_key_rpt(uint8_t key_mask)
{
cli();
key_mask &= key_rpt;
key_rpt ^= key_mask;
sei();
return key_mask;
}
uint8_t get_key_short(uint8_t key_mask)
{
cli();
return get_key_press(~key_state & key_mask);
}
uint8_t get_key_long(uint8_t key_mask)
{
return get_key_press(get_key_rpt(key_mask));
}
// Encoder initialisieren
// -----------------------------------------------------------------------
void encode_init(void)
{
int8_t neu;
neu = 0;
if (FOTODIODE_A)
neu = 3;
if (FOTODIODE_B)
neu ^= 1;
last = neu;
enc_delta = 0;
}
// Ein-/Ausänge zuweisen
// -----------------------------------------------------------------------
void ioinit(void)
{
OCR0A = (uint8_t)(F_CPU / 64.0 * 1e-3 - 0.5);
TCCR0B |= (1<<CS01 | 1<<CS00);
TIMSK |= (1<<OCIE0A | 1<<TOIE0);
TCNT0 = 0;
FOTODIODE_DDR &= ~FOTO_EINGANG; // Fotodioden als Eingang
FOTODIODE_PORT |= FOTO_PULLUP; // Fotodioden Pull-Up aktivieren
SEVEN_SEGMENT_DDR = ALL_HI; // 7-Segment Anzeige als Ausgang
SEVEN_SEGMENT_PORT = ALL_LOW; // 7-Segment Pin's auf LOW
MOTOR_DDR = MOTOR_AUSGANG; // Motorsteuerung als Ausgang
MOTOR_PORT = ALL_LOW; // Motorsteuerung Pins's auf LOW
}
// Hauptprogramm
// -----------------------------------------------------------------------
int main(void)
{
int16_t valganz = 0;
int16_t val = 0;
int16_t zahl_speicher = 0;
int8_t wert_ungleich = 0;
ioinit();
encode_init();
sei();
for (;;)
{
valganz += encode_read();
val = valganz / 4;
if (get_key_short(TASTER))
{
valganz = 0;
MOTOR_PORT &= ~MOTOR;
}
if (get_key_long(TASTER))
{
if (dp_ein == 0)
{
if (val |= 0)
{
zahl_speicher = val;
dp_ein = 1;
}
}
else
{
zahl_speicher = 0;
dp_ein = 0;
wert_ungleich = 0;
}
}
if ((dp_ein == 1) & (val != zahl_speicher) & (wert_ungleich == 0))
wert_ungleich = 1;
if ((wert_ungleich == 1) & (val == zahl_speicher))
MOTOR_PORT |= MOTOR;
if (dp_ein == 0)
MOTOR_PORT &= ~MOTOR;
Print(val);
}
}

Alles anzeigen

Das ganze wird ja auf einer Segmentanzeige angezeigt.
Und soll wie ein Zählwerk das Rückwerts zählt funktionieren. Das ja auch nicht bei 0 stoppt sondern dann wieder bei 9999 beginnt rückwerts zu zählen.

lvr · 7. August 2014

Aha, langsam lichtet sich der Nebel...
Es geht um ein Zählwerk mit einem Encoder. Der aktuelle Zählerstand steht in valganz und zur Anzeige teilst du den Wert vorher durch 4 (in val). Korrekt?
Und was geht jetzt und was geht nicht?
Mal angenommen die Encoder-Auswertung funktioniert (was ich momentan nicht überblicke), dann wird valganz beim Runterzählen irgendwann negativ. Das könnte Dein Problem sein.

Du könntest folgendes versuchen:

Code

for (;;)
{
valganz += encode_read();
if (valganz < 0)
valganz += 10000;
val = valganz / 4;

oder so ähnlich.

Mac Bacon · 7. August 2014

Was lvr sagt - wobei ich den Test und das "+= 10000" allerdings auf val, nicht auf valganz anwenden würde.

Sonstiges:

In C ist das Ergebnis der Operation "Negativer Wert nach rechts geshiftet" undefiniert. Das wird hier vermutlich nicht das Problem sein, kann einem aber den Tag verderben. [AxelStoll] Muss man nur wissen [/AxelStoll].

In Zeile 245 steht "if (val |= 0)" - ich weiß nicht, was Du da wolltest, aber das ist es vermutlich nicht.

EDIT: Den Unterschied zwischen "&" und "&&" bzw. "|" und "||" kennst Du? Kommt in diesem Fall aufs Gleiche raus, aber normalerweise nimmt man in Fällen wie hier die logischen Operatoren (also die doppelten).
Ach ja, und Du solltest an Deinen Variablennamen arbeiten, und mehr Kommentare schreiben.

DerSchatten · 7. August 2014

Ja, genau.
Die Auswertung des Encoders funktioniert problemlos. In meinem Falle ist es jedoch kein Encoder der die Werte liefert sondern zwei Lichtschranken die mittels einer Scheibe ... Mehr dazu kommt noch.

Dein Tipp ist schon der richtige Weg wie mir scheint, ~~aaaaber, er zählt seltsamerweise nach 0 von 2500 rückwerts.~~

Also:
3
2
1
0
2500
2499
...

Ähm, Logo: 9999 / 4

Mac Bacon · 7. August 2014

Zitat von DerSchatten

er zählt seltsamerweise nach 0 von 2500 rückwerts.

...und genau das ist der Unterschied zwischen "valganz" und "val".
Wo kommt jetzt eigentlich das Abschneiden der Nachkommastellen ins Spiel?

THaase · 7. August 2014

Zitat von Zirias

Sind mir zu viele arithmetische Operationen, nur dafür, das möglichst tricky aussehen zu lassen :p

Regel 2 der Real Programmers:

- Real programmers don't comment their code. If it was hard to write, it should be hard to read.

Der Code kann nicht der selbe sein .... man müsste sich aber mal den output anschauen um zu sehen was schneller ist ... bne/beq bzw. jmp sind recht lahm wenn ich mich da recht erinnere ...

DerSchatten · 7. August 2014

ja, bitweise oder logische Verknüpfung.

if (val |= 0) war genau das Problem das ich zuerst hatte.
Im Falle eines Nullwertes sollte bei einem langem Tastendruck nichts passieren.

Der Lange Tastendruck speichert den aktuellen Zählerstand in eine Variable. Was bei einem Nullwert nicht viel Sinn hätte.
Das dürfte jetzt auch so funktioniren.

Jedoch läuft die Zählung nun nicht korrekt.
Das Zählen beim Vorspulen ist langsamer als beim zurückspulen.

~~Hängt wohl jetzt mit dem~~

if (val < 0)
val += 10000;

~~zusammen.~~

Wieder falsch. Es liegt an der Datasette.
Die dürfte schneller spulen wenn das Band auf einer Rolle weniger ist. In dem Falle beim zurückspulen. Also ich denke mal das es daran liegt.

Zählen tut er korrekt.

lvr · 7. August 2014

Zitat von Mac Bacon

wobei ich den Test und das "+= 10000" allerdings auf val, nicht auf valganz anwenden würde.

Oh, natürlich.

Zitat von DerSchatten

In meinem Falle ist es jedoch kein Encoder der die Werte liefert sondern zwei Lichtschranken die mittels einer Scheibe ...

Also ein selbstgebauter Encoder.

DerSchatten · 7. August 2014

Richtig. Sogar ein Selbstdrehender

Ein kleiner Schönheitsfehler ist mir nun jedoch noch aufgefallen:
Wen von 9999 nach 0 gezählt wird bleibt die 0 doppelt so lange stehen wie wenn ein wechsel von 0 auf 1 auf 2 auf 3 ... erfolgt.

Beim zurückzählen wird's wohl genauso seind enke ich. Kann ich aber nicht 100% sagen da beim spulen natürlich das ganze recht schnell läuft.
Bei PLAY merkt man es aber.

Das liegt vermutlich daran weil -1 / 4 ebenfalls noch 0 ergibt.

Mac Bacon · 7. August 2014

Zitat von DerSchatten

if (val |= 0) war genau das Problem das ich zuerst hatte.
Im Falle eines Nullwertes sollte bei einem langem Tastendruck nichts passieren.

Verstehe ich das richtig, dass Du absichtlich "|= 0" schreibst, obwohl Du "!= 0" meinst?

DerSchatten · 7. August 2014

Nein, du hast natürlich recht. Sollte != (ungleich) lauten.

lvr · 7. August 2014

Ich glaub es ist doch einfacher auf valganz zu testen, sonst springt zwar val beim Runterzählen über 0 wieder auf 9999, aber valganz bleibt ja negativ.
Und wo ist eigentlich der Test auf positiven Überlauf 9999->0?

Code

valganz += encode_read();
if (valganz < 0)
valganz += 40000;
else if (valganz > 39999)
valganz = 0;
val = valganz / 4;

Oder hab ich jetzt wieder nen Denkfehler drin?

DerSchatten · 7. August 2014

Eine Prüfung auf Überlauf gibt's in dem Sinne nicht.

Das ganze wird ja nur durch diese Funktion hier begrenzt, soweit ich jetzt verstanden habe:

Code

void print(uint16_t num)
{
uint8_t i=0;
uint8_t j;
if (num>9999) return;
while (num)
{
digits[i]=num%10;
i++;
num=num/10;
}
for (j=i;j<4;j++) digits[j]=0;
}

Alles anzeigen

Meinst du in deinem Beispiel wirklich 40000 und 39999 ?

Da meckert der Compiler:
../main.c:236: warning: comparison is always false due to limited range of data type

Und das Ergebnis ist ganz verstümmelt. Vor null kommt 3615.

Mac Bacon · 7. August 2014

Es gibt da jetzt eine ganz tolle technologische Neuentwicklung: Mit den sogenannten "Kommentaren" kann man sich für jede verwendete Variable notieren, welchen Zweck und welchen Wertebereich sie haben soll...

lvr · 7. August 2014

Die Print() Funktion prüft nur auf > 9999 und bricht ab, wenn der Wert größer ist. Es wird dann einfach nichts angezeigt, der eigentliche Zähler macht aber weiter.

Statt der > 39999 kannst Du auch auf >= 40000 prüfen, wenn Dir das besser gefällt, kommt aber auf's gleiche raus.

OK, die Warnung liegt am Datentyp int16_t, der geht von -32768 bis +32767, kann also nie > 39999 werden. Der Compiler hat Recht.
Entweder auf int32_t ändern oder auf einen unsigned int, also uint16_t, der geht dann von 0 bis 65535. Da muss man aber die Abfrage auf Unterlauf ändern. Probiers zuerst mal mit int32_t.

DerSchatten · 8. August 2014

Mit int32_t funktioniert.
Dürfte nun soweit alles funktioniert. Habe jetzt sonst keine weiteren Mängel feststellen können.
Werde ich Morgen aber nochmal intensiver testen.

Dann gibt's auch ein Video dazu mit dem ganzen Aufbau.