Voor de geïnteresseerden:
Uitgebereide Uitleg en status update van mijn "max 1 start per dag aan/uit warmtepomp regeling"
Op verzoek van met name @Hippe Lip
NB.. Er zitten nog wat kleine onregelmatigheden in maar het is operationeel, het draait nu 41 dagen zonder grote problemen.
Zie
HIER voor de uitgebreide uitleg van mijn setup.
In het kort:
- Ik heb 2x Vaillant Geotherm vws36/4.1 3kW aan/uit warmtepomp.
- Ik heb dus 3 mogelijkheden: beiden uit, 1 aan, beiden aan.
- Ik heb een regelaar gemaakt die per dag maximaal 1x warmtepomp aan, en maximaal 1x uit schakelt.
De reden dat ik dat gemaakt heb is omdat "starts" sterk bepalend zijn voor de levensduur van de warmtepomp.
De data...
Het draait sinds 14 januari, dus 41 dagen
Sindsdien:
- linker warmtepomp heeft 20 runs gedaan dus ongeveer een halve run per dag
- rechter warmtepomp heeft 17 runs gedaan dus minder dan een halve run per dag
Geslaagd dus, minder dan 1 run per dag verdeeeld over 2 warmtepompen
Kwa comfort beleving
- Ik had gedacht dat het met slechts 1 run per dag minder comfortabel zou worden omdat ik compromissen zou moeten doen ten aanzien van de regel-nauwkeurigheid.
- Het omgekeerde blijkt waar: de regeling werkt nauwkeuriger!
De oorzaak ligt in de "traagheid" gecombineerd met de natuurlijke dag/nacht cyclus.
Voorheen regelde ik strak op actuele stooklijn. Echter... Ik had savonds steevast warmte tekort. Met 1 warmtepomp realiseer ik op de vloerverwarming 0.1 a 0.2graad per uur opwarming. Maar na 16:00 neemt de buitentemperatuur en daarmee de "stooklijn target" veel sneller af dan dat de warmtepomp kan bijhouden. De enige manier om dat te compenseren was de vloer artificiel overdag warmer te stoken en dan hopen dat het savonds wel ok was. Op zich ging dat wel maar was wel een beetje "gokken" en sterk buitentemperatuur afhankelijk.
Eigenlijk doet de regelaar dat nu vanzelf. Die rekent uit hoeveel draai-uren er nodig zijn om het om 23:00 nog OK te hebben. Die begint soms om 10 uur ochtends al te stoken.
De woonkamer heeft radiatoren en de serre heeft vloerverwarming. Die combinatie werkt ook perfect. De woonkamer hoeft alleen savonds verwarmd te worden. Het is zodanig uitgekiend dat de "dag-behoefte van de serre-vloer" gecentreerd rond de avond wordt gerealiseerd. Omdat de warmtepomp dus sowieso savonds draait kan de woonkamer-thermostaat op de actuele temperatuur regelen, naar believen warmte vragen en krijgen. Als de woonkamer warmte nodig heeft schakelt de warmtepomp naar de woonkamer, en zo niet, dan schakelt hij naar de vloerverwarming in de serre die daarmee zijn "energie-dump" krijgt.
En vervolgens gebruik ik de tijd tussen 24:00 en 7:00 als "buffer". Alle voorspel-fouten mbt het aantal draaiuren die bij het aanzetten van de warmtepomp werden gemaakt worden gladgestreken door eerder of later af te schakelen op een moment dat het niemand interesseert hoe warm het precies is.
De voorspelling van draaiuren gaat niet op basis van weersvoorspelling maar op basis van de gemiddelde temperatuur van de afgelopen 24 uur. Dat blijkt prima te gaan. Bij het uitzetten blijkt het uiteindelijk benodigde aantal draaiuren maximaal 20% af te wijken van de voorspelling bij het aanzetten. Dat komt neer op maximaal 2 uur meer of minder. Dat is dus gemakkelijk op te vangen tussen 24:00 en 6:00.
Mijn architectuur
Mijn huis heeft een Serre met vloerverwarming en een woonkamer met radiatoren. Ook nog wat andere vertrekken maar die verwarm ik bijna niet, mochten ze toch moeten verwarmen dan gaan ze als "slave" mee met de woonkamer.
Een gebruikelijke regeling zou er uit zien zoals op plaatje 1:
- Een stooklijn bestuurde warmtepomp die zorgt voor een constante circulatie en kamer-regelaars die naar behoefte van die circulatie aftappen.
/f/image/oPjcKTu5RLl8u7YqzKpbJTGF.png?f=fotoalbum_large)
Mijn regelaar heeft echter een architectuur zoals op plaatje 2:
- Niet de warmtepomp regelaar maar de kamer regelaars reageren op buitentemperatuur. Aan de hand daarvan bepalen die de momentane warmtevraag maar ook de totale dagbehoefte aan draaiuren en het aantal draaiuren "dat ze vandaag nog willen hebben".
- De warmtepomp regelaar reageert NIET op de buitentemperatuur maar plant het gevraagde aantal draaiuren zo optimaal mogelijk in.
- Vervolgens mogen de kamers NIET naar behoefte van de circulatie aftappen maar is er een "distributie regelaar" die de kamer op basis van verwacht gebruik prioriteit geeft (in mijn geval: serre overdag, woonkamer savonds)
/f/image/min71RKYpAPQkyij5RM5F9VH.png?f=fotoalbum_large)
Mijn Algorithme
de kamer regelaars maken gebruik van "model parameters"
dTdhr_dTout = afkoeling in graden per uur gedeeld door temperatuurverschil kamer<>buiten.
dTdhr_boost = opwarming in graden per per uur als warmtepomp aan staat
- benodigde draaitijd per dag is daarmee:
sec_day = 3600 * 24 * dTdhr_dTout * (avg_buitentemp - Ttarget) / dTdhr_boost;
- resterende tijd voor de rest van de dag is:
sec_todo = (sec_end - rawtime) * dTdhr_dTout * (avg_buitentemp - Ttarget) / dTdhr_boost
+ 3600 * (Ttarget - temp) / dTdhr_boost;
- voor de woonkamer is de target temperatuur de temperatuur van de thermostaat.
- voor de serre regel ik de vloer temperatuur. De actuele temperatuur meet ik met een sensor in de vloer. De target temperatuur haal ik uit een stooklijn:
Ttarget = temp_target_ + fraction * (temp_target_on -avg_buitentemp);
"fraction" is daarbij gebaseerd op de wetenschap dat er een energiebalans is waarbij heatflow-ruimte-naar-buiten gelijk is aan heatflow-vloer-naar-ruimte
heatflow-ruimte-naar-buiten = Kout *(temp_binnen - temp_buiten)
heatflow-vloer-naar-ruimte = Kfloor * (temp_vloer - temp_binnen)
dus:
Kfloor * (temp_vloer - temp_binnen) = Kout *(temp_binnen - temp_buiten)
oftewel:
temp_vloer = temp_binnen + Kout/Kfloor *(temp_binnen - temp_buiten)
= temp_binnen + fraction *(temp_binnen - temp_buiten)
Ik kan de twee K waardes niet berekenen, maar het quotient "fraction" wel.
adaptieve zelfcalibratie van de model parameters
Elke ochtend om 7:00 een 20% moving average update van fraction.
Om 7:00 omdat dan de invloed van gebruik van de dag ervoor minimaal is en er nog geen zon instraling is.
Ik heb experimenteeel verschillende tijden geprobeerd, 7:00 gaf de meest stabiele waarde.
fraction = 0.8*fraction + 0.2* (floor.temp-temp.temp)/(temp.temp-buitentemp);
Over elke "run" of "rust" periode bepaal ik de temperatuur verandering per uur:
dTdhr = (Tnow - Tstart)/((sec_now - sec_start)/3600.0); //temp change per hour, negative if wait; positive if boost
Na elke periode "rust"
20% moving average update van dTdhr_dTout:
dTdhr_dTout = 0.8*dTdhr_dTout + 0.2* dTdhr/(0.5*(Tnow + Tstart) - Tavg_out);
Na elke periode "heatpump actief"
20% moving average update van dTdhr_boost:
dTdhr_boost = 0.8*dTdhr_boost + 0.2* dTdhr/amount_of_heatpumps - dTdhr_dTout * (0.5*(Tnow + Tstart) - Tavg_out);
(deze formuel werkt dus voor meerdere heatpumps in parallel bedrijf)
warmtepomp regelaar
De warmtepomp regelaar kent een "state model":
INACTIVE
periode tot 3:00 snachts
er veranderd niks aan de besturing
tijdstip voor nieuwe "pivot tijd" en niet "inactive tijd" wordt berekend.
na 3:00 wordt state "FOOR_RUNOUT"
FLOOR_RUNOUT
periode tot "checkpunt vloer temperatuur".
"checkpunt vloer temperatuur" is instelbaar met klok theermostaat
Staat momenteel op 7:00
Tijdens deze periode wordt al gecheckt of er de komende 24uur meer warmtepomp uren nodig zijn dan in de resterende tijd passen. Als dat zo is wordt een warmtepomp bijgeschakeld
na "checkpunt vloer temperatuur" wordt state "ACTIVE"
ACTIVE
Tijdens deze periode wordt gekeken of de totale "voor vandaag resterende draaiuur behoefte" past in de resterende tijd.
Er is en instlbare pivot_tijd, die staat nu op 19:00.
Er wordt een warmtepomp bijgeschakeld als 2/3 van het "extra benodigde draaiuren" voor 19:00 past
Daarmeee wordt de dagbehoefte aan draaiuren dus op "2/3 voor 19:00" en "1/3 na 19:00" gepland.
Er wordt ook bijgehouden of aan de draaiuurbehoeft is voldaan. Als dat zo is dan wordt de state "ALL_DONE"
RAD_DONE, substate van "ACTIVE", registreert dat radiators "done" zijn.
FLOOR_DONE, substate van "ACTIVE", registreert dat vloerverwarming "done" is.
ALL_DONE
De dagbehoefte voor vandaag is dus gedaan.
Er wordt gecheckt of de dagbehoefte voor de volgende dag met 1 warmtepomp minder toe kan of dat alle power nodig is.
Als het met 1 minder toe kan wordt 1 warmtepomp afgeschakeld.
volgende state is "INACTIVE"
CYCLE_INIT
Initialisatie als het programma opstart
distributie regelaar
savonds krijgen de radiatoren voorraang
Overdag en snachts krijgt de vloerverwarming in de serre voorrang
code
de code is "bijna" origineel, ik heb het wel wat "cleaned" voor heeel specifieke zaken die buiten de regelaar vallen
code: calibratie module
code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
| int control_group_calibrate( heatgroup *X, int heat_mode, int group_run, float *sample_buitentemp, float buitentemp )
{ time_t sec_now;
struct tm *tt;
float Tavg_out;
int Tavg_nr;
int i;
int i_now;
int i_start;
int running;
float dTdhr;
float Tnow;
float newK;
float floor_target;
running = group_run;
if (X->running_old<0)
{ X->running_old = running; //in case of init do not trigger run-change action
X->sec_start = 0;
}
// calibrate dTdhr_dTout, dTdhr_boost
// measure over on/off period:
// Tavg_out = average of temps in measured period
// if wp ends a off period:
// dTdhr = (Tend - Tstart)/((sec_end - sec_start)/3600) >> negative because cooling down
// dTdhr_dTout = 0.8*dTdhr_dTout + 0.2* dTdhr/(0.5*(Tend+Tstart) - Tavg_out) >>>is negative number
// if wp ends a on period:
// dTdhr = (Tend - Tstart)/((sec_end - sec_start)/3600) >> postive unless cooldown is too much
// dTdhr_boost = 0.8*dTdhr_boost + 0.2* dTdhr -0.2* dTdhr_dTout * (0.5*(Tend+Tstart) - Tavg_out) >>>is positive number
if ( (running != X->running_old) || ( (sec_now - X->sec_start)>(10*3600 ) && X->sec_start>0) ) //trigger if chnage OR timout at 10hr
{ time(&sec_now);
tt = localtime(&sec_now);
i_now = 2*tt->tm_hour + tt->tm_min/30;
tt = localtime(&X->sec_start);
i_start = 2*tt->tm_hour + tt->tm_min/30;
// Tavg_out = average of temps in measured period
Tavg_out =0.0;
Tavg_nr =0;
for ( i=0; i<48; i++)
{ if ( (i>=i_start && i<=i_now) || !(i<i_start && i>i_now) )
{ Tavg_out += sample_buitentemp[i];
Tavg_nr++;
}
}
Tavg_out = Tavg_out/Tavg_nr;
if ( X->ht_type==FLOOR )
Tnow = X->floor.temp;
else
Tnow = X->temp.temp;
if ( (sec_now - X->sec_start)>(7200 ) && X->sec_start>0 ) //calibrate only if run longer than 2hrs
{ dTdhr = (Tnow - X->Tstart)/((sec_now - X->sec_start)/3600.0); //negative if wait; positive if boost
if (!X->running_old && ((0.5*(Tnow + X->Tstart) - Tavg_out)>5.0) ) //if ending off-stretch AND 5degree out-in difference
{ newK = dTdhr/(0.5*(Tnow + X->Tstart) - Tavg_out); // is negative number
if ( (newK<-0.004) && (newK>-0.04) )
X->dTdhr_dTout = 0.8*X->dTdhr_dTout + 0.2* newK; // is negative number
}
if (X->running_old ) //if ending on-stretch
{ newK = dTdhr/X->running_old - X->dTdhr_dTout * (0.5*(Tnow + X->Tstart) - Tavg_out); //is positive number
if ( (newK<1.0) && (newK>0.1) )
X->dTdhr_boost = 0.8*X->dTdhr_boost + 0.2* newK;
}
}
if ( running != X->running_old ) //initialize in case of state-change
{ X->sec_start = sec_now;
X->Tstart = Tnow;
X->running_old = running;
}
else //reset in case of timeout OR init
{ X->sec_start = 0;
X->Tstart = 0;
X->running_old = running;
}
}
//update automatic calibration of algorithm for floor temperature versus outside temperature
if (X->ht_type==FLOOR)
{ time(&sec_now);
tt = localtime(&sec_now);
if ( (tt->tm_hour==7) && (X->today!=tt->tm_yday) )
{ floor_target = X->temp_target + X->temp_extra
+ X->fraction * (X->temp_target-DTfraction -buitentemp);
if ((heat_mode==WPCV_OFF) || (heat_mode==WP_COOL) )
{ X->temp_extra = 0.0;
}
else if (X->temp.temp>buitentemp+4.0)
{ X->fraction = 0.8*X->fraction + 0.2* (X->floor.temp-X->temp.temp)/(X->temp.temp-DTfraction-buitentemp);
X->temp_extra -= 0.2* ( X->floor.temp - (floor_target - X->temp_extra) );
if (X->temp_extra>2.0) X->temp_extra=2.0;
else if (X->temp_extra<0.0) X->temp_extra=0.0;
}
else
{ X->temp_extra = 0.8*X->temp_extra;
}
X->today = tt->tm_yday;
}
}
return 1;
} |
code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
| int control_group_request( heatgroup *X, float buitentemp, float avg_buitentemp )
{ float smooth_on;
float floor_target;
float Ttarget;
time_t rawtime;
time_t sec_end;
struct tm *tt;
// calculate "seconds todo"
time(&rawtime);
tt = localtime(&rawtime);
tt->tm_hour = 0;
tt->tm_min = 0;
tt->tm_sec = 0;
if (X->ht_type==FLOOR) //Serre, vloerverwarming
{ sec_end = mktime(tt)+60*mins(X->timer1.on);
if (sec_end+1800 <=rawtime ) sec_end += 24*3600; //force half hour zero after done
Ttarget = X->temp_target_on + X->fraction * (X->temp_target_on-DTfraction -avg_buitentemp); //temp target from stooklijn
X->sec_day = 3600 * 24 * X->dTdhr_dTout * (avg_buitentemp - Ttarget) / X->dTdhr_boost;
//+ 3600 * (Ttarget - X->floor.temp) / X->dTdhr_boost; // include same bump as with todo
X->sec_todo = (sec_end - rawtime) * X->dTdhr_dTout * (avg_buitentemp - Ttarget) / X->dTdhr_boost
+ 3600 * (Ttarget - X->floor.temp) / X->dTdhr_boost;
}
else //Radiators
{ sec_end = mktime(tt)+60*mins(X->timer1.off);
if (sec_end+1800 <=rawtime ) sec_end += 24*3600; //force half hour zero after done
Ttarget = 0.5*(X->temp_target_off + X->temp_target_on); // temp target average high/low setting
X->sec_day = 3600 * 24 * X->dTdhr_dTout * (avg_buitentemp - Ttarget) / X->dTdhr_boost;
// + 3600 * (Ttarget - X->temp.temp) / X->dTdhr_boost; // include same bump as with todo
X->sec_todo = (sec_end - rawtime) * X->dTdhr_dTout * (avg_buitentemp - Ttarget) / X->dTdhr_boost
+ 3600 * (X->temp_target_on - X->temp.temp) / X->dTdhr_boost;
//if (X->sec_todo > X->sec_day ) X->sec_todo = X->sec_day ;;
}
if (sec_end<=rawtime)
{ X->sec_todo = 0;
}
else
{ if (X->sec_todo<0) X->sec_todo= 0;
}
return 1;
} |
code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
| int control_global( globalsystem *X, long sec_todo_floor, long sec_day_floor, long sec_todo_rad, long sec_day_rad )
{ time_t sec_now;
struct tm *tt;
time(&sec_now);
switch (X->cycle)
{ case CYCLE_INIT: //INITIALIZE controller
tt = localtime(&sec_now);
tt->tm_hour = X->pivot_hr;
tt->tm_min = 0;
tt->tm_sec = 0;
X->sec_pivot = mktime(tt); //pivot timer in absolute seconds
tt->tm_hour = X->inactive_hr;
X->sec_inactive = mktime(tt) + 24*3600; //inactive timer in absolute seconds
X->hp_level = ( (sec_todo_floor/2 + 2*sec_todo_rad/3 ) > ( (X->sec_pivot>sec_now)?(X->sec_pivot-sec_now+1200):1800 ) );
X->cycle=ACTIVE;
delay_set(&X->blackout_heatpump, 180); //fixed 3min initial blackout
break;
case INACTIVE: // if "all done" early, no state changes until "inactive time_point" (default 03:00)
if ( sec_now>X->sec_inactive && (sec_day_floor + sec_day_rad)>1800 ) //keep inactive until after in_active point AND more than 30min todo
{ if ( sec_now<X->sec_inactive+1800 ) X->cycle = FLOOR_RUNOUT; // only runout if close to inactive time point
else X->cycle = ACTIVE;
tt = localtime(&sec_now);
tt->tm_hour = X->pivot_hr;
tt->tm_min = 0;
tt->tm_sec = 0;
X->sec_pivot = mktime(tt); //pivot timer in absolute seconds
tt->tm_hour = X->inactive_hr;
X->sec_inactive = mktime(tt) + 24*3600; //inactive timer in absolute seconds
} break;
case FLOOR_RUNOUT:
if ( sec_todo_floor<=0) //next state when todo reaches bottom
{ X->cycle=ACTIVE;
}
else
sec_todo_floor += sec_day_floor; // add next day as long todo is not at bottom
//no break
case ACTIVE: // decide to step-up if time before pivot can absorp 2/3 of todo_hours (if hp_off, 1/2 of todo_floor & 2/3 of todo_rad to bring on-time a bit later)
if ( !delay_active(&X->blackout_heatpump) && X->hp_level<X->nr_heatpumps && X->sec_inactive>sec_now &&
( (!X->hp_level && (sec_todo_floor/2 + 2*sec_todo_rad/3 ) > ( (X->sec_pivot>sec_now)?(X->sec_pivot-sec_now):0 ) )
|| ( X->hp_level && 2*( sec_todo_floor + sec_todo_rad - (long)((X->sec_inactive+7200-sec_now)*X->hp_level) )/3 > ( (X->sec_pivot>sec_now)?(X->sec_pivot-sec_now):0 ) )
) )
{ X->hp_level++;
delay_set(&X->blackout_heatpump, 60*X->min_blackout_heatpump_on);
}
// no break
case RAD_DONE: // no step-up after rad_done
case FLOOR_DONE: // no step-up after floor_done
if ( sec_now+3600 > X->sec_pivot) // no "done" conclusions until 1 hr before pivot hr (this adsorbs the half hour minimum for step-up)
{ if (X->cycle==RAD_DONE) sec_todo_rad =0; // if rad_done triggered, force todo to zero even if got positive again
if (X->cycle==FLOOR_DONE) sec_todo_floor =0; // if floor_done triggered, force todo to zero even if got positive again
if ( !X->hp_level && (sec_todo_floor + sec_todo_rad) <= 1800 ) X->cycle=ALL_DONE; // if heatpump not running, donot start it for only 30mins
else if ( X->hp_level &&
(sec_todo_floor + sec_todo_rad) <= ( (X->sec_inactive+7200>sec_now)?( (X->sec_inactive+7200-sec_now)*(X->hp_level-1) ):0 )
// "all done" if remaining time to inactive+2hr is enough to fullfill demand with 1 heatpump less
) X->cycle=ALL_DONE;
else if ( sec_todo_rad <=0 ) X->cycle=RAD_DONE; //if rad done, prevent from getting undone
else if ( sec_todo_floor<=0 ) X->cycle=FLOOR_DONE; //if floor done, prevent from getting undone
}
break;
case ALL_DONE: // FINALIZE cycle, start counting run-hours again
if ( !delay_active(&X->blackout_heatpump) ) //cycle stops if radiators are non_active AND serre done ....
{ if ( X->hp_level && (sec_day_floor + sec_day_rad) < ( ((X->sec_inactive>sec_now)?(X->sec_inactive-sec_now):0) +24*3600 )*X->hp_level )
//step down if total todo in 1 day less than can be done at current run level
{ X->hp_level--;
delay_set(&X->blackout_heatpump, 60*X->min_blackout_heatpump_off);
}
X->cycle = INACTIVE;
} break;
default: break;
}
return 1;
} |
code:
1
2
3
4
5
6
7
8
9
10
11
12
13
| int control_distribution( globalsystem *X, long sec_todo_floor, long sec_todo_rad, int rad_active )
{ if (!X->hp_level) X->heat_state= WPCV_OFF;
else if (rad_active && sec_todo_rad && !sec_todo_floor) X->heat_state= WP_HOUSE; // finish todo rad during rad_active
else if (rad_active && X->radiator_need ) X->heat_state= WP_HOUSE; // follow rad need during rad_active
else if (X->cycle==INACTIVE || X->cycle==FLOOR_RUNOUT) X->heat_state= WP_FLOOR; // floor must finish before radiator can pickup
else if (!rad_active && X->serre_need ) X->heat_state= WP_FLOOR; // follow floor need if radiator is not active
else if (X->radiator_need ) X->heat_state= WP_HOUSE; // in all other cases, follow rad need
else if (sec_todo_floor ) X->heat_state= WP_FLOOR; // finalize floor todo if no rad need
else if (sec_todo_rad ) X->heat_state= WP_HOUSE; // finalize rad todo if floor todo is done
else X->heat_state= WP_FLOOR; // floor as default (appearantly no radiator need)
return 1;
} |
compleet zelfbouw/zelfprogrammeer home-automation, 57 PV panelen 9000kWh/jaar, 135heatpipes 150L zonneboiler met elektrische naverwarming, 2x Vaillant water/water warmtepomp vws36/4.1 3kW, smartEVSE laadpaal, 1wire/X10/P1, jacuzzi, sauna, ioniq5 EV
. Alleen waarom er dan binnenlandse warmtepompen naast staan.. Wat mag dat dan betekenen? (Haalt bij mij vooral het vertrouwen in de info omlaag.)
:strip_exif()/u/72870/crop5db2a0081b965.gif?f=community)
:fill(white):strip_exif()/f/image/oPjcKTu5RLl8u7YqzKpbJTGF.png?f=user_large)
:fill(white):strip_exif()/f/image/min71RKYpAPQkyij5RM5F9VH.png?f=user_large)
:strip_icc():strip_exif()/u/4202/crop59500930db0d0_cropped.jpeg?f=community)
:strip_exif()/u/55543/crop5eb8fd6c1bf0a_cropped.gif?f=community)
). :no_upscale():strip_icc():fill(white):strip_exif()/f/image/88pvd0fVNvVorXq1K0NzJOcj.jpg?f=user_large)
:no_upscale():strip_icc():fill(white):strip_exif()/f/image/CkgZjN5yjNqrtqXQbaRgMLQ3.jpg?f=user_large)
:fill(white):strip_exif()/f/image/CwOjYZRMwG4IqmTHuR5jC8CV.png?f=user_large)
:fill(white):strip_exif()/f/image/jBXoBwLBn9DkXSF41k0QAF8U.png?f=user_large)
:strip_icc():strip_exif()/u/396258/crop5c58365079ffa_cropped.jpeg?f=community)
:fill(white):strip_exif()/f/image/wuFCi0B48jHpgzpmdorswGRF.png?f=user_large)
:fill(white):strip_exif()/f/image/5cm2Zdg6Ui06nierSPvW1Pig.png?f=user_large)
:strip_exif()/u/134619/tanuki.gif?f=community)
:fill(white):strip_exif()/f/image/CV3wtoDqDCfvtBCAWbCSQwYs.png?f=user_large)
:fill(white):strip_exif()/f/image/JkM8lE1dgy9I7HTp1wk2ZIds.png?f=user_large)
:fill(white):strip_exif()/f/image/4ZzI4fTnrR5nLhzmPGaX9xxb.png?f=user_large)
:fill(white):strip_exif()/f/image/g6E6do4H1xLdeimlcjuqU45J.png?f=user_large)
:fill(white):strip_exif()/f/image/yL31PghVuxKYtxFv6c6LumJZ.png?f=user_large)
:fill(white):strip_exif()/f/image/3vVPHrZedULh1BS2gUb8acZz.png?f=user_large)
:fill(white):strip_exif()/f/image/cdy8NR80j5x9NYbIUpgMzzS3.png?f=user_large){kind=link}
