Pulsad termostat

[Eddie]

Är intresserad av att förbättra min termostat och använda mig av en tyristor driven av PWM... Har kod för att driva utgången och kan reglera den i 255 steg men vad används egentligen för algorithm på en pulsad termostat?

Finns det något känt sätt för hur många steg som ska ökas och sänkas och inom vilken tid osv. eller är det ett rent experimenterande?

Tacksam för alla tankar

[Icecap]

Det beror alldeles på vilken massa som styrs, jag använder en PID-styrning på min "värmeutvecklingsenhet", den har en reglertid på 2 min då det är en "stor" panna jag har så regleringstiden beror på trögheten i reaktionen.

El-startelementet styrs i 1 sek PWM-cykel.....

EDIT: ingen namn nämnda.....

[Eddie]

Ok... Jag använder termostaten till mina terrarier och effekten på värmare och volymen som ska värmas varierar ganska mycket. Vill ju gärna kunna använda samma kod då det rör sig om ett antal olika.

Vet ju att det finns termostater att köpa just för terrariebruk och de verkar ju fungera ok oavsett storlek och värmare...

Värmen i ett terrarium är väl iofs alltid en ganska långsam process. Får väl försöka hitta något som fungerar... (Kommer ihåg hur jävlig PID-regleringen i skolan kunde vara :wink: )

[Micke_s]

Det räcker nog med en PI regulator här(tror jag). Mycket enklare att implementera.

[Mindmapper]

Det är nog så att något så enkelt som en P-regulator skulle fungera. Terrariumen står förmodligen inomhus så att där är tempen ganska konstant. Skulle regleravikelsen vara någon grad så går det kompensera så länge som inte belastningen varierar mycket över tiden behövs inget mera avancerat.
Edit: Pelletsbrännaren har belastningsändringar och ett dynamiskt område som skiljer sig från terrarierna så det stänker om det, om inte terrarierna står ute förstås.

[Ulf]

Kolla denna artikel av Tim Wescott,
http://www.embedded.com/2000/0010/0010feat3.htm

Borde inte vara några problem att konvertera.

[Icecap]

Jag kan hålla med om att det räcker med en PI-reglering och den är enkel att åstadkomma:

Variabler:
int I_Summa = 0;
int Target_Value = <Önskat temperatur>;
int I_Factor = 1;
int P_Factor = 10;
int Output; // Resultatet som det ska skickas ut effekt enl.

Sedan behövs en Timer-funktion också.

För varje time-klick:
int Diff = Target_Value - <är-värde>;
I_Summa += Diff * I_Factor; (C för I_Summa = I_Summa + (Diff * I_Factor))
Output = I_Summa + Diff * P_Factor;

Output kan behöva att ha över och undergräns tillkopplat och det kan vara önskvärd att ha över- och undergräns på I_Summa också.

Sedan ställs effekten med värdet i 'Output', högt värde = mycket effekt.

P_Factor och I_Factor trimmas sedan till lagom värde, P_Factor bestämmer det snabba svar och I_Factor det integrerad svar.

På "värmeutvecklingsenheten" har jag D-faktorn på noll vilket ger att det de facto är en PI-reglering och visst, det är ett helt annat dynamikområde med den men regleringen är lika fast med andra värden (faktorer).

[Eddie]

Tack! Det där hjälpte massor... Jag kan tydligt se hur output ändras i takt med hur jag manipulerar temperaturen. Men hur exakt ställa PWM efter resultatet? Mellan vilka frekvenser bör en sån här styrning jobba mellan?

(Allt var tydligen inte så självklart som jag hoppats)

Hoppas det här projektet kan få mig att förstå PWM en gång för alla...

[Icecap]

PWM-frekvensen beror på VAD som styrs. Är det en lampa ska frekvensen vara ganska hög, 1 minut på och 10 minuter av är inte så användbart då men dessa tider kan fungera med ett värmeelement med större massa.

Ju lägre PWM-frekvens ju lägre störningsgrad EMI-mässigt, för låg kan ge störning i styrningen.

Men en akvarieelement...... min gissning är att det är 230V driven och om du då tar en noll-genomgångstyrd TRIAC-drivning kan du inte komma under 100Hz, massan i ett element brukar vara ganska stor så jag tror att din PWM-cykel kan vara 1Hz utan problem.

Alltså kan du styra i steg om 1% från 1-100% och detta tror jag är helt OK. Varje % blir då 1/100 sek, vill du ha högre upplösning får en PWM-cykel ta längre tid.

Med PWM menas alltså att om vi utgår ifrån t.ex. 10% kommer elementet att vara på 10/100 sek (=0,1 sek) och av resten av cykeln (90/100 sek = 0,9 sek). Ökar du Duty-Cycle ökar du "på"-tiden och minskar "av"-tiden motsvarande.

Du kan sannolikt även ha en PWM-cykel om kanske 10-30 sek utan problem, detta kan utöka upplösningen (tror ej att det behövs) eller sänka hastigheten som det behöver regleras med, om vi fasthåller steg om 1% blir varje % = 0,3 sek vid en cykeltid om 30 sek.

Men se såhär på saken:
* Regleringen gör sitt jobb och utgången från den reglering läggs i en variabel.
* Värdet i variabeln styr sedan PWM-regleringen så att de kör helt oberoende av varandra.

[Ulf]

Tittar man på de PWM:er som finns i rumstermostat så är det ganska långa tider det handlar om, ca 40 sekunder. Ett pulsförhållande på 50% ger halv effekt, dvs 20 sekunder till och 20 sekunder av.

Exakt vilken tid du ska ha beror på vilken tidskonstant ditt värmeelement har.

Och du behöver inte gå ut så ofta och kolla temperaturen, utan kan kanske göra andra nyttiga saker som att styra luftfuktigheten, eller?

[Eddie]

Käkar datablad och exempel men nånting blockerar mig från att förstå det här...

Så här ser min kod ut...

Kod: Markera allt

#include <inttypes.h>
#include <stdio.h>
#include <stdlib.h>
#include <avr/interrupt.h>

#include <avr/io.h>



int main(void)
{
	
	int I_Summa = 0; 
    int Target_Value = 25; 
    int I_Factor = 1; 
    int P_Factor = 10; 
    int Output; 
	
	TCCR2 = _BV(COM20) | _BV(COM21) | _BV(WGM20);
    TCCR2 = _BV(CS20) | _BV(CS21) | _BV(CS22);
	DDRB = 0x4 | DDRB;
	PORTB = (0xff ^ 0x04) & PORTB;


retrigger:

    for (;;)
	{
		
    	int Diff = Target_Value - 28; // <--- Ska hämta värde från sensor...  
    	I_Summa += Diff * I_Factor;  
    	Output = I_Summa + Diff * P_Factor;
		if (Output >= 255)
			Output = 255; 

	

		OCR2 = Output;



		unsigned char Sekunder = 0;  
		TCCR1B = _BV(CS10) | _BV(CS11); 

		for (;;)
   		{ 
     
       		if (TCNT1 >= 15625) 
      		{ 
         		TCNT1 = 0; 
         		Sekunder++; 

         		if (Sekunder == 60)  
         		{ 
            		Sekunder = 0;  
					goto retrigger;
            		
         		} 
      		} 
   		}
		


    }

}

Men jag har ingen reaktion alls på pinnen... Vad är det jag missar???

Otålig

[Icecap]

Hmmmm ..... AVR ...... Det är ju väldigt tydligt utan kommentarer *NOT*

Mitt förslag är att du använder timern till att ge interrupt, där gör du din sekund-räkning, sedan minut-räkningen och vid lämpliga tider sätter du en flagga som indikerar att du ska utföra en reglering.

Kod: Markera allt

typedef unsigned int  word;
typedef unsigned char byte;

byte Seconds, Minutes, Regulate_Timer;
volatile byte Regulate;

int Diff;

Timer_ISR:
  {
  static word Prescale;
  if(++Prescale > ETTVISSTVÄRDE)
    {
    if(++Seconds >= 60)
      {
      Seconds = 0;
      Minutes++;
      }
    if(Regulate_Timer)
      {
      if(!--Regulate_Timer)
        {
        Regulate_Timer = REGULATETIMEINTERVAL;
        Regulate = 1;
        }
      }
    }
  }

void main(void)
  {
  ... // Initiering av timer osv.
  while(1) // Kör i all evighet
    {
    if(Regulate) // Ahaa, det ska regleras!!!
      {
      Regulate = 0; // OK, vi gör det nu, rensa flaggan!
      Diff = Target_Value - 28; // <--- Ska hämta värde från sensor... 
      I_Summa += Diff * I_Factor; 
      Output = I_Summa + Diff * P_Factor;
      if(Output >= 255) Output = 255;
      OCR2 = Output;
      }
    }
  }

Att använda 'goto' i ett C-program är ett nödfall, är man tvungen att göra det är det antingen ytterst speciella omständigheter eller en dålig struktur i programmet! Likaså kan det vara tveksamt att definiera variabler mitt i programmet, de bör definieras innan programmet börjar, om det så är i headern på en rutin eller globalt.

"Diff = Target_Value - 28; // <--- Ska hämta värde från sensor..."
Jaha..... hur då? Menar du att du ska göra detta senare?