/*
 * 	alarmchata.c ... receiver of wireless meteostation data combined with a simple alarm
 *
 * 	Copyright (C) 2010-2013 Jiri Pittner <jiri@pittnerovi.com>
 *
 * 	This program is free software: you can redistribute it and/or modify
 * 	it under the terms of the GNU General Public License as published by
 * 	the Free Software Foundation, either version 3 of the License, or
 * 	(at your option) any later version.
 *
 * 	This program is distributed in the hope that it will be useful,
 * 	but WITHOUT ANY WARRANTY; without even the implied warranty of
 * 	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * 	GNU General Public License for more details.
 * 	You should have received a copy of the GNU General Public License
 * 	along with this program.  If not, see <http://www.gnu.org/licenses/>.
 * 	                                         
 * 	                                        
*/

/*
 * alarm chata atmega32, 14.7456MHz
 * UPLOAD2 flash+eeprom!!!
*/

//??? Reports from pir sensors via interrupt when disarmed?


#undef DEBUG
#define printsw print
#define printswP printP

#define AUTO_ON_PWR
#define BAUD 115200
#undef UART_ECHO


//always
#define ALARM_PULSE_WIDTH 200


#if (XTAL == 14745600L)
#define oversampling 4
#else
#define oversampling 2
#endif


#include "backward.h"

#include <stdio.h>
#include <string.h>
#include <stdarg.h>
#include <stdlib.h>
#include <ctype.h>
#include <setjmp.h>

#include <avr/io.h>
#include <avr/pgmspace.h>
#include <avr/eeprom.h>
#include <avr/interrupt.h>
#include <avr/sleep.h>
#include <avr/wdt.h>

#include "alarmchata.h"
#include "meteo2_keys.h"
#include "meteo2.h"

#define useled
#define THERMO
#define NTHERMO 2
#define TEMPPORT PINC
#define TEMPPULLUP PORTC
#define TEMPDDR DDRC
#define TEMPPIN0 PC0
#define TEMPPIN1 PC1
#define RELAY
#define RELAY0 PC3
#define RELAY1 PC4
#define RELAY2 PC5
#define AUTO_ON


#define itoa10(N,S) itoa(N,S,10)
#define itoa16(N,S) itoa(N,S,16)


static int16_t temper[NTHERMO];
static volatile jmp_buf env;

/*atmel specific utilities*/

watchdog(uint8_t onoff)
{
#if(MCU==atmega168)
wdt_enable(WDTO_8S); wdt_reset(); return;
#else
if(onoff) {wdt_enable(WDTO_2S); wdt_reset();}
else {wdt_reset();wdt_disable();}
#endif
}

#define UCR UCSRB
#define UART_INIT(baud) { \
UBRRH=0; \
UBRRL= (XTAL/baud+15)/16-1; \
UCSRB=(1<<TXEN)|(1<<RXEN); \
UCSRC=(1<<URSEL)|(1<<UCSZ0)|(1<<UCSZ1)|(1<<USBS); }

void print(char *string){
                   while (*string) {
                   loop_until_bit_is_set(UCSRA, UDRE);
                   UDR = *string++;
                   }
                   return;
                 }

void printP(PGM_P string){
        char c;
        c=pgm_read_byte(string);
                   while (c) {
                   loop_until_bit_is_set(UCSRA, UDRE);
                   UDR = c;
                   c=pgm_read_byte(++string);
                   }
                   return;
                 }

volatile uint8_t inuartlen=0;
#define INUARTMAX 128
volatile char inuart[INUARTMAX];
INTERRUPT(SIG_UART_RECV)
{
inuart[inuartlen]=UDR;
inuartlen = (inuartlen+1)&127;
}


//keeloq routines
#include "keeloq1.h"
#include "keeloq1.c"



//relay control
static uint8_t relays_all  __attribute__ ((section(".eeprom")))=0;

//PC3,4,5 control ext. relays
void relay(uint8_t n, uint8_t on)
{
if(n<3||n>5) return;
if(on) sbi(PORTC,n); else cbi(PORTC,n);
uint8_t all =  (PORTC>>3)&7;
if(all!=eeprom_read_byte(&relays_all)) eeprom_write_byte(&relays_all,all);
char c[32];
sprintf(c,"Ext. relay %d = %d\n",n,on);
print(c);
}

uint8_t relaytoggle(uint8_t n)
{
if(n<3||n>5) return 0;
uint8_t on = (PORTC>>n)&1;
on ^= 1;
relay(n,on);
return on;
}

void relays(uint8_t all)
{
uint8_t x = PORTC & (~(7<<3));
all &= 7;
x |= (all<<3);
PORTC=x;
if(all!=eeprom_read_byte(&relays_all)) eeprom_write_byte(&relays_all,all);
}




///////////////////////////////////////////////////////////////////////////
//receive routines
#define MAX(a,b) ((a)<(b)?(b):(a))
#define MESSAGE_BYTES MAX(16,sizeof(METEO2_DATAGRAM))
#define MAXCODELEN (MESSAGE_BYTES+1)
volatile uint8_t incode[MESSAGE_BYTES+1];
volatile uint8_t incodelen=0; //0 indicates ready to receive, non-zero indicates ready to read it in main
volatile static uint8_t bitcount=0, bytecount=0; //working counters

typedef enum {noise,upmark,ready} STATE;

//receive routine for the code-hopping car remote - PWM coded

void receive_car2(uint16_t time1, uint16_t time0)
{
static STATE state=noise;
static uint8_t headercount=0;
//{char c[6]; print(itoa(time1,c,10)); print(":"); print(itoa(time0,c,10)); print("\n"); }
switch(state) {
	case noise: 
		if(abs(time1-time0)<=2*oversampling) headercount++; else headercount=0;
		if(headercount>6) state=upmark;
		break;
	case upmark:
		if(time1>=3*oversampling && time1<=6*oversampling && time0>=30*oversampling&& time0<=60*oversampling) {state=ready; incode[0]=bitcount=bytecount=0;break;}
		if(time1>=3*oversampling && time1<=6*oversampling && time0>=3*oversampling && time0<=6*oversampling) headercount++; else {state=noise; headercount=bitcount=bytecount=0;}
		break;
	case ready:
		//{char c[6]; print(itoa(time1,c,10)); print(":"); print(itoa(time0,c,10)); print("\n"); }
		if(time1==time0||time1<2*oversampling || time1 >12*oversampling || time0<2*oversampling) {state=noise; incode[0]=incodelen=bitcount=bytecount=0; break;} //unexpected abort
		incode[bytecount]|= (time1>time0?0:1)<<bitcount++;
		if(bitcount==8) {bitcount=incode[++bytecount]=0; }
		if(time0>60*oversampling || bytecount>=MESSAGE_BYTES+1) {state=noise; incodelen=bitcount+(bytecount<<3)-1; } //legal end of transmition
		break;
	}
}


void receive_car(uint8_t level,uint16_t time)
{
static uint16_t time1=0;
//{char c[6]; print(level?"1:":"0:"); print(itoa(time,c,10)); print("\n");}
if(level) time1=time; else receive_car2(time1,time);
}



static uint16_t count[2]={0,0};
static uint8_t laststate=0;

//this generates a run length encoded stream of data from the receiver and passes control to specialized decoders
//but it seems to work reasonably like this
INTERRUPT(SIG_OUTPUT_COMPARE1B)
{
uint8_t state;
TCNT1=0; //with B it cannot run in CTC mode
state=(PIND&(1<<PD6))?1:0;
if(state==laststate) {if(++count[state]<=100*oversampling) return;}
//state!=laststate or same state for too long
	{
	uint8_t l;
	uint16_t t;
	t=count[l=laststate];
	laststate=state;
	count[state]=1;
	count[l]=0;
	if(incodelen) return; //buffer is full, main has to read it - ignore new data
	receive_car(l,t);
	}
}


static uint8_t receiving=0;
void do_receive(uint8_t onoff)
{
receiving=onoff;
incodelen=0;
if(onoff)
	{
	cbi(DDRD,PD6);
	cbi(PORTD,PD6);
	TCCR1B=CK; //no prescale
	TCCR1A=0;
	OCR1B=XTAL/10000/oversampling; //minimum recommended sampling = 10000
	//activate interrupts for receive
	TCNT1=0;
	sbi(TIMSK,OCIE1B);
	sbi(SREG,7);
	}
else
	{
	incodelen=0;
	cbi(TIMSK,OCIE1B);
	TCCR1B=0; //no prescale
        TCCR1A=0;
        OCR1B=0;
	}
}



//end receive routines
///////////////////////////////////////////////////////////////////////////////


void delay_xs(uint16_t xs)  //xs takes 4 clocks time
{
        asm volatile (
        "\n"
        "L_dl1%=:" "\n\t"
        "sbiw %0, 1" "\n\t"
        "brne L_dl1%=" "\n\t"
        : "=&w" (xs)
        );
        return;
}

void delay_ms(uint16_t ms) //ms takes 1/1000 s
{
while(ms--) delay_xs(XTAL/4/1000);
}



INTERRUPT(SIG_OVERFLOW1) { return; }

void delay_cs(uint16_t cs) //NOTE - will be ended prematurely by uart interrupt
{
delay_ms(10*cs);
}




/*definition of variables in eeprom memory storage*/
static uint8_t alarm_pending __attribute__ ((section(".eeprom"))) = 0;
static uint8_t  alarm_active __attribute__ ((section(".eeprom"))) = 0;
static uint8_t  alarm_armed  __attribute__ ((section(".eeprom"))) = 0;



//watchdog of the linux server
static volatile uint16_t rpiwatch;
static volatile uint8_t centiseconds;
static uint16_t rpiwatchmax;

INTERRUPT(SIG_OUTPUT_COMPARE0)
{
if(++centiseconds == 100)
        {
        centiseconds = 0;
        ++rpiwatch;
        }
}




//interrupt for alarm circuit

INTERRUPT(SIG_INTERRUPT0) 
{
cbi(GIMSK,INT0); //disable further occurence of this interrupt
cbi(SREG,7);
delay_ms(ALARM_PULSE_WIDTH); //prevent short spikes to cause false alarms
if( bit_is_clear(PIND,PD2) && (eeprom_read_byte(&alarm_pending)==0||eeprom_read_byte(&alarm_pending)==0xff)) eeprom_write_byte(&alarm_pending,1);
sbi(SREG,7);
sbi(GIMSK,INT0);
return;
}


void interrupt(uint8_t x)
{
//always set the INT0 bit as a input (without internal pull-up)
cbi(DDRD,PD2);
cbi(PORTD,PD2);


if(x) 
	{sbi(MCUCR,ISC01); cbi(MCUCR,ISC00); sbi(GIMSK,INT0); sbi(SREG,7);}
else 
	{cbi(GIMSK,INT0); cbi(GIMSK,INT1); }
}


int8_t eepromcmp(volatile uint8_t bitlen, const volatile uint8_t *code, const FIXEDCODE433 *eepromp)
{
register uint8_t i;
register int8_t z;
i=eeprom_read_byte(&eepromp->len);
if(bitlen==0 || i==0|| i == 0xff) return 1;
if(i!=bitlen) return i-bitlen;
//last received bit is just the battery-low indicator, skip it!
if(i==65) i=64;
//we are lazy for this simple alarm to implement here keeloq, just
//skip first 4 bytes of floating code, compare only the fixed portion of the code + button codes
uint8_t offset = 4;
code += 4;
i -= 32;
i=(i+7)>>3;
for(;i>0; --i) if(z=eeprom_read_byte(& eepromp->code[offset++])- *code++) return z;
return 0;
}



uint8_t  process_fixedcode(uint8_t xincodelen, uint8_t *xincode)
{
uint8_t i;
for(i=0;i<MAXFIXEDCODES;++i) 
	{
	if(!eepromcmp(xincodelen,xincode,&fixed_codes[i]))
		{
		if( eeprom_read_byte(&alarm_armed)!=0 && (eeprom_read_byte(&alarm_pending)&0xf)==0 && eeprom_read_byte(&alarm_active) != 1) eeprom_write_byte(&alarm_pending,i+2);
		char c[16];
		sprintf(c,"A: %d = 2\n",i+1);
		print(c);
		return 1;
		}
	}
return 0;
}



void armdisarm(uint8_t x)
{
interrupt(x);
char c[16];
uint8_t i;
//for(i=0; i<N_CIRCUITS; ++i) //act on all circuits 
i=0; //report just for one circuit
	{sprintf(c,"C %d = %d\n",i,x); print(c);}
if(x)
	{
	if(eeprom_read_byte(&alarm_pending)!=0) eeprom_write_byte(&alarm_pending,0);
        if(eeprom_read_byte(&alarm_armed)!=1) eeprom_write_byte(&alarm_armed,1);
        if(eeprom_read_byte(&alarm_active)!=0) eeprom_write_byte(&alarm_active,0);
	}
else
	{
	if(eeprom_read_byte(&alarm_active)!=0) eeprom_write_byte(&alarm_active,0);
        if(eeprom_read_byte(&alarm_armed)!=0) eeprom_write_byte(&alarm_armed,0);
        if(eeprom_read_byte(&alarm_pending)!=0) eeprom_write_byte(&alarm_pending,0);
	}
}




//note: remotes are plausiby assumed to have counter < 32768, i.e. within the resync window starting from 0
//otherwise eeprom storage and update of the counters were necessary
static REMOTE_ENTRY remotes[N_REMOTES_CHATA] = KEELOQ_CHATA_ALL ; 
static uint16_t resyncs[N_REMOTES_CHATA];


uint8_t process_keeloq1(const uint8_t *code) //messages from remotes
{
	uint8_t serial,buttons;
	uint8_t wrkbuf[9];
	char c[32];
	memcpy(wrkbuf,code,9);
	uint8_t r=process_message(&buttons,&serial,wrkbuf,N_REMOTES_CHATA,remotes,resyncs);
#ifdef DEBUG
	printP(PSTR("keeloq1 error status = "));
	c[2]='\n';
	c[3]=0;
	bin2octet(c,r);
	print(c);
#endif
	if(r!=0) return 0; //do not beep on foreign remotes
	watchdog(1);
	sprintf(c,"K %d %d %d\n",r,serial,buttons); print(c);
	    switch(buttons) {
		case BUTTON_I: 
		case BUTTON_II:
			{
			uint8_t i;
			uint8_t on = relaytoggle(buttons==BUTTON_I?3:4);
			if(on) for(i=0;i<5;++i) {watchdog(1); sbi(PORTB,PB4); delay_ms(100); cbi(PORTB,PB4); delay_ms(100);}
			else {sbi(PORTB,PB4); watchdog(1); delay_ms(1000); cbi(PORTB,PB4);}
			}
			break;
		case BUTTON_III: //arm
			armdisarm(1);
			relays(0);
			{
			uint8_t i;
			for(i=0;i<10;++i)
          {watchdog(1); sbi(PORTB,PB4); delay_ms(50); cbi(PORTB,PB4); delay_ms(50);}

			}
			break;
		case BUTTON_IV: //disarm
			armdisarm(0);
			sbi(PORTB,PB4); delay_ms(1000); cbi(PORTB,PB4); //long beep
			break;
		case BUTTON_III|BUTTON_IV:
			break;
		case BUTTON_RED: 
			break;
		default: 
			break;
   	}//switch
return 1;
}



int16_t temperature_smt0(uint8_t mux) // thermometers 0,1 , returns in 0.01 C
{
int16_t t;
uint16_t lcount,hcount;
uint8_t temppin=mux?TEMPPIN1:TEMPPIN0;


//SMT160-30 duty=0.320+0.00470*T, T=(duty-0.32)/0.00470


watchdog(1);

lcount=hcount=0;

cbi(SREG,7);

{
uint8_t i;
for(i=
#if (XTAL == 3686400L)
0
#else
#if (XTAL == 14745600L)
64
#else
128
#endif
#endif
; --i;)
{

watchdog(1);

//optimized compilation results in irreproducible and wrong timings, therefore inline assembly


if(mux==0) asm volatile (

//loop_until_bit_is_set(TEMPPORT,TEMPPIN0);
"TEMP1:\n\t"
"sbis %4,%5" "\n\t"
"rjmp TEMP1" "\n\t"

//loop_until_bit_is_clear(TEMPPORT,TEMPPIN0);
"TEMP2:\n\t"
"sbic %4,%5" "\n\t"
"rjmp TEMP2" "\n\t"

//while(bit_is_clear(TEMPPORT,TEMPPIN0)) ++lcount;
"TEMP3:\n\t"
"adiw %1,1" "\n\t"
"sbis %4,%5" "\n\t"
"rjmp TEMP3" "\n\t"

//while(bit_is_set(TEMPPORT,TEMPPIN0)) ++hcount;
"TEMP4:\n\t"
"adiw %0,1" "\n\t"
"sbic %4,%5" "\n\t"
"rjmp TEMP4" "\n\t"

//parameter lists
: "=w" (hcount), "=w" (lcount) //outputs
: "0" (hcount), "1" (lcount), "M" ((uint8_t) &(TEMPPORT) - 0x20), "I" (TEMPPIN0) //inputs
: "cc"  //clobber
);

else asm volatile (

//loop_until_bit_is_set(TEMPPORT,TEMPPIN1);
"TEMP1b:\n\t"
"sbis %4,%5" "\n\t"
"rjmp TEMP1b" "\n\t"

//loop_until_bit_is_clear(TEMPPORT,TEMPPIN1);
"TEMP2b:\n\t"
"sbic %4,%5" "\n\t"
"rjmp TEMP2b" "\n\t"

//while(bit_is_clear(TEMPPORT,TEMPPIN1)) ++lcount;
"TEMP3b:\n\t"
"adiw %1,1" "\n\t"
"sbis %4,%5" "\n\t"
"rjmp TEMP3b" "\n\t"

//while(bit_is_set(TEMPPORT,TEMPPIN1)) ++hcount;
"TEMP4b:\n\t"
"adiw %0,1" "\n\t"
"sbic %4,%5" "\n\t"
"rjmp TEMP4b" "\n\t"

//parameter lists
: "=w" (hcount), "=w" (lcount) //outputs
: "0" (hcount), "1" (lcount), "M" ((uint8_t) &(TEMPPORT) - 0x20), "I" (TEMPPIN1) //inputs
: "cc"  //clobber
);

}
}

sbi(SREG,7);

#if 0
{
uint32_t x;
x=10000; x*=hcount;
x /=((uint32_t)hcount+lcount);
char c[8];
itoa10(x,c);
printP(PSTR("10000*Duty=")); print(c); printP(PSTR("\n"));
}
#endif

uint32_t x;
x=68085L; x*=hcount;
x /=((uint32_t)hcount+lcount);
x*=10; 
int32_t y = x-217870;
y>>= 4;
return (int16_t) y;
}



#define NREP_SMT_LOG 5
int16_t temperature_smt(uint8_t mux) //in 0.01C
{
//check whether the sensor is present at all to prevent lockup in the next measurement
{
uint8_t temppin=mux?TEMPPIN1:TEMPPIN0;
cbi(TEMPDDR,temppin); sbi(TEMPPULLUP,temppin); //prevent random noise on disconnected high-Z input

uint8_t i,last,l;
watchdog(1);
last= bit_is_set(TEMPPORT,temppin);
for(i=0; i<100; ++i)
	{
	watchdog(1);
	delay_xs(XTAL/8000);
	if((l=bit_is_set(TEMPPORT,temppin))^last) goto passed;
	last=l;
	}
cbi(TEMPPULLUP,temppin);
return M2_UNDEFINED_TEMP;
passed:;
cbi(TEMPPULLUP,temppin);
}


uint8_t i;
int32_t t=0;
for(i=0; i<(1<<NREP_SMT_LOG); ++i) {t += temperature_smt0(mux);}
t >>= 1+NREP_SMT_LOG;
return t;
}



uint8_t voltage(uint8_t mux) //integer, in 0.1 V, max resolution is approx 0.015
{
uint32_t v;
//enable A/D converter in single conversion mode
ADMUX= mux&0x0f;
ADCSRA= (1<<ADEN)|(1<<ADIF)|(1<<ADSC)|7; 
loop_until_bit_is_set(ADCSRA,ADIF);
v=ADCL;
v|= (ADCH<<8);
//disable ADC again to save power consumption
ADCSRA=0;
#ifdef car_alarm
//v*=3.93/1023*183/33*10
v*=1745;
return (v+4096)>>13;
#else
//v*=5.0/1023*183/33*10
v*=1110;
return (v+2048)>>12;
#endif
}







void initialize(void)
{

//switch on radio remote receiver  atmega16 or higher required
do_receive(1);
watchdog(1);

//switch on LED
#ifdef useled
sbi(DDRB,PB1); sbi(DDRB,PB2);
#endif


}


void bin2letter(char *c, uint8_t b)
{
*c = b<10? '0'+b : 'A'+b-10;
}

void bin2octet(char *octet, uint8_t bin)
{
bin2letter(octet,bin>>4);
bin2letter(octet+1,bin&0x0f);
}

volatile uint8_t oldincodelen=0;
volatile uint8_t oldincode[MESSAGE_BYTES+1];

uint8_t check433(void)
{
if(!incodelen) return 0;
if(incodelen!=oldincodelen || memcmp(oldincode,incode,oldincodelen>>3))
	{
	oldincodelen=incodelen;
        memcpy(oldincode, incode,(oldincodelen+7)>>3);
        incodelen=0;

	//send the packet to linux computer
	{
	printP(PSTR("R: "));
	char c[4];
	bin2octet(c,oldincodelen);
	c[2]=0;
	print(c);print(" ");
	uint8_t i;
	for(i=0; i<(oldincodelen+7)>>3; ++i)
                {
		bin2octet(c,oldincode[i]);
		c[2]=0;
                print(c);
                }
	print("\n");
	}

	watchdog(1);

	//try rolling code remotes
	uint8_t recognized = 0;
	if(oldincodelen>=0x40 && oldincodelen<=0x42) recognized=process_keeloq1(oldincode);

	//try recognizing some fixed codes
	if(!recognized && oldincodelen>=0x40 && oldincodelen<=0x42) recognized=process_fixedcode(oldincodelen,oldincode);
	
	//other lengths are processed by the linux master rather than here
	return 1;
	}
else 
	{
	incodelen=0;
	return 0;
	}
}



/* main logic of the alarm */
int main(void)
{
watchdog(1);
uint16_t icount=0;
uint8_t power_ok=1;
uint8_t oldpower_ok=1;

//watchdog of rpi
cbi(PORTC,PC2);
sbi(DDRC,PC2);
rpiwatch=0;
rpiwatchmax=1800;

sbi(SREG,7);

//setup UART
UART_INIT(BAUD);
//allow uart interrupts
{char dummy=UDR;}
sbi(UCSRB,RXCIE);

//setup timer0
centiseconds=0;
TCNT0=0;
sbi(TIMSK,OCIE0);
OCR0 = XTAL/1024/100;
TCCR0=(1<<WGM01)|CK1024;


watchdog(1);
delay_ms(100);
printP(PSTR("\nreset!\n"));


//pin for receiver
cbi(DDRD,PD6);
cbi(PORTD,PD6);

cbi(PORTB,PB4);
sbi(DDRB,PB4);


//enable watchdog and reset it
watchdog(1);


initialize();

//restore  relays, and A/D convertor
{
relays(eeprom_read_byte(&relays_all));
sbi(DDRC,RELAY0);
sbi(DDRC,RELAY1);
sbi(DDRC,RELAY2);
}


//main loop
while(1) {


//execute the command from uart
watchdog(1);
if(inuartlen>0 && inuart[inuartlen-1]== '\n'||inuart[inuartlen-1]=='\r')
{
switch (inuart[0]) {
case 'l': //enquire about status
	{
	char c[32];
	sprintf(c,"A %d %d %d\n",eeprom_read_byte(&alarm_armed), eeprom_read_byte(&alarm_pending),eeprom_read_byte(&alarm_active));
	print(c);
	}
	break;
case 'p': //power cycle of rpi
	{
	if(strncmp(inuart,"powerdown",9)) break;
	printP(PSTR("Will cycle RPI power\n"));
        uint8_t i;
        for(i=0; i<30; ++i) {watchdog(1); delay_ms(1000);}
	sbi(DDRC,PC2); sbi(PORTC,PC2);
        for(i=0; i<10; ++i) {watchdog(1); delay_ms(1000);}
        cbi(PORTC,PC2);
	rpiwatch=0;
	rpiwatchmax=900;
	}
	break;
case 'O': //drive relays individually (counted from 0)
	{
	uint8_t n, on;
	n=inuart[1]-'0';
	on= inuart[2]=='1'||inuart[2]=='+';
	relay(n+3,on);
	}
	break;
case 'A': //simulate alarm, arm-disarm, cancel active or pending alarm
	{
	switch(inuart[1]) {
		case 'A': //simulate alarm
		eeprom_write_byte(&alarm_pending,4);
		break;
		case 'R': //reset and arm
		//no break;
		case '1': //arm
		armdisarm(1);
		break;
		case '0': //disarm
		armdisarm(0);
		break;
	      }
	}
	break;
case 'W': //watchdog 
		{
		char *p=strchr(inuart+2,' ');
		printP(PSTR("rpiwatch ")); 
		rpiwatch=0;
		if(!p) 
			{
			printP(PSTR("(missing check) "));
			}
		else
			{
			uint16_t rpiwatchmax2 = atoi(p+1);
			uint16_t rpiwatchmax1 = atoi(inuart+2);
			if(rpiwatchmax1==rpiwatchmax2) rpiwatchmax = rpiwatchmax1;
			else printP(PSTR("(mismatch) "));
			}
		{char c[6]; itoa10(rpiwatchmax,c); c[5]=0; print(c);} 
		printP(PSTR("\n"));
		}
		break;
default:
	printP(PSTR("Unrecognized command: ")); print(inuart); print("\n");
	break;
    }//switch
//allow uart receive again
cbi(UCSRB,RXCIE);
inuartlen=0;
sbi(UCSRB,RXCIE);
}


if((icount&63)==0) 
	{
	uint8_t i;
	for(i=0; i<NTHERMO; ++i) 
		{
		int16_t tmp;
		temper[i]=temperature_smt(i);
		watchdog(1);
		}
	char c[32];
	sprintf(c,"t= %d %d\n",temper[1],temper[0]);
	print(c);
	}




//check for pending alarm and activate alarm state
if(eeprom_read_byte(&alarm_pending)!=0 && eeprom_read_byte(&alarm_pending)!=0xff && eeprom_read_byte(&alarm_active)!=1)
	{
	//send message to linux
	char c[16];
	sprintf(c,"B %d = %d\n",eeprom_read_byte(&alarm_pending)-1,1);
	print(c);
	if(eeprom_read_byte(&alarm_active)!=1) eeprom_write_byte(&alarm_active,1);
	if(eeprom_read_byte(&alarm_pending)) eeprom_write_byte(&alarm_pending,0);
	}



//LED color
if(eeprom_read_byte(&alarm_active)==1) {sbi(PORTB,PB1); sbi(PORTB,PB2);}
else if(eeprom_read_byte(&alarm_armed)==1) sbi(PORTB,PB1);
else sbi(PORTB,PB2);


{
//check voltage, report powerfail
uint8_t v,v1;
v=voltage(0);
v1=voltage(1);
//some hysteresis to avoid too frequent reports
if(oldpower_ok) power_ok= v>=140;
else power_ok= v>=150;
if((icount&1023)==0 || power_ok!=oldpower_ok)
	{
	char c[16];
	sprintf(c,"v= %d %d\n",v,v1);
	print(c);
	oldpower_ok=power_ok;
	}
}


//delay before LED switch
watchdog(1); delay_ms(500);

//switch off LED in any case
cbi(PORTB,PB1);
cbi(PORTB,PB2);

uint8_t received = check433(); //check if the remote has sent a message with a recognized code and process it
if(received)
	{
	//blue led
	sbi(DDRA,PA7);
	sbi(PORTA,PA7);
	watchdog(1);delay_ms(300); 
	cbi(PORTA,PA7);
	cbi(DDRA,PA7);
	watchdog(1);delay_ms(300); 
	}

//watchdog the linux computer by cycling power
if(rpiwatch > rpiwatchmax && rpiwatchmax != 0)
        {
        rpiwatch=0;
	sbi(DDRC,PC2); sbi(PORTC,PC2);
	uint8_t i;
	for(i=0; i<6; ++i) {watchdog(1); delay_ms(1000);}
	cbi(PORTC,PC2);
        }


watchdog(1); delay_ms(500); 
watchdog(1); delay_ms(500); 
icount++;
}//all done

return 0;
}