hw_slinke.c

很少见的linux下的红外口的工具

    }

    if (slinke_settings.version != NULL)
    {
        free(slinke_settings.version);
	slinke_settings.version=NULL;
    }
    
    for (i=0; i<MAX_PORT_COUNT ; i++){
       if(queue[i].buf!=NULL) free(queue[i].buf);
    } /* for */
    
    return(1);
} /* slinke_deinit */

/*****************************************************************************/
#ifdef DEBUG
char *msgIdReprs[] = {
    "unknown","port receive","port disabled","port enabled",
    "transmission timeout","illegal command","receive error",
    "sampling period equals","carrier period equals","timeout period equals",
    "minimum message length equals","transmit ports equal",
    "receive ports equal","last receive port equals",
    "receive port polarities equal","ir routing table equals",
    "invalid sample period","handshaking mode equals",
    "configuration direction equals","baud rate equals",
    "serial port receive buffer overflow","serial port receive buffer overrun",
    "serial port receive framing error","baud rate illegal","version equals",
    "defaults loaded","defaults saved","serial number equals",
    "seeprom write error",
};
char *slinkePorts[] = {"SL0","SL1","SL2","SL3","IR0","PAR","SER","SYS"};
#endif

/*****************************************************************************/
lirc_t slinke_readdata(int timeout){
    lirc_t result;

    if (signal_queue_buf == NULL) return 0;
    if (signal_queue_rd_idx < signal_queue_length){
       result = signal_queue_buf[signal_queue_rd_idx++];
    }else{
       result = 0;
    } /* if */

    LOGPRINTF(3,"readdata: %d @ %d",
	      signal_to_int(result),signal_queue_rd_idx);
    return result;
} /* readdata */

static void reset_signal_queue(){
    if (signal_queue_buf == NULL){
        signal_queue_bufsize = 32; 
	signal_queue_buf = (lirc_t*)slinke_malloc(signal_queue_bufsize*
						  sizeof(lirc_t));
	if (signal_queue_buf == NULL){
            logprintf(LOG_ERR,"could not create signal queue buffer");
            return;
        } /* if */
    } /* if */
    signal_queue_buf[0] = PULSE_MASK; /* sync space */ 
    signal_queue_length = 1; 
    signal_queue_rd_idx = 0; 
} /* reset_signal_queue */

static void app_signal(int is_pulse, int period_len){
    lirc_t signal;
    
    if (signal_queue_buf == NULL) return;
    signal = (slinke_settings.sample_period > 0)
           ? (period_len * slinke_settings.sample_period) / 5
           : period_len;
    if (signal > PULSE_MASK) signal = PULSE_MASK; 
    if (is_pulse) signal |= PULSE_BIT;

    if (signal_queue_length >= signal_queue_bufsize){
        signal_queue_bufsize *= 2;
        signal_queue_buf = (lirc_t*)slinke_realloc
		(signal_queue_buf,signal_queue_bufsize*sizeof(lirc_t));
        if (signal_queue_buf == NULL){
            logprintf(LOG_ERR,"could not enlarge signal queue buffer");
            return;
        } /* if */
    } /* if */
    signal_queue_buf[signal_queue_length++] = signal; 
} /* app_signal */

static void end_of_signals(){
    if (signal_queue_buf == NULL) return;
    if (signal_queue_length > 0){
        int last_signal_idx = signal_queue_length-1; 
        if (is_space(signal_queue_buf[last_signal_idx])){
            signal_queue_buf[last_signal_idx] = PULSE_MASK; 
        }else{
            app_signal(/*is_pulse=*/0,PULSE_MASK); /* end sync space */
        } /* if */
    } /* if */
} /* end_of_signals */

#ifdef DEBUG
static char *signal_queue_to_string(){
    static char buf[10*QUEUE_BUF_MAX_SIZE];
    char s[30];
    int i;
    
    if (signal_queue_buf == NULL) return "";
    sprintf(buf,"{%d",signal_to_int(signal_queue_buf[0]));
    for (i=1; i<signal_queue_length; i++){
        sprintf(s,",%d",signal_to_int(signal_queue_buf[i]));
	if (strlen(buf)+strlen(s)+2 >= sizeof(buf)) break;
        strcat(buf,s); 
    } /* for */
    strcat(buf,"}"); 
    return buf;
} /* signal_queue_to_string */
#endif

/*****************************************************************************/
static char *process_rx_bytes(struct port_queue_rec *q, struct ir_remote *remotes){
    char *resp = NULL; 
    unsigned char *buf = q->buf; 
    int len = q->length;

    LOGPRINTF(2,"port #%d: %s",q->port_id,to_byte_string(buf,len));
    LOGPRINTF(2,"%s (0x%02x %s) len = %d",
	      slinkePorts[q->port_id],q->msg_id,msgIdReprs[q->msg_id],len);

    switch (q->msg_id){
    case MSG_ID_PORT_RECEIVE:{
         int i;
         int curr_period_len = 0; 
         int curr_period_is_pulse = 1; 
         reset_signal_queue(); 
         for (i=0; i<len; i++){
             int len = buf[i] & 0x7f; 
             int is_pulse = ((buf[i] & 0x80) != 0);
             if (is_pulse == curr_period_is_pulse){
                 curr_period_len += len;
             }else{
                 app_signal(curr_period_is_pulse,curr_period_len); 
                 curr_period_len = len; 
                 curr_period_is_pulse = is_pulse; 
             } /* if */
         } /* for */
         if (curr_period_len > 0) app_signal(curr_period_is_pulse,curr_period_len); 
         end_of_signals(); 

	 LOGPRINTF(2,"%d signals: %s",
		   signal_queue_length,signal_queue_to_string());

	     resp = decode_all(remotes);
         }break; 
    case MSG_ID_SAMPLING_PERIOD_EQUALS:{
         if (len == 2){
             slinke_settings.sample_period = (buf[0] << 8) | (buf[1]); 
             logprintf(LOG_INFO,"sample period %d * 1/5 usec",
		       slinke_settings.sample_period);
         } /* if */
         }break; 
    case MSG_ID_TIMEOUT_PERIOD_EQUALS:{
         if (len == 2){
             slinke_settings.timeout_samples = (buf[0] << 8) | (buf[1]); 
             logprintf(LOG_INFO,"timeout %d samples",
		       slinke_settings.timeout_samples);
         } /* if */
         }break; 
    case MSG_ID_VERSION_EQUALS:{
         if (len == 1){
             char s[10];
             sprintf(s,"%d.%d"
                    ,(unsigned)((buf[0] >> 4) & 0xf)
                    ,(unsigned)( buf[0]       & 0xf)); 
             if (slinke_settings.version != NULL)
	         free(slinke_settings.version);
             slinke_settings.version = strdup(s);
             if (slinke_settings.version == NULL){
                 logprintf(LOG_ERR,"could not allocate version string");
             }else{
                 logprintf(LOG_INFO,"Slink-e version %s",
			   slinke_settings.version);
             } /* if */
         } /* if */
         }break; 
    } /* switch */

    q->length = 0; 
    return resp;
} /* process_rx_bytes */

/*****************************************************************************/
static void enqueue_byte(struct port_queue_rec *q, unsigned char b){
    if (q->buf == NULL) return;
    if (q->length > q->bufsize){
       if (q->bufsize >= QUEUE_BUF_MAX_SIZE){
           if (q->bufsize == QUEUE_BUF_MAX_SIZE){
               LOGPRINTF(1,"maximum port queue buffer size reached");
           } /* if */
           return;
       } /* if */
       
       q->bufsize *= 2;
       q->buf = (unsigned char*)slinke_realloc(q->buf,q->bufsize);
       if (q->buf == NULL){
            logprintf(LOG_ERR,"could not enlarge port queue buffer");
            return;
       } /* if */
    } /* if */
    q->buf[q->length++] = b; 
} /* enqueue_byte */

/*****************************************************************************/
static char *accept_rx_byte(unsigned char rch, struct ir_remote *remotes){
    static int state = RX_STATE_IDLE; 
    static int msg_len;
    static unsigned char port_id = 0; 
    static struct port_queue_rec *curr_queue;
    char *resp = NULL; 

    LOGPRINTF(3,"accept_rx_byte %02x",rch);
    switch (state){

    case RX_STATE_IDLE: 
         port_id = (rch >> 5) & 7; 
         msg_len = rch & 0x1f; 
         curr_queue = &(queue[port_id]);
         switch (msg_len){
         case 0x00: /* PRE - port receive end */
              resp = process_rx_bytes(curr_queue,remotes);
              break; 
         case 0x1F: /* PSM - port special message */
              state = RX_STATE_PSM; 
              return NULL;
         default: 
              curr_queue->msg_id = MSG_ID_PORT_RECEIVE; 
              state = RX_STATE_RECEIVE; 
              return NULL;
         } /* switch */ 
         break;

    case RX_STATE_PSM:
         switch (rch){
         case 0x02: curr_queue->msg_id = MSG_ID_PORT_DISABLED;
                    break;
         case 0x03: curr_queue->msg_id = MSG_ID_PORT_ENABLED;
                    break; 
         case 0x81: curr_queue->msg_id = MSG_ID_TRANSMISSION_TIMEOUT;
                    break;
         case 0xff: curr_queue->msg_id = MSG_ID_ILLEGAL_COMMAND;
                    break;
         case 0x80: curr_queue->msg_id = MSG_ID_RECEIVE_ERROR;
                    break;
         case 0x82: curr_queue->msg_id = MSG_ID_INVALID_SAMPLE_PERIOD;
                    break;
         case 0x83: curr_queue->msg_id = MSG_ID_SERIAL_PORT_RECEIVE_BUFFER_OVERFLOW;
                    break;
         case 0x86: curr_queue->msg_id = MSG_ID_SERIAL_PORT_RECEIVE_BUFFER_OVERRUN;
                    break;
         case 0x85: curr_queue->msg_id = MSG_ID_SERIAL_PORT_RECEIVE_FRAMING_ERROR;
                    break;
         case 0x84: curr_queue->msg_id = MSG_ID_BAUD_RATE_ILLEGAL;
                    break;
         case 0x0f: curr_queue->msg_id = MSG_ID_DEFAULTS_LOADED;
                    break;
         case 0x0d: curr_queue->msg_id = MSG_ID_DEFAULTS_SAVED;
                    break;
         case 0x8f: curr_queue->msg_id = MSG_ID_SEEPROM_WRITE_ERROR;
                    break;
         default:
             state = RX_STATE_PSM_PAR;
             msg_len = 1;
             switch (rch){
             case 0x04: curr_queue->msg_id = MSG_ID_SAMPLING_PERIOD_EQUALS;
                        msg_len = 2;
                        break;
             case 0x06: curr_queue->msg_id = MSG_ID_CARRIER_PERIOD_EQUALS;
                        msg_len = 2;
                        break;
             case 0x0c: if (port_id == PORT_SYS){
                            curr_queue->msg_id = MSG_ID_SERIAL_NUMBER_EQUALS;
                            msg_len = 8;
                        }else{
                            curr_queue->msg_id = MSG_ID_TIMEOUT_PERIOD_EQUALS;
                            msg_len = 2;
                        } /* if */
                        break;
             case 0x0e: curr_queue->msg_id = MSG_ID_MINIMUM_MESSAGE_LENGTH_EQUALS;
                        break;
             case 0x08: if (port_id == PORT_IR0){
                            curr_queue->msg_id = MSG_ID_MINIMUM_MESSAGE_LENGTH_EQUALS;
                        }else{
                            curr_queue->msg_id = MSG_ID_BAUD_RATE_EQUALS;
                        } /* if */
                        break;
             case 0x01: curr_queue->msg_id = MSG_ID_LAST_RECEIVE_PORT_EQUALS;
                        break;
             case 0x0b: if (port_id == PORT_SYS){
                            curr_queue->msg_id = MSG_ID_VERSION_EQUALS;
                        }else{
                            curr_queue->msg_id = MSG_ID_RECEIVE_PORT_POLARITIES_EQUAL;
                        } /* if */
                        break;
             case 0x0a: curr_queue->msg_id = MSG_ID_IR_ROUTING_TABLE_EQUALS;
                        msg_len = 8;
                        break;
             case 0x10: curr_queue->msg_id = MSG_ID_HANDSHAKING_MODE_EQUALS;
                        break; 
             case 0x12: curr_queue->msg_id = MSG_ID_CONFIGURATION_DIRECTION_EQUALS;
                        break;
             } /* switch */
             return NULL;
         } /* switch */

         resp = process_rx_bytes(curr_queue,remotes);
         break; 
    
    case RX_STATE_PSM_PAR:
         enqueue_byte(curr_queue,rch); 
         if (--msg_len > 0) return NULL;
         resp = process_rx_bytes(curr_queue,remotes); 
         break;

    case RX_STATE_RECEIVE:
         enqueue_byte(curr_queue,rch); 
         if (--msg_len > 0) return NULL;
         break;

    default:
         return NULL;
    } /* switch */ 

    state = RX_STATE_IDLE; 
    return resp;
} /* accept_rx_byte */

/*****************************************************************************/
char *slinke_rec(struct ir_remote *remotes){
    char *resp = NULL; 
    int byteNo = 0; 
    unsigned char rch;

    do{
        if (!waitfordata(TIMEOUT)){
	    LOGPRINTF(0,"timeout reading byte %d",byteNo);
            return(NULL);
        } /* if */

        if (read(hw.fd,&rch,1) != 1){
	    LOGPRINTF(0,"reading of byte %d failed",byteNo);
            return(NULL);
        } /* if */
        byteNo++;

	LOGPRINTF(4,"byte %d: %02x",byteNo,rch);
    } while ((resp=accept_rx_byte(rch,remotes)) == NULL);
    gettimeofday(&end,NULL);
    last=end;

    return resp;
} /* slinke_rec */

/*****************************************************************************/
extern struct rbuf rec_buffer;

int slinke_decode(struct ir_remote *remote
                 ,ir_code          *prep
                 ,ir_code          *codep
                 ,ir_code          *postp
                 ,int              *repeat_flagp
                 ,lirc_t           *remaining_gapp){

    rewind_rec_buffer(); 
    rec_buffer.wptr = 0; 
    signal_queue_rd_idx = 0; 
	return receive_decode(remote
                         ,prep
                         ,codep
                         ,postp
                         ,repeat_flagp
                         ,remaining_gapp);
} /* slinke_decode */