Arduino oven controller Versie 1.0

blackdog

Golden Member

Hi!

Langzamerhand begint het een beetje vorm te krijgen...
Dan heb ik het over hoe ik mijn dubbele oven wil gaan uitvoeren wat het aansturen van de oven betreft.

Om nu wat ervaring op te doen met de tijdconstanten die aanwezig zijn wou ik eerst simpel beginnen en heb besloten een 50-Watt weerstand te gaan gebruiken als "testoven".

Dit is een plaatje van de sensoren die ik op de weerstand heb gemonteerd.
De linker sensor is een TMP37 van Analog Devices en geeft 20mV/C,
dit samen met de Arduino interne referentie van bij mij 1,0734V geeft een bitwaarde van iets meer dan 1mV.
Wat weer resulteerd in een resolutie van 0,02C.
De rechter sensor is een precisie NTC van 5K, deze gebruik ik omdat de KeySight 34461A multimeter die direct in C kan weergeven en ook grafiekjes kan schrijven.
Hierdoor kan ik hopelijk zien hoe goed de regeling gaat worden.
http://www.bramcam.nl/Arduino/Testoven/TestOven-01.png

Dit is de testsetup, een mooi groen display, met hierop wat waarden en die zal ik even uitleggen.
Linksboven op de eerste regel is de ruwe bitwaarde van de analoge innput die ik gebruik voor de TMP37 sensor, handig tijdens het ontwikkelen.
Rechts op de zelfde regel, de temperatuur nadat deze berekend is door de software, zien jullie ook het Celsius teken ;-)
De tweede regel begint met een "O" wat staat voor de Oven controler en de uitgang is hier laag en in het display aangegeven met "Off" En zichtbaar omdat de rode LED uit is.
PH betekend "Pre-Heath" en de status is "On" omdat de gemeten temperatuur zich beneden de ingestelde 26,5C bevind.

Er zitten hier nog twee sensoren op het breadboard maar vergeet deze maar, als ik ga testen met de weerstadn zitten deze er niet meer op.
Ook is er een 4K7 weerstand zichtbaar die naar de analoge ingang-7 gaat, hiermee heb ik nog een mogelijkheid om met een condensator wat te filteren aan de ingang van de Arduino.
http://www.bramcam.nl/Arduino/Testoven/TestOven-02.png

De uitgang die de rode LED aanstuurd gaat ook een "Low Level" fet aansturen via een netwerkje van wat weerstanden diode en een condensator.
Het komt er op neer dat de condensator van de Gate naar ground langzamer geladen gaat worden dan als de uitgangs zeg "0" wordt van de Arduino als de temperatuur bereikt is.
Met een diode en weerstand in serie maak ik het ontlaad proces van deze condensator sneller, hierdoor ontstaat er minder overshoot van de temperatuur bij het opwarmen.
Later laat ik schema hier van zien, nu te gaar om dit schema verder af te werken deze avond, omdat ik ook nu nog wat wil laten zien hoe ik de code heb gemaakt.
Ik heb mijn best gedaan wat ik tot nu toe heb geleerd toe te passen en het is aan jullie mij even de oren te wassen *grin*

Hier de al redelijk opgeschoonde code...

c code:

#include <Wire.h>
#include <LCD.h>
#include <LiquidCrystal_I2C.h>

LiquidCrystal_I2C  lcd(0x27,2,1,0,4,5,6,7);         // 0x27 is the I2C bus address for an unmodified backpack of a PCF8574

float temp;                                         // Variabelen nodig voor het middelen van een analoge temperatuur meting
float adcTemp = 0;
float uref = 1.0734;
float tempA;

word i = 0;
unsigned long tempReading;

const byte tempPin = 7;
const word smpl = 100;
const float setOven = 29.50;
const float preHeath = 26.50;


void setup() {
  Wire.begin();
  Serial.begin(9600);
  
  analogReference(INTERNAL);           // Maakt gebruikt van de interne referentie spanning van de gebruikte Arduino Nano (gemeten spanning 1.0734V)

  pinMode(10, OUTPUT);                 // Maakt van pin-10 een uitgang
  pinMode(11, OUTPUT);                 // Maakt van pin-11 een uitgang

  lcd.begin (16,2);                    // Steld het type LCD in: 16 x 2, met de achtergrond verlichting "aan"
  lcd.setBacklightPin(3,POSITIVE);                
  lcd.setBacklight(HIGH);              // Zet de achtergrondverlichting van het display aan
  
  digitalWrite(10, LOW);               // Startwaarde uitgang 10, "uit" de ingestelde temperatuur is nog niet bereikt
  digitalWrite(11, HIGH);              // Startwaarde uitgang 11, "aan" de ingestelde temperatuur voor de "preheat" is nog niet bereikt en de uitgang is hierom hoog
}

void loop (){

  for(int i = 0; i < smpl; i++)        // Hier wordt de analoge ingang (7) "x" gemeten, x = de variabele "smpl"
  {
  tempReading += analogRead(7);
  delay(1);
  }
  
  adcTemp = tempReading / smpl;       // Deelt de som van de metingen door het aantal samples "smpl"
                                       
  tempA = adcTemp * (uref/1024.0);    // Verrekend de verwerkte samples met de referentie spanning en de bitwaarde van de ADC converter
  temp = tempA / 0.02;                // Berekend de Temperatuur van de TMP37 Sensor met de 20mV/C gevoeligheid van de sensor, de variabel "temp" geeft nu de temperatuur aan in Celsius.


  if (temp > setOven) {               // Deze vergelijking kijkt of de oventemperatuur al is bereikt, als dit zo is, dan wordt uitgang "10" low en wordt de verwarming afgeschakeld
     digitalWrite(10, HIGH);
     lcd.setCursor (0,1);                           
     lcd.print("O = On "); 
   } else {
     digitalWrite(10, LOW);
     lcd.setCursor (0,1);                           
     lcd.print("O = Off");
   }

  if (temp > preHeath) {              // Deze vergelijking kijkt of de "preheath" temperatuur al is bereikt, als dit zo is, dan wordt uitgang "11" low en worden de verwarmings elementen in serie geschakeld
     digitalWrite(11, LOW);
     lcd.setCursor (8,1);                           
     lcd.print("PH = Off "); 
   } else {
     digitalWrite(11, HIGH);
     lcd.setCursor (8,1);                           
     lcd.print("PH = On ");
   }

  lcd.setCursor (8,0);                // Plaatst de temperatuur van de oven op positie "8 op regel "0"
  lcd.print(temp);
  lcd.print((char)223);               // Plaatst het "°C" achter de temperatuurwaarde
  lcd.print("C");
  
  lcd.setCursor (0,0);                // Plaatst de RAW waarde van de ADC op positie "0" op regel "1", handig tijdens het ontwikkelen
  lcd.print(analogRead(7));                                                    


  Serial.println(adcTemp);

  adcTemp = 0;
  tempReading = 0;

//  lcd.setCursor (0,0);              // Plaatst aantal gebruikte samples van de analoge meting op LCD scherm, handig tijdens het ontwikkelen
//  lcd.print(adcTemp);                   

delay(1);
}

Nog niet alles staat hier in de variabelen aangegeven zoals het aantal mV van de gebruikte sensor, deze staat nu nog als vaste waarde van 0.02 in de code.
Er zijn nog wat variaben die ik iets anders wil noemen voor de duidelijkheid, maar dat doe ik waarschijnlijk morgen, hangt van mijn werk af :-)
Ik hoor graag van jullie waar ik zaken moet aanpassen of meer netjes oplossen in de code.

Bedankt en gegroet,
Blackdog

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

Op 4 oktober 2016 23:02:47 schreef blackdog:

dit samen met de Arduino interne referentie van bij mij 1,0734V geeft een bitwaarde van iets meer dan 1mV.

Volgens het datasheet is dat 1.1V +/- 10%. Dus dit is prima binnen spec. Maar wat het datasheet niet vermeldt, is waar dit allemaal van afhangt. IK gok dat er een belangrijke temperatuurafhankelijkheid in zit.
(Ik ben in princiepe over op STM32. Dan heb ik 4096 stapjes tot 3.3V... Als ik dan een NCP1117-3.3 gebruik, dan zit daar behoorlijk wat variatie in, maar als ik een MCP1703 gebruik, is dat heel lekker nauwkeurig 3.3V).

four NANDS do make a NOR . Kijk ook eens in onze shop: http://www.bitwizard.nl/shop/

Ziet er redelijk uit. ;)
Waarom delay(1)?

blackdog

Golden Member

Morge rew, René,

rew, vooralsnog gebruik ik de interne referentie, de problemen met de referentie spanning en de voedingspanning zijn mij bekent van de microcontrolers.

Ik had in een ander topic al aangegeven dat het goed mogelijk is een TL317 (bij 5V voeding) te gebruiken als 1,23V referentie. (low cost)
Verder natuurlijk de LM385 en nog beter de LT1004 1,23V referenties.

Maar wat meer problematisch is, is het volgende: de zeer dunne massa banen op de Arduino Nano en de slechte ontkoppeling, er is geen enkel elcotje te bekennen.
Dus aan de hand van het schema en printtekening ga ik dat een beetje aanpassen.

Er is voor de dit deel wat ik hier laat zien geen hoge precisie nodig, maar gebruik de testschakeling wel om ervaring op te doen met de analoge ingangen van de Arduino.

Het middelen zoals ik de code gedaan wordt werk zover ik het getest heb goed en haal alsnog een goede meetsnelheid.
De loop tijdconstante wil ik grotendeel buiten de microcontroler doen met de filtering aan de Gate van de Power Fet.
De software filtering met de variabele "smpl" zorgt er dan voor dat dit signaal jitter vrij is en het externe filter voor de loop stabiliteit.
Deze staat op het ogenblik in de code die ik hier liet zien op 100 samples, dit kan waarschijlijk 50 worden omdat het "Gate Filter" hier ook nog bij helpt.

Dit zijn even aannames van hoe ik het wil gaan regelen, als het goed is komt vandaag of morgen een aantal buisjes binnen met een dikkere wanddikte van 5mm.
Hier kan ik dan mijn sensoren "in" boren voor een zeer goede koppeling, uit ervaring kan ik jullie zeggen dat dit eeen zeer groot deel van de loop problemen oplost.
Dat maakt mijn oventjes ook "snel" ;-)
Het nadeel van de 5mm wanddikte is weer de grotere thermische massa.

Maar als eerste als ik vandaag wat tijd over heb, de Arduino regeling testen met de powerweerstand om ervaring op te doen met deze opgevoerde Bang Bang controler.

René,
Die delay gaat er gewoon uit, net als nog wat fouten in de omschrijvingen zoals positie 8 wat 9 moet zijn.
De waarden voor de ovens staan ook nog niet goed in de weergegeven code, dit zal voor de PreHeath ongeveer 39C worden en voor de oven temperatuur 42C.
De waarden die er nu in staan zijn voor het testen met mijn vingen ;-)

Gegroet,
Blackdog

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

Golden Member

Waarom een elco en diode om overshoot te voorkomen ipv een PID regeling?

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

Golden Member

Hi Shiptronic, :-)

Ik kan en wil geen normale PID gebruiken voor de buitenoven.
Dit heeft te maken met het stoorveld dat hiermee in de ovens wordt opgewekt.
Bij de PreHeath stand is de stroom tussen de 0,5 en 1 Ampere.
En als de "normale" regeling gaat werken kan dit afhankelijk van de gebruikte ovenvoeding tussen 100 en 200mA zijn, als de oven stabiel is.
Dat is vrij veel energie en ik wil niet dat dit de spanningsreferentie schakeling beinvloed!

Ik ga dus proberen het filter zo te maken aan de Fet dat het "aan" traject langer duurt dan het "uit" traject.
Ik mijn testschakeling zet ik trimpots met een groot regelbeeik in de filters zodat het makelijker te tunen is.
De Fet wordt er één met lage steilheid, zoals b.v. de IRF710.

Oja geen elco maar een goede film condensator tussen de 1 en 10uF in het filter aan de Gate.
Het wordt denk ik wat duidelijker als het schema af is.

Als de Fet toch te steil blijkt, dit genereerd dan een te hoge gain in de loop met als gevolg lange regeltijden,
dan zal ik de Fet lineair moeten maken met een opamp.
Dit is niet moeilijk maar kost wel weer meer onderdelen en ik probeer het altijd KISS te houden. :-)

Groet,
Bram

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

Golden Member

Hi,

Ik heb het eerste test schema af en ga de onderdelen op een breadboard zetten.
http://www.bramcam.nl/Arduino/Testoven/TestOven-03.png

De IRFP450 en de LM317 komen op een klein koelplaatje i.v.m. de warmte in de PreHeath mode.
De opplettende kijker ziet twee ruim instelbare tijdconstanten, en die voor het uitschakelen kan veel korter worden ingesteld dan de tijdconstante die de oven inschakeld.
Ik heb geen idee van de waarden die het echt worden, maar ik weet wel dat de weerstand waarmee ik de eerste testen ga doen
veel sneller reageerd dan de ovenbuis die morgen binnenkomt voor de buitenoven.

Deze buis is 9cm doorsnee met een wanddikte van 5mm, dit geeft mij de mogelijkheid als ik precies boor om een TO92 behuizing van de TMP37 in de wand van de buis te boren.
Dit met de vriendelijke hulp van de zoetvijl om de behuizing iets kleiner te maken, de bruut die ik ben ;-)

Aan de rechterzijde van het schema kunnen jullie zien dat de uitgangsspanning vande LM317 door een BS170 Fetje wordt omgeschakeld.
De waarden die zijn gekozen is een inschatting en ook afhankelijk of ik de weerstand wel of niet inpak.
Ook is de maximale stroom door R6 en Q2 begrenst op ongeveer 600mA.

Wat niet in het schema is opgenemen is de 5K precisie NTC die ook op de 10 Ohm weerstand gemonteerd zit voor het loggen van de temperatuur met de KeySight meter.
Als het werk meezit morgen kan ik wat beginnen te testen, voor nu de onderdelen bij elkaar zoeken zodat ik morgen zo kan starten met bouwen.

Gegroet,
Blackdog

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

Golden Member

Hi,

Even een soort zijstapje, en de schuld leg ik bij Shiptronic voor al de onderstaande foto's *grin*

Je opmerking over de PID controler bleef toch jeuken...
Deze week kwamen de nieuwe Alu pijpjes binnen voor zowel de binnen en de buiten oven.
Vooral de buitenoven is duidelijk anders, de lengte is gelijk gebreven met 90mm maar de doorsne is nu 80mm en de wanddikte is 5mm.
Dit houd in dat ik net ruimte voldoende heb voor een TO92 sensor zoals de TMP37 of de MCP9701A.
Wat ik al eerder aangaf, de TO92 is net 5mm en dat gaat dus niet met 5mm wanddikte.
De TMP37 die nu in de buitenoven zit heb ik terug gebracht met vijl en slijptool naar ongeveer 3,9mm
Dus met een 4mm boor als je goed centerd, is dit net te doen.
Hier kunnen jullie mijn boorwerk zien, met opzet zitten de gaten niet allemaal in het midden van de wand.
Dit heeft te maken met de meetsnelheid (lag) hoemeer de sensor naar de binnenwand toe zit hoelange het duurt voor de sensor
meet dat er energie wordt toegevoerd aan de ovenwikkelingen.
De kleine gaatjes zijn voor de NTC weerstanden, ik gebruik voor deze testoven twee typen.
http://www.bramcam.nl/Arduino/Testoven/TestOven-05.png

Hier kan je zien dat ik een gaatje heb geboord naar het 5mm gat en dat een van de 3mm gaatjes iets te dicht bij de rand is geboord.
Dit is verder geen probleem, dat is later zichtbaar waarom.
http://www.bramcam.nl/Arduino/Testoven/TestOven-06.png

Er zijn sleufjes gemaakt om de sensoren vanuit ongeveer het midden in de ovenwand te steken.
Ik wil geen draden uit de zijkanten hebben waar ik ben begonnen te boren.
Er komen deksels op de zijkanten en deze moeten luchtdicht worden, en met draden die aan de zijkant uit de buis steken is dat wat lastig.
Voor het ovenbuisje liggen de drie sensoren di in de buis gemonteerd worden.
De bovenste is een zwarte 5K NTC die ik misschien aaneen anloge ingang van een Arduino hang,
de gele NTC is mijn meet NTC die naar de KeySight meter gaat.
De sensor met de gekleurde draden is de afgevijlde TMP37G.
http://www.bramcam.nl/Arduino/Testoven/TestOven-07.png

Een close up van de sensoren.
http://www.bramcam.nl/Arduino/Testoven/TestOven-08.png

De "bruut" die ik ben, de TMP37G is een jas kwijt! :-)
http://www.bramcam.nl/Arduino/Testoven/TestOven-09.png

Ja ja, daar is het weer, de blauwe thermische lijm die zijn werk doet.
Met de haardroger de buis lekker warm gemaakt om de lijm sneller te laten drogen en toen boodschappen gaan doen,
je moet toch wat met je tijd...
http://www.bramcam.nl/Arduino/Testoven/TestOven-10.png

De eerste laag glasvezeltape is op de ovenbuis aangebracht samen met wat krimpkousjes om de sensor bedrading te beschermen.
Deze tape is volgens 3M bruikbaar tot 180C.
http://www.bramcam.nl/Arduino/Testoven/TestOven-11.png

Het weerstandsdraad dat ik gebruik is eigenlijk niet te solderen, dus had ik hier een andere oplossing voor nodig.
Er schoot mij te binnen dat ik nog steeds een zetje van Knipex had, voor adereind hulsjes.
Na een eerste test bleek dit goed te werken, het grijze stukje plastic wat aan het adereind hulsje zit knip ik er af daar het te breed is.
Ter isolatie heb ik een stukje glaskous over de verbinding geschoven.
http://www.bramcam.nl/Arduino/Testoven/TestOven-12.png

Het wikkelen van de oven is begonnen, dit is de eerste test, het zijn 4 draden parallel zodat ik goed kan spelen met het vermogen
en het zo schakelen dat er weing magnetich veld word opgewekt in de oven.
De windingen zijn tussen 9,5 en 11 Ohm per stuk.
Het blauwe draad is speciaal, teflon isolatie met verzilverde draadjes, hier toegepast i.v.m. teflon isolatie.
http://www.bramcam.nl/Arduino/Testoven/TestOven-13.png

Alle windingen zitten er op, zo strak gewikkeld als ik maar kon en dit is zeer lastig.
Ook zijn de wikkelingen mooi verdeeld en raken zij elkaar niet, zodat ik ze in serie of parallel kan zitten zoals het mij uitkomt.
Probeer zelf eens zonder knoopjes, zonder knikken in het platte weerstandsband 4 stuks tegelijk naast elkaar te leggen...
Ja, ik heb nu wel wat kramp in mijn handen...
http://www.bramcam.nl/Arduino/Testoven/TestOven-14.png

Hij is klaar, extra strak twee lagen tape over de bedrading aangebracht, zodat er geen "hotspots" kunnen gaan optreden.
Dat is ook de rede dat ik het teflon draad gebruik, als ik de oven aanstuur direct op de ovenwikkeling
dan wordt deze erg warm en dat vind ik ongewest.
http://www.bramcam.nl/Arduino/Testoven/TestOven-15.png

Weer een zijsprongetje, ik had de gele vermogens weerstand laten zien met de twee sensoren er op.
Dit is de temperatuur van deze weerstand hier in het LAB over bijna 4 dagen gewoon los liggend op de werkbank.
http://www.bramcam.nl/Arduino/Testoven/TestOven-16.png

En dan komen we nu aan bij Shiptronic zijn opmerking over PID.
Ik had al een tijd terug op ebay een Berme Rex-C100 PID conttroler gekocht.
Daar zit een nogal dikke K type sensor bij die ik niet goed aan de ovenbuis kan koppelen en
zonder goede koppeling kan je beter niet aan een ovenregelcircuit beginnen.
Na enig zoeken kwam ik de sensor tegen die bij mijn Agilent 1272 meter hoort en
je kan links van de Rex-C100 de gele connector zien die onder de schroefjes zit,
niet optimaal maar voor nu voldoende.
Dat is ook vrijwel zeker de rede dat de temperatuur er 2C naast zit, maar dit is voor deze test niet belangrijk.
http://www.bramcam.nl/Arduino/Testoven/TestOven-17.png

Ik kon het toch niet laten, gewoon open op tafel, oven vertikaal, de warme lucht schiet er bij wijze van spreken uit :-)
En dan meet de KeySight meter dit, niet slecht.
http://www.bramcam.nl/Arduino/Testoven/TestOven-18.png

Dan is het zaak voor een beetje isolatie te zorgen, een kleine handdoek doet hier voor dienst.
De controler staat nu op 41C ingesteld daar dit een echte temperatuur opleverd van ongeveer 38,6C
http://www.bramcam.nl/Arduino/Testoven/TestOven-19.png

Dit is een tijdmeting van 1 uur en een kwartier, bij de ondershoot heb ik het handdoekje aangebracht.
Hierna krijg je een piekje die bijna 39C is, op de top heb ik de voeding die dan 30-Watt leverde terug gebracht naar 20-Watt.
Je ziet de temperatuur dan even zakken en daarna weer een beetje oplopen, op dat topje heb ik het maximale vermogen dat de voeding leverde verder terug gebracht naar 13-Watt en het geheel met rust gelaten.
http://www.bramcam.nl/Arduino/Testoven/TestOven-20.png

Hier kunnen jullie zien hoe een 13-Euro PID controlen met een klein beetje isolatie de temperatuur constand houd.
Wat mij betreft is dit netjes.
http://www.bramcam.nl/Arduino/Testoven/TestOven-21.png

Ik zal ook een testje gaan doen met de Arduino PID library en dan de flanken die uit de regeluitgang komen vertragen zodat dit zo min mogelijk storing op de gebruikte electronica oplevert.
Leuk Shiptonic!

Gegroet,
Blackdog

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

Golden Member

Graag gedaan, maar de bedoeling was dat de arduino de taak als PID regelaar op zich zou nemen ( met een Dallas DS18?20 als sensor ) >:)

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

Golden Member

Hi Shiptronic,

Nou...
Een DS18B20 gaat het in ieder geval niet worden, te traag.
Dit is de Gate spanning en er is te zien hoelang bij het bereiken van het equilibrium de schakel Fet aanstaat, ongeveer 0,9S
Dit resulteerd met de simpele isolatie van het handdoekje in ongeveer 4-Watt vermogens opnamen. bij 21,5C LAB temperatuur.
http://www.bramcam.nl/Arduino/Testoven/TestOven-22.png

Vandaag nog code zitten doorspitten wat betreft PID en het oversampelen van een analoge ingang van de Arduino.

Ik zal kijken hoever ik ga komen, eerst testen op de gele weerstand met de Arduino code dan de Alu oven.

Gegroet,
Bram

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

Golden Member

Morge :-)

Ik heb de REX-C100 PID controler gisteren aan gelaten om te kijken hoe de temperatuur wordt gehouden in een rustige omgeving.
Dit houd in, deur dicht en raam ook dicht.
Die blijft dan redelijk stabile ook al zakt de temperatuur in de ruimte ongeveer 3 graden.
Dan komt de grote disruptie, deur en raam gaan open, de temperatuur gaat direct onder de 38,5C.
Het duurd een tijdje en gaat langzaam weer naar de 38,5 toe.
Dan een wild gedrag, daar ben ik de oorzaak van, omdat ik toen de REC-C100 de opdracht heb gegeven de autotune functie te gebruiken.
Hierna komt de temperatuur weer mooi overheen met de temperatuur in het midden van de nacht.
http://www.bramcam.nl/Arduino/Testoven/TestOven-23.png

Je kan zien dat de "ruis" ongeveer 0,1C is en ik heb even opgezocht wat de Seebeck spanning is rond de 40C.
Deze spanning is bij een K type sensor 1,611V en hij veranderd rond de 40C 41uV per graad.
Dus 4uV is 0,1C, grote kans dat wat je aan "ruis" ziet op het plaatje de voor een groot deel de ruis is van de Thermokoppel meetversterker.

Verder gisterenavond bezig geweest met het oversampelen van de Arduino analoge ingang met ee nTMP37 Sensor er aan.
Dat was voorlopig geen succes, ik krijg de waarde die uit de oversampling software komt niet op het display...
Ben dit op het ogenblik aan het uitzoeken en als het werkt ga ik met de Arduino testen hoe goed de regeling is.

Groet,
Blackdog

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

Je bent aardig bezig Bram ;-)
Vraagje met betrekking tot je code, is er een bepaalde reden dat je in de verwerking van de waarde van de ADC deelt met 1024.0?
Zou verwachten dat delen met 1024 precies hetzelfde resultaat moet geven.

Groeten,
Marius.

P.s. kan prima meelezen met je code. Maar als ik het zelf zou moeten schrijven dan bak ik er niets van of tenminste niet zo netjes.

blackdog

Golden Member

Hi Marius, :-)

Ik doe mijn best het voor mijzelf leesbaar te houden.
Dat is heel belangrijk als je een set hersenen hebt die taal graag door elkaar rommelt!

Maar goed, ik loop dus echt vast nu, dus als Marius of anderen even naar dit simpel stukje code kunen kijken voor mij....
Er wordt gebruik gemaakt van de Oversample.h library.
Deze werkt wat mij betreft goed, ik krijg extra bits code uit de software.

Dit stukje code is om de waarde op te vragen en ik gebruik 4 digits achter de comma.
Met deze waarde kan ik niet reken zodat ik de temperatuur kan weergeven.

temp en bitU heb ik ook een "long" type van gemaakt, dit maakt echter geen verschil.
Dus... Waar maak ik mijn blunders?

c code:

#include <Oversample.h>

byte analogPin = A7;
byte resolution = 16;
byte interval = 1;

float temp = 0.00;                                         // Variabelen nodig voor het middelen van een analoge temperatuur meting
float bitU = 0.00;                                         // Waarde van een enkele bit (Is Ref spanning / 1024) 
const float uref = 1.0734;                          // De gemeten interne Referentie spanning van de microcontroler, nodig voor de berekening van de temperatuur

Oversample * sampler;

void setup() {
  Serial.begin(115200);
  analogReference(INTERNAL);                        // Geeft opdracht aan de compiler om de interne referentie spanning van de gebruikte Arduino Nano te gebruiken (gemeten spanning 1.0734V)
  sampler = new Oversample(analogPin, resolution);

  byte resolution = sampler->getResolution();
  //sampler->setResolution(16);
  Serial.print("Resolution: ");
  Serial.println(resolution);

  byte prescaler = sampler->getPrescaler();
  //sampler->setPrescaler(7);
  Serial.print("Prescaler: ");
  Serial.println(resolution);
}

void loop() {
  int single = analogRead(analogPin);
  double oversampled = sampler->read();
  long scaled = sampler->readDecimated();

  Serial.print(single);
  Serial.print(", ");
//  Serial.println(oversampled, 4);                   // Deze regel werkt als hij aan staat in de serieel monitor
//  Serial.print(", ");
//  Serial.println(scaled);

  bitU = (oversampled, 4) * (1.0734/65536.0);         // Hier porbeer ik de temperatuur te berekenen, bitU geeft 0.00 in de serieel monitor
  temp = bitU / 0.02;                                 // Berekend de Temperatuur van de TMP37 Sensor met de 20mV/C gevoeligheid van de sensor, de variabel "temp" geeft nu de temperatuur aan in Celsius.

  Serial.print(", ");
  Serial.println(bitU);                               //Test of de bitU berekening werkt, NOP! nada nix :-(

  delay(interval * 10);
}

Dank alvast,
Blackdog

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

van die laatste berekening, wat is de uitkomst van
(1.0734/65536.0)?
dat komt op een rekenmachine uit op 0,00001637 en ik vermoed dat je softwere die afrond op 0,000 ofzo

en een getal vermenigvuldigen met 0,000 blijft altijd 0,00

EDIT: hmmm, heb die code gestript ff laten lopen en ik loopt vast op die ",4" dat je in die formule gebruikt na oversampled. waarvoor is die?

bitU = (oversampled, 4) * (1.0734/65536.0);

als ik die eruit gooi, krijg ik wel mijn correcte berekening

c code:

bitU = (oversampled) * (1.0734/65536.0);
ik hou van werken ..., ik kan er uren naar kijken

Hey Blackdog, kan je niet beter twee verwarmingswikkelingen tegen elkaar in wikkelen zodat de magneetvelden elkaar opheffen?

Wat betreft ovens inregelen, daar heb ik wel wat ervaring mee. Ik heb nog wel een mooie tuningsmethode liggen. Niet ingewikkeld, je moet een simpel testje doen (hoeveel wijzigt de temperatuur als je het vermogen met x procent veranderd). De resultaten stop je in mijn excel file en je hebt resultaat.

blackdog

Golden Member

Hi,

fcapri,
Ik ben er ook net achter dat de waarde achter "oversampled" roet in het eten gooid.
Deze waarde geeft aan hoeveel digits je achter de comma wilt hebben bij de weergave.

necessaryevil
De hele rede van meer wikkelingen te gebruiken is juist het opheffen van de velden :-)
Alle code die mij helpt met dit project is welkom!

Wat betreft de codede waarde uit is rond de 420.xxxx bij 21C.
Misschien beter deze eerst te vermedigvuldigen 1 miljoen de berekening er op los laten voor de TMP37 en dan terug schalen?

Groet,
Blackdog

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

Ahh, kijk mooi werk. Het gaat overigens niet om code, maar om het vinden van de tuningsparameters (instellen van de controller).

Hallo Bram,

Ik denk dat je de oversample.h libary verkeerd heb begrepen.
Dit is het zoals ik het begrijp van de volgende pagina:
http://www.electricrcaircraftguy.com/2014/05/using-arduino-unos-built-…

Je oversample.h zorgt ervoor zoals je zelf ook al deed.
Je sampled niet 1 keer bij ,1 maar 2 keer waardoor je je waarde door 2 moet delen.
Vandaar dat je waarden niet meer kloppen bij het gebruik van deze libary.

Edit:
Ze geven aan 2^n aan waar de n voor het getal achter de komma staat.
Dat geen getal dus klopt is logisch aangezien 2^0 gelijk aan 1 staat.
1 keer sample is de goede waarde. 2x zou dus een 2x te hoge waarde moeten geven.

Groeten,
Marius.

[Bericht gewijzigd door MdBruin op 9 oktober 2016 13:32:04 (22%)]

blackdog

Golden Member

Hi Marius, :-)

Dat ik het verkeerd begrepen heb is nu duidelijk!
Ik moet gewoon de 10 bit waarde blijven gebruiken en krijg aan de hand van de resolutie die je invult meer digits achter de comma.

Ik krijg nu weer een normale waarde op mijn LCD display (12 bit resolutie gekozen in de setup) en op het ogenblik is dat met 0,001C resolutie op het display.
Dit kan nog hoger, maar dit is niet nodig voor mijn toepassing.
Ik heb ook besloten deze Oversample library niet te gebruiken, en dit is komt door het nogal vreemde gedrag van de output van de library.
Het is wat lastig dit hier te omschrijven maar het is een soort lag dat je het duidelijkste ziet bij hoger ingestelde bitwaarde.
Pas bij bij het punt van omklappen van de LSB van de AD in de Arduino komt het systeem goed in werking en dat is natuurlijk ook logies.
Want aleen met het rammelen van het LSB kan het systeem werken.
Dit gaat volgens mij raar gedrag vertonen als ik dit ga gebruiken voor een ovencontroler, dan is een 12 of 15 bit AD converter voor twee euro toch een beter keus als ik meer resolutie zou willen hebben.

Een leuk en af en toe een harentrekkend leerproces *grin*
Ik weet nu dat het getal achter de waarde oversampled alleen geld voor het weergeven in de serieel monitor.
En ik heb deze manier nu ook gebruikt om het aantal digits op mijn LCD scherm te bepalen.

Dus de Oversample.h wordt verwijderd en ik ga weer middelen zoals de eerder voorgestelde code.
De volgende stap is de PID code integreren en kijken of ik dit werkend krijg.

Heren, bedankt voor de input!

Groet,
Bram

PS,
De PID controler stook nog steeds de testoven, en ook met de zon hier binnen blijft hij mooi op temperatuur.
Het autotunen heeft duidelijk een beetje geholpen.

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

Ze noemen het wel zo, maar in de werkelijkheid is het volgens mij niet zo. Het is precies zoals je al zelf zegt gewoon middelen van de gemeten waarden. De stapjes worden niet kleiner zoals bij een hogere bits ADC wel het geval is.
Wordt het nauwkeuriger met een hogere bits ADC, ja de maar wordt dan wel dat er hogere eisen aan de referentie spanning worden gesteld. Aangezien 1 bit kleinere is en dus een schommeling in de referentie dan 1 of meerdere bit fouten kan veroorzaken.

Wat betreft die libary, snapte al die tijd die ze aangaven al niet bij een hoger getal achter de komma. Jij middelt al met 100 in je code die je vermeld. Die oversample.h doet het dus voor jou op een inefficiënte manier welke te veel tijd in beslag neemt.

Groeten,
Marius.

blackdog

Golden Member

Hi Marius,

Er kunnen best goede toepassingen voor die Library zijn, maar ik denk niet dat dit handig is voor het aansturen van een oven.

Op het ogenblik net weer terug van een wandeling en ik had de oven uit gezet.
Deze staat nu weer aan en ga dan kijken hoelang het duurt met de energie die ik nu heb ingesteld (13-Watt) voor hij zijn eind temperatuur heeft.
Ook hoe de flank er uit ziet, of er overshoot op treed, een leerproces hoe deze REX-C100 werkt. :-)

Met deze 12-Watt zou ik vanaf een graad of 10 goed de oven op temperatuur kunen houden.
Er van uitgaande dat zoals ik al aangaf het warmteverlies beneden de 4-Watt kan houden.
Dit is trouwens de tweede keer, dat ik een klein handdoekje gebruik als isolatie,
simpel en erg doeltreffend.
Ik zal ook testen als ik eens twee stuks gebruik kijken hoeveel dit scheeld in energie.

Gegroet,
Blackdog

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

Special Member

Uuhhh, wanneer kan die pizza erin. :+

Leuk project Bram, ik blijf het volgen. :)

Als je haar maar goed zit, GROETEN LAMBIEK.

Dmv oversampling kun je wel degelijk een hogere resolutie krijgen. Maar dan wel tgv wat ruis op je meetsignaal.

Als je bijvoorbeeld een ingangssignaal hebt dat overeen komt met een ADC waarde van 500.2 dan zal je ADC op 500 uitkomen. Ook als je 100 metingen neemt (allemaal 500) en daarna het gemiddelde berekent, dan nog is het resultaat 500.

Maar als je wat ruis toevoegt, dan zullen sommige samples op 501 uitkomen. En als je signaal iets oploopt naar bijvoorbeeld 500.8, dan krijg je meer samples van 501. Dus door het gemiddelde te berekenen kun je een hogere resolutie krijgen.

Maar dan moet je wel de juiste rekenmethode toepassen. Want als je met integers rekent dan valt alles achter de komma weg en dan werkt het niet meer.

PS, Officieel moet je ruis gaan toevoegen, maar in de praktijk krijg je die meestal kado.

blackdog

Golden Member

Hi deKees,

Ik weet ondertussen dat het maken van "extra" bits te maken heeft met onzekerheid zeg maar ruis.
Van lang terug kwamen er weer beelden boven dat ik er over gelezen had.
Ik heb niet veel gewerkt met AD en DA converters, en wat ik heb gedaan was allemaal simpel.

Die onzekerheid zie je ook in het gedrag bij de Arduino die ik gebruik, hij komt niet terug naar de vorige waarde, het is altijd anders.

Ondertussen is mij ook al opgevallen dat het "ruisniveau" van ingang "0" t/m "7" anders is.
De ingangen an de lage kant rammelen meer, het kan de opzet zijn van de print of een eigenschap van de microcontroler.
Door mijn lange filtertijden wordt deze ruis wel weg gewerk.
Maar het is duidelijk iets waar je rekening mee moet houden als je sneller wilt meten.

Mooi, plaatje van de REX-C100 controler, nu uitgerust met een drie draads aangesloten PT100 sensor.
Het opvallende is nu, dat ik de controler "lager" moet instellen, -1,9C voor het bereiken van de temperatuur.
38,1 geeft een oven temperatuur van 40C.
En ik vertrouw deze PT100 wel.
Dit zal de afwijking wel zijn van de REX-C100, iets om rekening mee te houden.
De REX-C100 staat nu dus op een PT sensor ingesteld en ik heb hem ook een "autotune" laten doen.
Dit is de situatie hoe er is gemeten, er is ook nog een doosje om de oven heen gekomen om de zien of de "ruis" op het signaal
komt door tocht hier op de werkbank.
http://www.bramcam.nl/Arduino/Testoven/TestOven-24.png

Dit is een meting van vannacht ruim 14 uur en geen rare sprongen i.v.m. deur open en raam open.
http://www.bramcam.nl/Arduino/Testoven/TestOven-25.png

Ik ga nog één testje doen met de REX-C100 controler en dan niet de oven in het plastig doosje geplaats, ik moet hiervoor wat variatie hebben.
Dit plastic doosje kan je zien als de behuizing waar mijn spannings referentie in komt.
De test houd in dat ik de binnen oven die ik al had gemaakt in de buitenoven aanbreng en dan kijk wat de variaties zijn in temperatuur van de binnen oven zonder dat deze wordt opgewarmd door de electronica.
Dan kan ik dus zien dat b.v. 1C aan de buitenzijde uiteindelijk xxxC variatie op de binnenoven geeft binnen een bepaald tijdsbestek.
Als je maar lang genoeg wacht, neemt de binnenoven altijd de temperatuur van de buitenoven aan.
Het gaat dus bij deze meting om het uitsmeren van de variaties en mijn inzicht hierin.

Stap-2 van de code
Ik ben weer een stukje verder, ik kan nu de twee TMP37 sensoren uitlezen met deze code en dit op het display plaatsen.
Verder heb ik er voor gekozen zoveel mogelijk tekst in het Nederlands te doen.
Ik schaaf voortdurend aan de code en de omschrijvingen, zoals dit weekeinde weer aardig last van een lichte vorm migraine.
Met als gevolg dat de omschrijvingen een beetje rammelen, laat vooral weten als dit niet klopt.

Eerst even de code en dan een vraag.

c code:

/*
  NoiseAmp Amsterdam - V0.2  Date: 10 okt 2016
  Dual Oven voor een spannings referentie

  Deze software controleerd voor beide ovens de "preheat"
  Deze "preheat" brengt bijde ovens snel tot vlak bij de de gewenste temperatuur en schakeld dan over op een precisie regeling
  De sensoren voor de "preheat" schakelen uiteindelijk een relais die de verwarmings wikkelingen van parallel naar serie schakelen
  zodat het opgenomen vermogen bij de precisie regeling dan maar 1/4 is van de "preheat" status.

  
  De status van de oven is op een LCD display zichtbaar
  
  -----------------------------------------------------
  ** Binnenoven instellingen **
  Oven temperatuur:               42C
  "preheat" temperatuur           40C

  ** Buitenoven instellingen **
  Oven temperature:               40C
  "preheat" temperature           38C
  -----------------------------------------------------
  
 */

#include <Wire.h>
#include <LCD.h>
#include <LiquidCrystal_I2C.h>
LiquidCrystal_I2C  lcd(0x27,2,1,0,4,5,6,7);         // 0x27 is het I2C bus addres for een ongemodificeerde PCF8574 12c naar parallel interface print 


// Variabelen voor de binnen oven
float tempI;                                        // Variabelen waar uiteindelijk na berekening de temperatuur in geplaatst word voor de binnen oven
float bitI;                                         // Waarde van een enkele bit (Is Ref spanning / 1024) voor de binnen oven
float adcTempI= 0;                                  // Gemiddelde waarde van het aantal genomen monsters voor de binnen oven
word i = 0;                                         // Tijdelijke variabel nodig bij het tellen van het aantal monsters voor de binnen oven
unsigned long tempReadingI;                         // Tijdelijke buffer voor het sommeren van de monsters voor de binnen oven
const byte tempPinI = 0;                            // Set de gebruikte analoge ingang voor de TMP37 sensor in de binnenoven
const word smplI = 100;                             // Set het aantal te nemen monsters voor de binnenoven
const float setOvenI = 42.00;                       // Set de binnenoven temperatuur
const float preHeathI = 40.00;                      // Set de PreHeath temperatuur voor de binnenoven
const int correctI =                                // Correctie waarde om de temperatuur meting te kalibreren voor de binnenoven

// Variabelen voor de buiten oven
float tempU;                                        // Variabelen waar uiteindelijk na berekening de temperatuur in geplaatst word voor de buitenoven
float bitU;                                         // Waarde van een enkele bit (Is Ref spanning / 1024) voor de buitenoven
float adcTempU = 0;                                 // Gemiddelde waarde van het aantal genomen monsters voor de buitenoven
word u = 0;                                         // Tijdelijke variabel nodig bij het tellen van het aantal monsters voor de buitenoven
unsigned long tempReadingU;                         // Tijdelijke buffer voor het sommeren van de monsters voor de buiten oven
const byte tempPinU = 1;                            // Set de gebruikte analoge ingang voor de TMP37 sensor in de buitenoven
const word smplU = 100;                             // Set het aantal te nemen monsters voor de buitenoven
const float setOvenU = 40.00;                       // Set de buitenoven temperatuur
const float preHeathU = 38.00;                      // Set de PreHeath temperatuur voor de buitenoven
const int correctU =                                // Correctie waarde om de temperatuur meting te kalibreren voor de buitenoven


const float uref = 1.0734;                          // De gemeten interne Referentie spanning van de microcontroler, nodig voor de berekening van de temperatuur

void setup() {
  analogReference(INTERNAL);                        // Geeft opdracht aan de compiler om de interne referentie spanning van de gebruikte Arduino Nano te gebruiken (gemeten spanning 1.0734V)
  Wire.begin();                                     // Start de i2c bus voor weergave van de wwarden op het display
  Serial.begin(9600);                               // Start de serieele monitor voor debugging
  
// Steld het gebruikte display in
  lcd.begin (16,2);                                 // Steld het type LCD in: 16 x 2, met de achtergrond verlichting "aan"
  lcd.setBacklightPin(3,POSITIVE);                
  lcd.setBacklight(HIGH);                           // Zet de achtergrondverlichting van het display aan

// Variabelen/Settings voor de buitenoven uitgangen
  pinMode(10, OUTPUT);                              // Maakt van pin-10 een uitgang, doel is de Gate sturing van de buitenoven
  pinMode(11, OUTPUT);                              // Maakt van pin-11 een uitgang, doel is de relais sturing van de preheath van de buitenoven
  digitalWrite(10, LOW);                            // Startwaarde uitgang 10, "uit" de ingestelde temperatuur is nog niet bereikt
  digitalWrite(11, HIGH);                           // Startwaarde uitgang 11, "aan" de ingestelde temperatuur voor de "preheat" is nog niet bereikt en de uitgang is hierom hoog

// Variabelen/Settings voor de binnenoven uitgangen
  pinMode(12, OUTPUT);                              // Maakt van pin-10 een uitgang, doel is de Gate sturing van de binnenoven
  pinMode(13, OUTPUT);                              // Maakt van pin-11 een uitgang, doel is de relais sturing van de preheath van de binnenoven
  digitalWrite(12, LOW);                            // Startwaarde uitgang 10, "uit" de ingestelde temperatuur is nog niet bereikt
  digitalWrite(13, HIGH);                           // Startwaarde uitgang 11, "aan" de ingestelde temperatuur voor de "preheat" is nog niet bereikt en de uitgang is hierom hoog
  
}

void loop () {

// Loop voor het meten van de buitenoven  
  adcTempU = 0;                                     // Maakt de adcTemp variabel weer leeg, voor een nieuwe meting
  tempReadingU = 0;                                 // Maakt de tempReading variabel weer leeg, voor een nieuwe meting
  
  for(int u = 0; u < smplU; u++)                    // Hier wordt de analoge ingang (7) "x" gemeten, x = de variabele "smpl"
  {
  tempReadingU +=analogRead(tempPinU);
  delay(1);
  }
  
  adcTempU = tempReadingU / smplU;                  // Deelt de som van de metingen door het aantal monsters "smpl"
  tempU = adcTempU * (uref/1024.0) /0.02;           // Verrekend de verwerkte monsters met de referentie spanning en de bitwaarde van de ADC converter en plaatst deze in de variabel "temp"                              
                                                    // uref is de referentie spanning, 1024 is de resolutie van de AD converter, 0.02 is het aantal V/C van de Sensor

  if (tempU > setOvenU) {                           // Deze vergelijking kijkt of de oventemperatuur al is bereikt, als dit zo is, dan wordt uitgang "10" laag en wordt de verwarming afgeschakeld
     digitalWrite(10, HIGH);
     lcd.setCursor (0,1);                           
     lcd.print("H = On "); 
   } else {
     digitalWrite(10, LOW);
     lcd.setCursor (0,1);                           
     lcd.print("H = Off");
   }

  if (tempU > preHeathU) {                          // Deze vergelijking kijkt of de "preheath" temperatuur al is bereikt, als dit zo is, dan wordt uitgang "11" laag en worden de verwarmings elementen omgeschakeld van parallel naar serie
     digitalWrite(11, LOW);
     lcd.setCursor (8,1);                           
     lcd.print("PH = Off "); 
   } else {
     digitalWrite(11, HIGH);
     lcd.setCursor (8,1);                           
     lcd.print("PH = On ");
   }

  lcd.setCursor (8,0);                              // Plaatst de temperatuur van de oven op positie "9 op regel "0"
  lcd.print(tempU);
  lcd.print((char)223);                             // Plaatst het "°C" achter de temperatuurwaarde
  lcd.print("C");


// Loop voor het meten van de binnenoven 
  adcTempI = 0;                                     // Maakt de adcTemp variabel weer leeg, voor een nieuwe meting
  tempReadingI = 0;                                 // Maakt de tempReading variabel weer leeg, voor een nieuwe meting
  
  for(int i = 0; i < smplI; i++)                    // Hier wordt de analoge ingang (7) "x" gemeten, x = de variabele "smpl"
  {
  tempReadingI +=analogRead(tempPinI);
  delay(1);
  }
  
  adcTempI = tempReadingI / smplI;                  // Deelt de som van de metingen door het aantal monsters "smpl"
  tempI = adcTempI * (uref/1024.0) /0.02;           // Verrekend de verwerkte monsters met de referentie spanning en de bitwaarde van de ADC converter en plaatst deze in de variabel "temp"                              
                                                    // uref is de referentie spanning, 1024 is de resolutie van de AD converter, 0.02 is het aantal V/C van de Sensor

  if (tempI > setOvenI) {                           // Deze vergelijking kijkt of de oventemperatuur al is bereikt, als dit zo is, dan wordt uitgang "10" laag en wordt de verwarming afgeschakeld
     digitalWrite(12, HIGH);
     lcd.setCursor (0,1);                           
     lcd.print("H = On "); 
   } else {
     digitalWrite(12, LOW);
     lcd.setCursor (0,1);                           
     lcd.print("H = Off");
   }

  if (tempI > preHeathI) {                          // Deze vergelijking kijkt of de "preheath" temperatuur al is bereikt, als dit zo is, dan wordt uitgang "11" laag en worden de verwarmings elementen omgeschakeld van parallel naar serie
     digitalWrite(13, LOW);
     lcd.setCursor (8,1);                           
     lcd.print("PH = Off "); 
   } else {
     digitalWrite(13, HIGH);
     lcd.setCursor (8,1);                           
     lcd.print("PH = On ");
   }

  lcd.setCursor (0,0);                              // Plaatst de temperatuur van de oven op positie "0 op regel "0"
  lcd.print(tempI);
  lcd.print((char)223);                             // Plaatst het "°C" achter de temperatuurwaarde
  lcd.print("C");

  
//  lcd.setCursor (0,0);                            // Plaatst de "RAW" waarde van de ADC op positie "0" op regel "0", handig tijdens het ontwikkelen
//  lcd.print(analogRead(0));                                                    

// Serial.println(adcTempU);
// Serial.println(adcTempI);
}

De TMP37 sensoren zijn niet perfect ondanks dat ik de beste versie heb aangeschaft.
De temperatuur die op het display word weergegeven wil ik wel binnen 0,1C goed hebben.
Dit kan ik met een professionele sensor en mijn Tek DMM4050 DMM doen.

Boven in de variabelen voor mijn temperatuur sensoren heb ik dit opgenomen:

c code:

const int correctI = -312

De -312 is voor nu even de willekeurige waarde voor de binnen oven.

Ik wil deze variabel opnemen in dit stukje code om de weergegeven temperatuur correct te maken:

c code:

tempI = adcTempI * (uref/1024.0) /0.02;

tempI bevat de temperatuur die gebruikt wordt voor de vergelijkingen en het display.

Ik zou de correctie waarde die een positieve of een negatieve waarde kan hebben willen verrekenen met de "adcTempI"
als ik dit doe:

c code:

tempI = (adcTempI - correctI) * (uref/1024.0) /0.02;

Wordt dit dan correct uitgerekend bij een waarde die zowel negatief, positief of "0" is?

De adcTempI is het gemiddelde van het aantal metingen die er zijn gedaan en dat lijkt mij de goede plek om de sensor te kalibreren.
Vinden jullie dit ook, of kan ik het ook beter anders toepassen?

Dank weer en gegroet,
Blackdog

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

Een tip, zet bij die Rex-C100 wel de optie "DF" uit, met DF aan word PV = SV op het display als PV dicht genoeg bij SV is.

Zet COD op 0001, in het extra menu wat je dan krijgt kun je DF op 0 zetten.

Bij mijn Rex-C100 bleek dat 8 stuks 7 segments displays wat veel zijn voor de 78L05 die maar 100mA aan kan. de elco's in de voeding van de Rex-C100 zijn de bekende "chinese brol" kan ook niet anders voor dat geld.

Na vervanging van de 78L05 door een LM7805 die 1A aan kan, en het vervangen van de elco's door merk spul werd de werking een stuk stabieler.

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.