LaundrySorcery

laundrysorcery.c (4343B)

---

 
 #include <stdio.h>
 #include <wiringPi.h>
 #include <time.h>
 #include <rrd.h>
 #include <math.h>
 
 typedef struct {
 	double mean;
 	double variance;
 	unsigned int measurements;
 } Gaussian;
 
 
 void update_gaussian_lambda(Gaussian *g, double value, double lambda){
 	g->mean=g->mean*lambda+(1-lambda)*value;
 	g->variance=g->variance*lambda+(1-lambda)*value*value;
 	unsigned int tmp=g->measurements++;
 	if(tmp > g->measurements){
 		g->measurements=tmp;
 	}
 }
 
 #define MIN_MEASURES 100
 
 double calculate_lambda(Gaussian *g){
 	double lambda=0.75+0.25/MIN_MEASURES*g->measurements;
 	lambda=fmin(lambda,0.999995);
 	return lambda;
 }
 
 void update_gaussian(Gaussian *g, double value){
 	update_gaussian_lambda(g,value,calculate_lambda(g));
 }
 
 
 double get_sigma(Gaussian *g){
 	return (g->variance - (g->mean * g->mean));
 }
 
 double get_stdev(Gaussian *g){
 	return sqrt(get_sigma(g));
 }
 
 Gaussian g_on,g_off;
 int on=0;
 Gaussian *current=&g_off;
 struct timespec timestamp;
 double running_mean;
 
 char *on_file;
 char *log_file;
 
 void write_log_file(char *term){
 	if(!log_file)
 		return;
 	FILE *f=fopen(log_file, "a");
 	if(!f){
 		perror("fopen of log file");
 		return;
 	}
 	fprintf(f, "%lu%s", time(NULL), term);
 	fclose(f);
 }
 
 void write_on_file(char *prefix){
 	FILE *f=fopen(on_file, "w");
 	if(!f){
 		perror("fopen of on_file");
 	}
 	fprintf(f, "%s%lu\n",prefix, time(NULL));
 	fclose(f);
 }
 
 void turn_on(void){
 	write_on_file("");
 	write_log_file(" ");
 }
 
 void turn_off(void){
 	write_on_file("-");
 	write_log_file("\n");
 }
 
 void toggle_on_off(void){
 	if(on){
 		on=0;
 		current=&g_off;
 		turn_off();
 	}
 	else{
 		on=1;
 		current=&g_on;
 		turn_on();
 	}
 }
 
 int guess_is_on(double delta_t){
 	if(g_on.measurements==0){
 		return fabs(delta_t-current->mean)>5*get_stdev(current);
 	}
 	else{
 		//we assume that sigma_on == sigma_off here, to make the calculation simpler
 		if(fabs(delta_t-g_on.mean)>fabs(delta_t-g_off.mean)){ // closer to "off"
 			return 0;
 		}
 		else{
 			return 1;
 		}
 	}
 }
 
 int guess_if_toggle(double delta_t){
 	return guess_is_on(delta_t)^on;
 }
 
 void process_datapoint(double delta_t){
 	static unsigned int consecutive_outliers=0;
 	static Gaussian tmp={0,0,0};
 	running_mean=(running_mean+delta_t)/2;
 	if(current->measurements>MIN_MEASURES){
 		if(guess_if_toggle(delta_t)){
 			if(consecutive_outliers == 0){
 				tmp=*current;
 			}
 			if(consecutive_outliers++>100){
 				toggle_on_off();
 				consecutive_outliers=0;
 			}
 			update_gaussian(&tmp,delta_t);
 			return;
 		}
 		else{
 			if(consecutive_outliers>0){
 				*current=tmp;
 				consecutive_outliers=0;
 			}
 		}
 	}
 	update_gaussian(current,delta_t);
 }
 
 void falling_edge(void) {
 	clock_gettime(CLOCK_MONOTONIC, &timestamp);
 	digitalWrite (0, HIGH);
 }
 
 void rising_edge(void) {
 	struct timespec timetemp;
 	clock_gettime(CLOCK_MONOTONIC, &timetemp);
 	double delta_t = (double)(timetemp.tv_sec - timestamp.tv_sec) * 1.0e6 +
               (double)(timetemp.tv_nsec - timestamp.tv_nsec)*1e-3;
 	digitalWrite (0, LOW);
 	static unsigned int measurements=0;
 	unsigned int tmp=measurements++;
 	if(tmp>measurements) measurements=tmp;
 	if(measurements>50){
 		process_datapoint(delta_t);
 	}
 }
 
 
 
 void edge(void) {
 	if(digitalRead(1)==0)
 		falling_edge();
 	else
 		rising_edge();
 }
 
 unsigned long microseconds_since(struct timespec ts){
 	struct timespec now;
 	clock_gettime(CLOCK_MONOTONIC, &now);
 	return (unsigned long)(now.tv_sec - ts.tv_sec)*1000000 + (unsigned long)(now.tv_nsec - ts.tv_nsec)/1000;
 }
 
 
 int main(int argc, char **argv)
 {
 	wiringPiSetup () ;
 	pinMode (0, OUTPUT) ;
 	pinMode (1, INPUT) ;
 	if(!(argc == 2 || argc == 3)){
 		printf("Usage: %s </path/to/onfile> [/path/to/log_file]\n", argv[0]);
 		return 0;
 	}
 	on_file=argv[1];
 	if(argc == 3){
 		log_file=argv[2];
 	}
 
 	digitalWrite (0, LOW);
 	delay(5);
 	digitalWrite (0, HIGH);
 
 	turn_off();
 
 	char buffer[512];
 	const char* arr[]={buffer};
 	struct timespec secondtimer;
 	clock_gettime(CLOCK_MONOTONIC, &secondtimer);
 	while(1) {
 		while(digitalRead(1)==0){
 			;
 		}
 		rising_edge();
 		while(digitalRead(1)==1){
 			;
 		}
 		falling_edge();
 		if(microseconds_since(secondtimer)>1000000){
 			snprintf(buffer,sizeof(buffer),"%lu:%e:%e:%e:%e:%e:%d",(unsigned long)time(NULL),running_mean,g_off.mean,g_off.variance,g_on.mean,g_on.variance,on);
 			rrd_update_r("database.rrd", NULL, 1, arr);
 			clock_gettime(CLOCK_MONOTONIC, &secondtimer);
 		}
 	}
 	return 0;
 }