📄 sircs_m04_c2.c
字号:
/****************************************************************************************************/
/* $Header :
/* AUTHOR : TC PUI
/* FILE NAME: SIRCS.C
/* PURPOSE : SIRCS CONTROL
/* MODEL : 2004 CIS 2-CH AMP
/* Copyright (c) 2004 Sony Corporation All Rights Reserved
/****************************************************************************************************/
#define _SIRCS_C
#include "_main_M04_C2.h"
/****************************************************************************************************/
/* local variables definition which are refered only this file
/****************************************************************************************************/
typedef union sirflag {
struct sirbit {
unsigned char bit7 :1;
unsigned char bit6 :1;
unsigned char bit5 :1;
unsigned char bit4 :1;
unsigned char bit3 :1;
unsigned char slp :1; /* u-com sleep request flag */
unsigned char fst :1; /* input first flag */
unsigned char req :1; /* event request flag */
} bit;
unsigned char byte;
} SIRFLAG_;
typedef struct sircs {
unsigned char cnt; /* sircs code time counter */
unsigned char bit; /* sircs code bit counter */
unsigned char stt; /* sircs code state */
unsigned long cod; /* sircs code */
unsigned long buf; /* sircs id buffer */
unsigned char cht; /* chattring counter */
unsigned int ctm; /* sircs cancel timer */
unsigned int tim; /* sircs event timer */
SIRFLAG_ flag; /* sircs flag */
}SIRW_;
/* working */
SIRW_ sir; /* sircs struct data */
/****************************************************************************************************/
/* static define value
/****************************************************************************************************/
#define F_SIRREQ sir.flag.bit.req
#define F_SIRFST sir.flag.bit.fst
#define F_SIRSLP sir.flag.bit.slp
#define F_SIRFLG sir.flag.byte
#define SIRCS_DAT_0 __asm(" clrb 0x0E:3 ") /* (P_SIRCS_OUT = 0) */
#define SIRCS_DAT_1 __asm(" setb 0x0E:3 ") /* (P_SIRCS_OUT = 1) */
#define LED_DAT_0 __asm(" clrb 0x02:2 ") /* (P_OPERATION_LED = 0)*/
#define LED_DAT_1 __asm(" setb 0x02:2 ") /* (P_OPERATION_LED = 1)*/
#define _CARIER_START 0x80
const unsigned int SirEventTable[SIRCS_EVENT_NUM] = {
EV_NOP, /* 000 S_NOP = 0, */
EV_SIRPOWERONOFF, /* 001 S_POWERONOFF, */
EV_SIRPOWERON, /* 002 S_POWERONOFF, */
EV_SIRPOWEROFF, /* 003 S_POWERONOFF, */
EV_VOLUP, /* 004 S_VOLUP, */
EV_VOLDW, /* 005 S_VOLDW, */
EV_MUTING, /* 006 S_MUTING, */
};
/******************************************************************************/
/* Sircs Decode Table */
/******************************************************************************/
const unsigned int SirDecTable0[SIRCS_EVENT_NUM][SIRCOM_IDMAX]={ /* sircs data code (D0 - D9) */
/* ID0, ID1 , ID2, ID3, ID4, ID5, ID6, ID7, ID8, ID9, ID10, ID11, ID12, */
{ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, }, /* [00] nop */
{ 0x0002, 0x0002, 0x0142, 0x00A2, 0x01E2, 0x0052, 0x0132, 0x00F2, 0x018A, 0x002A, 0x016A, 0x009A, 0x01DA, }, /* [01] power on/off */
{ 0x0202, 0x0202, 0x0342, 0x02A2, 0x03E2, 0x0252, 0x0332, 0x02F2, 0x038A, 0x022A, 0x036A, 0x029A, 0x03DA, }, /* [02] power on */
{ 0x0102, 0x0102, 0x00C2, 0x01A2, 0x0012, 0x0152, 0x00B2, 0x01F2, 0x004A, 0x012A, 0x00EA, 0x019A, 0x003A, }, /* [03] power off */
{ 0x0302, 0x0302, 0x02C2, 0x03A2, 0x0212, 0x0352, 0x02B2, 0x03F2, 0x024A, 0x032A, 0x02EA, 0x039A, 0x023A, }, /* [04] vol + */
{ 0x0082, 0x0082, 0x01C2, 0x0062, 0x0112, 0x00D2, 0x01B2, 0x000A, 0x014A, 0x00AA, 0x01EA, 0x005A, 0x013A, }, /* [05] vol - */
{ 0x0282, 0x0282, 0x03C2, 0x0262, 0x0312, 0x02D2, 0x03B2, 0x020A, 0x034A, 0x02AA, 0x03EA, 0x025A, 0x033A, }, /* [06] muting */
};
/******************************************************************************/
/* Sircs Decode (Number of bit '1') Table */
/******************************************************************************/
const unsigned char SirDecNumOne[SIRCS_EVENT_NUM][SIRCOM_IDMAX]={ /* use for determine the gap lenght */
/* ID0, ID1 , ID2, ID3, ID4, ID5, ID6, ID7, ID8, ID9, ID10, ID11, ID12, */
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, }, /* [00] nop */
{ 0x05, 0x05, 0x07, 0x07, 0x09, 0x07, 0x08, 0x09, 0x08, 0x07, 0x09, 0x08, 0x0A, }, /* [01] power on/off */
{ 0x06, 0x06, 0x08, 0x08, 0x0A, 0x08, 0x09, 0x0A, 0x09, 0x08, 0x0A, 0x09, 0x0B, }, /* [02] power on */
{ 0x06, 0x06, 0x07, 0x08, 0x06, 0x08, 0x08, 0x0A, 0x07, 0x08, 0x09, 0x09, 0x08, }, /* [03] power off */
{ 0x07, 0x07, 0x08, 0x09, 0x07, 0x09, 0x09, 0x0B, 0x08, 0x09, 0x0A, 0x0A, 0x09, }, /* [04] vol + */
{ 0x06, 0x06, 0x08, 0x07, 0x07, 0x08, 0x09, 0x06, 0x08, 0x08, 0x0A, 0x08, 0x09, }, /* [05] vol - */
{ 0x07, 0x07, 0x09, 0x08, 0x08, 0x09, 0x0A, 0x07, 0x09, 0x09, 0x0B, 0x09, 0x0A, }, /* [06] muting */
};
/****************************************************************************************************/
/* FUNCTION : IniSircs
/* PURPOSE : Sircs Input Data Initialize
/* INPUT : None
/* RETURN VALUE : None
/****************************************************************************************************/
void SirInitialize(void)
{
/* working data */
sir.cnt = CLEAR; /* sircs code bit counter */
sir.bit = CLEAR; /* sircs code tim counter */
sir.stt = CLEAR; /* sircs code tim state */
sir.cod = CLEAR; /* sircs code data */
sir.buf = S_OFF; /* sircs id buffer */
sir.cht = CLEAR; /* chattring counter */
sir.ctm = CLEAR; /* sircs cancel timer */
sir.tim = CLEAR; /* sircs event timer */
sir.flag.byte = CLEAR; /* sircs flag */
/* global data */
Sir.Sircom = SIRCOM_ID1; /* sir.command type(temp) */
SirCode = CLEAR;
SirBit = CLEAR;
return;
}
/****************************************************************************************************/
/* FUNCTION : SirExIntEnable
/* PURPOSE : Sircs External Interrupt Enable
/* INPUT : None
/* RETURN VALUE : None
/****************************************************************************************************/
void SirExIntEnable(void)
{
return;
}
/****************************************************************************************************/
/* FUNCTION : SirExIntDisable
/* PURPOSE : Sircs External Interrupt Disable
/* INPUT : None
/* RETURN VALUE : None
/****************************************************************************************************/
void SirExIntDisable(void)
{
return;
}
/****************************************************************************************************/
/* FUNCTION : IntSircs
/* PURPOSE : Sircs 100us Interrupt
/* INPUT : None
/* RETURN VALUE : None
/****************************************************************************************************/
__interrupt void IntSircs(void)
{
TMRL_UF = CLEAR;
if (++TimerCount == TIME_OFF_SET) { TimerCount = CLEAR; TIMEUP_A = SET; }
/* Get Sircs Code */
sir.cnt++;
if (sir.stt == SIR_COD_INIT) {
/* status0:initialize */
if (P_SIRCS == LOW) {
sir.cnt = CLEAR; /* timer counter */
sir.bit = CLEAR; /* bit counter */
sir.cod = CLEAR; /* sircs code */
sir.stt = SIR_COD_GUID; /* sircs state */
}
} else if (sir.stt == SIR_COD_GUID) {
/* status1:guide pulse */
if (P_SIRCS == HIGH) {
sir.stt = SIR_COD_INIT;
if ((sir.cnt >= TMIN_TGUIDP) && (sir.cnt <= TMAX_TGUIDP)) { /* guid pulse time o.k.? : 2.0~2.8ms */
sir.cnt = CLEAR; /* timer couter */
sir.stt = SIR_COD_TOFF; /* sircs state */
}
} else {
if (sir.cnt > TMAX_TGUIDP) {
sir.stt = SIR_COD_INIT;
} /* sircs state */
}
} else if (sir.stt == SIR_COD_TOFF) {
/* status2:off time check*/
if (P_SIRCS == LOW) {
sir.stt = SIR_COD_INIT;
if ((sir.cnt >= TMIN_TOFEND) && (sir.cnt <= TMAX_TOFEND)) { /* off time end ? : 0.3~0.9ms(100us) */
sir.stt = SIR_COD_T_ON; /* don't clear "sir.cnt"!*/
}
} else {
if (sir.cnt >= TMIN_CODEND) { /* code end ? >= 1ms(100us)*/
/* status 4: code finish */
sir.stt = SIR_COD_FNSH;
if (sir.bit == BCNT_08BIT) { /* result : 8 bit code */
sir.cod = sir.cod & MASK_08BIT;
} else if (sir.bit == BCNT_12BIT) { /* result : 12 bit code */
sir.cod = sir.cod & MASK_12BIT;
} else if (sir.bit == BCNT_15BIT) { /* result : 15 bit code */
sir.cod = sir.cod & MASK_15BIT;
} else if (sir.bit == BCNT_20BIT) { /* result : 20 bit code */
sir.cod = sir.cod & MASK_20BIT;
} else { /* other bit code */
sir.stt = SIR_COD_INIT; /* false safe */
}
}
}
} else if (sir.stt == SIR_COD_T_ON) {
/* status3:on time check */
if (P_SIRCS == HIGH) {
sir.stt = SIR_COD_INIT;
if ((sir.cnt >= TMIN_TOFON0) && (sir.cnt <= TMAX_TOFON1)) { /* min: off + on0 time AND max: off + on1 time /* 0.9~2.2ms*/
if ((sir.cnt <= TMAX_TOFON0) || (sir.cnt >= TMIN_TOFON1)) {
sir.cod <<= 1; /* next bit */
if (sir.cnt >= TMIN_TOFON1) { /* (off + on1) end ? */
sir.cod |= COD_BIT_ON; /* bit set */
}
sir.bit++; /* bit counter up */
sir.cnt = CLEAR; /* timer counter clear */
sir.stt = SIR_COD_TOFF;
} else {
sir.stt = SIR_COD_INIT; /* sircs state */
}
}
} else {
/* false safe */
if (sir.cnt > TMAX_TOFON1) {
sir.stt = SIR_COD_INIT; /* sircs state */
}
}
}
return;
}
/****************************************************************************************************/
/* FUNCTION : SirControl
/* PURPOSE : Sircs Control
/* INPUT : none
/* RETURN VALUE : none
/****************************************************************************************************/
void SirControl(void)
{
unsigned char task; /* key on fisrt info. */
unsigned int id; /* sircs data id */
if (sir.stt >= SIR_COD_FNSH) { /* sircs code finished ? */
SirCode = sir.cod; /* copy buffer */
SirBit = sir.bit; /* copy buffer */
id = GetSircsID(sir.cod); /* get sircs id */
id = GetSircsAct(id);
switch(id) { /* get sircs code action */
case SIROFF: F_SIRREQ = CLEAR; /* sircs event req.flag */
F_SIRFST = CLEAR; /* sircs input first flag */
break;
case SIRFST: F_SIRREQ = SET; /* sircs event req.flag */
F_SIRFST = SET; /* sircs input first flag */
break;
default: break;
}
sir.stt = SIR_COD_INIT; /* reset sircs code state */
sir.ctm = CANCEL_TIME; /* set cancel time */
} else {
Is10msATimeOver(&sir.ctm);
if (sir.ctm == TIME_UP) { /* time up cancel timer? */
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -