DS18B20 en TMP37 Kalibrator

blackdog

Golden Member

Hi,

Dank weer beide voor de code en de inzet.

Ik heb de bijlage van hardbass in de Arduino IDE geplakt en laten lopen, dit geeft geen fouten bij het compileren maar ik be nu wel alle resolutie kwijt.
De uitlezing is nu wel rete stabiel op hele graden Celsius afgerond. :+

hardbass, zo staat het nu in de Arduino IDE bij mij.

c code:


#include <ADC.h>

// Thermistor Eigenschappen Vishay NTCLE300E3502SB
#define RT0 5000                                                              // Ω
#define B   3977                                                              // K
#define VCC 2.4985                                                            // Referentie Spanning van Maxim voltage reference IC
#define R   2368.85                                                           // Weerstand naar de referentie spanning voor de NTC in Ohm
#define T0  (25 + 273.15)                                                     // Temperature T0 from datasheet, conversion from Celsius to kelvin fot the NTC Sensor

ADC *adc = new ADC();                                                         // ADC object voor de Teensy ADC
 

// Configuratie middeling voor de NTC ingang
template <class T>
class Filter 
{
public:
  int N = 0;                                                                  // Aantal te middelen waarde
  T *meetwaardes;                                                             // Opslag individuele meetwaarden
  T accumulator = 0;                                                          // Optelsom van alle individuele meetwaarden
  int index = 0;                                                              // Meetwaarden teller

  Filter(const int n)
  {
    meetwaardes = new T[n];
    N = n;
    for(int i = 0; i < n; i++)
    {  
      meetwaardes[i] = 0;
    }
  }

  ~Filter()
  {
    delete[] meetwaardes;
  }

  void AddSample(int NewSample)
  {  
    accumulator -= meetwaardes[index];        
    meetwaardes[index] = NewSample;                                          // Bewaar nieuwe meetwaarde
    accumulator += meetwaardes[index];                                       // Accumuleer nieuwste meetwaarde
    index++; 
    index %= N;                                                              // Teller loopt van 0 tot N-1
  }

  T Average()
  {  
    return accumulator/N;                                                    // Bereken de gemmiddelde waarde
  }
};


//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
void setup() 
{
    Serial.begin(115200);
  
 // Configuratie van ADC_0 Teensy-LC
    adc->adc0->setReference(ADC_REFERENCE::REF_EXT);                            // Selecteer de externe referentie ingang voor ADC_0
    adc->adc0->setAveraging(32);                                                // Selecteer de middeling van de gebruikte ADC
    adc->adc0->setResolution(16);                                               // Selecteerd de resolutie van de geselecteerde ADC
    adc->adc0->setConversionSpeed(ADC_CONVERSION_SPEED::HIGH_SPEED_16BITS);     // Selecteerd de conversie snelheid
    adc->adc0->setSamplingSpeed(ADC_SAMPLING_SPEED::LOW_SPEED);                 // Selecteerd de sample snelheid
    adc->adc0->recalibrate();                                                   // Kalibreeer de ADC
                
}


Filter<float> Filter_TMP37(64);
Filter<float> Filter_NTC(16); 

//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
void loop() 
{
  
  unsigned long start = micros();                                                

  //Temperatuur van de TMP37
  float sample_TMP37_RAW = (float)analogRead(A9);
  float sample_TMP37_Celcius = sample_TMP37_RAW * (2.4985/65536 / 0.02);  
  


  // Temperatuur van de NTC
  float sample_NTC_RAW = (float)analogRead(A8);
  float VRT = 2.4985 * sample_NTC_RAW / 65536.00; 
  float VR = VCC - VRT;
  float RT = VRT * R / VR; 
  float ln = log(RT / RT0);
  float TX = (1 / ((ln / B) + (1 / T0)));                                        
  float sample_NTC_Celcius = TX - 273.15;   


  // Samples toevoegen aan het filter.
  Filter_TMP37.AddSample(sample_TMP37_Celcius);
  Filter_NTC.AddSample(sample_NTC_Celcius);

  //Uitlezen resultaat filters.
  float avg_TMP37_Celcius = Filter_TMP37.Average();
  float avg_NTC_Celcius = Filter_NTC.Average();

  // Print TMP37 Temperatuur
  Serial.print("TMP37: ");
  Serial.print(avg_TMP37_Celcius, 3);                          
  Serial.print("C\t\t\t");
  
  // Print NTC Temperatuur
  Serial.print("Temperature-NTC: ");
  Serial.print(avg_NTC_Celcius, 3);                                                            // Geeft de gemeten temperatuur van de NTC sensor in beeld
  Serial.println("C");

  // Bereken code run time
  unsigned long end = micros();
  unsigned long delta = end - start;
  Serial.println(delta);

  delay(10);
}

Groet,
Bram

Waarheden zijn "Illusies waarvan men vergeten is dat het illusies zijn"

Ik zou de accumulator en de Average() wel op floats houden. Alleen de meetwaardes komt als int binnen. Het heeft geen nut en kost wel ruimte om daar dan direkt floats van te maken.

De accumulator telt een groot aantal van die meetwaarden bij elkaar, en dan wil je geen overflow.

En de Average() kan best wel met een paar cijfers achter de komma. Die raak je kwijt als je er een int van maakt.

De oorspronkelijke code had een static array:

code:


 int   meetwaardes[N];   

En die werd dus wel door de compiler op nul gezet door avr-gcc. Maar dat is idd compiler afhankelijk. Erg consequent is het allemaal niet dus je kunt beter altijd zelf voorzien in initialisatie. Dan weet je het zeker.

blackdog

Golden Member

Hi,

Ik probeer stukje bij beetje iets van de class te begrijpen, maar het volgende begrijp is dus zeker niets van...
Dit zie ik in de class staat:

c code:



  T *meetwaardes;
// en dan direct hieronder?
  T accumulator = 0;

//En weer verderop

  T Average()

Hoeveel gedaantes heeft die T eigenlijk?

Groet,
Bram

Waarheden zijn "Illusies waarvan men vergeten is dat het illusies zijn"

Beetje vreemde benadering van hardbass. Als je de ADC waarde (int) al omrekent naar temperatuur (op 3 cijfers achter de komma) voordat je gaat filteren, dan heb je niks aan een int filter. En dan heeft dit template dus ook geen nut.

Wel zou je dat template kunnen gebruiken om de lengte van de array variable te maken, maar dat is dan weer een andere methode. :)

Blackdog raakt zijn resolutie kwijt bij de declaratie van AddSample():

code:


    void AddSample(int NewSample)

Je moet hier ook het template type T (=floats) gebruiken :

code:


    void AddSample(T NewSample)

Hoeveel gedaantes heeft die T eigenlijk?

Nu wordt het wel ingewikkeld. We hebben het hier over een template. Dat is een soort mal waar je verschillende classes mee kunt definiëren.

Bovenaan staat

code:


template <class T>
class Filter 

En daarmee wordt T de naam van een type die je binnen de template kunt gebruiken. Die krijgt dan overal de waarde die je opgeeft bij het aanmaken van een object.

Dus dat wordt een float bij :

code:


Filter<float> Filter_TMP37(64);

Of int bij

code:


   Filter<int> Filter_TMP37(64);

Of byte bij

code:


   Filter<byte> Filter_TMP37(64);

Zo kan de compiler automatisch de complete class definitie aanpassen aan verschillende type variabelen want je kunt dus in alle drie gevallen dezelfde template gebruiken, ook gelijktijdig binnen 1 programma.

PS.
Bij ons op de afdeling zijn we nooit fan geworden van templates. Het klinkt wel leuk, maar debuggen is vrijwel niet te doen, en de foutmeldingen die je krijgt zijn voor veel professionele software angineers not volslagen onbegrijpelijk.

[Bericht gewijzigd door deKees op 6 juli 2020 15:42:55 (13%)]

Aah de AddSample had ik over het hoofd gezien. Dat is een beetje het probleem als je het zelf niet kan testen.

Het aantal gedaantes van T:
In principe kan T alles zijn wat de standaard reken operators ondersteund. Bijvoorbeeld: int, float, double, byte, char, unsigned long etc.

Vandaar dat ik zij laat die template nog even voor wat het is.

blackdog

Golden Member

Hi,

Tja, dat is voorlopig lastig voor mij te begrijpen, ik weet wel wat je bedoeld te zeggen dat je een sjabloon hebt die je op verschillende punten in je code kan gebruiken, als ik het daarmee goed uitleg.

Maar wat verontruster is, de code heb ik nu aangepast met de T er in, maar ik krijg fouten in de temperatuur weergave, en dat kan absoluut niet in deze calibrator tot ruim 1°C asl error t.o.v. analogSmooth...

Kan dat de oorzaak zijn van afrondings fouten?

Groet,
Bram

Waarheden zijn "Illusies waarvan men vergeten is dat het illusies zijn"
blackdog

Golden Member

Hi,

Mmmm, er was waarschijnlijk nog meer aan de hand, nu lijkt het goed te zijn met de laatste code.
Misschien een probleem met de testopstelling, de temperatuur is hier niet echt constant met steeds wel en dan weer geen zon.

Dus voor nu negeer mijn opmerking nog even betreffende de temperatuur verschillen, ik ga eerst het geheel in een doosje plaatsen op een meer stabiele plek.

Groet,
Bram

Waarheden zijn "Illusies waarvan men vergeten is dat het illusies zijn"

Als ik bijvoorbeeld een float wil gebruiken kun je het volgende doen:

Filter<float> Filter_TMP37(64);

In de class Filter vervang je alle plaatsen waar T staat voor float:

c code:


template <class T>
class Filter 
{
public:
  int N = 0;                                                                  // Aantal te middelen waarde
  float *meetwaardes;                                                             // Opslag individuele meetwaarden
  float accumulator = 0;                                                          // Optelsom van alle individuele meetwaarden
  int index = 0;                                                              // Meetwaarden teller

  Filter(const int n)
  {
    meetwaardes = new float[n];
    N = n;
    for(int i = 0; i < n; i++)
    {  
      meetwaardes[i] = 0;
    }
  }

  ~Filter()
  {
    delete[] meetwaardes;
  }

  void AddSample(float NewSample)
  {  
    accumulator -= meetwaardes[index];        
    meetwaardes[index] = NewSample;                                          // Bewaar nieuwe meetwaarde
    accumulator += meetwaardes[index];                                       // Accumuleer nieuwste meetwaarde
    index++; 
    index %= N;                                                              // Teller loopt van 0 tot N-1
  }

  float Average()
  {  
    return accumulator/N;                                                    // Bereken de gemmiddelde waarde
  }
};
blackdog

Golden Member

Hi,

Vanavond wezen testen met de PWM fuctionaliteit van de Teensy-LC.
Met deze Microcontroler kan je PWM over een groot bereik instellen, en dit geld zowel wat PWM frequentie betreft, als ook de PWM resolutie.

Deze twee eigenschappen kunnen niet helemaal los van elkaar worden ingesteld, als je een hoge resolutie wilt zoals 16Bits dan is er maximaal een PWM frequentie mogelijk van 732Hz.
Bij de Arduino Uno en de Nano is de PWM frequentie 490Hz en op de pinnen 5&6 is dit 980Hz, maar verder altijd zover ik weet 8-Bits.

Hieronder een lijstje van de keuzes die je kan maken tussen de PWM frequentie en de resolutie bij de Teensy-LC
https://www.bramcam.nl/NA/DS18B20-TMP37-Kal/PWM-Lijst-Teensy-LC.png

.
Voor uitgebreide info betreffende PWM van de Teensy controlers kan je op onderstaande link klikken.
https://www.pjrc.com/teensy/td_pulse.html

Zoals waarschijnlijk wel bekend is, hou ik van testen, dus mijn Teensy-LC controlers moesten er ook aan geloven. :-)
Als eerste had ik het voorbeeld script geladen dat drie geklerde LED's aan kan sturen, in het script stond niet vermeld dat b.v. de Teensy-LC geen PWM op poort 15 heeft. |:(
En ik maar denken dat ik een type foutje had gemaakt, of de waardes voor de PWM frequentie verkeert had in gevoerd, niets van dat alles dus, i.p.v. pin-15 pin-16 ingevoerd in de code en walla, we hadden PWM op die pin.
Daarna heb ik voor PWM op pin-3 gekozen, dit om nette metingen te kunnen doen met een scoop probe, massa en pin-3 zitten redelijk dicht bij elkaar zodat ik het "veertje" voor de massa verbinding kon gebruiken.
Dit resulteerde in nette scoop foto's zoals hieronder te zien, geen overshoot en ook geen ondershoot van betekenis.

Eerst even het hele simpel stukje code dat ik gebruikt heb om de PWM functies te testen.

c code:


/* 
                                 Test PWM Teensy LC voor PWM frequentie en Resolutie

  Bij 16 Bit resolutie vallen de onderste 3 a 4 bits weg, dit is een beetje te tunen door de opgegeven frequentie fijn in te stellen
  Bij mij lukte het bij de Teensy LC waarmee ik het teste tot twee bits van het minimum of maximum hiermee werkend te krijgen.
*/



//---------------------------------
//---------------------------------
void setup()   {                
  analogWriteFrequency(3, 732.6);       // Set frequentie PWM naar bijna 3Khz, geld voor alle PWM uitgangen

  analogWriteResolution(16);            // Steld de PWM resolutie in voor alle PWM uitgangen
}


//---------------------------------
//---------------------------------
void loop()                     
{
  analogWrite(3, 2);                   // Set minimal waarde +2 voor 16 Bit PWM in deze code
  delay(1000);
  analogWrite(3, 3);                   // Set minimal waarde +3 voor 16 Bit PWM in deze code
  delay(1000);
 }



Zoals te zien is, is het erg simpel de PWM frequentie en de resolutie in te stellen, maar zover ik dit begrepen heb geld dit dan wel voor alle PWM uitgangen tegelijk.
In de loop van de code hierboven schrijf ik iedere seconde een lage bitwaarde weg bij een 16Bits PWM resolutie.

De hier aangegeven waarden van 2 en 3Bits zijn de minimale waarden die gekozen kunnen worden, dus alleen bit-1 aanzetten gaat niet lukken.
De pulsbreedte die hier voor nodig is schijnt niet voor handen te zijn en ik denk dat dit met timing in het IC te maken heeft.
De 16Bit resolutie is wel beschikbaar maar er is door de timing een paar bit error helmaal onderin, wat mij betreft geen enkel probleem.
Trouwens dit geld ook helemaal bovenin bij bit 65534. hoe er rekening mee dat je dus bij 16 bit PWM boven en onderin een paar bits zal missen.
Bij 15Bit heb ik een enkele keer gezien dat ik iets miste, maar 14Bit is geheel zoals het tekstbboek het zegt.

De plaatjes, zodat jullie kunnen zien waarom er een paar Bits missen bij de 16Bit PWM.
Dit is dus bij een 16Bit PWM instellen met waarde 3 van de 65536 ingevoerd, pulsbreedte ongeveer 20nSec.
De gebruikte middeling tast niet de signaal vorm aan, maar verlaagt wel de ruis in het weergegeven plaatje.
https://www.bramcam.nl/NA/DS18B20-TMP37-Kal/Teensy-LC-16Bits-PWM-Bit3.png

.
En dit is bij de zelfde code maar nu met waarde 2 van de 65536 ingevoerd, pulsbreedte ongeveer 10nSec.
Als ik waarde "1" invoed blijf de uitgang laag, dat is niet zo vreemd als je naar onderstaande foto kijkt.
De puls haalt maar net de maximale 3.3V waarde.
https://www.bramcam.nl/NA/DS18B20-TMP37-Kal/Teensy-LC-16Bits-PWM-Bit2.png

Deze hoge resolutie voor de PWM heb ik helemaal niet nodig voor dit project, maar omdat dit de eerste keer is dat ik met een Teensy-LC met PWM speelde
lijk het mij wel handig even wat kennis te gaan opdoen door het en en ander te testen.
Deze controler heeft duidellijk meer mogelijkheden dan veel van de endere Arduino typen.
Er is ook nog een echte DAC uitgang van 12Bits aanwezig bij deze Teensy-LC en die ga ik misschien gebruiken om het oventje aan te sturen.
Het een en ander hangt af van jullie hulp. :+
De PID software voor de arduino staat standaard op 8Bits ingesteld, en ik heb al eens in de C files gekeken om te zien of deze waarde is aan te passen.
Maar dit komt later wel aan bod.

Voor alsnog zie ik leuke toepassingen voor de PWM en de ze controler buiten dit project.
Wel wil ik er op attenderen dat de uiteindelijke DC waarde als je b.v. deze controler voor een LAB voeding zou gaan gebruiken afhangt van de DC stabiliteit
van de voedingspanning van je controler, daar zijn natuurlijk wel oplossingen voor zoals opto couplers.
Maar hou wel rekening met de snelheid i.v.m. de pulsbreedte van 10nSec.

Zoals altijd, SHOOT!

Groet,
Bram

Waarheden zijn "Illusies waarvan men vergeten is dat het illusies zijn"
blackdog

Golden Member

Hi 575, :-)

Dank je, lijken mij twee mooie artikelen die ik later ga lezen, nu moet ik twee computers voor klanten gereed maken.
Altijd goed om voldoende achtergrond info te hebben over het soort filter/karakteristiek bij PWM signalen, daar is nog niet zo veel kennins aanwezig hier.

PID software
Wel heb ik ondertussen gevonden dat je bij de PID software in de Arduino IDE in de setup gewoon je Bitdiepte kan instellen een dit samen met een min en max waarde waartussen geregeld moet worden, b.v. bij 12 Bit : pid.SetOutputLimits(45,4090);

En ik denk dat ik de DAC van de Teensy LC hiervoor ga gebruiken, en voor dit projectje de PWM dan niet gebruik.
Voor het andere project van een oventje dat ik ook nog heb lopen, dat wordt dan wel PWM gestuurd, dan kan ik twee verschillende manieren testen.

Vandaag ik ook mijn display voor dit project binnen gekomen, het is een ILI9341 240x320 TFT.
Hierdoor heb ik hopelijk voldoende ruimte om alles weer te geven wat ik zinning vind.

Verder niet voor dit project bedoeld, maar er is ook een Teensy 4.0 binnen gekomen, wat een hele kleine krachtpatser is.
Kijken jullie maar eesn hier: https://www.pjrc.com/store/teensy40.html/

Nu weer aan het werk!

Groet,
Bram

Waarheden zijn "Illusies waarvan men vergeten is dat het illusies zijn"
blackdog

Golden Member

Hi,

Gisteren een bezoekje aan een bouwmarkt gedaan om wat O-Ringen te kopen
en te kijken of ik ook nog wat kon vinden als net dopje voor over het oventje.

De collectie O-ringen was niet om over naar huis te schrijven, wat ik wat vreemd vond omdat allerlij ander materiaal zeer ruim op voorraad was.
Ook nog even flink wat alcohol ingeslagen :-) voor desinfectie en wat buis isolatie maar beide afmetingen kwamen net niet helemaal goed uit.

Maar met een zakje O-ringen welke eigenlijk een beetje te klein zijn is het wel al goed werken betreffende het vastzetten van de twee sensoren.
Hieronder wat plaatjes van wat ik gisteren gekocht heb.

Aan het O-ringetje is te zien dat hij net wet te klein is, deze zijn 2,5mm dik en aan de buitenzijde 21mm.
De blauwe waas aan de bovenzijde is een laagje Conformal Coating om alle kiertjes daar dicht te maken.
https://www.bramcam.nl/NA/DS18B20-TMP37-Kal/DS18B20-TMP37-Kal-64.png

.
Wel lekker strak tegen het oventje aangedrukt zo.
https://www.bramcam.nl/NA/DS18B20-TMP37-Kal/DS18B20-TMP37-Kal-65.png

,
Zij aanzicht.
https://www.bramcam.nl/NA/DS18B20-TMP37-Kal/DS18B20-TMP37-Kal-66.png

.
Dit is een ge-hackt dopje er zat nog ee noring in die weer iets te groot was, dus niet bruikbaar,
maar door behalve de O-ring ook nog een ander onderdeel te verwijderen pas hij net over het oventje heen.
https://www.bramcam.nl/NA/DS18B20-TMP37-Kal/DS18B20-TMP37-Kal-67.png

.
Een klien beetje kantelen en hij past er op.
https://www.bramcam.nl/NA/DS18B20-TMP37-Kal/DS18B20-TMP37-Kal-68.png

.
De verschillende dopjes die ik nu heb, test ik uit als de oven electronica klaar is.
https://www.bramcam.nl/NA/DS18B20-TMP37-Kal/DS18B20-TMP37-Kal-69.png

Klant roept! :+

Groet,
Bram

Waarheden zijn "Illusies waarvan men vergeten is dat het illusies zijn"
blackdog

Golden Member

Hi,

Even iets anders tussendoor, ik was aan het uitzoeken welke displays ik allemaal heb.
En welke eventueel bruikbaar zou kunnen zijn voor dit projectje, de ili9341 is wel aardig maar het wegschrijven van tekst en kaders vind ik niet echt prettig op gelost in de library.
Ook is het niet een echt snelheidsmonster en veel van de wat snellere library's voor dit display werken niet met mijn Teensy LC.
Maar goed, dat onderzoek loopt dus nog, maar ik kwam een processor printje tegen wat ik niet ga gebruiken.
Jaren terug ben ik begonnen met PIC processoren en het onderstaande printje heb ik behalve een basis test verder nooit meer gebruikt.

Als iemand er intresse in heeft, dan hoor ik het wel.
Het gaat om een PICkit Demo Board met een PIC18F45K20 Chip er op.

Bovenzijde van het printje.
https://www.bramcam.nl/NA/DS18B20-TMP37-Kal/PIC-Demo-01.png

Onderzijde van het printje.
https://www.bramcam.nl/NA/DS18B20-TMP37-Kal/PIC-Demo-02.png

Alleen de verzendkosten zijn voor de krijger.

Groet,
Bram

Waarheden zijn "Illusies waarvan men vergeten is dat het illusies zijn"
Shiptronic

Golden Member

Leuk te lezen dat de O-ring oplossing werkt. :)

Wie de vraag stelt, zal met het antwoord moeten leren leven.
blackdog

Golden Member

Hi Shiptronic, :-)

Ja de ringetjes die ik nu heb zitten wat strak, maar ik heb er voldoende voor als er één stuk gaat, mooie oplossing.

Dan heb ik dit weekeinde vrij veel tijd gestoken in het uitzoeken hoe ik het een en ander op een ILI9341 scherpje plaats.
Ik ben uiteindelijk gewoon maar begonnen...

Zeer veel tijd zit er in om alees redelijk op zijn plaatst te zetten, de NTC en T-sic sensor temperaturen zijn niet echt,
dat is dummy tekst om de positie netjes te bepalen.

Ik ga de oven twee temperaturen geven die redelijk dich bij elkaar liggen en dat is 40 en 45 °C
Er is al aardig wat code nodig om dat groene kaders om de 45 °C te krijgen en om de kaders, want het zijn er twee i.v.m. de dikte die ik wou hebben,
bij de 45 °C weer weg te krijgen zonder het hele scherm te wissen.
Het hele scherm wissen is een drama, dat is wanstaltig traag.
Dus schijf ik voor de temperatuur setting die niet gebruikt wordt i.p.v. groene kaders, kaders met de kleur van de achtergrond, probleem opgelost!

Onder in het scherm staan ook de dummy waarden voor de PID controler settings.
Die ga ik instellen voor het testen met de mooie 3 voudige i2c encoder print van deKees.
Ook hier nu weer dummy waarden in het beeld.

De kleuren zijn niet echt best van deze foto, maar ik had geen zin de goede camera van mijn vriendin te pakken en van mijn eigen Sony camera was de accu leeg...
https://www.bramcam.nl/NA/DS18B20-TMP37-Kal/DS18B20-TMP37-Kal-70.png

En dit is de code, een groot deel wat je hieronder ziet is dus voor de tekst die op beeld staat.
Ik heb zoveel mogelijk van de tekst, lijnen en kaders in de setup gezet.

De tekst "Oven Not Ready" moet ik nog zo maken dat deze alleen geschreven wordt als er een verandering is in de code, dus als de oven op temperatuur is
wordt maar één keer "Oven Ready" geschreven en omgekeerd als de temperatuur nog niet bereikt is.
Schijven naar het scherm is duur in tijd...

De code welke ik als laatste heb opgeslagen, kunnen jullie zien hoe ik het een en ander aan elkaar frut.
De code is nog niet voldoende van opmerkingen voorzien, dat komt nog.

c code:


#include "SPI.h"
#include "Adafruit_GFX.h"
#include "Adafruit_ILI9341.h"
#include <PID_v1.h>



// Extra fonts voor het display
#include <Fonts/FreeSans9pt7b.h>
#include <Fonts/FreeSerif9pt7b.h>
#include <Fonts/FreeMono9pt7b.h>

//Adafruit_ILI9341 tft = Adafruit_ILI9341(TFT_CS-10, TFT_DC-9, TFT_MOSI-11, TFT_CLK-13, TFT_RST-8, TFT_MISO-12);
Adafruit_ILI9341 tft = Adafruit_ILI9341(10, 9, 11, 13, 8, 12);


// Variabelen nodig voor het selecteren van de Referentie Temperatuur
const int T_buttonpin = 2;                                                  // the number of the pushbutton pin
const int T_Output = 3;                                                     // the number of the LED pin

int T_range = LOW;                                                          // the current state of the output pin
int buttonState;                                                            // the current reading from the input pin
int lastButtonState = LOW;                                                  // the previous reading from the input pin

unsigned long lastDebounceTime = 0;                                         // the last time the output pin was toggled
unsigned long debounceDelay = 10;                                           // the debounce time; increase if the output flickers
// * Variabelen nodig voor het selecteren van de Referentie Temperatuur




// -------------------------------------------------------------------------
// -------------------------------------------------------------------------
void setup() {
  Serial.begin(9600);
  
  SPI.begin();
  SPI.setClockDivider(SPI_CLOCK_DIV2);
   
  tft.begin();
  tft.setRotation(1); // Horizontaal
  tft.fillScreen(ILI9341_BLACK);

// Lijnen en kaders

     tft.fillRect(0, 75, 320, 58, 0x001F);
     tft.drawLine(0, 22, 320, 22, ILI9341_GREEN);
     tft.drawLine(0, 43, 320, 43, ILI9341_GREEN);
     tft.drawLine(0, 75, 320, 75, ILI9341_WHITE);
     tft.drawLine(0, 132, 320, 132, ILI9341_WHITE);
     
// * Lijnen en kaders


// Tekst die altijd in beeld staat
     tft.setFont(&FreeSans9pt7b);
     tft.setTextColor(0x03EF);  tft.setTextSize(0);

     tft.setCursor(80, 16);
     tft.println("NA-TMP-cal   V1.0");
    
     tft.setCursor(33, 38);
     tft.setTextColor(ILI9341_WHITE); tft.setTextSize(1);
     tft.println("Temperature Sensor Calibrator");

     tft.setTextColor(ILI9341_GREEN);  tft.setTextSize(1);
     tft.setCursor(10, 65);
     tft.println("Set Temperature:");

     tft.setCursor(171, 66);
     tft.setTextColor(ILI9341_WHITE); tft.setTextSize(1);
     tft.println(40);

     tft.setCursor(240, 66);
     tft.setTextColor(ILI9341_WHITE); tft.setTextSize(1);
     tft.println(45);

     // Set Celcius karakter op het scherm voor temp-40
     tft.fillCircle(196, 56, 2, 0xFFFF); 
     tft.setCursor(200, 66);
     tft.println("C");

     // Set Celcius karakter op het scherm voor temp-45
     tft.fillCircle(265, 56, 2, 0xFFFF); 
     tft.setCursor(269, 66);
     tft.println("C");

     // Plaats tekst voor de oven sensoren op het scherm
     
     // Set de tekst op beeld de oven NTC
     tft.fillCircle(114, 113, 2, 0xFFFF);
     tft.setCursor(5, 123);
     tft.setTextColor(ILI9341_WHITE); tft.setTextSize(1);
     tft.println("NTC: 40,564  C");
    
     // Set de tekst op beeld de oven T-SIC sensor
     tft.fillCircle(299, 113, 2, 0xFFFF);
     tft.setCursor(180, 123);
     tft.setTextColor(ILI9341_WHITE); tft.setTextSize(1);
     tft.println("T-SIC: 40,561  C");






     // Set de tekst op beeld voor de P waarde
     tft.setCursor(0, 235);
     tft.setTextColor(ILI9341_WHITE); tft.setTextSize(1);
     tft.println("P = 900");

     // Set de tekst op beeld voor de I waarde
     tft.setCursor(130, 235);
     tft.setTextColor(ILI9341_WHITE); tft.setTextSize(1);
     tft.println("i = 160");

     // Set de tekst op beeld voor de D waarde
     tft.setCursor(250, 235);
     tft.setTextColor(ILI9341_WHITE); tft.setTextSize(1);
     tft.println("D = 240");
     
// * Tekst die altijd in beeld staat

// Variabelen drukknop voor het selecteren van de Referentie temperatuur
    pinMode(T_buttonpin, INPUT);
    pinMode(T_Output, OUTPUT);

    // set initial LED state
    digitalWrite(T_Output, T_range);

// * Variabelen drukknop voor het selecteren van de Referentie temperatuur
    
}


// -------------------------------------------------------------------------
// -------------------------------------------------------------------------
void loop(){

  // Lees Button uit sectie
    int reading = digitalRead(T_buttonpin);
    if (reading != lastButtonState) {
    lastDebounceTime = millis();
  }

    if ((millis() - lastDebounceTime) > debounceDelay) {
    if (reading != buttonState) {
    buttonState = reading;
        if (buttonState == HIGH) {
        T_range = !T_range;
      }
    }
  }

 // set de digitale uitgang:
  digitalWrite(T_Output, T_range);

  // save the reading. Next time through the loop, it'll be the lastButtonState:
  lastButtonState = reading;

  // * Lees Button uit sectie




// Plaatst kader om de gekozen temperatuur waarde.

  if (T_range == 0) {
     tft.drawRoundRect(237, 49, 49, 22, 3, ILI9341_BLACK);                           // Overschrijft groene kader met zwart van 45C
     tft.drawRoundRect(236, 48, 51, 24, 4, ILI9341_BLACK);                           // Overschrijft groene kader met zwart van 45C
     tft.drawRoundRect(168, 49, 49, 22, 3, ILI9341_GREEN);                           // Plaatst groene kader om de waarde 40C
     tft.drawRoundRect(167, 48, 51, 24, 4, ILI9341_GREEN);                           // Plaatst groene kader om de waarde 40C
  }
  else {
     tft.drawRoundRect(168, 49, 49, 22, 3, ILI9341_BLACK);                           // Overschrijft groene kader met zwart van 40C
     tft.drawRoundRect(167, 48, 51, 24, 4, ILI9341_BLACK);                           // Overschrijft groene kader met zwart van 40C
     tft.drawRoundRect(237, 49, 49, 22, 3, ILI9341_GREEN);                           // Plaatst groene kader om de waarde 45C
     tft.drawRoundRect(236, 48, 51, 24, 4, ILI9341_GREEN);                           // Plaatst groene kader om de waarde 45C
  }


//      tft.fillRoundRect(83, 79, 145, 21, 4, ILI9341_RED);
      tft.setCursor(90, 93);
      tft.setTextColor(ILI9341_YELLOW); tft.setTextSize(1);
      tft.println("Oven Not Ready");

 Serial.println(T_range);

delay(3);

  
}

Groet,
Bram

Waarheden zijn "Illusies waarvan men vergeten is dat het illusies zijn"

Ik heb ook wel eens wat met dat soort schermpjes gespeeld en kwam er toen ook achter dat ze inderdaad heel erg traag zijn. Toen had ik dat gestoken op de Arduino. Ik weet niet hoe snellere processoren hier mee omgaan. Gebruikte jij nou de Teensy of nog steeds een Arduino?

blackdog

Golden Member

Hi hardbass,

Ik gebruik voor dit project de Teensy LC, dat is een van de goedkopere maar een stuk sneller dan een Arduino UNO of NANO.

Ik heb er voor gekozen het nu met dit display te doen, samen met wat trucjes om het sneller te laten werken.
Ook heb ik i.v.m. de tijd die het mij kost besloten de grafische opbouw simpel te houden.
Ik had veel meer in mijn hoofd hoe het er uit zou moeten zien maar dat kost te veel tijd of anders een Teensy-4 die zeer snel is en ook hier naast mij ligt.

Door de tijd en mijn gebrekkige codeer eigenschappen, zal ik steeds moeten hakken wat ik allemaal wil, het zij zo! ;)

Nu weer even bezich geweest met het schema voor het aansturen van het oventje, dat is Teensy-LC opamps stroombron en geschakelde LM317
die de voeding voor de oven naar beneden brengt als hij is opgewarmd, dus als het oventje 38°C is, gaat de voeding voor de oven van 12V naar iets van 7,5V.

Deze print wordt voorzien van de test setup voor dit oventje, als alles verder goed werkt zijn de drie encoders niet meer nodig,
de PID waarden komen dan vast in de code te staan.
Waar de NANO op het printje ligt komt ongeveer de TEENSY-LC microcontroler, de vrije ruimte rechts komt een klein koelelement met een LM317 regelaar.
De drie encoder print is door deKees ontworpen en kan ik dus mooi gebruiken voor het testen van de code, een van de schakelaars gaat dan gebruikt worden
voor het omschakelen van de oven temperatuur, voorlopig tussen 40 en 45°C
https://www.bramcam.nl/NA/DS18B20-TMP37-Kal/DS18B20-TMP37-Kal-71.png

.
Om te laten zien hoe klien de Teensy-4 is heb ik hem naast de print neer gelegd, deze komt niet in dit project.
https://www.bramcam.nl/NA/DS18B20-TMP37-Kal/DS18B20-TMP37-Kal-72.png

.
Ik heb met een loep gekeken, de afwerking van de Teensy printjes is perfect!
https://www.bramcam.nl/NA/DS18B20-TMP37-Kal/DS18B20-TMP37-Kal-73.png

Terug naar het tekenwerk!

Groet,
BRam

Waarheden zijn "Illusies waarvan men vergeten is dat het illusies zijn"
blackdog

Golden Member

Hi,

Tja, was wat druk met ondermeer uitzoekwerk voor een klant, ja weer VLAN problemen, maar niet die van een paar jaar geleden, dat is getackkeld.
Nu was het de VLAN performance van de apparatuur die ik had wat soms triest was en soms weer niet, dus daarom wat minder posts van mij .

Terug on topic
Daar ik meerdere schakelaar nodig had met een tokkel functie waren het toch wel aardig wat code regels en onoverzichtelijk voor mij.
Dus ben ik gaan spelen met verschillende "Button" Library's om te kijken wat mij het beste aanspreekt.

Uiteindelijk ben ik bij de Library van Jack Christensen uitgekomen waarmee je heel helder (voor mij) schakelaar functies kan toepassen in je code.
Hier de URL van de door mij gekozen Library: https://github.com/JChristensen/JC_Button

Er zit in de Library veel meer dan dat ik voor mijn functies nodig heb en de Library verbruikt voor mijn processor niet te veel geheugen, ik ben er blij mee.

Hier is de code toegepast

c code:


#include "SPI.h"
#include "Adafruit_GFX.h"
#include "Adafruit_ILI9341.h"
#include <PID_v1.h>

#include <JC_Button.h>          // https://github.com/JChristensen/JC_Button


// Extra fonts voor het display
#include <Fonts/FreeSans9pt7b.h>
#include <Fonts/FreeSerif9pt7b.h>
#include <Fonts/FreeMono9pt7b.h>

//Adafruit_ILI9341 tft = Adafruit_ILI9341(TFT_CS-10, TFT_DC-9, TFT_MOSI-11, TFT_CLK-13, TFT_RST-8, TFT_MISO-12);
Adafruit_ILI9341 tft = Adafruit_ILI9341(10, 9, 11, 13, 8, 12);


// Button variabelen nodig voor het selecteren van de Referentie Temperatuur(40 of 45C) en van de Sensor voedingspanning, +3.3V of +5.0V
const byte
    BUTTON1_PIN(1),             // 40C or 45C Oven temperatuur        Connect a button switch from this pin to ground, internal pull up
    BUTTON2_PIN(2),             // 3.3V or 5V Sensor power supply     Connect a button switch from this pin to ground, internal pull up
    BUTTON3_PIN(3),             // Extra                              Connect a button switch from this pin to ground, internal pull up
    
    LED1_PIN(4),          // Output is "High" when On
    LED2_PIN(5),          // Output is "High" when On
    LED3_PIN(6);          // Output is "High" when On, Extra

ToggleButton                    // define the buttons
    btn1(BUTTON1_PIN),          // this button's initial state is off
    btn2(BUTTON2_PIN),          // this button's initial state is off
    btn3(BUTTON3_PIN, true);    // this button's initial state is on, for now not in use...
// *  Button variabelen nodig voor het selecteren van de Referentie Temperatuur(40 of 45C) en van de Sensor voedingspanning, +3.3V of +5.0V






// -------------------------------------------------------------------------
// -------------------------------------------------------------------------
void setup() {
  Serial.begin(9600);
  
  SPI.begin();
  SPI.setClockDivider(SPI_CLOCK_DIV2);
   
  tft.begin();
  tft.setRotation(1); // Horizontaal
  tft.fillScreen(ILI9341_BLACK);

// Lijnen en kaders

     tft.fillRect(0, 75, 320, 58, 0x001F);
     tft.drawLine(0, 22, 320, 22, ILI9341_GREEN);
     tft.drawLine(0, 43, 320, 43, ILI9341_GREEN);
     tft.drawLine(0, 75, 320, 75, ILI9341_WHITE);
     tft.drawLine(0, 132, 320, 132, ILI9341_WHITE);
     
// * Lijnen en kaders


// Tekst die altijd in beeld staat
     tft.setFont(&FreeSans9pt7b);
     tft.setTextColor(0x03EF);  tft.setTextSize(0);

     tft.setCursor(80, 16);
     tft.println("NA-TMP-cal   V1.0");
    
     tft.setCursor(33, 38);
     tft.setTextColor(ILI9341_WHITE); tft.setTextSize(1);
     tft.println("Temperature Sensor Calibrator");

     tft.setTextColor(ILI9341_GREEN);  tft.setTextSize(1);
     tft.setCursor(10, 65);
     tft.println("Set Temperature:");

     tft.setCursor(171, 66);
     tft.setTextColor(ILI9341_WHITE); tft.setTextSize(1);
     tft.println(40);

     tft.setCursor(240, 66);
     tft.setTextColor(ILI9341_WHITE); tft.setTextSize(1);
     tft.println(45);

     // Set Celcius karakter op het scherm voor temp-40
     tft.fillCircle(196, 56, 2, 0xFFFF); 
     tft.setCursor(200, 66);
     tft.println("C");

     // Set Celcius karakter op het scherm voor temp-45
     tft.fillCircle(265, 56, 2, 0xFFFF); 
     tft.setCursor(269, 66);
     tft.println("C");

    // Plaats tekst voor de oven sensoren op het scherm
     
     // Set de tekst op beeld de oven NTC
     tft.fillCircle(114, 113, 2, 0xFFFF);
     tft.setCursor(5, 123);
     tft.setTextColor(ILI9341_WHITE); tft.setTextSize(1);
     tft.println("NTC: 40,564  C");
    
     // Set de tekst op beeld de oven T-SIC sensor
     tft.fillCircle(299, 113, 2, 0xFFFF);
     tft.setCursor(180, 123);
     tft.setTextColor(ILI9341_WHITE); tft.setTextSize(1);
     tft.println("T-SIC: 40,561  C");


     // Set de tekst op beeld voor de P waarde
     tft.setCursor(0, 235);
     tft.setTextColor(ILI9341_WHITE); tft.setTextSize(1);
     tft.println("P = 900");

     // Set de tekst op beeld voor de I waarde
     tft.setCursor(130, 235);
     tft.setTextColor(ILI9341_WHITE); tft.setTextSize(1);
     tft.println("i = 160");

     // Set de tekst op beeld voor de D waarde
     tft.setCursor(250, 235);
     tft.setTextColor(ILI9341_WHITE); tft.setTextSize(1);
     tft.println("D = 240");
     
// * Tekst die altijd in beeld staat


//  Initialize the button objects
    btn1.begin();
    btn2.begin();
    btn3.begin();
    
    // set the LED pins as outputs
    pinMode(LED1_PIN, OUTPUT);
    pinMode(LED2_PIN, OUTPUT);
    pinMode(LED3_PIN, OUTPUT);
    
    // show the initial states
    digitalWrite(LED1_PIN, btn1.toggleState());
    digitalWrite(LED2_PIN, btn2.toggleState());
    digitalWrite(LED3_PIN, btn3.toggleState());
// * Initialize the button objects

}


// -------------------------------------------------------------------------
// -------------------------------------------------------------------------
void loop(){
    // read the buttons
    btn1.read();
    btn2.read();
    btn3.read();

    // if button state changed, update the LEDs
    if (btn1.changed()) digitalWrite(LED1_PIN, btn1.toggleState());
    if (btn2.changed()) digitalWrite(LED2_PIN, btn2.toggleState());
    if (btn3.changed()) digitalWrite(LED3_PIN, btn3.toggleState());

//  tijdelijke debug serial commands
 Serial.print("Drukknop-1   ");  Serial.println(btn1.toggleState());
 Serial.print("Drukknop-2   ");  Serial.println(btn2.toggleState());
 Serial.print("Drukknop-3   ");  Serial.println(btn3.toggleState());
// * tijdelijke debug serial commands



//-------------------------------------------------------------------------------------------
//-------------------------------------------------------------------------------------------


//-------------------------------------------------------------------------------------------
//-------------------------------------------------------------------------------------------


// Plaatst kader om de gekozen temperatuur waarde.
  if ((btn1.toggleState()) == 0) {                                     Hier wordt de de eerst drukknop uitgelezen voor het plaatsen van het kader om de temperatuur setting
     tft.drawRoundRect(237, 49, 49, 22, 3, ILI9341_BLACK);                           // Overschrijft groene kader met zwart van 45C
     tft.drawRoundRect(236, 48, 51, 24, 4, ILI9341_BLACK);                           // Overschrijft groene kader met zwart van 45C
     tft.drawRoundRect(168, 49, 49, 22, 3, ILI9341_GREEN);                           // Plaatst groene kader om de waarde 40C
     tft.drawRoundRect(167, 48, 51, 24, 4, ILI9341_GREEN);                           // Plaatst groene kader om de waarde 40C
  }
  else {
     tft.drawRoundRect(168, 49, 49, 22, 3, ILI9341_BLACK);                           // Overschrijft groene kader met zwart van 40C
     tft.drawRoundRect(167, 48, 51, 24, 4, ILI9341_BLACK);                           // Overschrijft groene kader met zwart van 40C
     tft.drawRoundRect(237, 49, 49, 22, 3, ILI9341_GREEN);                           // Plaatst groene kader om de waarde 45C
     tft.drawRoundRect(236, 48, 51, 24, 4, ILI9341_GREEN);                           // Plaatst groene kader om de waarde 45C
  }
// * Plaatst kader om de gekozen temperatuur waarde.

//    tft.fillRoundRect(83, 79, 145, 21, 4, ILI9341_RED);
      tft.setCursor(90, 93);
      tft.setTextColor(ILI9341_YELLOW); tft.setTextSize(1);
      tft.println("Oven Not Ready");



}

Verder hab ik nog aan het schema gewerkt voor het aansturen van de oven en het schakelen van de LM317.
In de "Pre Heat" stand krijgt de oven ongeveer 12V en als de oven drie °C onder de gekozen referentie temperatuur is aangekomen gaat de voeding
van de oven naar ongeveer 7,5V of wat na metingen de beste temperatuur blijkt.
https://www.bramcam.nl/NA/DS18B20-TMP37-Kal/DS18B20-TMP37-Kal-74.png

De voeding spanningen heb ik instelbaar gemaakt met trimpots.
Q3 de 2N2222a is daar op die plek speciaal gekozen i.v.m. zijn lage verzadigings spanning.
Ik heb geen kleine MOSFet die met 3.3V gate spanning goed werkt, vandaar deze transistor oplossing.

De Teensy LC die ik dus gebruik voor dit project heeft een echte DAC uitgang die de hier getoonde opamp ingang gaat aansturen zoals ik al eerder aangaf.

Er zijn twee LDO regelaars bijgeplaatst een 3V3 en een 5V die de 5V voed de opamp en de 3V3 LDO.
Bij de lage belasting in deze schakeling is de variatie van de 5V minimaal als de hoofdvoeding van 12V naar 7.5V.

Zoals altijd, laters meer...

Groet,
Bram

Waarheden zijn "Illusies waarvan men vergeten is dat het illusies zijn"
blackdog

Golden Member

Hi,

Even snel tussendoor het laatste schema van de Teensy Controler.
Kunnen jullie nog blunders zien?

https://www.bramcam.nl/NA/DS18B20-TMP37-Kal/DS18B20-TMP37-Kal-75-Klein.png

Verder loop ik vast bij het gebruik van de i2c print en software van deKees, dat moet ik goed voorbereiden en daar is nu even geen tijd voor.
Bij het laden van de deKees software vallen delen van mijn code uit enz, maar straks meer hierover.

Dank vast voor het kijken hiernaar.

Groet,
Bram

Waarheden zijn "Illusies waarvan men vergeten is dat het illusies zijn"

Q1 een pull up geven ? Theoretisch kan nu de analoge sensor voeding kort 5V zijn zolang Q1 niet aangestuurd word. Een 5V sensor kan wel tegen 3.3V, omgekeerd is niet altijd het geval.

It's the rule that you live by and die for It's the one thing you can't deny Even though you don't know what the price is. It is justified.

En een pull-up aan de /CS van het spi tft, anders is die tijdens opstarten ongedefinieerd.

Arco - "Simplicity is a prerequisite for reliability" - hard en software ontwikkeling: www.arcovox.com
blackdog

Golden Member

Hi Roland,

Ik had bij mijn schema nog niet alle afwegingen vermeld, dat zal ik nu doen.

De LM317 welke VR2 wordt genoemd levert 7,7V of 12V voor de oven VR1 en ok voor de LF50 regelaar.
De uitgang van de LF50 regelaar is schoon en blijft dat ook vrij goed omdat de Teensy LC een 3.3V regelaar voor de processor on board heeft.

Daarom wordt de oven sensor TSIC-506 ook uit de LF50 gevoed.
Ook de 3.3V voor het display komt uit de regelaar op de Teensy LC, het grootste verbruik is statisch en dat is van de display LED's.

De te meten temperartuur sensoren hebben hun eigen LM317, welke eventueel nog een TL317 wordt, moet nog wat metingen hier aan doen om te bepalen of dit zinning is.
Beide type te kalibreren sensoren worden gezamelijk omgeschakeld wat voedingspanning betreft.
Dit heb ik aangebracht om te kunnen meten in hoeverre de te kalibreren sensoren gevoelig zijn voor variaties van de voeding spanning.

De twee 2N2222A transistoren zitten mij nog steeds niet lekker, ik heb als ik het mij goed herrinner nog wat kleine TO92 MOSFets die logic level zijn.
Ik zal zo weer een zoekopdracht gaan doen bij Farnell. :-)

Arco
Ik heb de Pull Up weerstand in het schema getekend, dit is de eerste keer dat ik dit hoor of zie.
Maar ik heb wel een paar keer gehad dat het geheel in een vreemde toestand kwam, misschien wel door het ontbreken van de pull up.

Pinnummers Teensy LCNog wat foutjes er uit gehaald wat nummering betreft, maar dat controleer ik later nog een keer.
Ik heb met opset de meeste van de pinummers zo gekozen dat ze alkaar zo min mogelijk storen.
Dus de pinnummers zijn nog niet helemaal goed ingedeeld, er mag geen snel schakelende datalijn zoals de CLK van het display naast een analoge ingang zitten.
Daar voldoe ik nog niet helemaal aan, denk dat ik een Excel lijstje ga maken van de Teensy LC pinnummers met hun functie er naast, dat lijkt mij makkelijk voor het overzicht.

Het schema is alweer aangepast, er zijn aan de onderzijde de drukknopjes geplaatst en de digitale uitgangen als ik die nog zou gaan gebruiken.
Verder heb ik een MOSFet gevonden in TO92 uitvoering die goed genoeg werkt bij 3.3V gatespanning (neem ik aan volgens de datasheet)

Schema is weer klikbaar voor een grotere versie.
https://www.bramcam.nl/NA/DS18B20-TMP37-Kal/DS18B20-TMP37-Kal-76-Klein.png

Onderdelen zijn besteld en dan nu de Excel lijst voor de Teensy LC pinnummers maken.

Dank voor het meekijken!
Bram

Waarheden zijn "Illusies waarvan men vergeten is dat het illusies zijn"

Wel eerder genoemd, maar niet in schema:
ontkoppel-C over TSIC
pull-up voor de NTC

blackdog

Golden Member

Hi 575, :-)

Voor beide ben je correct, de pull up voor de NTC ben ik gewoon tot 2x aan toe vergeten te tekenen,
gisteren dacht ik nog aan welk punt zal ik hem hangen en het was net zo snel weer uit mijn brein als dat het omhoog kwam *grin*.

Da nwat de TSIC betreft, ja ik herrinner het me dat je dat gezecht hebt, en ik ben vergeten uit te leggen dat die condensator er echt al in zit,
kijk hier maar eens: http://www.bramcam.nl/NA/DS18B20-TMP37-Kal/DS18B20-TMP37-Kal-07.png

Ik zal hem in ieder geval in het schema er bij zetten, want dat is wel de bedoeling!
Ik heb nog meer vergeten te tekenen in het schema, daar ben ik nu mee bezig, dat is de LT1019 2.5V referentie met zijn ontkoppeling.
Die ben ik nu aan het tekenen dus aan het einde van de avond weer een schema update.

Dank weer voor de opmerkingen.

Groet,
Bram

Waarheden zijn "Illusies waarvan men vergeten is dat het illusies zijn"