Code:
#include <stdint.h>
#include <stdio.h>
#include "board.h"
#include "dbgu.h"
#include "common/swi.h"
#define nop() __asm__ __volatile__("nop")
#define RTTC_INTERRUPT_LEVEL 0
#define PIV_200_MS 600000 //* 200 ms for 48 MHz
#define MCK 48054857
#define BAUD 115200
#define LED_A (1<<8)
#define CLKOUT (1<<30)
#define LCD_UNK0 (1<<28)
#define LCD_REFRESH (1<<26)
#define LCD_DATA (1<<24)
#define LCD_CLOCK (1<<22)
#define LCD_SELECT (1<<20)
#define LCD_STOP (1<<14)
#define LCD_UNK1 (1<<18)
#define SERIAL_RX AT91C_PA5_RXD0
#define SERIAL_TX AT91C_PA6_TXD0
#define K_LINE_RX AT91C_PA9_DRXD
#define K_LINE_TX AT91C_PA10_DTXD
#define L_LINE (0<<0)
#define STALK_BUTTON AT91C_PIO_PA12
#define FUEL_CONS AT91C_PIO_PA4
#define VBAT AT91C_ADC_CH5
#define REMOTE_TX FUEL_CONS
#define REMOTE_RX STALK_BUTTON
#define OBD_ADDR_DME 0x10
#include <string.h>
volatile AT91PS_PMC pPMC = AT91C_BASE_PMC;
volatile AT91PS_PIO pPIO = AT91C_BASE_PIOA;
volatile AT91PS_AIC pAIC = AT91C_BASE_AIC;
volatile AT91PS_TC pTC0 = AT91C_BASE_TC0;
volatile AT91PS_TC pTC1 = AT91C_BASE_TC1;
volatile AT91PS_USART pUSART0 = AT91C_BASE_US0;
volatile AT91PS_USART pUSART1 = AT91C_BASE_US1;
volatile AT91PS_DBGU pDBGU = AT91C_BASE_DBGU;
volatile AT91PS_ADC pADC = AT91C_BASE_ADC;
int voltagewhole;
int voltagepart;
char clock_buffer[5] = "131v";
char lcd_buffer[40] = "";
int freeze_lcd = 0;
unsigned int freeze_clock = 0;
int clock_type = 0;
void lcd_update();
void delayhus(unsigned int hus)
{
while(hus--)
{
nop();
nop();
nop();
nop();
nop();
nop();
}
}
void delayus(unsigned int us)
{
while(us--)
{
// for(volatile int i = 0; i < 1; i++);
nop();
nop();
nop();
nop();
nop();
nop();
nop();
nop();
}
}
void delayms(unsigned int ms)
{
unsigned int i;
while(ms--)
{
// delayus(1000);
i = 2000;
while(i--)
nop();
}
}
void int_pit(void)
{
volatile uint32_t status;
// Interrupt Acknowledge
status = AT91C_BASE_PITC->PITC_PIVR;
if(pPIO->PIO_ODSR & LED_A)
pPIO->PIO_CODR = LED_A;
else
pPIO->PIO_SODR = LED_A;
int voltage = pADC->ADC_CDR5;
pADC->ADC_CR = AT91C_ADC_START;
voltagewhole = voltage * 18.4 / 1023;
voltagepart = voltage * 18.4 / 1023 * 10;
voltagepart = voltagepart % 10;
// printf("(%iv%i)\n", voltagewhole, voltagepart);
// float voltagef = (float)voltage * 15.51 / 1023;
// sprintf(clockstring, "%.1f", voltagef);
if(!freeze_clock)
{
switch(clock_type)
{
case 0:
// sprintf(clockstring, "%i", voltage);
sprintf(clock_buffer, "%iv%i", voltagewhole, voltagepart);
break;
case 1:
sprintf(clock_buffer, "29C ");
break;
case 2:
if(pPIO->PIO_PDSR & FUEL_CONS)
clock_buffer[3] = '1';
else
clock_buffer[3] = '0';
if(pPIO->PIO_PDSR & STALK_BUTTON)
clock_buffer[2] = '1';
else
clock_buffer[2] = '0';
break;
default:
clock_type = 0;
}
}
else
freeze_clock--;
if(!freeze_lcd)
sprintf(lcd_buffer, "EXT:29C INT:31C");
else
freeze_lcd--;
lcd_update();
}
static void int_timer_clock(void)
{
pTC1->TC_SR;
if(pPIO->PIO_ODSR & CLKOUT)
pPIO->PIO_CODR = CLKOUT;
else
pPIO->PIO_SODR = CLKOUT;
}
static void int_pio(void)
{
unsigned int before = pPIO->PIO_ISR;
delayms(20);
if(before & STALK_BUTTON && !(pPIO->PIO_PDSR & STALK_BUTTON))
{
static int status = 0;
status++;
if(status > 2)
status = 0;
switch(status)
{
case 0:
sprintf(clock_buffer, "131v");
break;
case 1:
sprintf(clock_buffer, "29C ");
break;
case 2:
sprintf(clock_buffer, "0342");
break;
}
lcd_update();
while(!(pPIO->PIO_PDSR & STALK_BUTTON));
}
}
void init_lcd(void)
{
pPMC->PMC_PCER = (1 << AT91C_ID_PIOA);
pPIO->PIO_PPUDR = CLKOUT | LCD_CLOCK | LCD_DATA | LCD_SELECT | LCD_REFRESH | LCD_STOP | LCD_UNK0 | LCD_UNK1;
pPIO->PIO_MDER = CLKOUT | LCD_CLOCK | LCD_DATA | LCD_SELECT | LCD_REFRESH | LCD_STOP | LCD_UNK0 | LCD_UNK1;
pPIO->PIO_PER = CLKOUT | LCD_CLOCK | LCD_DATA | LCD_SELECT | LCD_REFRESH | LCD_STOP | LCD_UNK0 | LCD_UNK1;
pPIO->PIO_CODR = CLKOUT | LCD_CLOCK | LCD_DATA | LCD_SELECT | LCD_REFRESH | LCD_STOP | LCD_UNK0 | LCD_UNK1;
pPIO->PIO_SODR = LCD_DATA | LCD_SELECT;
pPIO->PIO_OER = CLKOUT | LCD_CLOCK | LCD_DATA | LCD_SELECT | LCD_REFRESH | LCD_STOP | LCD_UNK0 | LCD_UNK1;
pAIC->AIC_IDCR = 1 << AT91C_ID_TC1;
pAIC->AIC_SVR[AT91C_ID_TC1] = (unsigned)&int_timer_clock;
pAIC->AIC_SMR[AT91C_ID_TC1] = AT91C_AIC_PRIOR_HIGHEST | AT91C_AIC_SRCTYPE_HIGH_LEVEL;
pPMC->PMC_PCER = (1 << AT91C_ID_TC1);
pTC1->TC_CMR = AT91C_TC_CLKS_TIMER_DIV1_CLOCK | AT91C_TC_CPCTRG;
pTC1->TC_RC = 156;
pTC1->TC_IER = AT91C_TC_CPCS;
pTC1->TC_CCR = AT91C_TC_CLKEN | AT91C_TC_SWTRG;
pAIC->AIC_ICCR = (1 << AT91C_ID_TC1);
pAIC->AIC_IECR = (1 << AT91C_ID_TC1);
}
void init_security(void)
{
pPMC->PMC_PCER = (1 << AT91C_ID_PIOA);
pPIO->PIO_ODR = REMOTE_RX | REMOTE_TX;
pPIO->PIO_PPUDR = REMOTE_TX | REMOTE_RX;
pPIO->PIO_MDER = REMOTE_TX;
pPIO->PIO_SODR = REMOTE_TX;
pPIO->PIO_PER = REMOTE_RX | REMOTE_TX;
pPIO->PIO_OER = REMOTE_TX;
// pAIC->AIC_IDCR = 1 << AT91C_ID_PIOA;
// pAIC->AIC_SVR[AT91C_ID_PIOA] = (unsigned int)&int_remote;
// pAIC->AIC_SMR[AT91C_ID_PIOA] = AT91C_AIC_PRIOR_HIGHEST;
// pPIO->PIO_IER = REMOTE_TX;
// pPIO->PIO_ISR;
// pAIC->AIC_ICCR = (1 << AT91C_ID_PIOA);
// pAIC->AIC_IECR = (1 << AT91C_ID_PIOA);
}
void init_input(void)
{
pPMC->PMC_PCER = (1 << AT91C_ID_PIOA);
// pPIO->PIO_ODR = STALK_BUTTON | FUEL_CONS;
// pPIO->PIO_PPUDR = STALK_BUTTON | FUEL_CONS | VBAT;
// pPIO->PIO_IFER = STALK_BUTTON;
// pPIO->PIO_PER = STALK_BUTTON | FUEL_CONS;
pPIO->PIO_PDR = VBAT;
// pAIC->AIC_IDCR = 1 << AT91C_ID_PIOA;
// pAIC->AIC_SVR[AT91C_ID_PIOA] = (unsigned int)&int_pio;
// pAIC->AIC_SMR[AT91C_ID_PIOA] = AT91C_AIC_PRIOR_LOWEST;
// pPIO->PIO_IER = STALK_BUTTON;
// pAIC->AIC_ICCR = (1 << AT91C_ID_PIOA);
// pAIC->AIC_IECR = (1 << AT91C_ID_PIOA);
pADC->ADC_MR = AT91C_ADC_TRGEN_DIS | AT91C_ADC_TRGSEL_TIOA0 | AT91C_ADC_LOWRES_10_BIT | AT91C_ADC_SLEEP_NORMAL_MODE | AT91C_ADC_PRESCAL | AT91C_ADC_STARTUP | AT91C_ADC_SHTIM;
pADC->ADC_CHER = VBAT;
pADC->ADC_CR = AT91C_ADC_START;
}
void init_obd(void)
{
pPMC->PMC_PCER = 1 << AT91C_ID_PIOA | 1 << AT91C_ID_US0;
pPIO->PIO_PPUDR = K_LINE_RX | K_LINE_TX | L_LINE;
pPIO->PIO_MDDR = K_LINE_RX | K_LINE_TX | L_LINE;
pPIO->PIO_ODR = K_LINE_RX;
pPIO->PIO_ASR = K_LINE_TX | K_LINE_RX;
pPIO->PIO_PDR = K_LINE_TX | K_LINE_RX;
// pPIO->PIO_PER = K_LINE_RX;
// pPIO->PIO_SODR = L_LINE;
// pUSART0->US_CR = AT91C_US_RSTRX | AT91C_US_RSTTX | AT91C_US_RXDIS | AT91C_US_TXDIS;
// pUSART0->US_MR = AT91C_US_USMODE_NORMAL | AT91C_US_CLKS_CLOCK | AT91C_US_CHRL_7_BITS | AT91C_US_PAR_ODD | AT91C_US_NBSTOP_1_BIT;
// pUSART0->US_BRGR = MCK/16/6;
// pUSART0->US_CR = AT91C_US_TXEN;
pDBGU->DBGU_CR = AT91C_US_RSTRX | AT91C_US_RSTTX | AT91C_US_RXDIS | AT91C_US_TXDIS;
pDBGU->DBGU_MR = AT91C_US_USMODE_NORMAL | AT91C_US_CLKS_CLOCK | AT91C_US_CHRL_8_BITS | AT91C_US_PAR_NONE | AT91C_US_NBSTOP_1_BIT;
pDBGU->DBGU_BRGR = MCK/16/9600;
pDBGU->DBGU_CR = AT91C_US_RXEN | AT91C_US_TXEN;
}
static void init(void)
{
// Enable User Reset and set its minimal assertion to 960 us
AT91C_BASE_RSTC->RSTC_RMR = AT91C_RSTC_URSTEN | (0x4<<8) | (unsigned int)(0xA5<<24);
pPMC->PMC_PCER = (1 << AT91C_ID_PIOA);
AT91F_DBGU_Init();
init_input();
init_security();
init_lcd();
init_obd();
pPIO->PIO_MDDR = LED_A;
pPIO->PIO_PER = LED_A;
pPIO->PIO_CODR = LED_A;
pPIO->PIO_OER = LED_A;
pAIC->AIC_IDCR = 1 << AT91C_ID_SYS;
pAIC->AIC_SVR[AT91C_ID_SYS] = (unsigned int)&int_pit;
pAIC->AIC_SMR[AT91C_ID_SYS] = AT91C_AIC_SRCTYPE_INT_POSITIVE_EDGE | 5;
AT91C_BASE_PITC->PITC_PIMR = AT91C_PITC_PITEN | AT91C_PITC_PITIEN | (MCK/16/1000*200);
pAIC->AIC_ICCR = 1 << AT91C_ID_SYS;
pAIC->AIC_IECR = 1 << AT91C_ID_SYS;
}
int dbgu_putc(int c)
{
while(!(AT91C_BASE_DBGU->DBGU_CSR & AT91C_US_TXRDY));
return(AT91C_BASE_DBGU->DBGU_THR = c);
}
int dbgu_getc(void)
{
while(!(AT91C_BASE_DBGU->DBGU_CSR & AT91C_US_RXRDY));
return(AT91C_BASE_DBGU->DBGU_RHR & 0xff);
}
int uart0_putc(int c)
{
while(!(AT91C_BASE_US0->US_CSR & AT91C_US_TXRDY));
return(AT91C_BASE_US0->US_THR = c);
}
// int uart0_getc(void)
// {
// while(!(AT91C_BASE_US0->US_CSR & AT91C_US_RXRDY));
// return(AT91C_BASE_US0->US_RHR & 0xff);
// }
int obd_send(char* data, int bytes)
{
for(int byte = 0; byte < bytes; byte++)
{
// printf("[%02x]", data[byte]);
dbgu_putc(data[byte]);
while(!(pDBGU->DBGU_CSR & AT91C_US_TXRDY));
delayus(1000);
if(!(pDBGU->DBGU_CSR & AT91C_US_RXRDY))
{
printf("!");
return 0;
}
char c = dbgu_getc();
if(c != data[byte])
{
printf("?%02x?", c);
return 0;
}
if(byte == bytes - 1)
return bytes;
double wait = 0;
for(wait = 0; wait < 500000; wait++)
{
if(!(pDBGU->DBGU_CSR & AT91C_US_RXRDY))
continue;
char c = dbgu_getc();
// printf("<%02x>", c);
if(c != (data[byte] ^ 0xff))
{
printf("?%02x?", c);
return 0;
}
else
break;
}
if(wait == 500000)
printf("*");
}
return bytes;
}
int obd_get(char* data, int length)
{
int bytes = 0;
for(double wait = 0; wait < 500000; wait++)
{
if(!(pDBGU->DBGU_CSR & AT91C_US_RXRDY))
continue;
char c = dbgu_getc();
data[bytes] = c;
// printf("<%02x>", c);
if(bytes == data[0] || bytes == length-1)
{
// printf("got 0x%x bytes\n", bytes);
data[bytes+1] = '\0';
return bytes;
}
// printf("[%02x]", data[bytes] ^ 0xff);
dbgu_putc(data[bytes] ^ 0xff);
while(!(pDBGU->DBGU_CSR & AT91C_US_TXRDY));
delayus(1000);
if(!(pDBGU->DBGU_CSR & AT91C_US_RXRDY))
{
printf("!");
return 0;
}
c = dbgu_getc();
if(c != (data[bytes] ^ 0xff))
{
printf("?%02x?", c);
return 0;
}
// bytes++;
bytes++;
}
return bytes;
}
int obd_init_l(int address, int keycode)
{
char reply[10];
delayms(3000);
pDBGU->DBGU_CR = AT91C_US_RXDIS;
pPIO->PIO_SODR = K_LINE_TX;
pPIO->PIO_OER = K_LINE_TX;
pPIO->PIO_PER = K_LINE_TX;
pPIO->PIO_CODR = K_LINE_TX;
delayms(1);
if(pPIO->PIO_PDSR & K_LINE_RX)
{
printf("not low!\n");
freeze_lcd = 65500;
sprintf(lcd_buffer, "not low!!");
return 0;
}
pPIO->PIO_SODR = K_LINE_TX;
delayms(1);
if(!(pPIO->PIO_PDSR & K_LINE_RX))
{
printf("not high!\n");
freeze_lcd = 65500;
sprintf(lcd_buffer, "not high!!");
return 0;
}
bool parity = 1;
printf("[%02x]", address);
freeze_clock = 5;
sprintf(clock_buffer, "0x%02x", address);
pPIO->PIO_OER = K_LINE_TX;
//start bit
pPIO->PIO_CODR = K_LINE_TX;
delayms(200);
for(int bit = 0; bit < 7; bit++)
{
if(address & (1 << bit))
{
pPIO->PIO_SODR = K_LINE_TX;
parity ^= 1;
}
else
pPIO->PIO_CODR = K_LINE_TX;
delayms(200);
}
//parity bit
if(parity)
pPIO->PIO_SODR = K_LINE_TX;
else
pPIO->PIO_CODR = K_LINE_TX;
delayms(200);
//stop bit
pPIO->PIO_SODR = K_LINE_TX;
delayms(200);
pPIO->PIO_ODR = K_LINE_TX;
pPIO->PIO_PDR = K_LINE_TX;
pDBGU->DBGU_CR = AT91C_US_RXEN;
int bytes = 0;
for(double wait = 0; wait < 500000; wait++)
{
if(!(pDBGU->DBGU_CSR & AT91C_US_RXRDY))
continue;
char c = dbgu_getc();
reply[bytes] = c;
printf("<%02x>", c);
if(reply[0] == 0x55 && bytes == 2)
{
printf("[%02x]", reply[bytes] ^ 0xff);
dbgu_putc(reply[bytes] ^ 0xff);
while(!(pDBGU->DBGU_CSR & AT91C_US_TXRDY));
delayus(1000);
if(!(pDBGU->DBGU_CSR & AT91C_US_RXRDY))
{
printf("!");
return 0;
}
c = dbgu_getc();
if(c != (reply[bytes] ^ 0xff))
{
printf("?%02x?", c);
return 0;
}
if(reply[1] == (keycode >> 8) && reply[2] == (keycode & 0xff))
return 1;
else
return 0;
}
bytes++;
}
return 0;
}
int obd_query(int command, char* data, int length, int* reply_type, char* reply_data, int* reply_length)
{
char input[64];
int seq = 0;
char ack[4] = {0x03, 0x00, 0x09, 0x03};
if(!obd_init_l(OBD_ADDR_DME, 0x81))
return 0;
if(!obd_get(input, sizeof(input)))
return 0;
seq = input[1];
while(input[2] != 0x09)
{
ack[1] = ++seq;
if(!obd_send(ack, 4))
return 0;
if(!obd_get(input, sizeof(input)))
return 0;
seq = input[1];
// printf("type (%02x)\n", input[2]);
}
char query[64];
query[0] = length + 3;
query[1] = ++seq;
query[2] = command;
memcpy(query+3, data, length);
query[query[0]] = 0x03;
if(!obd_send(query, length+4))
return 0;
if(!obd_get(input, sizeof(input)))
return 0;
seq = input[1];
ack[1] = ++seq;
obd_send(ack, 4);
*reply_type = (int)input[2];
*reply_length = input[0] - 3;
memcpy(reply_data, input+3, *reply_length);
// while(input[input[0]] == 0xc8)
// {
// if(!obd_get(input, sizeof(input)))
// return 0;
//
// seq = input[1];
// ack[1] = ++seq;
// obd_send(ack, 4);
//
// *reply_length += input[0] - 3;
// memcpy(reply_data + (*reply_length - input[0] - 3), input+3, *reply_length);
// }
return 1;
}
void obd_test(void)
{
for(int address = 0; address < 0x1000; address += 0x10)
{
printf("\n%iv%i\n", voltagewhole, voltagepart);
printf("querying...\n");
int type;
char data[64];
int length;
char args[16] = {0x10, address >> 8, address & 0xff};
if(!obd_query(0x01, args, 0x03, &type, data, &length))
{
address -= 0x10;
if(address < -0x10)
address = 0;
printf("bad\n");
freeze_lcd = 100;
sprintf(lcd_buffer, "RPM: bad");
}
else
{
char string[128] = "";
for(int i = 0; i < length && i < 8; i++)
{
char buffer[10];
sprintf(buffer, "%02x ", data[i]);
strcat(string, buffer);
}
// printf("good (type: 0x%02x, length: 0x%02x data: { %s})\n", type, length, string);
int byte = 0;
// for(int row = 0; row < 0x10; row++)
// {
// if(byte >= length)
// break;
printf("\n0x%02x ", address);
for(int col = 0; col < 0x10; col++)
{
if(byte >= length)
break;
printf("%02x ", data[byte++]);
}
printf("\n");
// }
}
// delayms(5000);
}
while(1);
}
void lcd_putc(unsigned char c)
{
int bit = 8;
while(bit--)
{
if(c & (1 << bit))
pPIO->PIO_SODR = LCD_DATA;
else
pPIO->PIO_CODR = LCD_DATA;
delayhus(1);
pPIO->PIO_SODR = LCD_CLOCK;
delayhus(1);
pPIO->PIO_CODR = LCD_CLOCK;
}
pPIO->PIO_SODR = LCD_DATA;
delayus(1);
// if(c != 8)
// {
pPIO->PIO_SODR = LCD_STOP;
delayhus(1);
pPIO->PIO_CODR = LCD_STOP;
delayus(1);
// }
}
void lcd_update()
{
if(lcd_buffer[strlen(lcd_buffer)-1] != ' ' && strlen(lcd_buffer) / 2 < 10)
{
for(int i = strlen(lcd_buffer) / 2; i < 10; i++)
strcat(lcd_buffer, " ");
}
char buffer[80];
sprintf(buffer, " %s%s ", lcd_buffer, clock_buffer);
char *output = buffer;
pPIO->PIO_CODR = LCD_SELECT;
delayhus(1);
while(*output != '\0')
{
lcd_putc(*output++);
}
delayhus(1);
pPIO->PIO_SODR = LCD_REFRESH;
delayus(1);
pPIO->PIO_CODR = LCD_REFRESH;
delayhus(1);
pPIO->PIO_SODR = LCD_SELECT;
delayhus(1);
}
void remote_send(int data)
{
#define CLOCK_WIDTH 800
// pPIO->PIO_OER = REMOTE_TX;
for(int repeat = 0; repeat < 10; repeat++)
{
pPIO->PIO_CODR = REMOTE_TX;
delayus(4300);
for(int bit = 30; bit; )
{
bit--;
pPIO->PIO_CODR = REMOTE_TX;
delayus(CLOCK_WIDTH);
pPIO->PIO_SODR = REMOTE_TX;
delayus(CLOCK_WIDTH);
if(data & (1<<bit))
{
delayus(CLOCK_WIDTH + 400);
// pPIO->PIO_SODR = REMOTE_TX;
// delayus(CLOCK_WIDTH);
// pPIO->PIO_CODR = REMOTE_TX;
}
else
{
}
}
pPIO->PIO_CODR = REMOTE_TX;
delayus(CLOCK_WIDTH);
}
pPIO->PIO_SODR = REMOTE_TX;
delayus(CLOCK_WIDTH);
// pPIO->PIO_ODR = REMOTE_TX;
}
int main(void)
{
init();
IntEnable(); // thu swi-call
pPIO->PIO_CODR = LCD_UNK0 | LCD_UNK1;
delayus(10);
pPIO->PIO_SODR = LCD_UNK0 | LCD_UNK1;
delayus(10);
delayms(1000);
printf("\nstart\n");
printf("%iv%i\n", voltagewhole, voltagepart);
while(1)
{
obd_test();
delayms(1000);
}
#define CHANNELS 1
#define SAMPLESIZE 440
#define SAMPLE_RATE_HZ 10000
#define DELAY (1000000 / SAMPLE_RATE_HZ)
#define HEIGHT 6
int intsave = pAIC->AIC_IMR;
// pAIC->AIC_IDCR = 0xff;
int period = 0;
int periodd = 0;
while(0)
{
for(int clocks = 0; clocks < 7;)
{
int timeup = 0;
int timedown = 0;
while(!(pPIO->PIO_PDSR & REMOTE_RX));
while(pPIO->PIO_PDSR & REMOTE_RX)
{
timeup++;
delayus(5);
}
if(!(timeup > 100 && timeup < 140))
{
clocks = 0;
period = 0;
periodd = 0;
continue;
}
while(!(pPIO->PIO_PDSR & REMOTE_RX))
{
timedown++;
delayus(5);
}
if(!(timedown > 60 && timedown < 100))
{
clocks = 0;
period = 0;
periodd = 0;
continue;
}
// if(clocks > 3)
// {
// char buffer[20];
// sprintf(buffer, "%i %i\r\n", timeup, timedown);
// debug(buffer);
// }
clocks++;
period += timeup;
periodd += timedown;
}
intsave = pAIC->AIC_IMR;
pAIC->AIC_IDCR = 0xff;
period /= 7;
// periodd /= 7;
while((pPIO->PIO_PDSR & REMOTE_RX));
while(!(pPIO->PIO_PDSR & REMOTE_RX));
int input = 0;
for(int bit = 24; bit;)
{
bit--;
delayus(5 * periodd / 4);
if(pPIO->PIO_PDSR & REMOTE_RX)
input += (1 << bit);
while(pPIO->PIO_PDSR & REMOTE_RX);
while(!(pPIO->PIO_PDSR & REMOTE_RX));
}
#define ALARM_REMOTE_TEST 0x00
#define ALARM_ARM 0x01
#define ALARM_DISARM 0x02
#define ALARM_ARMED_DOOR 0x03
#define ALARM_DISARMED 0x04
#define ALARM_ALARM_SHOCK 0x05
#define ALARM_ALARM_DOOR 0x06
#define ALARM_ENGINE_STOP 0x07
#define ALARM_TRUNK_OPEN 0x08
#define ALARM_ENGINE_STOP 0x09
#define ALARM_ENGINE_FLASH 0x0a
#define ALARM_ENGINE_START 0x0b
#define ALARM_CALL 0x0c
#define ALARM_SIREN_OFF 0x0d
#define ALARM_SIREN_ON 0x0e
#define ALARM_ARM_DISARMED 0x0f
#define ALARM_AUX2 0x12
#define ALARM_SHOCK_WARN 0x14
#define ALARM_SIREN_HD 0x15
#define ALARM_SIREN_PAN 0x1a
#define ALARM_AUX1 0x1b
#define ALARM_ENGINE_START 0x1c
#define ALARM_ON 0x1d
#define ALARM_OFF 0x1e
#define ALARM_VALET_OFF 0x1f
#define ALARM_VALET_ON 0x20
#define ALARM_ALARM_TRUNK 0x23
#define ALARM_SHOCK_OFF 0x30
#define ALARM_NUMBER 0x31
#define ALARM_TEMP 0x32
#define ALARM_IN_1_1 0x01
#define ALARM_IN_1_2 0x03
#define ALARM_IN_1_3 0x04
#define ALARM_IN_1_4 0x02
#define ALARM_IN_2_1 0x00
#define ALARM_IN_2_2 0x0f
#define ALARM_IN_2_3 0x0a
#define ALARM_IN_2_4 0x0c
#define ALARM_IN_3_1 0x0
#define ALARM_IN_3_2 0x01
#define ALARM_IN_3_3 0x02
#define ALARM_IN_3_4 0x01
#define ALARM_IN_4_1 0x00
#define ALARM_IN_4_2 0x07
#define ALARM_IN_4_3 0x05
#define ALARM_IN_4_4 0x06
#define ALARM_IN_PANIC 0x05
#define ALARM_IN_STATUS 0x07
#define ALARM_IN_DEG 0x09
#define ALARM_IN_VALET 0x0b
#define ALARM_IN_CHIRP 0x06
#define ALARM_IN_PASIVE 0x08
#define ALARM_IN_COLD 0x04
#define ALARM_IN_HOT 0x05
#define ALARM_ADDR1 (0x8c1 << 18)
#define ALARM_ADDR2 (0xa53 << 6)
static int send = 0x8c1 << 18 | 0x8c1 << 6 | ALARM_VALET_ON;
char buffer[20];
sprintf(buffer, "0x %03x %02x %02x ", input >> 12, input >> 6 & 0x3f, input & 0x3f);
debug(buffer);
freeze_lcd = 25;
pAIC->AIC_IECR = intsave;
switch(input & 0x3f)
{
case ALARM_IN_1_1:
sprintf(lcd_buffer, "ARMED");
freeze_clock = 10;
sprintf(clock_buffer, "0x%02x", send & 0x3f);
remote_send(ALARM_ADDR1 | ALARM_ARM);
send--;
break;
case ALARM_IN_1_2:
sprintf(lcd_buffer, "DISARMED");
freeze_clock = 10;
sprintf(clock_buffer, "0x%02x", send & 0x3f);
remote_send(ALARM_ADDR1 | ALARM_DISARM);
send++;
break;
case ALARM_IN_1_3:
sprintf(lcd_buffer, "AUX1");
remote_send(ALARM_ADDR1 | ALARM_AUX1);
break;
case ALARM_IN_1_4:
sprintf(lcd_buffer, "ENGINE STOP");
remote_send(ALARM_ADDR1 | ALARM_ENGINE_STOP);
break;
case ALARM_IN_2_3:
sprintf(lcd_buffer, "SENDING 0x%02x", send & 0x3f);
remote_send(send);
break;
case ALARM_IN_2_4:
sprintf(lcd_buffer, "ENGINE START");
remote_send(ALARM_ADDR1 | ALARM_ENGINE_START);
break;
case ALARM_IN_4_4:
sprintf(lcd_buffer, "REMOTE LCD TEST");
remote_send(ALARM_ADDR1 | ALARM_REMOTE_TEST);
break;
case ALARM_IN_2_2:
clock_type++;
break;
}
// sprintf(clockstring, "0x%02x", send & 0x3f);
printf("0x %03x %03x %02x\r\n", send >> 18, send >> 6 & 0xfff, send & 0x3f);
lcd_update();
delayms(300);
// remote_send(send);
// intsave = pAIC->AIC_IMR;
// pAIC->AIC_IDCR = 0xff;
}
while(1)
{
while(!(pPIO->PIO_PDSR & K_LINE_RX));
bool samples[2][SAMPLESIZE];
for(int i = 0; i < SAMPLESIZE; i++)
{
int sample = pPIO->PIO_PDSR;
if(sample & K_LINE_RX)
samples[0][i] = 1;
else
samples[0][i] = 0;
if(sample & REMOTE_RX)
samples[1][i] = 1;
else
samples[1][i] = 0;
delayus(DELAY);
}
// for(int i = 0; i < 3500; i++)
// {
// if(samples[i])
// debug("1");
// else
// debug("0");
// }
// debug("\r\n\n");
printf("rate: %iHz samples: %i time: %ims sample width: %ius\r\n", SAMPLE_RATE_HZ, SAMPLESIZE, SAMPLESIZE / (SAMPLE_RATE_HZ / 1000), DELAY);
for(int channel = 0; channel < CHANNELS; channel++)
{
for(int i = 0; i < SAMPLESIZE; i++)
{
if(samples[channel][i])
debug("_");
else
debug(" ");
}
debug("\r\n");
for(int n = 0; n < HEIGHT; n++)
{
for(int i = 0; i < SAMPLESIZE; i++)
{
if(samples[channel][i] && !samples[channel][i+1])
debug("|");
else if(!samples[channel][i] && samples[channel][i+1])
debug("|");
else
debug(" ");
}
debug("\r\n");
}
for(int i = 0; i < SAMPLESIZE; i++)
{
if(samples[channel][i] && !samples[channel][i+1])
debug("|");
else if(!samples[channel][i] && samples[channel][i+1])
debug("|");
else if(!samples[channel][i])
debug("_");
else
debug(" ");
}
printf("\r\nchannel: %i\r\n\n", channel);
}
printf("rate: %iHz samples: %i time: %ims sample width: %ius\r\n\r\n", SAMPLE_RATE_HZ, SAMPLESIZE, SAMPLESIZE / (SAMPLE_RATE_HZ / 1000), DELAY);
delayms(500);
}
return(0);
}
schematic: (attached)
Bookmarks