C Temperaturanzeige (DS1621) auf 4 - Digit 7-Segmentanzeige

Das mit dem inkrement abhängig vom 9ten Bit (also dem MSB des "TempL") rundet den halb Grad genauen Wert auf einen ganzzahlig genauen. Statt des increment könntest Du ebenso eine ",5"-Anzeige an oder ausschalten. Da Du die aber nicht hast, wird gerundet. Durch das runden bleibt deine Anzeige immer noch bei ganzen °C, allerdings zeigt es jetzt bei 4,7°C (was der Sensor als 4,5°C mißt) eben korrekt gerundete 5°C an, und nicht 4°C.

Wenn Du aber mittelst, also n Werte integrierst, und Durch n teilst, Muß die Variable die die Summe aufnimmt breiter als ein Byte sein. Warum? Das theoretische Maximum des Sensors liegt bei 125°C, der Sensor liefert dann 01111101bin TempH und 00000000bin TempL.
Selbst wenn Du das 9te Bit wegläßt/vorher rundest, würdest Du mit 16 möglichen 125-Werten aufintegriert auf 16*125=2000 kommen -
binär also (01111101bin<<4)=011111010000bin. Wären also 11 Bit breite Zahlen nötig. Also 2 Bytes. Da Dir dann aber eh 16bit zur Verfügung stehen, kannst Du auch das 9te Bit in den Mittelwert einfliessen lassen - dann wäre 125 (rechtsorientiert und mit 1bit=0,5) dargestellt 00000000.11111010, wenn der 16mal integriert wurde (also 2000=max) 00001111.10100000 - du könntest sogar 256 Werte mitteln.
Da Dein Ergebnis halbe °C darstellt, ist es nicht durch 16 zu teilen, sondern durch (2*16), genaugenommen ist also fünfmal rechtszuschieben.
Dabei ist das zuletzt rausgeschobene Bit für die Rundung auf ganze Grad relevant, es gibt aber auch einen anderen Trick, der hier angewendet werden kann:
Es wird einfach vor dem 5fach-Schieben "0,5" addiert (also 00010000bin bzw 16dez), diesen Trick hatte Dino schonmal irgendwo mal erwähnt.

Die Mittelung hilft Dir aber auch nicht immer gegen Deine schwankenden Werte - ok, durch die reduzierte Aktualisierungsfrequenz der Anzeige nimmst Du das nicht mehr so wahr, auf der Anderen kannst Du zufällig entsprechende Werte innerhalb der schwankenden Temperatur treffen, oder nicht.

Die Frage die Du Dir eigentlich stellen mußt ist, warum der Sensor ständig schwankende Temperaturen erkennt/digitalisiert, zwischen 2 aufeinanderfolgenden(?) Samples, und um ein bis zwei (?) volle Kelvin. Das wären ja die letzten 3 der 9 bits...

Ich hab's ja schon mehrfach geschrieben: den Sensor mal lichtgeschützt und isoliert messen lassen, sinnigerweise das 9bit-Ergebnis über viele Werte loggen (über die serielle Schnittstelle an den PC), und die Schwankungen sichtbar machen.
Entweder Du liest den Sensor etwas langsamer aus als alle 0,75s (timerbasiert, um garantiert jedesmal einen neu digitalisierten Wert aufzuzeichnen), oder Du pollst das "Messung fertig Flag" aus dem Control-Register des Sensors, was mir in Verbindung mit dem Dauerlauf aber noch nicht ganz klar ist/herauszufinden wäre. (Also ggf Einzelschußmodus, pollen, Schuß auslösen, Wert lesen/verarbeiten/übertragen, pollen, ...)

Ein integrierter Sensor, der mit 9 bit auf'n halbes Kelvin genau mißt, und dabei durch Rauschen über 2 Kelvin (3 Bit) hinweg schwankt, erscheint mir nicht plausibel. Wenn die Ergebnisse dermaßen schwanken, werden auch die Temperature auf der Sensoroberfläche (vielleicht auch der Beinchen) schwanken...
 
Ich habe mir gedacht, dass ich mit in meiner ISR (z.B jede 10 ms) eine Variable Incrementiere... Wenn die Variable z.B 2400 erreicht hat... sagen wir mal 4 Min. Dann in der while(1), einmal den Sensor abfragen.
So hätte ich jede 4 Minuten einen neuen Wert. Währe das vill auch eine gute Idee oder eher nicht ?
 
Die Temperatur scheint bei Dir ständig rauf und runterzuhüpfen - zumindest aus der Sicht des Sensors. Deine Erfassungen fotografieren quasi jedesmal die momentanen Werte der Ergebnis-Register.
Da die Temperatur angenommenerweise bis auf die beiden möglichen Werte (oben, unten) konstant ist, kannst Du halt entweder oben oder unten "treffen". Daran ändert sich nix wenn Du die Anzeige häufiger oder seltener aktualisierst - die neue Anzeige ist entweder oben oder unten. Die potentiellen Sprünge sind halt jetzt nur in größeren Zeitabständen sichtbar. Überspitzt: wenn Du nur einmal m Jahr messen läßt, ändert sich das mit Sicherheit das ganze Jahr nicht...

Wenn die ursächlichen Schwankungen eine Periodik besitzen, könnte bei gleicher Sample-Frequenz dann jeder Wert oben oder unten sein, auch die Mittelwertbildung könnte dann irgendwas sinniges ergeben - wenn die Frequenzen voneinander abweichen, können sich diese Schwankungen der Displaydarstellung verschieben. Wenn...
Egal, solange Du nicht weißt wie die tatsächlich gemessene Schwankung über eine Zeit hinweg aussieht, kannst Du nur willkürlich entscheiden, auf welchem Weg Du das Schwanken der Anzeige unterdrückst.
Deswegen mein Vorschlag, das ganze mal zu loggen. Bei einer möglichen Periodendauer des Sensors sind das ja in einer Stunde maximal 4800 Werte. Und das dann mal in Exel oder so ansehen - Thomas würde sich für sowas wohl mal fix 'n VisualBasic-Programm zusammenstricken...
Das schwanken ist ja irgendwas, was der Sensor mißt, was also (scheinbar?) da ist. Wenn Du Veränderungen nicht darstellen/'ne statische Anzeige willst, brauchst Du nur einmal messen
 
Ich denke mal das passt jetzt schon so! Wir wollen es ja auch nicht übertreiben. Wie du schon sagst, die Umwelteinflüsse ( Wind , Sonne (Sonnenstahlen etc.) spielen dabei auch eine große Rolle.
Im großen und ganzen passt das jetzt mit der Messung.

Das nächste mal kann man den Sensor abschotten von der anderen Elektronik... Vill. bringt das auch was (wenn auch nur minimal).

Ich danke euch allen, für eure Hilfe ;)

:victory:
 
Hallo,

Deswegen mein Vorschlag, das ganze mal zu loggen. Bei einer möglichen Periodendauer des Sensors sind das ja in einer Stunde maximal 4800 Werte. Und das dann mal in Exel oder so ansehen
...
Das schwanken ist ja irgendwas, was der Sensor mißt, was also (scheinbar?) da ist. Wenn Du Veränderungen nicht darstellen/'ne statische Anzeige willst, brauchst Du nur einmal messen

wenn der Sensor frei läuft und einfach "nur abgefragt" wird ...
Code:
        i2c_start(DS1621_Read);
        TempH = i2c_readAck();
        TempL = i2c_readNak();
        i2c_stop();
... dann sehe ich da einige grundlegende Probleme mit dem Timing :p
Denkt doch mal an 10Bit-Wandlung im Atmel, die Abfrage des High/Low-Bytes und Race-Conditions :rolleyes:

Im Datenblatt des Sensors steht folgendes ...
OPERATION AND CONTROL
The DS1621 must have temperature settings resident in the TH and TL registers for thermostatic operation. A configuration/status register also determines the method of operation that the DS1621 will use in a particular application, aswell as indicating the status of the temperature conversion operation.
The configuration register is defined as follows:
MSb Bit 6 Bit5 Bit 4 Bit 3 Bit 2 Bit 1 LSb
DONE THF TLF NVB X X POL 1SHOT
where
DONE= Conversion Done bit. “1” = Conversion complete, “0” = Conversion in progress.

Man sollte die Abfrage machen wenn keine Wandlung stattfindet. Also recht fix nach dem Ende der Wandlung da aus dem Datenblatt nicht wirklich ersichtlich ist wie lange das Ergebnis im Continuous-Modus stabil im Ergebnisregister stehen bleibt. Es könnte also passieren das man das HighByte noch abgefragt bekommt, das LowByte aber bereits irgendwas anderes enthält weil der Chip bereits wieder die Wandlung gestartet hat. Müßte man sich mal genauer ansehen.

Wenn man jedoch einen freilaufenden Wandlerchip einfach mit einem freilaufenden Programm abfragt, dann hat man sozusagen zwei verschiedene Ablauffrequenzen die einen Schwebungseffekt erzeugen. Die Herangehensweise ist also vom Ansatz her bereits falsch. Ohne dieses DONE-Bit abzufragen ist das auf jeden Fall programmtechnischer Selbstmord. Da wird man nie reproduzierbare Ergebnisse rausbekommen.

Gruß
Dino
 
Hallo,



wenn der Sensor frei läuft und einfach "nur abgefragt" wird ...
Code:
        i2c_start(DS1621_Read);
        TempH = i2c_readAck();
        TempL = i2c_readNak();
        i2c_stop();
... dann sehe ich da einige grundlegende Probleme mit dem Timing :p
Denkt doch mal an 10Bit-Wandlung im Atmel, die Abfrage des High/Low-Bytes und Race-Conditions :rolleyes:

Im Datenblatt des Sensors steht folgendes ...


Man sollte die Abfrage machen wenn keine Wandlung stattfindet. Also recht fix nach dem Ende der Wandlung da aus dem Datenblatt nicht wirklich ersichtlich ist wie lange das Ergebnis im Continuous-Modus stabil im Ergebnisregister stehen bleibt. Es könnte also passieren das man das HighByte noch abgefragt bekommt, das LowByte aber bereits irgendwas anderes enthält weil der Chip bereits wieder die Wandlung gestartet hat. Müßte man sich mal genauer ansehen.

Wenn man jedoch einen freilaufenden Wandlerchip einfach mit einem freilaufenden Programm abfragt, dann hat man sozusagen zwei verschiedene Ablauffrequenzen die einen Schwebungseffekt erzeugen. Die Herangehensweise ist also vom Ansatz her bereits falsch. Ohne dieses DONE-Bit abzufragen ist das auf jeden Fall programmtechnischer Selbstmord. Da wird man nie reproduzierbare Ergebnisse rausbekommen.

Gruß
Dino


Stimmt! Da habe ich noch gar nicht dran gedacht. Dann sollte ich das Bit wohl am besten mit Auswerten?!
Und wenn das "high" ist die nächste Messung starten.
 
...wenn der Sensor frei läuft und einfach "nur abgefragt" wird ...
Code:
        i2c_start(DS1621_Read);
        TempH = i2c_readAck();
        TempL = i2c_readNak();
        i2c_stop();
... dann sehe ich da einige grundlegende Probleme mit dem Timing :p
Denkt doch mal an 10Bit-Wandlung im Atmel, die Abfrage des High/Low-Bytes und Race-Conditions :rolleyes:

Im Datenblatt des Sensors steht folgendes ...


Man sollte die Abfrage machen wenn keine Wandlung stattfindet. Also recht fix nach dem Ende der Wandlung da aus dem Datenblatt nicht wirklich ersichtlich ist wie lange das Ergebnis im Continuous-Modus stabil im Ergebnisregister stehen bleibt....
Mal vorweg: der Sensor braucht 750ms für 'ne Wandlung, die Wahrscheinlichkeit genau in dem Moment auszulesen ist mMn sehr gering - aber natürlich vorhanden. Beim 10Bit-ADC der AVR ist deswegen der Zugriff gepuffert, mit dem Hinweis auf die Reichenfolge beim Auslesen... hier ist die Reihenfolge festgelegt, ob da irgendeine Pufferung stattfindet ist dem Datenblatt nicht entnehmbar. Ok, kann man also nicht von ausgehen.

Trotzdem ist anzumerken, daß Janiiix3's Schwank-Problem bereits in dem High-Byte selbst besteht (das lowbyte enthält ja lediglich ein bit). Oder meinst Du, der Chip verändert die beiden Registerinhalte (die man gerade zurücklesen könnte) während der sukzessiven Approximation? Quark, is ja kein ADC... klingt eher danach, als wenn hier irgendwas über'n temperaturabhängigen Widerstand geladen wird oder so, und die dafür benötigte Zeit gezählt wird. Paßt dann eher zum "Counter" und "Slope" Register. Da wäre es zumindest vorstellbar, daß mehrere Zugriffe innerhalb einer Messung unterschiedliche Werte liefern...
...Wenn man jedoch einen freilaufenden Wandlerchip einfach mit einem freilaufenden Programm abfragt, dann hat man sozusagen zwei verschiedene Ablauffrequenzen die einen Schwebungseffekt erzeugen. Die Herangehensweise ist also vom Ansatz her bereits falsch. Ohne dieses DONE-Bit abzufragen ist das auf jeden Fall programmtechnischer Selbstmord...
Das mit dem Done Bit ist mir im continous-Mode unklar...

Im single-shot-mode wird es nach einer Wandlung gesetzt, und beim Start einer Messung (conversion in progress) gelöscht, alles klar, damit kann man arbeiten (war ja so auch irgendwo schon mein Vorschlag)...
Aber im Continious Mode? Da startet die nächste doch sofort, das Bit wird also sofort wieder gelöscht. Da das Done keine Leitung ist, wo man auf'n kurzen Strobe reagieren könnte, kann man das dann praktisch nie treffen, beim Auslesen.
Dann würde der ganze Mode doch unseren Überlegungen da oben nach gar keinen Sinn machen wenn die, zu einem beliebigen Zeitpunkt ausgelesenen Werte nicht sicher verwertbar sind, also nicht mal nur die des High-Bytes...

Das heißt... Stop...
Der IC kann ja mit den programmierbaren Grenzen als Thermostat etc verwendet werden, diese Grenzen und die Moduswahl sind nichtflüchtig abgespeichert. Wenn hier die Ausleserei uninteressant ist, macht der nach 2wire-Programmierung und eventuell folgendem Standalone-Betrieb durchaus S...inn
 
Hi,

Trotzdem ist anzumerken, daß Janiiix3's Schwank-Problem bereits in dem High-Byte selbst besteht (das lowbyte enthält ja lediglich ein bit). Oder meinst Du, der Chip verändert die beiden Registerinhalte (die man gerade zurücklesen könnte) während der sukzessiven Approximation? Quark, is ja kein ADC... klingt eher danach, als wenn hier irgendwas über'n temperaturabhängigen Widerstand geladen wird oder so, und die dafür benötigte Zeit gezählt wird. Paßt dann eher zum "Counter" und "Slope" Register. Da wäre es zumindest vorstellbar, daß mehrere Zugriffe innerhalb einer Messung unterschiedliche Werte liefern...

ist wohl ein ADC ...

OPERATION
Measuring Temperature
A block diagram of the DS1621 is shown in Figure 1.
The DS1621 measures temperature using a bandgap-based temperature sensor. A delta-sigma analog-to-digital converter (ADC) converts the measured temperature to a digital value that is calibrated in °C; for °F applications, a lookup table or conversion routine must be used.

Gegenüber den anderen fehlenden Sachen steht das zufällig mal im Datenblatt ;)

Gruß
Dino
 
:p
egal...
ICH würde anstelle von Janiiix3 wie gesagt die 9bit-Werte mal 'ne zeitlang mitloggen, also auf das done pollen, und die "Rohdaten" an den PC senden. Wenn man positive Werte garantiert, ist das MSB (von TempH) ja immer 0, könnte man also die 8 restlichen bit in einem Byte übertragen, und mal in Exel oder so darstellen.
Bei 8MHz wäre 38k4 'ne brauchbare Baudrate.
Außerdem würde MICH interessieren, ob sich die ausgelesenen Werte innerhalb einer Wandlung des Sensors ändern. Also so wie oben, aber im continious mode ohne pollen. Die Ergebnis Bytes erstmal ins SRAM puffern (bis es voll ist), und dann alles an den PC übertragen.
 
:p
egal...
ICH würde anstelle von Janiiix3 wie gesagt die 9bit-Werte mal 'ne zeitlang mitloggen, also auf das done pollen, und die "Rohdaten" an den PC senden. Wenn man positive Werte garantiert, ist das MSB (von TempH) ja immer 0, könnte man also die 8 restlichen bit in einem Byte übertragen, und mal in Exel oder so darstellen.
Bei 8MHz wäre 38k4 'ne brauchbare Baudrate.
Außerdem würde MICH interessieren, ob sich die ausgelesenen Werte innerhalb einer Wandlung des Sensors ändern. Also so wie oben, aber im continious mode ohne pollen. Die Ergebnis Bytes erstmal ins SRAM puffern (bis es voll ist), und dann alles an den PC übertragen.


Also...

Mit der aktuellen "Mittelwertbildung" klappt es besser als ohne. Aktuell sample ich das Temp Ergebniss 128 mal.
 
Also...

Mit der aktuellen "Mittelwertbildung" klappt es besser als ohne. Aktuell sample ich das Temp Ergebniss 128 mal.

Du meinst, du summierst 128 Messergebnisse? Eine Messung dauert knapp eine Sekunde? Ich habe das Thema nun nicht komplett mitverfolgt, wartest du eine Messung ab oder liest du permanent einfach die Inhalte vom Ergebnisregister?
 
Du meinst, du summierst 128 Messergebnisse? Eine Messung dauert knapp eine Sekunde? Ich habe das Thema nun nicht komplett mitverfolgt, wartest du eine Messung ab oder liest du permanent einfach die
Inhalte vom Ergebnisregister?

Also aktuell summier ich die Werte aus dem Ergebnissregister. Ich muss meine Software noch so umschreiben, dass ich nur jede Sekunde die Ergebnisse auf summiere. Dann ist es wohl am besten wenn ich die ''Single Shot'' Methode nehme und das ''Done'' Bit abfrage oder ?

Code:
if ((Done (ConfigRegister) & 0b10000000) == (0b10000000))
{
  neue Messung starten;
}
 
Kann es sein, dass ich das "Done Bit" nur im "1Shoot" Mode abfragen kann & es sich im "Continues" Mode nicht ändert ?
 
Selbst wenn es sich in dem kurzen Moment zwischen zwei Messungen kurz ändern sollte, kannst Du diesen praktisch nie mit Sicherheit beim Pollen treffen.
 
Continuous Conversion Mode

Hi,

ich hab mal versucht ein paar Infos zu finden ...

Arduino Forum - Read out of DS1621
Re: Read out of DS1621
« Reply #2 on: December 19, 2007, 11:51:33 am »
The DS1621 is I2C. You probably want to set it up for continuous conversion mode -- you don't seem to be doing that in your code. The data sheet shows how. When continuous conversion is used you can read the temperature at any time (though I believe the first conversion takes about one second to complete).

berkeley.edu - Kernel driver ds1621
The DS1621 has two modes of operation: "Continuous" conversion, which can
be understood as the default stand-alone mode where the chip gets the
temperature and controls external devices via its Tout pin or tells other
i2c's about it if they care. The other mode is called "1SHOT", that means
that it only figures out about the temperature when it is explicitly told
to do so; this can be seen as power saving mode.

Now if you want to read REG_COUNT and REG_SLOPE, you have to either stop
the continuous conversions until the contents of these registers are valid,
or, in 1SHOT mode, you have to have one conversion made.

Hier sind auch noch ein paar Infos über den DS1621 drin ...

Anhang anzeigen DS1621_AN127_Reverse Compatibility of the DS1721 Digital Temperature Sensor with the DS1621.pdf

Anhang anzeigen DS1621_AN176_Using the DS1631 Temperature Sensor in DS1621 Applications.pdf

Gruß
Dino
 
Ich habe das Gefühl, dass ich den "OneShoot" Mode nicht richtig nutze.
Anbei mein aktueller Quellcode. In der ISR versuche ich nur 1 x (jede 2 Sekunden) den Inhalt des Temperaturregisters aus zu lesen und auf zu summieren.


Code:
/* PD.0 = A
   PD.1 = B
   PD.2 = C
   PD.3 = D
   PD.4 = E
   PD.5 = F
   PD.6 = G
   
   
0 = 0b00111111
1 = 0b00000110
2 = 0b01011011
3 = 0b01001111   
4 = 0b01100110
5 = 0b01101101   
6 = 0b01111101   
7 = 0b00100111
8 = 0b01111111 
9 = 0b01101111
* = 0b01100011
C = 0b01000000
   
*/

#define F_CPU 8000000

#define DS1621_Write  0x9E
#define DS1621_Read   0x9F

#define Segment_1_AN PORTB &= ~(1<<PB3)
#define Segment_1_AUS PORTB |= (1<<PB3)

#define Segment_2_AN PORTB &= ~(1<<PB2)
#define Segment_2_AUS PORTB |= (1<<PB2)

#define Segment_3_AN PORTB &= ~(1<<PB1)
#define Segment_3_AUS PORTB |= (1<<PB1)

#define Segment_4_AN PORTB &= ~(1<<PB0)
#define Segment_4_AUS PORTB |= (1<<PB0)

#define KONFIGURATIONSREGISER 0xAC
#define TEMPERATUR_LESEN      0xAA
#define START_UMWANDLUNG      0xEE
#define STOP_UMWANDLUNG          0x22
#define ONE_SHOT_MODE          0x01
#define CONTINUES_MODE          0x00


#define Mittelwert 16

int Zahlen[13]= {
                    0b00111111, // 0
                    0b00000110, // 1
                    0b01011011, // 2
                    0b01001111, // 3
                    0b01100110, // 4
                    0b01101101, // 5
                    0b01111101, // 6
                    0b00100111, // 7
                    0b01111111, // 8
                    0b01101111, // 9
                    0b01100011, // *
                    0b01000000, // Minus
                    0b00000000  // alle Aus
                };

#include <avr/io.h>
#include <util/delay.h>
#include "i2cmaster.h"
#include <avr/interrupt.h>

volatile unsigned char  TempH, TempL = 0;
volatile int16_t        Wert, Summe, Ergebnis;
volatile int8_t            TempAbs = 0;
volatile uint8_t        IsNegative, I, Done;
 

int main(void)
{
    DDRB |= ((1<<PB0) | (1<<PB1) | (1<<PB2) | (1<<PB3));
    DDRD |= ((1<<PD0) | (1<<PD1) | (1<<PD2) | (1<<PD3) | (1<<PD4) | (1<<PD5) | (1<<PD6));
    
    OCR1A   = 15624;                        // Legt den Wert ZUM Überlaufes fest ( ca. jede 2 Sec. (15624))
    TCCR1A |= (1<<WGM11);                    // CTC Modus
    TIMSK  |= (1<<OCIE1A);                    // Compare Match Interrupt enable
    TCCR1B |= ((1<<CS12) | (1<<CS10));        // Prescaler auf 1024 setzen (F_CPU/1024)
    sei();
    

    i2c_init();
    
    i2c_start(DS1621_Write); // Aktivieren des "ONE_SHOOT" Modes
    i2c_write(KONFIGURATIONSREGISER);
    i2c_write(ONE_SHOT_MODE);  
    i2c_stop();
                 

    Segment_1_AUS; Segment_2_AUS; Segment_3_AUS; Segment_4_AUS;

    Summe = 0;
    
while (1)
{
    
    Segment_1_AN;
    PORTD = Zahlen[Wert & 0x000F];
    _delay_ms(4);
    Segment_1_AUS;

    Segment_2_AN;
    PORTD = Zahlen[(Wert & 0x00F0) >> 4];
    _delay_ms(4);
    Segment_2_AUS;
    
    Segment_3_AN;
    PORTD = Zahlen[(Wert & 0x0F00) >> 8];
    _delay_ms(4);
    Segment_3_AUS;
    
    Segment_4_AN;
    PORTD = Zahlen[(Wert & 0xF000) >> 12];
    _delay_ms(4);
    Segment_4_AUS;

} // Ende While
} // Ende Main

ISR (TIMER1_COMPA_vect)
{
    


    if (I <= Mittelwert)
    {    
        
        i2c_start(DS1621_Write); // Temperaturregister "anwählen"
        i2c_write(TEMPERATUR_LESEN);
        i2c_stop();

        i2c_start(DS1621_Write); // Starten der Umwandlung (Messung)
        i2c_write(START_UMWANDLUNG);
        i2c_stop();        
        
        
        I++;    
        i2c_start(DS1621_Read); // Dateb aus dem "Temperaturregister" lesen & abspeichern
        TempH = i2c_readAck();
        TempL = i2c_readNak();
        i2c_stop();

        if ((TempL & 0b10000000) == (0b10000000))
        {
            TempH++;
        }
            
            Summe += TempH;
        
        i2c_start(DS1621_Write); // Dem Temperatursensor "mitteilen" das die Messung vorbei ist
        i2c_write(STOP_UMWANDLUNG);
        i2c_stop();
        
    }


    if (I == Mittelwert)
    {
        Ergebnis = Summe / Mittelwert;
        I = 0;
        Summe = 0;
    }
    


    if (Ergebnis < 0)
    {
        IsNegative = 1;
        TempAbs = ~(Ergebnis) + 1;
    }
        else
    {
        IsNegative = 0;
        TempAbs = Ergebnis;
    }

    Wert = ((((TempAbs / 10) % 10) << 8) | ((TempAbs % 10) << 4) | (0x0A)); // Wert entspricht dem "Wert" aus dem Array (Zahlen)

    if (TempAbs == 0)
    {
        Wert = 0xCC0A;
    }
    else if (TempAbs >= 100)
    {
        Wert = (Wert | 0x1000);
    }
    else if (TempAbs < 10)
    {
        Wert = (Wert | 0xCC00);
    }
    else if (TempAbs < 100)
    {
        Wert = (Wert | 0xC000);
    }

    if (IsNegative == 1)
    {
        Wert = (Wert & 0x0FFF) | (0xB000);
    }
    
    
}// Ende ISR
 
Aber wenn ich nur jede 2 Sekunden in die ISR laufe (der Sensor braucht fast ca. eine Sekunde für eine neue Messung) und den Wert des Temperaturregisters abfrage, dürfte ich doch immer den aktuellsten Wert abgreifen können oder nicht ? Dann bräuchte ich den "OneShoot" Mode ja garnicht
 
Hi,

die Einstellung des 1Shoot sollte soweit passen, ABER Du beschreibst den nichtflüchtigen Bereich so bei jedem Reset. Ich gehe jetzt einfach mal davon aus daß der (ähnlich wie beim AVR) nur begrenzt oft beschreibbar ist. Du solltest den also nur einmal festlegen, in diesem Programm brauchst Du ihn dann nicht mehr. (Also mit einem Programm beschreiben, vielleicht mit einem 2ten kontrollieren - wenn der stimmt, brauchst Du in Deinem richtigen Programm nix mehr tun...

Außerdem solltest Du mindestens 10ms warten, nachdem das Eeprom des Sensors beschrieben wurde (man kann auch ein entsprechendes Flag dort pollen).

Was meiner Meinung aber nicht paßt, ist die Reihenfolge beim Auslesen in der ISR:
Du gibst die Anweisung, die Temperatur-Register auszulesen, vor den entsprechenden Read-Instruktionen brichst Du aber ab (bzw unterbrichst). Selbst wenn Du die Kommunikation genau dort fortsetzen könntest, tust Du das aber nicht - stattdessen gibst Du jetzt ein anderes Kommando, nämlich "Starte neue Konversion"

Also Du solltest das Auslesen nicht auseinanderreissen, und sinnigerweise die nächste Konversion erst danach starten.
 
Aber Lodadac,

Wenn ich nur jede 2 Sek. in die ISR springe & den neuen Messwert abhole, kann ich doch ruhig den "Continues" Mode nutzen oder nicht ?
Wenn der Sensor um die "1 Sek." braucht bis der neue Messwert zur Verfügung steht oder sehe ich das falsch ?:confused:
 

Über uns

  • Makerconnect ist ein Forum, welches wir ausschließlich für einen Gedankenaustausch und als Diskussionsplattform für Interessierte bereitstellen, welche sich privat, durch das Studium oder beruflich mit Mikrocontroller- und Kleinstrechnersystemen beschäftigen wollen oder müssen ;-)
  • Dirk
  • Du bist noch kein Mitglied in unserer freundlichen Community? Werde Teil von uns und registriere dich in unserem Forum.
  •  Registriere dich

User Menu

 Kaffeezeit

  • Wir arbeiten hart daran sicherzustellen, dass unser Forum permanent online und schnell erreichbar ist, unsere Forensoftware auf dem aktuellsten Stand ist und der Server regelmäßig gewartet wird. Auch die Themen Datensicherheit und Datenschutz sind uns wichtig und hier sind wir auch ständig aktiv. Alles in allem, sorgen wir uns darum, dass alles Drumherum stimmt :-)

    Dir gefällt das Forum und unsere Arbeit und du möchtest uns unterstützen? Unterstütze uns durch deine Premium-Mitgliedschaft!
    Wir freuen uns auch über eine Spende für unsere Kaffeekasse :-)
    Vielen Dank! :ciao:


     Spende uns! (Paypal)