static int put_debugreg(long pid, unsigned int regno, long data)
{
int ret = 0;
register int old_srs;
#ifdef CONFIG_ETRAX_KGDB
/* Ignore write, but pretend it was ok if value is 0
(we don't want POKEUSR/SETREGS failing unnessecarily). */
return (data == 0) ? ret : -1;
#endif
/* Simple owner management. */
if (!bp_owner)
bp_owner = pid;
else if (bp_owner != pid) {
/* Ignore write, but pretend it was ok if value is 0
(we don't want POKEUSR/SETREGS failing unnessecarily). */
return (data == 0) ? ret : -1;
}
/* Remember old SRS. */
SPEC_REG_RD(SPEC_REG_SRS, old_srs);
/* Switch to BP bank. */
SUPP_BANK_SEL(BANK_BP);
switch (regno - PT_BP) {
case 0:
SUPP_REG_WR(0, data); break;
case 1:
case 2:
if (data)
ret = -1;
break;
case 3:
SUPP_REG_WR(3, data); break;
case 4:
SUPP_REG_WR(4, data); break;
case 5:
SUPP_REG_WR(5, data); break;
case 6:
SUPP_REG_WR(6, data); break;
case 7:
SUPP_REG_WR(7, data); break;
case 8:
SUPP_REG_WR(8, data); break;
case 9:
SUPP_REG_WR(9, data); break;
case 10:
SUPP_REG_WR(10, data); break;
case 11:
SUPP_REG_WR(11, data); break;
case 12:
SUPP_REG_WR(12, data); break;
case 13:
SUPP_REG_WR(13, data); break;
case 14:
SUPP_REG_WR(14, data); break;
default:
ret = -1;
break;
}
/* Restore SRS. */
SPEC_REG_WR(SPEC_REG_SRS, old_srs);
/* Just for show. */
NOP();
NOP();
NOP();
return ret;
}
void wait(unsigned long t) {
unsigned long o = __time;
while (o+t > __time) {
NOP();
}
}
int main(void){
unsigned char ordem = 0;//usada para compararar uma sequência de dados recebidos com uma string.
unsigned char etapa=0;
unsigned char funcao=0;//utilizada para determinar qual função o PIC vai executar (abrir porta, fornecer histórico, fornecer status atual)
unsigned char conta=0;
unsigned char conta_a_ser_alterada=0;
unsigned char cont=0;
unsigned char qtd_total_contas=0;
unsigned char ultimo_caractere_recebido=0;
//CONFIGURAÇÃO OSCILADOR
OSCCON=0XF0;
//CONFIGURAÇÃO INTERRUPÇÕES
INTCON = 0b11100000;
INTCON2 =0b00000000;
PIE1=0b00100001;
RCONbits.IPEN = 0;
//CONFIGURAÇÃO TIMER0(CONTAGEM HORAS)
T0CON = 0b10000111;
TMR0H=0xC2; //TMR0=34446(1 interrupção = 1s para FOSC=16MHz)
TMR0L= 0xF7;
//CONFIGURAÇÃO DAS PORTAS
LATD=0; //4 primeiros bits = LEDs para debug(indicam se algo aconteceu, como o pressionamento do botão do teclado matricial ou o funcionamento do timer0(relógio) )
//4 ultimos bits -> Teclado matricial
TRISB=0xF0; // 4 ultimos bits-> teclado matricial
LATB=0x0F;
TRISC=0xC3;
TRISD=0x00;
ADCON1=0XFF;
CMCON=0X07;
//CONFIGURAÇÃO TIMER1(CONTAGEM DE TEMPO NO MODO_T9)
T1CON = 0b00001110;
TMR1H=0XC0; //TMR1 = 49152 (1 interrupção = 0.5s para cristal de 32,768khz)
TMR1L=0;
if(eeprom_read(0) == 0xFF){eeprom_config_inicial();}
configurar_serial(35);
qtd_total_contas = verificar_num_contas();
numero_para_ascii(qtd_total_contas);
for(conta=0;conta<qtd_total_contas;conta++){
carregar_senha(conta, senha);}
conta=0;
RCIE=1;
data_atual.ano=0;
data_atual.mes= Janeiro;
data_atual.dia=1;
data_atual.dia_da_semana= dia_da_semana(data_atual.ano,data_atual.mes,data_atual.dia);
data_atual.hora=0;
data_atual.minuto=0;
data_atual.segundo=0;
PORTB_SR=PORTB;//Leitura do PORTB antes de habilitar a interrupção para evitar uma interrupção não desejada.
RBIE=1;
RBIF=0;
cont=0;
while(1){
if(receber == 1){
receber=0;
numero_para_ascii(qtd_total_contas);
TXREG = '\n';
while(!TRMT){}
char j;
for(j=0;j<qtd_caracteres_recebidos_serial;j++){
TXREG = buffer_serial[j];
while(!TRMT){}
}
TXREG = '\n';
while(!TRMT){}
for(cont=0;cont<qtd_caracteres_recebidos_serial;cont++){
if(testar_bit(FLAGS_1,TRANSICAO_ETAPA)){
if(buffer_serial[cont] != PROXIMA_ETAPA) {
setar_bit(FLAGS_1,ERRO_PROTOCOLO);}
resetar_bit(FLAGS_1,TRANSICAO_ETAPA);
ordem=0;
etapa++;}
else if(etapa == etapa_inicial){//Inicio da comunicação
if(buffer_serial[cont] != INICIO) {setar_bit(FLAGS_1,ERRO_PROTOCOLO);}
setar_bit(FLAGS_1,TRANSICAO_ETAPA);
}
else if(etapa == etapa_recebe_funcao){
funcao = buffer_serial[cont++];
if(funcao<ABERTURA_PORTA || funcao>MUDAR_SENHA) {setar_bit(FLAGS_1,ERRO_PROTOCOLO);}
conta = ((buffer_serial[cont]) - '0');
if(!(conta<QTD_MAX_CONTAS)) setar_bit(FLAGS_1,ERRO_IDENTIF_CONTA);
setar_bit(FLAGS_1,TRANSICAO_ETAPA);
}
else if(etapa == etapa_login){//executa funcao
for(ordem=0;senha[conta][ordem]!= 0;ordem++){
if(senha[conta][ordem] != buffer_serial[cont++]) {
setar_bit(FLAGS_1,ERRO_SENHA);
TXREG = senha[conta][ordem]; while(!TRMT){}
TXREG = buffer_serial[--cont]; while(!TRMT){}
}
}
cont--;
setar_bit(FLAGS_1,TRANSICAO_ETAPA);
}
else if(etapa == etapa_detalha_funcao){
if(funcao == ABERTURA_PORTA || funcao == REQUERIMENTO_STATUS_ATUAL){
for(ordem=0;ordem<2;ordem++){
if( buffer_serial[cont++] != ('N'+(ordem))) {setar_bit(FLAGS_1,ERRO_PROTOCOLO);}
}
setar_bit(FLAGS_1,TRANSICAO_ETAPA);
}
else if(funcao == REQUERIMENTO_HISTORICO){
if(ordem==0){
endereco_inic_eeprom = (1794 + (buffer_serial[cont] *26));
ordem++;
}
}
//Não implementado
else if(funcao == RECONFIGURAR_PIC){
//ordem 0 ajuste de ano
//ordem 1 ajuste de mes
//ordem 2 ajuste de dia
//ordem 3 ajuste de hora
//ordem 4 ajuste de minuto
//ordem 5 ajuste de segundo
//ordem 6 ajuste de dia_da_semana(não pode ser ignorado se o dia for alterado também)
ptr_data= &data_atual.ano;
for(ordem=0;ordem<7;ordem++){
if(buffer_serial[cont] == IGNORAR) {//Pula para o próximo ajuste
ordem++;
cont+=2;}
*ptr_data = ascii_para_numero('0',buffer_serial[cont],buffer_serial[cont+1]);
cont+=2;}
cont--;
}
else if(funcao == MUDAR_SENHA){
conta_a_ser_alterada = (buffer_serial[cont] - '0');
if( conta_a_ser_alterada != conta && (!(testar_bit(nivel_acesso,PERMISSAO_RECONFIGURAR_OUTRAS_CONTAS))) ){
setar_bit(FLAGS_1,ERRO_NIVEL_DE_ACESSO);
}
for(ordem=0;ordem<(TAMANHO_SENHA-1);ordem++){
cont++;
if(buffer_serial[cont] == '<') {
if(ordem<5) setar_bit(FLAGS_1,ERRO_PROTOCOLO);
else {
if(ordem<TAMANHO_SENHA-2) eeprom_write( ((conta_a_ser_alterada*16)+ordem) , 0);
break;}
}
else{
senha[conta_a_ser_alterada][ordem] = buffer_serial[cont];
eeprom_write( ((conta_a_ser_alterada*16)+ordem) ,buffer_serial[cont]);}
}
setar_bit(FLAGS_1,TRANSICAO_ETAPA);}
}
else if(etapa == etapa_final){//Fim da comunicação
if(buffer_serial[cont] != FIM) {setar_bit(FLAGS_1,ERRO_PROTOCOLO);}
enviar=1; receber=qtd_caracteres_recebidos_serial=0;}
if(FLAGS_1>3 ) {
resetar_bit(FLAGS_1,TRANSICAO_ETAPA);
TXREG = '0' + etapa;
etapa = etapa_inicial;
enviar=1;
receber=qtd_caracteres_recebidos_serial=0;}
}
numero_para_ascii(qtd_total_contas);}
if(enviar==1){
enviar=0;
qtd_caracteres_recebidos_serial=0;
etapa = etapa_inicial;
cont=0;
enviar_caractere_serial(NOVA_LINHA);
enviar_caractere_serial(INICIO);
if(FLAGS_1<4 && etapa == etapa_final){ //Não houve erros
etapa = etapa_inicial;
LATDbits.LD2^=1;
char OK[] = {"OK"};
enviar_string_serial(OK);
if(funcao == REQUERIMENTO_STATUS_ATUAL){
numero_para_ascii(data_atual.ano);
numero_para_ascii(data_atual.mes);
numero_para_ascii(data_atual.dia_da_semana);
numero_para_ascii(data_atual.dia);
numero_para_ascii(data_atual.hora);
numero_para_ascii(data_atual.minuto);
numero_para_ascii(data_atual.segundo);
numero_para_ascii(qtd_total_contas);
numero_para_ascii(QTD_MAX_CONTAS);
numero_para_ascii(SENSOR_ABERTURA_FECHADURA);}
else if(funcao == MUDAR_SENHA){
char i=0;
do{
senha[conta_a_ser_alterada][i] = nova_senha[i];
eeprom_write(((conta_a_ser_alterada*16) + i),nova_senha[i]);
while(WR){}
i++;} while(nova_senha[i-1] && i<TAMANHO_SENHA);
}
else if(funcao == ABERTURA_PORTA){
while(SENSOR_ABERTURA_FECHADURA == 0){
//cont++; //quantidade de vezes que se tentou destravar a fechadura
FECHADURA=1;
delay_ms(325);
FECHADURA=0;
if(SENSOR_ABERTURA_FECHADURA == 0) delay_ms(100);
}
}
}
else{
LATDbits.LD3^=1;
if(testar_bit(FLAGS_1,ERRO_NIVEL_DE_ACESSO)){
char EN[] = {"EN"};
enviar_string_serial(EN);
resetar_bit(FLAGS_1,ERRO_NIVEL_DE_ACESSO);}
if(testar_bit(FLAGS_1,ERRO_PROTOCOLO)){
char EP[] = {"EP"};
enviar_string_serial(EP);
if(funcao == MUDAR_SENHA){
TXREG = 'S'; //indica que a nova senha tem menos que 6 caracteres;
while(!TRMT){}
}
resetar_bit(FLAGS_1,ERRO_PROTOCOLO);}
if(testar_bit(FLAGS_1,ERRO_COMUNICACAO)){
char EC[] = {"EC"};
enviar_string_serial(EC);
resetar_bit(FLAGS_1,ERRO_COMUNICACAO);}
if(testar_bit(FLAGS_1,ERRO_SENHA)){
char ES[] = {"ES"};
enviar_string_serial(ES);
resetar_bit(FLAGS_1,ERRO_SENHA);}
if(testar_bit(FLAGS_1,ERRO_IDENTIF_CONTA)){
char EI[] = {"EI"};
enviar_string_serial(EI);
resetar_bit(FLAGS_1,ERRO_IDENTIF_CONTA);}
}
enviar_caractere_serial(FIM);
PORTB_SR = PORTB;
RBIE=1;}
if((PORTB&0xF0) == 0xF0 && RBIE==0 && debounce==1 && MODO_TECLADO_MATRICIAL){//Tratamento de debounce. Espera-se até que nenhum botão esteja pressionado e que o debounce esteja autorizado
//(existem situações em que RBIE=0 e não se quer fazer tratamento de debounce
delay_ms(60);
if(!(testar_bit(FLAGS_2,MODO_T9))){//Modo_t9 desativado, o caractere_recebido é armazenado diretamente
receber=1;
}
else if(caractere_recebido == MODO_T9_ON_OFF ||caractere_recebido == MAIUSCULA_MINUSCULA){//Caracteres não são armazenadas
NOP();}
else if(caractere_recebido == ultimo_caractere_recebido){
if(++qtd_vezes_mesma_tecla_pressionada > Letras_por_tecla || ( (qtd_vezes_mesma_tecla_pressionada>Letras_por_tecla-1) && caractere_recebido == '9')){
TMR1ON=0;
TMR1H=0xC0;
qtd_vezes_mesma_tecla_pressionada=0;}
else ultimo_caractere_recebido= caractere_recebido; //atualiza ultimo caractere recebido
}
else if(testar_bit(FLAGS_2,MODO_T9)){ //caractere_recebido != do ultimo caractere recebido e modo t9 ativado
if(qtd_vezes_mesma_tecla_pressionada>0) receber=1;
ultimo_caractere_recebido= caractere_recebido;//atualiza ultimo caractere recebido
}
PORTB_SR=PORTB;//leitura do PORTB antes de ativar a interrupção para evitar uma interrupção não desejada.
RBIE=1;
debounce=0;
}
}
}
void huge ( )
{
cholmod_sparse *A, *C ;
cholmod_triplet *T ;
cholmod_factor *L ;
cholmod_dense *X ;
size_t n, nbig ;
int ok = TRUE, save ;
Int junk ;
FILE *f ;
double beta [2] ;
n = Size_max ;
CHOLMOD (free_work) (cm) ;
CHOLMOD (allocate_work) (n, 0, 0, cm) ;
OK (cm->status == CHOLMOD_TOO_LARGE) ;
n = CHOLMOD(add_size_t) (n, 1, &ok) ;
NOT (ok) ;
/* create a fake zero sparse matrix, with huge dimensions */
A = CHOLMOD (spzeros) (1, 1, 0, CHOLMOD_REAL, cm) ;
A->nrow = Size_max ;
A->ncol = Size_max ;
A->stype = 0 ;
/* create a fake factor, with huge dimensions. */
L = CHOLMOD (allocate_factor) (1, cm) ;
OKP (L) ;
L->n = Size_max ;
CHOLMOD (factorize) (A, L, cm) ;
OK (cm->status == CHOLMOD_TOO_LARGE) ;
/* free the fake factor */
L->n = 1 ;
CHOLMOD (free_factor) (&L, cm) ;
/* create a valid factor to test resymbol */
C = CHOLMOD (speye) (1, 1, CHOLMOD_REAL, cm) ;
C->stype = 1 ;
L = CHOLMOD (analyze) (C, cm) ;
OKP (L) ;
CHOLMOD (factorize) (C, L, cm) ;
ok = CHOLMOD (resymbol) (C, NULL, 0, 0, L, cm) ;
OK (ok) ;
C->nrow = Size_max ;
C->ncol = Size_max ;
L->n = Size_max ;
ok = CHOLMOD (resymbol) (C, NULL, 0, 0, L, cm) ;
NOT (ok) ;
OK (cm->status == CHOLMOD_TOO_LARGE) ;
printf ("rowfac:\n") ;
beta [0] = 1 ;
beta [1] = 0 ;
C->xtype = CHOLMOD_COMPLEX ;
L->xtype = CHOLMOD_COMPLEX ;
ok = CHOLMOD (rowfac) (C, NULL, beta, 0, 0, L, cm) ;
printf ("rowfac %d\n", cm->status) ;
OK (cm->status == CHOLMOD_TOO_LARGE) ;
C->xtype = CHOLMOD_REAL ;
L->xtype = CHOLMOD_REAL ;
printf ("rowfac done:\n") ;
C->stype = -1 ;
ok = CHOLMOD (resymbol_noperm) (C, NULL, 0, 0, L, cm) ;
NOT (ok) ;
OK (cm->status == CHOLMOD_TOO_LARGE) ;
C->ncol = 1 ;
CHOLMOD (rowadd) (0, C, L, cm) ;
OK (cm->status == CHOLMOD_TOO_LARGE) ;
CHOLMOD (rowdel) (0, C, L, cm) ;
OK (cm->status == CHOLMOD_TOO_LARGE) ;
C->ncol = 4 ;
CHOLMOD (updown) (1, C, L, cm) ;
OK (cm->status == CHOLMOD_TOO_LARGE) ;
C->nrow = 1 ;
C->ncol = 1 ;
L->n = 1 ;
CHOLMOD (free_sparse) (&C, cm) ;
CHOLMOD (free_factor) (&L, cm) ;
C = CHOLMOD (allocate_sparse) (Size_max, Size_max, Size_max, 0, 0, 0, 0, cm);
NOP (C) ;
OK (cm->status == CHOLMOD_TOO_LARGE) ;
CHOLMOD (rowcolcounts) (A, NULL, 0,
&junk, &junk, &junk, &junk, &junk, &junk, cm) ;
OK (cm->status == CHOLMOD_TOO_LARGE) ;
C = CHOLMOD (submatrix) (A, &junk, Size_max/2, &junk, Size_max/2, 0, 0, cm) ;
NOP (C) ;
OK (cm->status == CHOLMOD_TOO_LARGE) ;
ok = CHOLMOD (transpose_unsym) (A, 0, &junk, &junk, Size_max, A, cm) ;
NOT (ok) ;
OK (cm->status == CHOLMOD_TOO_LARGE) ;
A->stype = 1 ;
ok = CHOLMOD (transpose_sym) (A, 0, &junk, A, cm) ;
NOT (ok) ;
OK (cm->status == CHOLMOD_TOO_LARGE) ;
C = CHOLMOD (ptranspose) (A, 0, &junk, NULL, 0, cm) ;
NOP (C) ;
OK (cm->status == CHOLMOD_TOO_LARGE) ;
A->stype = 0 ;
CHOLMOD (amd) (A, NULL, 0, &junk, cm) ;
OK (cm->status == CHOLMOD_TOO_LARGE) ;
L = CHOLMOD (analyze) (A, cm) ;
OK (cm->status == CHOLMOD_TOO_LARGE) ;
NOP (L) ;
#ifndef NPARTITION
CHOLMOD (camd) (A, NULL, 0, &junk, NULL, cm) ;
OK (cm->status == CHOLMOD_TOO_LARGE) ;
#endif
printf ("calling colamd\n") ;
CHOLMOD (colamd) (A, NULL, 0, 0, &junk, cm) ;
OK (cm->status == CHOLMOD_TOO_LARGE) ;
#ifndef NPARTITION
printf ("calling ccolamd\n") ;
CHOLMOD (ccolamd) (A, NULL, 0, NULL, &junk, cm) ;
OK (cm->status == CHOLMOD_TOO_LARGE) ;
#endif
CHOLMOD (etree) (A, &junk, cm) ;
OK (cm->status == CHOLMOD_TOO_LARGE) ;
L = CHOLMOD (allocate_factor) (Size_max, cm) ;
OK (cm->status == CHOLMOD_TOO_LARGE) ;
NOP (L) ;
#ifndef NPARTITION
CHOLMOD (metis) (A, NULL, 0, 0, &junk, cm) ;
OK (cm->status == CHOLMOD_TOO_LARGE) ;
CHOLMOD (bisect) (A, NULL, 0, 0, &junk, cm) ;
OK (cm->status == CHOLMOD_TOO_LARGE) ;
CHOLMOD (nested_dissection) (A, NULL, 0, &junk, &junk, &junk, cm) ;
OK (cm->status == CHOLMOD_TOO_LARGE) ;
#endif
CHOLMOD (postorder) (&junk, Size_max, &junk, &junk, cm) ;
OK (cm->status == CHOLMOD_TOO_LARGE) ;
/* causes overflow in 32-bit version, but not 64-bit */
f = fopen ("../Tcov/Matrix/mega.tri", "r") ;
T = CHOLMOD (read_triplet) (f, cm) ;
if (sizeof (Int) == sizeof (int))
{
NOP (T) ;
OK (cm->status != CHOLMOD_OK) ;
}
CHOLMOD (free_triplet) (&T, cm) ;
fclose (f) ;
n = Size_max ;
X = CHOLMOD (allocate_dense) (n, 1, n, CHOLMOD_REAL, cm) ;
NOP (X) ;
OK (cm->status == CHOLMOD_TOO_LARGE) ;
/* supernodal symbolic test */
C = CHOLMOD (speye) (1, 1, CHOLMOD_REAL, cm) ;
C->stype = 1 ;
save = cm->supernodal ;
cm->supernodal = CHOLMOD_SIMPLICIAL ;
L = CHOLMOD (analyze) (C, cm) ;
OKP (L) ;
junk = 0 ;
C->nrow = Size_max ;
C->ncol = Size_max ;
L->n = Size_max ;
CHOLMOD (super_symbolic) (C, C, &junk, L, cm) ;
OK (cm->status == CHOLMOD_TOO_LARGE) ;
cm->supernodal = save ;
C->nrow = 1 ;
C->ncol = 1 ;
L->n = 1 ;
CHOLMOD (free_sparse) (&C, cm) ;
CHOLMOD (free_factor) (&L, cm) ;
/* supernodal numeric test */
C = CHOLMOD (speye) (1, 1, CHOLMOD_REAL, cm) ;
C->stype = -1 ;
save = cm->supernodal ;
cm->supernodal = CHOLMOD_SUPERNODAL ;
L = CHOLMOD (analyze) (C, cm) ;
OKP (L) ;
OK (cm->status == CHOLMOD_OK) ;
C->nrow = Size_max ;
C->ncol = Size_max ;
L->n = Size_max ;
CHOLMOD (super_numeric) (C, C, beta, L, cm) ;
cm->supernodal = save ;
C->nrow = 1 ;
C->ncol = 1 ;
L->n = 1 ;
CHOLMOD (free_sparse) (&C, cm) ;
CHOLMOD (free_factor) (&L, cm) ;
/* free the fake matrix */
A->nrow = 1 ;
A->ncol = 1 ;
CHOLMOD (free_sparse) (&A, cm) ;
fprintf (stderr, "\n") ;
}
/*---------------------------------------------------------------------------*
* Routine: UART2_Start
*---------------------------------------------------------------------------*
* Description:
* Each time the timer fires off an interrupt, this routine catches it
* and passes it to the given interrupt service routine.
* Inputs:
* uint32_t baud -- baud rate (e.g. 115200 baud), or bits per second
* Outputs:
* void
*---------------------------------------------------------------------------*/
void UART2_Start(uint32_t baud)
{
/* Reset FIFO buffers */
G_UART2_RXIn = G_UART2_RXOut = 0;
G_UART2_TXIn = G_UART2_TXOut = 0;
G_UART2_TX_Empty = true;
/* supply SAU0 clock */
SAU1EN = 1U;
NOP();
NOP();
NOP();
NOP();
/* disable UART2 receive and transmit */
ST1 |= _SAU_CH1_STOP_TRG_ON | _SAU_CH0_STOP_TRG_ON;
/* Turn Off Interrupts */
STMK2 = 1U; /* disable INTST0 interrupt */
STIF2 = 0U; /* clear INTST0 interrupt flag */
SRMK2 = 1U; /* disable INTSR0 interrupt */
SRIF2 = 0U; /* clear INTSR0 interrupt flag */
SREMK2 = 1U; /* disable INTSRE0 interrupt */
SREIF2 = 0U; /* clear INTSRE0 interrupt flag */
STPR12 = UART2_TX_INTERRUPT_PRIORITY; /* Set INTST0 priority */
STPR02 = UART2_TX_INTERRUPT_PRIORITY;
SRPR12 = UART2_RX_INTERRUPT_PRIORITY; /* Set INTSR0 priority */
SRPR02 = UART2_RX_INTERRUPT_PRIORITY;
SREPR12 = UART2_RE_INTERRUPT_PRIORITY; /* Set INTSRE0 priority */
SREPR02 = UART2_RE_INTERRUPT_PRIORITY;
/* Configure TX0 */
SMR10 = _SAU_SMRMN_INITIALVALUE | _SAU_CLOCK_SELECT_CK00 | _SAU_TRIGGER_SOFTWARE |
_SAU_MODE_UART | _SAU_TRANSFER_END;
SCR10 = _SAU_TRANSMISSION | _SAU_INTSRE_MASK | _SAU_PARITY_NONE | _SAU_LSB | _SAU_STOP_1 |
_SAU_LENGTH_8;
NFEN0 |= _SAU_RXD0_FILTER_ON;
/* Configure RX0 */
SIR11 = _SAU_SIRMN_FECTMN | _SAU_SIRMN_PECTMN | _SAU_SIRMN_OVCTMN; /* clear error flag */
SMR11 = _SAU_SMRMN_INITIALVALUE | _SAU_CLOCK_SELECT_CK00 | _SAU_TRIGGER_RXD | _SAU_EDGE_FALL |
_SAU_MODE_UART | _SAU_TRANSFER_END;
SCR11 = _SAU_RECEPTION | _SAU_INTSRE_ENABLE | _SAU_PARITY_NONE | _SAU_LSB | _SAU_STOP_1 |
_SAU_LENGTH_8;
SO1 |= _SAU_CH0_DATA_OUTPUT_1;
SOL1 |= _SAU_CHANNEL0_NORMAL; /* output level normal */
SOE1 |= _SAU_CH0_OUTPUT_ENABLE; /* enable UART2 output */
UART2_SetBaudRate(baud);
PM1 |= 0x10U; /* Set RxD2 pin */
P1 |= 0x08U; /* Set TxD2 pin */
PM1 &= 0xF7U;
STIF2 = 0U; /* clear INTST0 interrupt flag */
STMK2 = 0U; /* enable INTST0 interrupt */
SRIF2 = 0U; /* clear INTSR0 interrupt flag */
SRMK2 = 0U; /* enable INTSR0 interrupt */
SREIF2 = 0U; /* clear INTSRE0 interrupt flag */
SREMK2 = 0U; /* enable INTSRE0 interrupt */
SO1 |= _SAU_CH0_DATA_OUTPUT_1; /* output level normal */
SOE1 |= _SAU_CH0_OUTPUT_ENABLE; /* enable UART2 output */
/* enable UART2 receive and transmit */
SS1 |= _SAU_CH1_START_TRG_ON | _SAU_CH0_START_TRG_ON;
}
void halWaitX10 (UINT16 timeout)
{
// Time base: 14,745,600 cycles per sec: 147 cycles; error 0.3%
do {
NOP();
NOP();
NOP();
NOP();
NOP();
NOP();
NOP();
NOP();
NOP();
NOP();
NOP();
NOP();
NOP();
NOP();
NOP();
NOP();
NOP();
NOP();
NOP();
NOP();
NOP();
NOP();
NOP();
NOP();
NOP();
NOP();
NOP();
NOP();
NOP();
NOP();
NOP();
NOP();
NOP();
NOP();
NOP();
NOP();
NOP();
NOP();
NOP();
NOP();
NOP();
NOP();
NOP();
NOP();
NOP();
NOP();
NOP();
NOP();
NOP();
NOP();
NOP();
NOP();
NOP();
NOP();
NOP();
NOP();
NOP();
NOP();
NOP();
NOP();
NOP();
NOP();
NOP();
NOP();
NOP();
NOP();
NOP();
NOP();
NOP();
NOP();
NOP();
NOP();
NOP();
NOP();
NOP();
NOP();
NOP();
NOP();
NOP();
NOP();
NOP();
NOP();
NOP();
NOP();
NOP();
NOP();
NOP();
NOP();
NOP();
NOP();
NOP();
NOP();
NOP();
NOP();
NOP();
NOP();
NOP();
NOP();
NOP();
NOP();
NOP();
NOP();
NOP();
NOP();
NOP();
NOP();
NOP();
NOP();
NOP();
NOP();
NOP();
NOP();
NOP();
NOP();
NOP();
NOP();
NOP();
NOP();
NOP();
NOP();
NOP();
NOP();
NOP();
NOP();
NOP();
NOP();
NOP();
NOP();
NOP();
NOP();
NOP();
NOP();
NOP();
NOP();
NOP();
NOP();
NOP();
NOP();
NOP();
NOP();
NOP();
NOP();
NOP();
NOP();
NOP();
NOP();
NOP();
} while (--timeout);
} // halWaitX10
void halWait (UINT16 timeout)
{
// Time base: 14,745,600 cycles per sec: 15 cycles; error 1.75%
do {
NOP();
NOP();
NOP();
NOP();
NOP();
NOP();
NOP();
NOP();
NOP();
NOP();
NOP();
NOP();
NOP();
NOP();
NOP();
} while (--timeout);
} // halWait
void interrupt FastTick(void) {
static unsigned char LowTrigger = 80;
static unsigned char Motor_Encoder = 0;
static signed long interal_PID_MeasuredPoint = 10;
static unsigned int TimmingError = 0;
static unsigned char BacklightPWM_PR = 8;
unsigned char RXDat;
//Reset for 40kHz
TMR0H = 0xFE;
TMR0L = 0x83;
TMR0IF = 0; //Clear the Timer Interrupt Flag
if ((TXSTA1bits.TRMT) && (TX_bCount)) {
TXREG = TXBuffer[TX_Idx];
TX_Idx++;
TX_bCount--;
}
if ((RCSTA1bits.OERR) | (RCSTA1bits.FERR)) {
RCSTA1bits.CREN = 0;
NOP();
RCSTA1bits.CREN = 1;
RXDat = RCREG;
RXDat = RCREG;
RX_Idx = 0;
RX_MsgComplete = 0;
RX_InProgress = 0;
}
if (RC1IF) {
RXDat = RCREG;
if (RXDat == '@') {
RX_Idx = 0;
RX_MsgComplete = 0;
RX_InProgress = 1;
}
if (RXDat == '#') {
RX_MsgComplete = 1;
RX_InProgress = 0;
}
if (RX_Idx > 254) RX_Idx = 0;
if (RX_InProgress) {
RXBuffer[RX_Idx] = RXDat;
RX_Idx++;
}
}
if (BacklightPWM_PR) BacklightPWM_PR--;
else BacklightPWM_PR = 7;
if (LCD_BacklightEnabled) {
if (Config.BacklightPWM_Duty > BacklightPWM_PR) LCD_BL = 1;
else LCD_BL = 0;
} else LCD_BL = 0;
LowTrigger--;
bTick40Khz = !bTick40Khz;
if (LowTrigger == 0) {
TimmingError++;
if (TimmingError == 401) {
LowTrigger = 79;
TimmingError = 0;
} else LowTrigger = 80;
TMR1IF = 1;
}
Motor_Encoder <<= 2;
Motor_Encoder |= MOTOR_ENCODER;
Motor_Encoder &= 0x0F;
interal_PID_MeasuredPoint -= enc_states[Motor_Encoder];
if (bClear_MotorPosition) {
bClear_MotorPosition = 0;
interal_PID_MeasuredPoint = 0;
}
if (!bLock_Motor_Position) Motor_Position = interal_PID_MeasuredPoint;
}
static void DelayNOP(u32 count)
{
while(count--) NOP();
}
