void decodeIR(void) {
WriteTimer1(1);
invertEdge();
if (necState == invalid)
return;
if (necState == inactive) {
necState = lead_pulse;
T1CONbits.TMR1ON = 1;
T3CONbits.TMR3ON = 1;
return;
}
if (necState == lead_pulse) {
if (CCPR1H > NEC_LEAD_PULSE_MIN || CCPR1H < NEC_LEAD_PULSE_MAX)
necState = lead_space;
else
necState = invalid;
return;
}
if (necState == lead_space) {
if (CCPR1H > NEC_LEAD_SPACE_MIN && CCPR1H < NEC_LEAD_SPACE_MAX) {
necState = data_pulse;
withinFrame = 1;
} else if (CCPR1H > NEC_REPEAT_SPACE_MIN && CCPR1H < NEC_REPEAT_SPACE_MAX)
necState = repeat_pulse;
else
necState = invalid;
return;
}
if (necState == repeat_pulse && withinFrame) {
if (CCPR1H > NEC_SHORT_MIN && CCPR1H < NEC_SHORT_MAX) {
ir.decoded = 1;
ir.repeated = 1;
WriteTimer3(0);
} else {
necState = invalid;
}
return;
}
if (necState == data_pulse) {
if (CCPR1H > NEC_SHORT_MIN && CCPR1H < NEC_SHORT_MAX)
necState = data_space;
else
necState = invalid;
return;
}
if (necState == data_space) {
// Received a 0
if (CCPR1H > NEC_SHORT_MIN && CCPR1H < NEC_SHORT_MAX) {
capture.data = capture.data >> 1;
capture.bitcount++;
necState = data_pulse;
// Received a 1
} else if (CCPR1H > NEC_LONG_MIN && CCPR1H < NEC_LONG_MAX) {
/*********************************************************************
* Function: void InitSymbolTimer()
*
* PreCondition: none
*
* Input: none
*
* Output: none
*
* Side Effects: TMR0 for PIC18 is configured for calculating
* the correct symbol times. TMR2/3 for PIC24/dsPIC
* is configured for calculating the correct symbol
* times
*
* Overview: This function will configure the UART for use at
* in 8 bits, 1 stop, no flowcontrol mode
*
* Note: The timer interrupt is enabled causing the timer
* roll over calculations. Interrupts are required
* to be enabled in order to extend the timer to
* 4 bytes in PIC18. PIC24/dsPIC version do not
* enable or require interrupts
********************************************************************/
void InitSymbolTimer()
{
#if defined(__18CXX)
TMR_CON = 0b00000000 | CLOCK_DIVIDER_SETTING;
TMR_IP = 1;
TMR_IF = 0;
TMR_IE = 1;
TMR_ON = 1;
timerExtension1 = 0;
timerExtension2 = 0;
#elif defined(__dsPIC30F__) || defined(__dsPIC33F__) || defined(__PIC24F__) || defined(__PIC24FK__) || defined(__PIC24H__)
T2CON = 0b0000000000001000 | CLOCK_DIVIDER_SETTING;
T2CONbits.TON = 1;
#elif defined(__PIC32MX__)
#if defined (SECOND_PROTOTYPE) //Timer 3 freed for ADC rjk
CloseTimer4();
WriteTimer4(0x00);
WriteTimer5(0x00);
WritePeriod5(0xFFFF);
OpenTimer4((T4_ON|T4_32BIT_MODE_ON|CLOCK_DIVIDER_SETTING),0xFFFFFFFF);
#else
CloseTimer2();
WriteTimer2(0x00);
WriteTimer3(0x00);
WritePeriod3(0xFFFF);
OpenTimer2((T2_ON|T2_32BIT_MODE_ON|CLOCK_DIVIDER_SETTING),0xFFFFFFFF);
#endif
#else
#error "Symbol timer implementation required for stack usage."
#endif
}
void TMR3_init(unsigned int reload , void (*func)())
{
// Enagle TMR1 interrrupt,16 bit counter, with internal clock, No prescalar
OpenTimer3(TIMER_INT_ON & T3_16BIT_RW & T3_SOURCE_INT & T3_PS_1_1 & T3_SYNC_EXT_OFF );
// Reload value for 1ms overflow
WriteTimer3(reload);
// Make timer1 interrupt high priority
//IPR2bits.TMR3IP = 1;
tmr[2].reload = reload;
tmr[2].func = func;
}
/**
* Configura o gerador de sinais, a partir dos parâmetros recebidos
*
* Recebe do PC:
* Pulso (descida -> subida) a receber na entrada de sinal. TEMPO DESCONHECIDO.
* Valor de K
* Valor da velocidade
*
* A4 85 00 05 (1BYTE VENSAIO) + (4BYTES K_ENSAIO) CRC16
* A6 85 00 08 (4BYTES TEMPO32) + (4BYTES N_PULSO) CRC16
*
* Se velocidade = 0, desligar interrupção para a geração de sinal.
* Se houve alteração nos parâmetros de configuração:
* reinicia medição;
* altera o gerador.
* Gera evento EVENT_NOVA_CALIBRACAO.
* Se a solicitação mantiver os parâmetros:
* não altera a medição.
* Gera evento EVENT_NONE_CALIBRACAO.
*
* NÃO HÁ AJUSTE NO FATOR DE CORREÇÃO. O TEMPO DE ENTRADA NÃO É CONHECIDO O DAVI.
* Apresentar o valor medido, com correção no tempo de atraso. Usar fator de correção
* na rotina de aquisição de tempo.(interrupção).
* Gerar velocidade a partir do valor informado de velocidade/K.
* Interromper gerador ao comando Abortar.
*/
void calibra_pwm(void)
{
uint32_t k_temp;
uint8_t v_temp;
uint8_t i;
/*armazena os valores temporariamente*/
k_temp = param_ensaio.CALIBRA.K_ENSAIO;
v_temp = param_ensaio.CALIBRA.V_ENSAIO;
/*recebe e armazena os valores dos parametros recebidos pelo comando CALIBRA*/
for (i = 0; i < SIZE_COMMAND_CALIBRACAO_DAVI ; i++)
param_ensaio.CALIBRA_A4[i] = mensagem_Davi.payload.parameter[i];
/*coleta valor de k*/
param_ensaio.CALIBRA.K_ENSAIO =
endian_shortint(param_ensaio.CALIBRA.K_ENSAIO);
/*V_ENSAIO não precisa de correção*/
/*converter valor de entrada, se estiver em BCD*/
if (mensagem_Davi.overhead.format == FORMAT_BCD_DAVI) {
param_ensaio.CALIBRA.K_ENSAIO =
Converter_BCD_to_HEX((uint32_t)param_ensaio.CALIBRA.K_ENSAIO);
}
/*verifica se houve mudança nos parâmetros*/
if ((param_ensaio.CALIBRA.V_ENSAIO != v_temp) ||
(param_ensaio.CALIBRA.K_ENSAIO != k_temp)) {
/*habilita a contagem de tempo e
redefine o valor inicial do contador de tempo*/
di();
odometro_in = 0;
PIE2bits.TMR3IE = false;
WriteTimer3(0);
PIR2bits.TMR3IF = false;
PIE2bits.TMR3IE = true;
ConfigPulseIn(true);/*habilita a contagem de pulsos*/
ei();
/*reinicia contadores do ensaio*/
odometro_out = 0; /*pulsos de saída total do gerador*/
odometro_in = 0;/*número de janelas de medição*/
flag_int.tempo_fracao = false;
/*se velocidade > 0 prepara gerador*/
/*se velocidade = 0 desliga gerador*/
gera_velocidade(¶m_ensaio.CALIBRA.V_ENSAIO, ¶m_ensaio.CALIBRA.K_ENSAIO);
}
}
/*********************************************************************
* Function: void InitSymbolTimer()
*
* PreCondition: none
*
* Input: none
*
* Output: none
*
* Side Effects: TMR0 for PIC18 is configured for calculating
* the correct symbol times. TMR2/3 for PIC24/dsPIC
* is configured for calculating the correct symbol
* times
*
* Overview: This function will configure the UART for use at
* in 8 bits, 1 stop, no flowcontrol mode
*
* Note: The timer interrupt is enabled causing the timer
* roll over calculations. Interrupts are required
* to be enabled in order to extend the timer to
* 4 bytes in PIC18. PIC24/dsPIC version do not
* enable or require interrupts
********************************************************************/
void InitSymbolTimer()
{
#if defined(__18CXX)
T0CON = 0b00000000 | CLOCK_DIVIDER_SETTING;
INTCON2bits.TMR0IP = 1;
INTCONbits.TMR0IF = 0;
INTCONbits.TMR0IE = 1;
T0CONbits.TMR0ON = 1;
timerExtension1 = 0;
timerExtension2 = 0;
#elif defined(__dsPIC30F__) || defined(__dsPIC33F__) || defined(__PIC24F__) || defined(__PIC24FK__) || defined(__PIC24H__)
T2CON = 0b0000000000001000 | CLOCK_DIVIDER_SETTING;
T2CONbits.TON = 1;
#elif defined(__PIC32MX__)
CloseTimer2();
WriteTimer2(0x00);
WriteTimer3(0x00);
WritePeriod3(0xFFFF);
OpenTimer2((T2_ON|T2_32BIT_MODE_ON|CLOCK_DIVIDER_SETTING),0xFFFFFFFF);
#else
#error "Symbol timer implementation required for stack usage."
#endif
}
void ReStart_T3()
{
T3CONbits.TON = 0;
WriteTimer3(0);
T3CONbits.TON = 1;
}
void main(void) {
unsigned char i,j;
/* Output configurations */
ADCON1 |= 0x0F; // All possible analog input pins config as digital I/O
CMCON = 0x07; // Comparators disabled
/* Natural interaction expansion port configuration */
TRISAbits.TRISA4 = 1; // A4 Botton 3
TRISAbits.TRISA3 = 1; // A3 Botton 2
TRISAbits.TRISA2 = 1; // A2 Botton 1
TRISAbits.TRISA1 = 1; // A1 Potentiometer 2
TRISAbits.TRISA0 = 1; // A0 Potentiometer 1
TRISB = 0; // B0..B6 Serial input for the Shift Registers
TRISD = 0; // D0..D3 Shift Registers control inputs: SCK, RCK, _SCL, _G
TRISEbits.TRISE0 = 1; //Input button PORTEbits.RE0
LATA = 0; // Disable expansion port
_SCL = 1; // Disable Shift Register _SCL (Global Clear)
_G = 0; // Enables Shift Regusters outputs _G
// Resetting variables
for (i = 0; i <= MAX_INDEX_G_BUFFER_GREYSCALE; i++) {
gBufferGreyscale[i] = 0;
gPreBufferGreyscale[i] = 0;
}
for (i = 0; i <= MAX_INDEX_M_BUFFER_MATRIX; i++) {
mBufferMatrix[i] = RESET_M_BUFFER_MATRIX;
}
iGreyscale = 0;
iTimer1 = 0;
iMenu = 0;
FIRST = 0;
SECOND = 0;
THIRD = 0;
FOURTH = 0;
FIFTH = 0;
SIXTH = 0;
pwm = 0;
/* Timer 0 Configuration */
// Used to trigger the refresh matrix printed data routine
OpenTimer0(TIMER_INT_ON & T0_8BIT & T0_SOURCE_INT & T0_PS_1_1);
WriteTimer0(0);
/* Timer 1 Configuration */
// Used to periodically check the input data (external buttons)
OpenTimer1(TIMER_INT_ON & T1_SOURCE_INT & T1_PS_1_8 & T1_OSC1EN_OFF & T1_SYNC_EXT_OFF);
WriteTimer1( 0x00 & 0x00 );
/* Timer 3 Configuration */
// Used to create delays within the different menus without blocking with delays
OpenTimer3( TIMER_INT_ON & T3_16BIT_RW & T3_SOURCE_INT & T3_PS_1_8 & T3_SYNC_EXT_OFF);
WriteTimer3( 0x00 & 0x00 );
/* A/D configuration */
//ADCON1
ADCON1bits.VCFG1 = 0; // Voltage Reference Configuration bit (Vref-) = Vss
ADCON1bits.VCFG0 = 0; // Voltage Reference Configuration bit (Vref+) = Vdd
ADCON1bits.PCFG3 = 1; // PCFG = "1110" enables AN0 and AN1
ADCON1bits.PCFG2 = 1;
ADCON1bits.PCFG1 = 1;
ADCON1bits.PCFG0 = 0;
//ADCON0
ADCON0bits.ADON = 1; // A/D converter module is enabled
ADCON0bits.CHS0 = 0; // CHS = "0000" AN0 selected
ADCON0bits.CHS1 = 0;
ADCON0bits.CHS2 = 0;
ADCON0bits.CHS3 = 0;
//ADCON2
ADCON2bits.ADCS0 = 0; // A/D Adquisition Clock Select bits
ADCON2bits.ADCS1 = 1; // Tad = conversion time per bit. The A/D conversion requires 11 Tad
ADCON2bits.ADCS2 = 0; // "010" = 32 * Tosc
ADCON2bits.ACQT0 = 0; // A/D Adquisition time bits "000" = Manual adquisition
ADCON2bits.ACQT1 = 0;
ADCON2bits.ACQT2 = 0;
ADCON2bits.ADFM = 0; // Left justified . . .ADRESH . . : . . ADRESL. . .
// 7 6 5 4 3 2 1 0 : 7 6 5 4 3 2 1 0
// X X X X X X X X . X X . . . . . . <-Left Justified
/* Enabling interrups */
INTCONbits.TMR0IE = 1; // Enables interrupts for TIMER0
PIE1bits.TMR1IE = 1; // Enables interrupts for TIMER1
PIE2bits.TMR3IE = 1; // Enables interrupts for TIMER3
INTCONbits.PEIE = 1; // Peripherial interrupt enabled
INTCONbits.GIE = 1; // Global interrupt enabled
/* Main Loop */
while(1)
{
/* Main MENU includes the different modes that the table can show
Switching between menus is done using external button(RE0):
0 - Fixed light dimmed with external control
1 - Slow square
2 - Slow chess board
3 - Message
4 - Invaders
5 - Party (Dirty)
*/
switch(iMenu) {
/******************************************************************/
/* 0 - Fixed light dimmed with external control */
/******************************************************************/
case 0:
if (FIRST == 0) {
deleteMatrix();
(FIRST = 1);
}
drawLine(1,1,1,5,pwm); //dirty way to draw the all pixels at the same time
drawLine(2,1,2,5,pwm);
drawLine(3,1,3,5,pwm);
drawLine(4,1,4,5,pwm);
drawLine(5,1,5,5,pwm);
break;
/******************/
/* 1- Slow square */
/******************/
case 1:
if (SECOND == 0) {
deleteMatrix();
(SECOND = 1);
}
for(j = 130, i = 254; j<=254; j++, i--) {
drawSquare(1,1,5,5,j);
drawSquare(2,2,4,4,i);
drawPoint(3,3,j);
Delay10KTCYx(100);
if(iMenu != 1) {
break;
}
}
if(iMenu != 1) {
break;
}
for(j = 130, i = 254; j<=254; j++, i--) {
drawSquare(1,1,5,5,i);
drawSquare(2,2,4,4,j);
drawPoint(3,3,i);
Delay10KTCYx(100);
if(iMenu != 1) {
break;
}
}
if(iMenu != 1) {
break; // It allows to break the case during the executation
}
/***********************/
/* 2- Slow Chess board */
/***********************/
case 2:
if (THIRD == 0) {
deleteMatrix();
(THIRD = 1);
}
for(j = 130, i = 254; j<=254; j++, i--) {
drawPoint(1,5,j);
drawLine(1,3,3,5,j);
drawLine(1,1,5,5,j);
drawLine(3,1,5,3,j);
drawPoint(5,1,j);
drawLine(1,4,2,5,i);
drawLine(1,2,4,5,i);
drawLine(2,1,5,4,i);
drawLine(4,1,5,2,i);
Delay10KTCYx(100);
if(iMenu != 2) {
break;
}
}
if(iMenu != 2) {
break;
}
for(j = 130, i = 254; j<=254; j++, i--) {
drawPoint(1,5,i);
drawLine(1,3,3,5,i);
drawLine(1,1,5,5,i);
drawLine(3,1,5,3,i);
drawPoint(5,1,i);
drawLine(1,4,2,5,j);
drawLine(1,2,4,5,j);
drawLine(2,1,5,4,j);
drawLine(4,1,5,2,j);
Delay10KTCYx(100);
if(iMenu != 2) {
break;
}
}
if(iMenu != 2) {
break; // It allows to break the case during the executation
}
/**************/
/* 3- Message */
/**************/
case 3:
if (FOURTH == 0) {
deleteMatrix();
(FOURTH = 1);
}
//knightRider(4);
scrollText((rom unsigned char *)&Nino[0], TRANS_RIGHT_2_LEFT);
break;
/***************/
/* 4- Invaders */
/***************/
case 4:
if (FIFTH == 0) {
deleteMatrix();
(FIFTH = 1);
}
for(i = 1; i <= INVADERS_PAIR_REPETITIONS; i++) {
drawFrame((rom unsigned char *)&invaders[0]);
Delay10KTCYx(DELAY_INVADERS);
if(iMenu != 4) {
break;
}
drawFrame((rom unsigned char *)&invaders[1]);
Delay10KTCYx(DELAY_INVADERS);
if(iMenu != 4) {
break;
}
}// end for
for(i = 1; i <= INVADERS_PAIR_REPETITIONS; i++) {
drawFrame((rom unsigned char *)&invaders[2]);
Delay10KTCYx(DELAY_INVADERS);
if(iMenu != 4) {
break;
}
drawFrame((rom unsigned char *)&invaders[3]);
Delay10KTCYx(DELAY_INVADERS);
if(iMenu != 4) {
break;
}
}// end for
for(i = 1; i <= INVADERS_PAIR_REPETITIONS; i++) {
drawFrame((rom unsigned char *)&invaders[4]);
Delay10KTCYx(DELAY_INVADERS);
if(iMenu != 4) {
break;
}
drawFrame((rom unsigned char *)&invaders[5]);
Delay10KTCYx(DELAY_INVADERS);
if(iMenu != 4) {
break;
}
}// end for
break;
/********************/
/* 5- Party (Dirty) */
/********************/
case 5:
if (SIXTH == 0) {
deleteMatrix();
drawLine(1,5,5,5,254);
}
for(j = 100, i = 254; j<=254; j++, i--) {
drawSquare(1,1,5,5,j);
drawSquare(2,2,4,4,i);
drawPoint(3,3,j);
if(iMenu != 5) {
break;
}
}
if(iMenu != 5) {
break;
}
for(j = 100, i = 254; j<=254; j++, i--) {
drawSquare(1,1,5,5,i);
drawSquare(2,2,4,4,j);
drawPoint(3,3,i);
if(iMenu != 5) {
break;
}
}
if(iMenu != 5) {
break; // It allows to break the case during the executation
}
//SOLVES A BUG: because when TMR1F is called from this case, FIFTH is
//reset but when we come back is set one because we are in case 4 not 1,
if (iMenu == 5)(SIXTH = 1);
break;
default:
drawPoint(3,3, 180);
}// End switch iMenu
}// End while
CloseTimer0();
CloseTimer1();
}//end main
