du kan använda en annan metod, du behåller det aktuella genomsnittet och gör sedan

  genomsnitt = (vikt1 * genomsnitt + vikt2 * nytt_värde) / (vikt1 + vikt2);  

det är inte ett riktigt rullande medelvärde och har olika semantik, men det kan ändå passa dina behov

för en mer effektiv beräkningsmetod för dina 9 bitar per lösning kan du behålla 8 högsta bitar av värdena i en matris och separera de minst signifikanta bitarna:

  uint8_t [28] highbits; uint32_t lowbits;  

för att ställa in ett värde du måste dela upp det

  void getvalue (uint8_t index, uint16_t value) {highbits [index] = value>>1; uint32_t flagga = (värde & 1) <<index; highbits | = flagga; highbits& = ~ flagga;}  

vilket resulterar i 2 skift en AND och en OR och en inte

för att beräkna genomsnittet kan du använda olika bit tricks för att påskynda det :

  uint16_t getAverage () {uint16_t sum = 0; för (uint8_t i = 0; i<28; i ++) {sum + = highbits [i]; } sum<< = 1; // multiplicera med 2 efter slingans summa + = bitantal (lowbits); retursumma / 28;}  

du kan använda ett effektivt parallellt bitantal för bitcount()

Om dina data har låg standardavvikelse skulle en metod vara att summera värden över fönstret och sedan fortsätta subtrahera medelvärdet från summan samtidigt som du lägger till det nya värdet.

Detta skulle fungera bra om det inte finns inga avvikelser , vilket leder till att det sammanlagda felet tenderar till noll över tiden.

  // Pseudokodräkning = 0 medan nyläsning och count<7: sum + = new_reading // Beräkna summan av de första 7 värdena räknas ++ medan ny läsning: // Loop till nya avläsningar tillgängliga avg = summa / 7 // Beräkna genomsnittlig summa - = avg // Subtrahera genomsnitt från summasumma + = new_reading // Lägg till nästa avläsning till summan skriv avg  

Vad sägs om att bara lagra skillnaden från det tidigare värdet? Inom elektronik finns ett liknande koncept som kallas Delta Sigma-omvandlare, som används för DA / AD-omvandlare. Det förlitar sig på det faktum att den tidigare mätningen är rimligt nära den nuvarande.

Varför kunde du inte bara lägga till värdena så snart du fick dem. Så vad jag menar är att du får värdet för dag 1, du delar det med 1 och lagrar det och 1 någonstans. Sedan multiplicerar du 1 med värdet och lägger till det till nästa värde och delar dem båda med 2.

Att göra den här metoden skulle skapa ett rullande medelvärde med två eller tre variabler som jag kan tänka mig. Jag skulle skriva lite kod men jag är ny på stackexchange så snälla ha med mig.

finns det ett mer effektivt sätt att beräkna ett glidande medelvärde med ... 28 dagar och 7 dagar? ... behöver komma ihåg 27 dagars historia ...?

Du kan komma tillräckligt nära lagring av 11 värden snarare än 28 värden, kanske något som:

  // oproverad kod // statiska variabler // kanske i enheter på 0,01 kWh? uint16_t vecka_energi [4]; // kanske i enheter på 0,1 kWh? void print_week_status () {Serial.print (F ("förra veckans totala energi:")); Serial.println (vecka_energi [0]); int summa = 0; för (int i = 0; i<4; i ++) {sum + = vecka_energi [i]; }; Serial.print (F ("Total energi under de senaste fyra fullständiga veckorna:")); Serial.println (summa); int genomsnitt_vecka_energi = summa / 4; int genomsnittlig_energi = genomsnittlig_energi / 7; Serial.print (F ("Genomsnittlig daglig energi de senaste 4 veckorna:")); Serial.println (average_daily_energy);} ogiltig print_day_status () {Serial.print (F ("gårdagens energi:")); Serial.println (daglig_energi [0]); Serial.print (F ("genomsnittlig daglig energi under de senaste sju hela dagarna:")); int summa = 0; för (int i = 0; i<7; i ++) {sum + = daglig_energi [i]; }; int genomsnitt = summa / 7; Serial.println (genomsnitt);}  

Med andra ord, snarare än att lagra varje detalj varje dag under de senaste 27 dagarna, (a) lagra 7 eller så värden med detaljerad daglig information för de senaste sju dagarna, och (b) lagrar fyra eller så "sammanfattade" värden för total eller genomsnittlig information för var och en av de senaste fyra eller så veckorna.