/**
* \fn void note(char temps, int note)
* \brief Permet de jouer une note pendant un certain temps
* \param [IN] temps est la duree pendant laquelle on souhaite jouer la note
- temps ne doit pas depasser la valeur 11 ( 2^8 / 5760 )
[IN] note est la fréquence d'OCR0A que l'on souhaite jouer
*/
void note(char temps, int note)
{
start_timer0(note);
start_timer1(temps * 5760); // 100 ms
wait_OCR1A_timer1();
stop_timer1();
stop_timer0();
}
/***************************************************************************
Declaration : void rf_enable_pulse(void)
Description : Generates a 10us chip enable pulse to nRF24L01
***************************************************************************/
void rf_enable_pulse(void)
{
RF_ENABLE; // Set chip enable
start_timer0(RF_ENABLE_WIDTH,DIV1); // Init Timer0
while(!TIMER0_TIMEOUT) // Wait for Timer0 timeout
;
RF_DISABLE; // Clear chip enable
}
///////////////////////////////////////////////////////////////////////////////
// Инициализация системы
///////////////////////////////////////////////////////////////////////////////
unsigned char init_system( void )
{
init_pio();
init_led();
init_systimer0();
start_timer0();
return OK;
}
/***************************************************************************
Declaration : char wait_rf_irq(char timeout, char prescaler)
Description : Waits for RF Interrupt or Timeout
***************************************************************************/
char wait_rf_irq(char timeout, char prescaler)
{
start_timer0(timeout,prescaler);
while(1)
{
if(TIMER0_TIMEOUT)
return(STATUS_TIMEOUT);
if(!nRF_IRQ)
return(STATUS_RF_READY);
}
}
int main()
{
uint8_t index = 0;
uint8_t maxhsize = DISPLAY_CHAR_WIDTH;
FRESULT fr;
uint32_t state = ST_START;
uint32_t nameCount = 0;
uint32_t vpos = 0;
uint32_t hpos = 0;
#if defined(PCBTARANIS)
wdt_reset();
RCC->AHB1ENR |= RCC_AHB1ENR_GPIOAEN; // Enable portA clock
#endif
pwrInit();
#if defined(PCBSKY9X)
MATRIX->CCFG_SYSIO |= 0x000000F0L; // Disable syspins, enable B4,5,6,7
#endif
#if defined(PCBSKY9X)
init_SDcard();
PIOC->PIO_PER = PIO_PC25; // Enable bit C25 (USB-detect)
start_timer0();
#endif
lcdInit();
#if defined(PCBSKY9X)
extern uint8_t OptrexDisplay;
OptrexDisplay = 1;
#endif
lcd_clear();
lcd_putsLeft(0, BOOTLOADER_TITLE);
lcd_invert_line(0);
lcdRefresh();
#if defined(PCBSKY9X)
OptrexDisplay = 0;
lcdRefresh();
#endif
#if defined(PCBTARANIS)
keysInit();
I2C_EE_Init();
init_hw_timer();
#endif
__enable_irq();
init10msTimer();
#if defined(PCBSKY9X)
EblockAddress = -1;
init_spi();
#endif
#if defined(PCBSKY9X)
LockBits = readLockBits();
if (LockBits) {
clearLockBits();
}
#endif
#if defined(PCBTARANIS)
// SD card detect pin
sdInit();
usbInit();
usbStart();
#endif
for (;;) {
wdt_reset();
if (Tenms) {
if (EE_timer) {
if (--EE_timer == 0) {
#if defined(PCBSKY9X)
writeBlock();
#endif
}
}
Tenms = 0;
lcd_clear();
lcd_putsLeft(0, BOOTLOADER_TITLE);
lcd_invert_line(0);
uint8_t event = getEvent();
if (state != ST_USB) {
if (usbPlugged()) {
state = ST_USB;
if (!unlocked) {
unlocked = 1;
unlockFlash();
}
usbPluggedIn();
}
}
if (state == ST_START) {
lcd_putsLeft(2*FH, "\010Write Firmware");
lcd_putsLeft(3*FH, "\010Restore EEPROM");
lcd_putsLeft(4*FH, "\010Exit");
lcd_invert_line(2+vpos);
lcd_putsLeft(7*FH, INDENT "Or plug in a USB cable for mass storage");
if (event == EVT_KEY_FIRST(BOOT_KEY_DOWN)) {
vpos == 2 ? vpos = 0 : vpos = vpos+1;
}
else if (event == EVT_KEY_FIRST(BOOT_KEY_UP)) {
vpos == 0 ? vpos = 2 : vpos = vpos-1;
}
else if (event == EVT_KEY_BREAK(BOOT_KEY_MENU)) {
switch (vpos) {
case 0:
state = ST_FLASH_MENU;
break;
case 1:
state = ST_RESTORE_MENU;
break;
default:
state = ST_REBOOT;
}
}
}
if (state == ST_USB) {
lcd_putsLeft(4*FH, "\026USB Connected");
if (usbPlugged() == 0) {
vpos = 0;
if (unlocked) {
lockFlash();
unlocked = 0;
}
state = ST_START;
}
#if defined(PCBSKY9X)
usbMassStorage();
#endif
}
if (state == ST_FLASH_MENU || state == ST_RESTORE_MENU) {
sdInit();
memoryType = (state == ST_RESTORE_MENU ? MEM_EEPROM : MEM_FLASH);
state = ST_DIR_CHECK;
}
else if (state == ST_DIR_CHECK) {
fr = f_chdir(getBinaryPath());
if (fr == FR_OK) {
state = ST_OPEN_DIR;
}
else {
lcd_putsLeft(2*FH, INDENT "Directory is missing!");
if (event == EVT_KEY_BREAK(BOOT_KEY_EXIT) || event == EVT_KEY_BREAK(BOOT_KEY_MENU)) {
vpos = 0;
state = ST_START;
}
}
}
if (state == ST_OPEN_DIR) {
index = 0;
fr = f_opendir(&Dj, ".");
if (fr == FR_OK) {
state = ST_FILE_LIST;
nameCount = fillNames(0);
hpos = 0;
vpos = 0;
}
}
if (state == ST_FILE_LIST) {
uint32_t limit = 6;
if (nameCount < limit) {
limit = nameCount;
}
maxhsize = 0;
for (uint32_t i=0; i<limit; i++) {
uint32_t x;
x = strlen(Filenames[i]);
if (x > maxhsize) {
maxhsize = x;
}
if (x > DISPLAY_CHAR_WIDTH) {
if (hpos + DISPLAY_CHAR_WIDTH > x) {
x = x - DISPLAY_CHAR_WIDTH;
}
else {
x = hpos;
}
}
else {
x = 0;
}
lcd_putsnAtt(INDENT_WIDTH, 16 + FH * i, &Filenames[i][x], DISPLAY_CHAR_WIDTH, 0);
}
if (event == EVT_KEY_REPT(BOOT_KEY_DOWN) || event == EVT_KEY_FIRST(BOOT_KEY_DOWN)) {
if (vpos < limit - 1) {
vpos += 1;
}
else {
if (nameCount > limit) {
index += 1;
nameCount = fillNames(index);
}
}
}
else if (event == EVT_KEY_REPT(BOOT_KEY_UP) || event == EVT_KEY_FIRST(BOOT_KEY_UP)) {
if (vpos > 0) {
vpos -= 1;
}
else {
if (index) {
index -= 1;
nameCount = fillNames(index);
}
}
}
#if !defined(PCBTARANIS)
else if (event == EVT_KEY_REPT(BOOT_KEY_RIGHT) || event == EVT_KEY_FIRST(BOOT_KEY_RIGHT)) {
if (hpos + DISPLAY_CHAR_WIDTH < maxhsize) {
hpos += 1;
}
}
else if (event == EVT_KEY_REPT(BOOT_KEY_LEFT) || event == EVT_KEY_FIRST(BOOT_KEY_LEFT)) {
if (hpos) {
hpos -= 1;
}
}
#endif
else if (event == EVT_KEY_BREAK(BOOT_KEY_MENU)) {
// Select file to flash
state = ST_FLASH_CHECK;
Valid = 0;
}
else if (event == EVT_KEY_FIRST(BOOT_KEY_EXIT)) {
state = ST_START;
vpos = 0;
}
lcd_invert_line(2 + vpos);
}
else if (state == ST_FLASH_CHECK) {
int result = menuFlashFile(vpos, event);
FirmwareSize = FileSize[vpos] - BOOTLOADER_SIZE;
if (result == 0) {
// canceled
state = ST_FILE_LIST;
}
else if (result == 1) {
// confirmed
firmwareAddress = FIRMWARE_ADDRESS + BOOTLOADER_SIZE;
firmwareWritten = 0;
eepromAddress = 0;
eepromWritten = 0;
state = ST_FLASHING;
}
}
else if (state == ST_FLASHING) {
// commit to flashing
lcd_putsLeft(4*FH, "\032Writing...");
if (!unlocked && (memoryType == MEM_FLASH)) {
unlocked = 1;
unlockFlash();
}
int progress;
if (memoryType == MEM_FLASH) {
writeFlashBlock();
firmwareWritten += sizeof(Block_buffer);
progress = (200*firmwareWritten) / FirmwareSize;
}
else {
writeEepromBlock();
eepromWritten += sizeof(Block_buffer);
progress = (200*eepromWritten) / EESIZE;
}
lcd_rect( 3, 6*FH+4, 204, 7);
lcd_hline(5, 6*FH+6, progress, FORCE);
lcd_hline(5, 6*FH+7, progress, FORCE);
lcd_hline(5, 6*FH+8, progress, FORCE);
fr = f_read(&FlashFile, (BYTE *)Block_buffer, sizeof(Block_buffer), &BlockCount);
if (BlockCount == 0) {
state = ST_FLASH_DONE; // EOF
}
if (firmwareWritten >= FLASHSIZE - BOOTLOADER_SIZE) {
state = ST_FLASH_DONE; // Backstop
}
if (eepromWritten >= EESIZE) {
state = ST_FLASH_DONE; // Backstop
}
}
if (state == ST_FLASH_DONE) {
if (unlocked) {
lockFlash();
unlocked = 0;
}
lcd_putsLeft(4*FH, "\024Writing Complete");
if (event == EVT_KEY_FIRST(BOOT_KEY_EXIT) || event == EVT_KEY_BREAK(BOOT_KEY_MENU)) {
state = ST_START;
vpos = 0;
}
}
if (event == EVT_KEY_LONG(BOOT_KEY_EXIT)) {
state = ST_REBOOT;
}
lcdRefresh();
if (PowerUpDelay < 20) { // 200 mS
PowerUpDelay += 1;
}
else {
sdPoll10ms();
}
}
if (pwrCheck() == e_power_off && state != ST_FLASHING && state != ST_USB) {
pwrOff();
for (;;) {
// Wait for power to go off
}
}
if (state == ST_REBOOT) {
if ((~readKeys() & 0x7E) == 0) {
NVIC_SystemReset();
}
}
}
return 0;
}
int main(void)
{
int i;
int count = 0;
DDRB = 0;
DDRC = 0;
DDRE = 0;
// Enable the pullup on RESET pin.
#if defined(__AVR_AT90PWM316__)
PORTE = (1<<PINE0);
PORTE &= ~(1<<PINE0);
#elif defined(__AVR_ATmega328__) || defined(__AVR_ATmega328P__)
PORTC = (1<<PINC6);
PORTC &= ~(1<<PINC6);
#else
#warning "Didn't enable reset pin pullup"
#endif
// Setup all of port C as inputs, except for pin C5
SETUP_DEBUG_PINS();
// Set up the ADC single conversion pin.
DDRC &= ~(1<<PINC6);
PORTC &= ~(1<<PINC6);
// Disable all the ADC digital inputs.
DIDR1 = 0xFF;
DIDR0 = 0xFF & ~(1<<ADC1D);
// populate the buffer with known values
ringBuffer_initialize(&txbuffer,txbuffer_storage,TXBUFFER_LEN);
ringBuffer_initialize(&adcbuffer,adcbuffer_storage,BUFFER_LEN);
ringBuffer_initialize(&rxbuffer,rxbuffer_storage,RXBUFFER_LEN);
// Populate the ADC read schedule with the mux indices that you want.
adc_mux_schedule[0] = 2;
adc_mux_schedule[1] = 10;
adc_mux_schedule[2] = 6;
adc_mux_schedule[3] = 3;
uart_init( UART_BAUD_SELECT_DOUBLE_SPEED(UART_BAUD_RATE,F_CPU), &rxbuffer, &txbuffer);
//uart_config_default_stdio();
// Translate those indices and the mask specifying which MUXes to turn on,
// to an encoded mux schedule that the ADC understands.
adc_encode_muxSchedule(adc_mux_schedule, SCHEDULE_LEN);
adc_init(ADC_MODE_MANUAL, &adcbuffer, adc_mux_schedule, SCHEDULE_LEN);
timer0_init();
sei();
uart_puts_P("\f\r\n\r\nADC and UART Demo. Commands:\n"
"b Begin 4 channel read bursts at CLK/16K\n"
"e End reading.\n"
"s Single conversion.\n");
DEBUG_PIN1_OFF();
while(1)
{
do
{
i = uart_getc();
} while (i == UART_NO_DATA);
DEBUG_PIN1_ON();
if(i == 'b'){
uart_puts_P("Begin.\n");
start_timer0();
}
else if(i == 'e'){
stop_timer0();
_delay_us(100);
uart_puts_P("End.\n");
}
else if(i == 's'){
uart_puts_P("ADC");
uart_put_hex8(count);
uart_puts_P(": ");
i = adc_single_conversion(count);
uart_put_hex8((i >> 8) & 0xFF);
uart_put_hex8(i & 0xFF);
uart_putc('\n');
count = (count + 1) & 0xF;
if(count == 11)
{
count = 13;
}
}
else{
