remote.cpp

WinLIRC软件:WinLIRC是一个以 LIRC为基础而在Windows环境发展出来的模块, 而什么是LIRC呢...它其实是 Linux InfraredRemote Control的缩写, 本

	}
	if (type&INVERTED) {
		tmp=on;
		on=off;
		off=tmp;
	}
	off();
	transmittertype=type;
	return;
}

int uwait(unsigned long usecs)
// waits for a specified number of microseconds then returns 0.  returns -1 if timing is not supported
{
    __int64 end;
    end= lasttime + usecs * freq / 1000000;               // Convert microseconds to performance counter units per move.
    do
    {
        QueryPerformanceCounter((LARGE_INTEGER*)&lasttime);
    } while (lasttime < end);
    lasttime=end;
    return (0);
}

void send(unsigned long *raw, int cnt)   //transmits raw data 1st value must be a pulse								 
{
    for (int i=0;i<cnt;i++) {
        if (i%2) send_space(raw[i]);
        else send_pulse(raw[i]);
    }
    off();
}

bool config_transmitter(struct ir_remote *rem) //configures the transmitter for the specified remote
{
	if (rem->freq==0) rem->freq=38000;				//default this should really be elsewhere
	if (rem->duty_cycle==0) rem->duty_cycle=50;		//default this should really be elsewhere
	pulse_width=(unsigned long) rem->duty_cycle*10000/rem->freq;
	space_width=(unsigned long) 1000000L/rem->freq-pulse_width;
	if (transmittertype!=rem->transmitter)	SetTransmitPort(tPort,rem->transmitter);
	if (transmittertype==TXTRANSMITTER) //tx software carrier
	{
		DCB dcb;
		if(!GetCommState(tPort,&dcb))
		{
			CloseHandle(tPort);
			tPort=NULL;
			return false;
		}
		dcb.BaudRate=CBR_115200;
		dcb.Parity=NOPARITY;
		dcb.StopBits=ONESTOPBIT;
		if (rem->freq<48000)
		{
			dcb.ByteSize=7;
			pulse_byte_length=78; // (1+bytesize+parity+stopbits+)/Baudrate*1E6
			if (rem->duty_cycle<50) for (int i=0;i<MAXPULSEBYTES;i++) pulsedata[i]=0x5b;
			else for (int i=0;i<MAXPULSEBYTES;i++) pulsedata[i]=0x12;
		} else {		
			dcb.ByteSize=8;
			pulse_byte_length=87; // (1+bytesize+parity+stopbits+)/Baudrate*1E6
			for (int i=0;i<MAXPULSEBYTES;i++) pulsedata[i]=0x55;
		}
		if(!SetCommState(tPort,&dcb))
		{
			CloseHandle(tPort);
			tPort=NULL;
			DEBUG("SetCommState failed.\n");
			return false;
		}
	}
	return true;
}

void send (ir_ncode *data,struct ir_remote *rem, unsigned int reps)
{
    if (!rem) return;
	DWORD mypriorityclass,mythreadpriority;
	HANDLE myprocess,mythread;

	myprocess=GetCurrentProcess();  //save these handles, because we'll need them several times
	mythread=GetCurrentThread();
	mythreadpriority=GetPriorityClass(myprocess);  //store priority settings
    mypriorityclass=GetThreadPriority(mythread);
	config_transmitter(rem);
    if(rem->toggle_bit>0) rem->repeat_state=!rem->repeat_state; //select toggle_bit state
    SetPriorityClass(myprocess,REALTIME_PRIORITY_CLASS);		//boost priority
    SetThreadPriority(mythread,THREAD_PRIORITY_TIME_CRITICAL);

	init_timer();
	init_send(rem,data); 
    send_space(rem->remaining_gap);
	if (reps>0)
	{
		repeat_remote=rem;
		repeat_code=data;
		for (; reps > 0; --reps)
		{
			init_send(rem,data); 
			send_space(rem->remaining_gap);  
		}
		repeat_remote=NULL;
		repeat_code=NULL;
	}
    SetPriorityClass(myprocess,mypriorityclass); //restore original priorities
    SetThreadPriority(mythread,mythreadpriority);
}

/*
void send_command(struct ir_remote *remote,struct ir_ncode *code)
{
	struct timeval current;
	unsigned long usecs;

	clear_send_buffer();
	if(is_shift(remote))
	{
		send_buffer.is_shift=1;
	}
	
	if(repeat_remote!=NULL && has_repeat(remote))
	{
		send_repeat(remote);
	}
	else
	{
		if(!is_raw(remote))
		{
			send_code(remote,code->code);
		}
	}
		
	if(bad_send_buffer())
	{
		logprintf("buffer too small\n");
		return;
	}

	gettimeofday(&current,NULL);

#if !defined(SIM_SEND) || defined(DAEMONIZE)
	if(remote->last_code!=NULL)
	{
		usecs=time_left(&current,&remote->last_send,
				remote->remaining_gap);
		if(usecs>0) usleep(usecs);
	}
#endif

	if(write_send_buffer(code->length,code->signals)==-1)
	{
		logprintf("write failed\n");
		logperror(NULL);
	}
	else
	{
		gettimeofday(&remote->last_send,NULL);
		if(is_const(remote))
		{
			remote->remaining_gap=remote->gap
			-send_buffer.sum;
		}
		else
		{
			if(has_repeat_gap(remote) && 
			   repeat_remote!=NULL && 
			   has_repeat(remote))
			{
				remote->remaining_gap=remote->repeat_gap;
			}
			else
			{
				remote->remaining_gap=remote->gap;
			}
		}
		remote->last_code=code;
#if defined(SIM_SEND) && !defined(DAEMONIZE)
		printf("space %ld\n",remote->remaining_gap);
#endif
	}
}

********************
SENDING STUFF done
********************/


/*
  decoding stuff
*/

void clear_rec_buffer(unsigned long data)
{
	int move;

#       ifdef __DEBUG2
	logprintf("c%ld\n",data&(PULSE_BIT-1));
#       endif
	move=rec_buffer.wptr-rec_buffer.rptr;
	if(move>0 && rec_buffer.rptr>0)
	{
		memmove(&rec_buffer.data[0],
			&rec_buffer.data[rec_buffer.rptr],
			sizeof(unsigned long)*move);
		rec_buffer.wptr-=rec_buffer.rptr;
	}
	else
	{
		rec_buffer.wptr=0;
	}
	rec_buffer.rptr=0;

	rec_buffer.data[rec_buffer.wptr]=data;
	rec_buffer.wptr++;

	rec_buffer.too_long=0;
	rec_buffer.is_biphase=0;
	rec_buffer.pendingp=0;
	rec_buffer.pendings=0;
	rec_buffer.sum=0;
}

inline void rewind_rec_buffer()
{
	rec_buffer.rptr=0;
	rec_buffer.too_long=0;
	rec_buffer.pendingp=0;
	rec_buffer.pendings=0;
	rec_buffer.sum=0;
}

inline void unget_rec_buffer(int count)
{
	if(count==1 || count==2)
	{
		rec_buffer.rptr-=count;
		rec_buffer.sum-=rec_buffer.data[rec_buffer.rptr]&(PULSE_BIT-1); //&(PULSE_MASK) in LIRC 0.6.5
		if(count==2)
		{
			rec_buffer.sum-=rec_buffer.data[rec_buffer.rptr+1]
			&(PULSE_BIT-1); //&(PULSE_MASK) in LIRC 0.6.5
		}
	}
}

unsigned long get_next_rec_buffer(unsigned long maxusec)
{
	if(rec_buffer.rptr<rec_buffer.wptr)
	{
#               ifdef __DEBUG2
		logprintf("<%ld\n",rec_buffer.data[rec_buffer.rptr]
			  &(PULSE_BIT-1));
#               endif
		rec_buffer.sum+=rec_buffer.data[rec_buffer.rptr]&(PULSE_BIT-1);
		return(rec_buffer.data[rec_buffer.rptr++]);
	}
	else
	{
		if(rec_buffer.wptr<RBUF_SIZE)
		{
			if(use_ir_hardware)
				rec_buffer.data[rec_buffer.wptr]=ir_driver->readdata(maxusec,IRThreadEvent);
			else
				rec_buffer.data[rec_buffer.wptr]=learn_dialog->readdata(maxusec);
			if(rec_buffer.data[rec_buffer.wptr]==0) return(0);
			rec_buffer.sum+=rec_buffer.data[rec_buffer.rptr]
			&(PULSE_BIT-1);
			rec_buffer.wptr++;
			rec_buffer.rptr++;
#                       ifdef __DEBUG2
			logprintf("+%ld\n",rec_buffer.data[rec_buffer.rptr-1]
				  &(PULSE_BIT-1));
#                       endif
			return(rec_buffer.data[rec_buffer.rptr-1]);
		}
		else
		{
			rec_buffer.too_long=1;
			return(0);
		}
	}
	return(0);
}

inline unsigned long get_next_pulse()
{
	unsigned long data;

	data=get_next_rec_buffer(1000*1000);
	if(data==0) return(0);
	if(!is_pulse(data))
	{
#               ifdef __DEBUG
		logprintf("pulse expected\n");
#               endif
		return(0);
	}
	return(data&(PULSE_BIT-1));  //&(PULSE_MASK) in LIRC 0.6.5
}

inline unsigned long get_next_space()
{
	unsigned long data;

	data=get_next_rec_buffer(1000*1000);
	if(data==0) return(0);
	if(!is_space(data))
	{
#               ifdef __DEBUG
		logprintf("space expected\n");
#               endif
		return(0);
	}
	return(data);
}

int expectpulse(struct ir_remote *remote,int exdelta)
{
	unsigned long deltas,deltap;
	int retval;

	if(rec_buffer.pendings>0)
	{
		deltas=get_next_space();
		if(deltas==0)
		{
			return(0);
		}
		retval=expect(remote,deltas,rec_buffer.pendings);
		if(!retval)
		{
			return(0);
		}
		rec_buffer.pendings=0;
	}
	
	deltap=get_next_pulse();
	if(deltap==0)
	{
		return(0);
	}
	if(rec_buffer.pendingp>0)
	{
		retval=expect(remote,deltap,
			      rec_buffer.pendingp+exdelta);
		if(!retval) 
		{ 	
			return(0);
		}
		rec_buffer.pendingp=0;
	}
	else
	{
		retval=expect(remote,deltap,exdelta);
	}
	return(retval);
}

int expectspace(struct ir_remote *remote,int exdelta)
{
	unsigned long deltas,deltap;
	int retval;

	if(rec_buffer.pendingp>0)
	{
		deltap=get_next_pulse();
		if(deltap==0) return(0);
		retval=expect(remote,deltap,rec_buffer.pendingp);
		if(!retval) return(0);
		rec_buffer.pendingp=0;
	}
	
	deltas=get_next_space();
	if(deltas==0) return(0);
	if(rec_buffer.pendings>0)
	{
		retval=expect(remote,deltas,
			      rec_buffer.pendings+exdelta);
		if(!retval) return(0);
		rec_buffer.pendings=0;
	}
	else
	{
		retval=expect(remote,deltas,exdelta);
	}
	return(retval);
}

inline int expectone(struct ir_remote *remote,int bit)
{
	if(is_biphase(remote))
	{
		if(is_rc6(remote) &&
		   remote->toggle_bit>0 &&
		   bit==remote->toggle_bit-1)
		{
			if(remote->sone>0 &&
			   !expectspace(remote,2*remote->sone))
			{
				unget_rec_buffer(1);
				return(0);
			}
			rec_buffer.pendingp=2*remote->pone;
		}
		else
		{
			if(remote->sone>0 && !expectspace(remote,remote->sone))
			{
				unget_rec_buffer(1);
				return(0);
			}
			rec_buffer.pendingp=remote->pone;
		}
	}
	else
	{
		if(remote->pone>0 && !expectpulse(remote,remote->pone))
		{
			unget_rec_buffer(1);
			return(0);
		}
		if(remote->ptrail>0)
		{
			if(remote->sone>0 &&
			   !expectspace(remote,remote->sone))
			{
				unget_rec_buffer(2);
				return(0);
			}
		}
		else
		{
			rec_buffer.pendings=remote->sone;
		}
	}
	return(1);
}

inline int expectzero(struct ir_remote *remote,int bit)
{
	if(is_biphase(remote))
	{
		if(is_rc6(remote) &&
		   remote->toggle_bit>0 &&
		   bit==remote->toggle_bit-1)
		{
			if(!expectpulse(remote,2*remote->pzero))
			{
				unget_rec_buffer(1);
				return(0);
			}
			rec_buffer.pendings=2*remote->szero;
			
		}
		else
		{
			if(!expectpulse(remote,remote->pzero))
			{
				unget_rec_buffer(1);
				return(0);
			}
			rec_buffer.pendings=remote->szero;
		}
	}
	else
	{
		if(!expectpulse(remote,remote->pzero))
		{
			unget_rec_buffer(1);
			return(0);
		}
		if(remote->ptrail>0)
		{
			if(!expectspace(remote,remote->szero))
			{
				unget_rec_buffer(2);
				return(0);
			}
		}
		else
		{
			rec_buffer.pendings=remote->szero;
		}
	}
	return(1);
}

inline int sync_rec_buffer(struct ir_remote *remote)
{
	int count;
	unsigned long deltas,deltap;

	count=0;
	deltas=get_next_space();
	if(deltas==0) return(0);
	if(last_remote!=NULL && !is_rcmm(remote))
	{
		while(deltas<remote->remaining_gap*(100-remote->eps)/100
		      && deltas<remote->remaining_gap-remote->aeps)
		{
			deltap=get_next_pulse();
			if(deltap==0) return(0);
			deltas=get_next_space();
			if(deltas==0) return(0);
			count++;
			if(count>REC_SYNC) /* no sync found, 
							      let's try a diffrent remote */
			{
				return(0);
			}
		}
	}
	rec_buffer.sum=0;
	return(deltas);
}

inline int get_header(struct ir_remote *remote)
{
	if(is_rcmm(remote))
	{
		int deltap,deltas,sum;
		deltap=get_next_pulse();
		if(deltap==0)
		{
			unget_rec_buffer(1);
			return(0);
		}
		deltas=get_next_space();
		if(deltas==0)
		{
			unget_rec_buffer(2);
			return(0);
		}
		sum=deltap+deltas;
		if(expect(remote,sum,remote->phead+remote->shead))
		{
			return(1);
		}
		unget_rec_buffer(2);
		return(0);
	}
	if(!expectpulse(remote,remote->phead))
	{
		unget_rec_buffer(1);
		return(0);
	}
	if(!expectspace(remote,remote->shead))
	{
		unget_rec_buffer(2);
		return(0);
	}
	return(1);
}

inline int get_foot(struct ir_remote *remote)
{
	if(!expectspace(remote,remote->sfoot)) return(0);
	if(!expectpulse(remote,remote->pfoot)) return(0);
	return(1);
}

inline int get_lead(struct ir_remote *remote)
{
	if(remote->plead==0) return(1);
	//if(!expectpulse(remote,remote->plead)) return(0);
	rec_buffer.pendingp=remote->plead;
	return(1);	
}

inline int get_trail(struct ir_remote *remote)
{
	if(remote->ptrail!=0)
	{
		if(!expectpulse(remote,remote->ptrail)) return(0);
	}
	if(rec_buffer.pendingp>0)
	{
		if(!expectpulse(remote,0)) return(0);
	}
	return(1);
}

inline int get_gap(struct ir_remote *remote,unsigned long gap)
{
	unsigned long data;

	data=get_next_rec_buffer(gap*(100-remote->eps)/100);
	if(data==0) return(1);
	if(!is_space(data))
	{
#               ifdef __DEBUG
		logprintf("space expected\n");
#               endif
		return(0);
	}
#       ifdef __DEBUG2
	logprintf("sum: %ld\n",rec_buffer.sum);
#       endif
	if(data<gap*(100-remote->eps)/100 &&
	   data<gap-remote->aeps)
	{
#               ifdef __DEBUG
		logprintf("end of signal not found\n");
#               endif
		return(0);
	}
	else
	{
		unget_rec_buffer(1);
	}
	return(1);	
}

inline int get_repeat(struct ir_remote *remote)
{
	if(!get_lead(remote)) return(0);
	if(is_biphase(remote))
	{
		if(!expectspace(remote,remote->srepeat)) return(0);
		if(!expectpulse(remote,remote->prepeat)) return(0);
	}