void poti_init(void) { AT91F_SPI_CfgPMC(); AT91F_PIO_CfgPeriph(AT91C_BASE_PIOA, AT91C_PA13_MOSI | AT91C_PA14_SPCK, 0); AT91F_PIO_CfgOutput(AT91C_BASE_PIOA, OPENPICC_PIO_SS2_DT_THRESH); AT91F_PIO_SetOutput(AT91C_BASE_PIOA, OPENPICC_PIO_SS2_DT_THRESH); AT91F_PIO_CfgOutput(AT91C_BASE_PIOA, OPENPICC_PIO_nSLAVE_RESET); poti_reset(); #if 0 AT91F_AIC_ConfigureIt(AT91C_BASE_AIC, AT91C_ID_SPI, OPENPCD_IRQ_PRIO_SPI, AT91C_AIC_SRCTYPE_INT_HIGH_LEVEL, &spi_irq); AT91G_AIC_EnableIt(AT9C_BASE_AIC, AT91C_ID_SPI); #endif AT91F_SPI_CfgMode(spi, AT91C_SPI_MSTR | AT91C_SPI_PS_FIXED | AT91C_SPI_MODFDIS); /* CPOL = 0, NCPHA = 1, CSAAT = 0, BITS = 0000, SCBR = 13 (3.69MHz), * DLYBS = 6 (125nS), DLYBCT = 0 */ AT91F_SPI_CfgCs(spi, 0, AT91C_SPI_BITS_8 | AT91C_SPI_NCPHA | (13 << 8) | (6 << 16)); AT91F_SPI_Enable(spi); }
//*---------------------------------------------------------------------------- //* \fn AT91F_USBDEV_Open //* \brief //*---------------------------------------------------------------------------- AT91PS_USBDEV AT91F_USBDEV_Open(AT91PS_USBDEV pUsbdev, AT91PS_UDP pUdp, unsigned char cdcHid) { // Set the PLL USB Divider // writes to FFFFFC2C, divider should divide by 2 AT91C_BASE_CKGR->CKGR_PLLR |= AT91C_CKGR_USBDIV_1 ; // Specific Chip USB Initialisation // Enables the 48MHz USB clock UDPCK and System Peripheral USB Clock AT91C_BASE_PMC->PMC_SCER = AT91C_PMC_UDP; AT91C_BASE_PMC->PMC_PCER = (1 << AT91C_ID_UDP); // Enable UDP PullUp on D+ line AT91F_PIO_CfgOutput(AT91C_BASE_PIOA, USB_DP_PUP); AT91F_PIO_ClearOutput(AT91C_BASE_PIOA, USB_DP_PUP); #ifdef USB_DM_PUP AT91F_PIO_CfgOutput(AT91C_BASE_PIOA, USB_DM_PUP); AT91F_PIO_SetOutput(AT91C_BASE_PIOA, USB_DM_PUP); #endif pUsbdev->pUdp = pUdp; pUsbdev->cdcOrHid = cdcHid; // 1: HID, 0: CDC/ACM pUsbdev->currentConfiguration = 0; pUsbdev->currentConnection = 0; pUsbdev->currentRcvBank = AT91C_UDP_RX_DATA_BK0; pUsbdev->IsConfigured = AT91F_UDP_IsConfigured; pUsbdev->Write = AT91F_CDC_Write; pUsbdev->Read = AT91F_CDC_Read; pUsbdev->SendReport = AT91F_HID_SendReport; return pUsbdev; }
void ledInitialise() { // Initialise the Appliance LED's AT91F_PIO_CfgOutput( AT91C_BASE_PIOA, (LED_0 | LED_1)); AT91F_PIO_SetOutput( AT91C_BASE_PIOA, (LED_0 | LED_1)); // Initialise the IR sensed automatic lights AT91F_PIO_CfgOutput( AT91C_BASE_PIOA, (LED_2 | LED_3)); AT91F_PIO_SetOutput( AT91C_BASE_PIOA, (LED_2 | LED_3)); }
static void GPIO_device_init_port(unsigned int port, unsigned int mode) { unsigned int portMask = 0; switch(port) { case 0: portMask = GPIO_1; break; case 1: portMask = GPIO_2; break; case 2: portMask = GPIO_3; break; default: break; } if (mode == MODE_INPUT) { AT91F_PIO_CfgInput(AT91C_BASE_PIOA, portMask); AT91C_BASE_PIOA->PIO_PPUDR = portMask; //disable pullup AT91C_BASE_PIOA->PIO_IFER = portMask; //enable input filter } else { AT91F_PIO_CfgOutput( AT91C_BASE_PIOA, portMask ); AT91F_PIO_ClearOutput( AT91C_BASE_PIOA, portMask ); } }
//*-------------------------------------------------------------------------------------- //* Function Name : Main //* Object : Software entry point //* Input Parameters : none. //* Output Parameters : none. //*-------------------------------------------------------------------------------------- int main() { int i; // First, enable the clock of the PIO AT91F_PMC_EnablePeriphClock ( AT91C_BASE_PMC, 1 << AT91C_ID_PIOA ) ; // then, we configure the PIO Lines corresponding to LED1 to LED4 // to be outputs. No need to set these pins to be driven by the PIO because it is GPIO pins only. AT91F_PIO_CfgOutput( AT91C_BASE_PIOA, LED_MASK ) ; // Clear the LED's. On the EB55 we must apply a "1" to turn off LEDs AT91F_PIO_SetOutput( AT91C_BASE_PIOA, LED_MASK ) ; //* Init timer interrupt timer_init(); // Loop forever for (;;) { // Once a Shot on each led for ( i=0 ; i < NB_LEB ; i++ ) { AT91F_PIO_ClearOutput( AT91C_BASE_PIOA, led_mask[i]); wait(); AT91F_PIO_SetOutput( AT91C_BASE_PIOA, led_mask[i] ); wait(); } // Once a Shot on each led for ( i = (NB_LEB - 1) ; i >= 0 ; i-- ) { AT91F_PIO_ClearOutput( AT91C_BASE_PIOA, led_mask[i]); wait(); AT91F_PIO_SetOutput( AT91C_BASE_PIOA, led_mask[i]); wait(); } } }
int main (void) { int i; // Enable the Clock of the PIO AT91F_PMC_EnablePeriphClock(AT91C_BASE_PMC, 1 << AT91C_ID_PIOA); // Configure the PIO Lines corresponding to LED1..LED4 as Outputs AT91F_PIO_CfgOutput(AT91C_BASE_PIOA, LED_MASK); // Clear the LED's. On the Board we must apply a "1" to turn off LEDs AT91F_PIO_SetOutput(AT91C_BASE_PIOA, LED_MASK); // Loop forever for (;;) { for (i = 0; i < NB_LED; i++) { AT91F_PIO_ClearOutput(AT91C_BASE_PIOA, led_mask[i]); wait(); AT91F_PIO_SetOutput (AT91C_BASE_PIOA, led_mask[i]); wait(); } for (i = (NB_LED - 1); i >= 0; i--) { AT91F_PIO_ClearOutput(AT91C_BASE_PIOA, led_mask[i]); wait(); AT91F_PIO_SetOutput (AT91C_BASE_PIOA, led_mask[i]); wait(); } } }
/* * Disable the PIO assignments for the DBGU */ void AT91F_DBGU_Fini(void) { ((AT91PS_USART) AT91C_BASE_DBGU)->US_CR = AT91C_US_RXDIS | AT91C_US_TXDIS; AT91F_PIO_CfgOutput(AT91C_BASE_PIOA, AT91C_PA10_DTXD); AT91F_PIO_CfgInput(AT91C_BASE_PIOA, AT91C_PA9_DRXD); // Maybe FIXME, do more? -- Henryk Plötz <*****@*****.**> }
void nRFLL_Init(void) { AT91F_PIO_SetOutput (AT91C_BASE_PIOA,CSN_PIN); AT91F_PIO_ClearOutput(AT91C_BASE_PIOA, CE_PIN|MOSI_PIN|SCK_PIN); AT91F_PIO_CfgOutput (AT91C_BASE_PIOA,CSN_PIN|CE_PIN|MOSI_PIN|SCK_PIN); AT91F_PIO_CfgInput (AT91C_BASE_PIOA,MISO_PIN); }
void spi_low_cs_init(void) { // Enable PIO for CSx AT91F_PMC_EnablePeriphClock ( AT91C_BASE_PMC, 1 << AT91C_ID_PIOA ) ; // manual config CS AT91F_PIO_CfgOutput( AT91C_BASE_PIOA, SPI_ALL_MASK ); AT91F_PIO_SetOutput( AT91C_BASE_PIOA, SPI_ALL_MASK ); }
//инициализация основных узлов системы void CPUinit() { //нициализация EFC (Flash-памяти) AT91C_BASE_MC->MC_FMR = AT91C_MC_FWS_1FWS ; // 1 цикла на чтение, 3 цикла на запись //настройка тактовых частот //включение и задание времени запуска основного генератора AT91C_BASE_PMC->PMC_MOR = (( AT91C_CKGR_OSCOUNT & (0x40 <<8) | AT91C_CKGR_MOSCEN )); // ожидание стабилизации частоты основного генератора while(!(AT91C_BASE_PMC->PMC_SR & AT91C_PMC_MOSCS)); //задание частоты PLL 96,109 МГц и такт частоты UDP 48,058 МГц AT91C_BASE_PMC->PMC_PLLR = AT91C_CKGR_USBDIV_1|(16 << 8) | (AT91C_CKGR_MUL & (72 << 16)) | (AT91C_CKGR_DIV & 14); //ожидание стабилизации PLL while( !(AT91C_BASE_PMC->PMC_SR & AT91C_PMC_LOCK) ); // ожидание стабилизации задающей частоты от PLL while( !(AT91C_BASE_PMC->PMC_SR & AT91C_PMC_MCKRDY) ); //задание задающей частоты и частоты процессора PLL/2=48 МГц //регистр PMC_MCKR не должен програмироваться одной операцией записи AT91C_BASE_PMC->PMC_MCKR = AT91C_PMC_PRES_CLK_2; // ожидание стабилизации задающей частоты while( !(AT91C_BASE_PMC->PMC_SR & AT91C_PMC_MCKRDY) ); AT91C_BASE_PMC->PMC_MCKR |= AT91C_PMC_CSS_PLL_CLK; // ожидание стабилизации задающей частоты while( !(AT91C_BASE_PMC->PMC_SR & AT91C_PMC_MCKRDY) ); // отключение сторожевого таймера AT91C_BASE_WDTC->WDTC_WDMR = AT91C_WDTC_WDDIS; // разрешение тактирования PIO AT91F_PMC_EnablePeriphClock ( AT91C_BASE_PMC, 1 << AT91C_ID_PIOA ) ; // конфигурирование линий PIO как выходов обслуживания светодиодов LED1,...LED4 AT91F_PIO_CfgOutput( AT91C_BASE_PIOA, LED_MASK ) ; // установка выходов - гашение светодиодов AT91F_PIO_SetOutput( AT91C_BASE_PIOA, LED_MASK ) ; // конфигурирование линии PIO как выхода генерации частоты отриц напряж для LCD AT91F_PIO_CfgOutput( AT91C_BASE_PIOA, U_NEG ) ; // сброс выхода генерации частоты отриц напряж для LCD AT91F_PIO_ClearOutput( AT91C_BASE_PIOA, U_NEG ) ; // конфигурирование линий PIO как выходов обслуживания ЖКИ AT91F_PIO_CfgOutput( AT91C_BASE_PIOA, LCD_MASK ) ; // сброс выходов обслуживания ЖКИ AT91F_PIO_ClearOutput( AT91C_BASE_PIOA, LCD_MASK ) ; }
static void prvSetupHardware( void ) { /* When using the JTAG debugger the hardware is not always initialised to the correct default state. This line just ensures that this does not cause all interrupts to be masked at the start. */ AT91C_BASE_AIC->AIC_EOICR = 0; /* Most setup is performed by the low level init function called from the startup asm file. */ /* Configure the PIO Lines corresponding to LED1 to LED4 to be outputs as well as the UART Tx line. */ AT91F_PIO_CfgOutput( AT91C_BASE_PIOA, LED_MASK ); /* Enable the peripheral clock. */ AT91F_PMC_EnablePeriphClock( AT91C_BASE_PMC, 1 << AT91C_ID_PIOA ); }
unsigned char nRFCMD_Init(void) { volatile int dummy; const int SCBR = ((int)(MCK / 8e6) + 1)&0xFF; nRFCMD_Macro=nRFCMD_MacroResult=NULL; vSemaphoreCreateBinary(xnRF_SemaphoreDMA); vSemaphoreCreateBinary(xnRF_SemaphoreACK); if(!(xnRF_SemaphoreDMA && xnRF_SemaphoreACK)) return 1; xSemaphoreTake(xnRF_SemaphoreDMA,0); xSemaphoreTake(xnRF_SemaphoreACK,0); AT91F_SPI_CfgPMC(); AT91F_PIO_CfgPeriph(AT91C_BASE_PIOA, NRF_SPI_PINS_PERIPHERAL_A, NRF_SPI_PINS_PERIPHERAL_B); AT91F_PIO_CfgInput(AT91C_BASE_PIOA, IRQ_PIN); AT91F_PIO_ClearOutput(AT91C_BASE_PIOA, CE_PIN); AT91F_PIO_CfgOutput(AT91C_BASE_PIOA, CE_PIN); portENTER_CRITICAL(); /* CPOL = 0, NCPHA = 1, CSAAT = 0, BITS = 0000, SCBR = <8MHz, * DLYBS = 0, DLYBCT = 0 */ AT91C_BASE_SPI->SPI_MR = AT91C_SPI_MSTR | AT91C_SPI_PS_FIXED; AT91F_SPI_CfgCs(AT91C_BASE_SPI, 0, AT91C_SPI_BITS_8|AT91C_SPI_NCPHA|(SCBR<<8)); AT91F_SPI_Enable(AT91C_BASE_SPI); AT91F_AIC_ConfigureIt(AT91C_ID_SPI, 4, AT91C_AIC_SRCTYPE_INT_POSITIVE_EDGE, nRFCMD_ISR_DMA ); AT91C_BASE_SPI->SPI_IER = AT91C_SPI_ENDTX; /* Enable PIO interrupt for IRQ pin */ AT91F_AIC_ConfigureIt(AT91C_ID_PIOA, 3, AT91C_AIC_SRCTYPE_HIGH_LEVEL, nRFCMD_ISR_ACK ); /* reset IRQ status */ dummy = AT91C_BASE_PIOA->PIO_ISR; AT91C_BASE_PIOA->PIO_IER = IRQ_PIN; AT91C_BASE_AIC->AIC_IECR = (0x1 << AT91C_ID_SPI) | (0x1 << AT91C_ID_PIOA) ; portEXIT_CRITICAL(); return 0; }
//*---------------------------------------------------------------------------- //* \fn AT91F_USB_Open //* \brief This function Open the USB device //*---------------------------------------------------------------------------- void AT91F_USB_Open(void) { // Set the PLL USB Divider AT91C_BASE_CKGR->CKGR_PLLR |= AT91C_CKGR_USBDIV_1 ; // Specific Chip USB Initialisation // Enables the 48MHz USB clock UDPCK and System Peripheral USB Clock AT91C_BASE_PMC->PMC_SCER = AT91C_PMC_UDP; AT91C_BASE_PMC->PMC_PCER = (1 << AT91C_ID_UDP); // Enable UDP PullUp (USB_DP_PUP) : enable & Clear of the corresponding PIO // Set in PIO mode and Configure in Output AT91F_PIO_CfgOutput(AT91C_BASE_PIOA,AT91C_PIO_PA16); // Clear for set the Pul up resistor AT91F_PIO_ClearOutput(AT91C_BASE_PIOA,AT91C_PIO_PA16); // CDC Open by structure initialization AT91F_CDC_Open(&pCDC, AT91C_BASE_UDP); }
//=============================================================================================== //*---------------------------------------------------------------------------- //* \fn AT91F_TWI_Open //* \brief Initializes TWI device //*---------------------------------------------------------------------------- void AT91F_TWI_Init(void) { TWI_QUEUE = xQueueCreate( 1, sizeof( unsigned int ) ); TWI_NACK_Error = ErrorCreate("TWI Nack"); TWI_TMO_Error = ErrorCreate("TWI TimeOut"); TWI_SEM_Error = ErrorCreate("TWI Access"); TWI_WriteData_Error = ErrorCreate("TWI Write"); TWI_OVRE_Error = ErrorCreate("TWI OVRE"); vSemaphoreCreateBinary( TWI_Semaphore ); while( TWI_QUEUE == 0 ) ; // Queue was not created and must not be used. portENTER_CRITICAL(); { // Configure TWI in master mode AT91F_TWI_Configure (AT91C_BASE_TWI); // Configure TWI PIOs AT91F_PIO_CfgOutput(AT91C_BASE_PIOA, AT91C_PA1_TWCK ); AT91F_PIO_CfgOpendrain(AT91C_BASE_PIOA, // PIO controller base address ((unsigned int) AT91C_PA1_TWCK ) | ((unsigned int) AT91C_PA0_TWD ) ); AT91F_TWI_CfgPIO(); // Configure PMC by enabling TWI clock AT91F_TWI_CfgPMC (); // AT91F_PMC_EnablePeriphClock ( AT91C_BASE_PMC, 1<<AT91C_ID_TWI ) ; // Set TWI Clock Waveform Generator Register AT91F_SetTwiClock(); AT91F_AIC_ConfigureIt ( AT91C_BASE_AIC, AT91C_ID_TWI, TWI_INTERRUPT_LEVEL, AT91C_AIC_SRCTYPE_INT_LEVEL_SENSITIVE, ( void (*)( void ) )AT91_TWI_ISR_ENTRY); AT91F_AIC_EnableIt (AT91C_BASE_AIC, AT91C_ID_TWI); TWI_TransferStatus = FREE; } portEXIT_CRITICAL(); }
static inline void prvSetupHardware (void) { /* When using the JTAG debugger the hardware is not always initialised to the correct default state. This line just ensures that this does not cause all interrupts to be masked at the start. */ AT91C_BASE_AIC->AIC_EOICR = 0; /* Enable PIOA outputs. */ AT91F_PIO_CfgInput ( AT91C_BASE_PIOA, IRQ_PIN ); AT91F_PIO_CfgOutput( AT91C_BASE_PIOA, LED_MASK ); AT91F_PIO_SetOutput( AT91C_BASE_PIOA, LED_MASK ); /* Enable the peripheral clock. */ AT91C_BASE_PMC->PMC_PCER = 1 << AT91C_ID_PIOA; AT91C_BASE_PMC->PMC_PCER = 1 << AT91C_ID_PIOB; unsigned char nid[5] = DEFAULT_NID; ob_init( 1, 2, DEFAULT_CHANNEL, nid ); /* Initialization done - Turn on green LED */ AT91F_PIO_SetOutput( AT91C_BASE_PIOA, LED_GREEN ); AT91F_PIO_SetOutput( AT91C_BASE_PIOA, LED_RED ); }
SemaphoreHandle_t xEMACInit( void ) { /* Code supplied by Atmel (modified) --------------------*/ /* disable pull up on RXDV => PHY normal mode (not in test mode), PHY has internal pull down. */ AT91C_BASE_PIOB->PIO_PPUDR = 1 << 15; #if USE_RMII_INTERFACE != 1 /* PHY has internal pull down : set MII mode. */ AT91C_BASE_PIOB->PIO_PPUDR= 1 << 16; #endif /* clear PB18 <=> PHY powerdown. */ AT91F_PIO_CfgOutput( AT91C_BASE_PIOB, 1 << 18 ) ; AT91F_PIO_ClearOutput( AT91C_BASE_PIOB, 1 << 18) ; /* After PHY power up, hardware reset. */ AT91C_BASE_RSTC->RSTC_RMR = emacRESET_KEY | emacRESET_LENGTH; AT91C_BASE_RSTC->RSTC_RCR = emacRESET_KEY | AT91C_RSTC_EXTRST; /* Wait for hardware reset end. */ while( !( AT91C_BASE_RSTC->RSTC_RSR & AT91C_RSTC_NRSTL ) ) { __asm( "NOP" ); } __asm( "NOP" ); /* EMAC IO init for EMAC-PHY com. Remove EF100 config. */ AT91F_EMAC_CfgPIO(); /* Enable com between EMAC PHY. Enable management port. */ AT91C_BASE_EMAC->EMAC_NCR |= AT91C_EMAC_MPE; /* MDC = MCK/32. */ AT91C_BASE_EMAC->EMAC_NCFGR |= ( 2 ) << 10; /* Wait for PHY auto init end (rather crude delay!). */ vTaskDelay( emacPHY_INIT_DELAY ); /* PHY configuration. */ #if USE_RMII_INTERFACE != 1 { unsigned long ulControl; /* PHY has internal pull down : disable MII isolate. */ vReadPHY( AT91C_PHY_ADDR, MII_BMCR, &ulControl ); vReadPHY( AT91C_PHY_ADDR, MII_BMCR, &ulControl ); ulControl &= ~BMCR_ISOLATE; vWritePHY( AT91C_PHY_ADDR, MII_BMCR, ulControl ); } #endif /* Disable management port again. */ AT91C_BASE_EMAC->EMAC_NCR &= ~AT91C_EMAC_MPE; #if USE_RMII_INTERFACE != 1 /* Enable EMAC in MII mode, enable clock ERXCK and ETXCK. */ AT91C_BASE_EMAC->EMAC_USRIO = AT91C_EMAC_CLKEN ; #else /* Enable EMAC in RMII mode, enable RMII clock (50MHz from oscillator on ERFCK). */ AT91C_BASE_EMAC->EMAC_USRIO = AT91C_EMAC_RMII | AT91C_EMAC_CLKEN ; #endif /* End of code supplied by Atmel ------------------------*/ /* Setup the buffers and descriptors. */ prvSetupDescriptors(); /* Load our MAC address into the EMAC. */ prvSetupMACAddress(); /* Try to connect. */ if( prvProbePHY() ) { /* Enable the interrupt! */ prvSetupEMACInterrupt(); } return xSemaphore; }
int _main_dbgu(char key) { switch (key) { case 'o': if (duty_percent >= 1) duty_percent--; pwm_duty_set_percent(0, duty_percent); break; case 'p': if (duty_percent <= 99) duty_percent++; pwm_duty_set_percent(0, duty_percent); break; case 'k': pwm_stop(0); break; case 'l': pwm_start(0); break; case 'n': if (pwm_freq_idx > 0) { pwm_freq_idx--; pwm_stop(0); pwm_freq_set(0, pwm_freq[pwm_freq_idx]); pwm_start(0); pwm_duty_set_percent(0, 22); /* 22% of 9.43uS = 2.07uS */ } break; case 'm': if (pwm_freq_idx < ARRAY_SIZE(pwm_freq)-1) { pwm_freq_idx++; pwm_stop(0); pwm_freq_set(0, pwm_freq[pwm_freq_idx]); pwm_start(0); pwm_duty_set_percent(0, 22); /* 22% of 9.43uS = 2.07uS */ } break; case 'u': DEBUGPCRF("PA23 output high"); AT91F_PIO_CfgOutput(AT91C_BASE_PIOA, AT91C_PIO_PA23); AT91F_PIO_SetOutput(AT91C_BASE_PIOA, AT91C_PIO_PA23); break; case 'y': DEBUGPCRF("PA23 output low"); AT91F_PIO_CfgOutput(AT91C_BASE_PIOA, AT91C_PIO_PA23); AT91F_PIO_ClearOutput(AT91C_BASE_PIOA, AT91C_PIO_PA23); return 0; break; case 't': DEBUGPCRF("PA23 PeriphA (PWM)"); AT91F_PIO_CfgPeriph(AT91C_BASE_PIOA, 0, AT91C_PA23_PWM0); return 0; break; case 'f': DEBUGPCRF("%sabling Force100ASK", force_100ask ? "Dis":"En"); if (force_100ask) { force_100ask = 0; opcd_rc632_clear_bits(RAH, RC632_REG_TX_CONTROL, RC632_TXCTRL_FORCE_100_ASK); } else { force_100ask = 1; opcd_rc632_set_bits(RAH, RC632_REG_TX_CONTROL, RC632_TXCTRL_FORCE_100_ASK); } return 0; break; case 'v': if (mod_conductance > 0) { mod_conductance--; opcd_rc632_reg_write(RAH, RC632_REG_MOD_CONDUCTANCE, rsrel_table[mod_conductance]); } break; case 'b': if (mod_conductance < 0x3f) { mod_conductance++; opcd_rc632_reg_write(RAH, RC632_REG_MOD_CONDUCTANCE, rsrel_table[mod_conductance]); } break; case 'g': if (cw_conductance > 0) { cw_conductance--; opcd_rc632_reg_write(RAH, RC632_REG_CW_CONDUCTANCE, rsrel_table[cw_conductance]); } break; case 'h': if (cw_conductance < 0x3f) { cw_conductance++; opcd_rc632_reg_write(RAH, RC632_REG_CW_CONDUCTANCE, rsrel_table[cw_conductance]); } break; case '?': help(); return 0; break; case '<': tc_cdiv_phase_inc(); break; case '>': tc_cdiv_phase_dec(); break; case '{': if (cdiv_idx > 0) cdiv_idx--; tc_cdiv_set_divider(cdivs[cdiv_idx]); break; case '}': if (cdiv_idx < ARRAY_SIZE(cdivs)-1) cdiv_idx++; tc_cdiv_set_divider(cdivs[cdiv_idx]); break; #ifdef SSC case 's': ssc_rx_start(); break; case 'S': ssc_rx_stop(); break; #endif default: return -EINVAL; } DEBUGPCR("pwm_freq=%u, duty_percent=%u, mod_cond=%u, cw_cond=%u tc_cdiv=%u", pwm_freq[pwm_freq_idx], duty_percent, mod_conductance, cw_conductance, cdivs[cdiv_idx]); return 0; }
void UHP_Test(int iterations) { AT91PS_UHP pUhp = AT91C_BASE_UHP; AT91PS_UDP pUdp = AT91C_BASE_UDP; unsigned int i; AT91S_TIMEOUT timeout; iterations = 1; /* multiple iterations test not yet implemented */ DebugPrint("\n\n\r-I- ======================================\n\r"); DebugPrint("-I- AT91RM9200 basic UHP example\n\r"); DebugPrint("-I- --------------------------------------\n\r"); DebugPrint("-I- Connect the UDP port to a UHP port...\n\r"); DebugPrint("-I- ======================================\n\r"); /* ************************************************ */ /* Deactivate UDP pull up */ /* ************************************************ */ AT91F_PIO_CfgOutput(AT91C_BASE_PIOB, AT91C_PIO_PB22); AT91F_PIO_ClearOutput(AT91C_BASE_PIOB, AT91C_PIO_PB22); /* ************************************************ */ /* Open UDP+UHP clocks */ /* ************************************************ */ // Open clocks for USB host + device AT91F_UHP_CfgPMC(); AT91F_UDP_CfgPMC(); AT91C_BASE_PMC->PMC_SCER |= (AT91C_PMC_UHP | AT91C_PMC_UDP); /* ************************************************ */ /* Configure the UHP */ /* ************************************************ */ // Desactivate all IT pUdp->UDP_IDR = (unsigned int) -1; // Disable all pending IT pUdp->UDP_ICR = (unsigned int) -1; // RESET UDP pUdp->UDP_RSTEP = 0; pUdp->UDP_GLBSTATE = 0; // Forcing UHP_Hc to reset pUhp->UHP_HcControl = 0; // Writing the UHP_HCCA pUhp->UHP_HcHCCA = (unsigned int) &HCCA; // Enabling list processing pUhp->UHP_HcControl = 0; // Set the frame interval pUhp->UHP_HcFmInterval = AT91C_FMINTERVAL; pUhp->UHP_HcPeriodicStart = AT91C_PRDSTRT; // Create a default endpoint descriptor AT91F_CreateEd( (unsigned int) pUHPEd, // ED Address 8, // Max packet 0, // TD format 0, // Skip 0, // Speed 0x0, // Direction 0x0, // Endpoint 0x0, // Func Address (unsigned int) &pUHPTd[3], // TDQTailPointer (unsigned int) &pUHPTd[0], // TDQHeadPointer 0, // ToggleCarry 0x0); // NextED // Setup PID AT91F_CreateGenTd( (unsigned int) &pUHPTd[0], // TD Address 2, // Data Toggle 0x7, // DelayInterrupt 0x0, // Direction 1, // Buffer Rounding (unsigned int) pUHPSetup, // Current Buffer Pointer (unsigned int) &pUHPTd[1], // Next TD 8); // Buffer Length // Data IN AT91F_CreateGenTd( (unsigned int) &pUHPTd[1], // TD Address 0, // Data Toggle 0x7, // DelayInterrupt 0x2, // Direction 1, // Buffer Rounding (unsigned int) pUHPData, // Current Buffer Pointer (unsigned int) &pUHPTd[2], // Next TD DataSIZE); // Buffer Length // Status OUT AT91F_CreateGenTd( (unsigned int) &pUHPTd[2], // TD Address 3, // Data Toggle 0x7, // DelayInterrupt 0x1, // Direction 1, // Buffer Rounding 0x0, // Current Buffer Pointer (unsigned int) &pUHPTd[3], // Next TD 0x0); // Buffer Length AT91F_CreateGenTd( (unsigned int) &pUHPTd[3], // TD Address 3, // Data Toggle 0x7, // DelayInterrupt 0x1, // Direction 1, // Buffer Rounding 0x0, // Current Buffer Pointer (unsigned int) 0, // Next TD 0x0); // Buffer Length // Programming the BHED pUhp->UHP_HcControlHeadED = (unsigned int) pUHPEd; // Programming the BCED pUhp->UHP_HcControlCurrentED = (unsigned int) pUHPEd; // Initializing the UHP_HcDoneHead pUhp->UHP_HcBulkDoneHead = 0x00; HCCA.UHP_HccaDoneHead = 0x0000; // Forcing UHP_Hc to Operational State pUhp->UHP_HcControl = 0x80; // Enabling port power pUhp->UHP_HcRhPortStatus[0] = 0x00000100; pUhp->UHP_HcRhPortStatus[1] = 0x00000100; pUhp->UHP_HcRhStatus = 0x00010000; /* ************************************************ */ /* Activate UDP pull up */ /* ************************************************ */ // UDP: Connect a pull-up AT91F_PIO_SetOutput(AT91C_BASE_PIOB, AT91C_PIO_PB22); /* ************************************************ */ /* Detect a connected deviced, generate a reset... */ /* ************************************************ */ // UHP: Detect the device on one port, generate a reset and enable the port AT91F_InitTimeout(&timeout, 2); while (1) { if ( (pUhp->UHP_HcRhPortStatus[0] & 0x01) ) { DebugPrint("-I- Device detected on port 0\n\r"); pUhp->UHP_HcRhPortStatus[0] = (1 << 4); // SetPortReset while (pUhp->UHP_HcRhPortStatus[0] & (1 << 4)); // Wait for the end of reset pUhp->UHP_HcRhPortStatus[0] = (1 << 1); // SetPortEnable break; } else if ( (pUhp->UHP_HcRhPortStatus[1] & 0x01) ) { pUhp->UHP_HcRhPortStatus[1] = (1 << 4); // SetPortReset while (pUhp->UHP_HcRhPortStatus[1] & (1 << 4)); // Wait for the end of reset pUhp->UHP_HcRhPortStatus[1] = (1 << 1); // SetPortEnable break; } else if ( !AT91F_TestTimeout(&timeout) ) { DebugPrint("-E- Please connect the UHP port to the UDP port\n\r"); goto error; } } // UHP: UHP is now operational and control list processing is enabled pUhp->UHP_HcControl = 0x90; // UDP: Wait for end bus reset AT91F_InitTimeout(&timeout, 2); while ( !(pUdp->UDP_ISR & AT91C_UDP_ENDBUSRES)) { if ( !AT91F_TestTimeout(&timeout)) { DebugPrint("-E- End of bus reset not received\n\r"); goto error; } } pUdp->UDP_ICR = AT91C_UDP_ENDBUSRES; pUdp->UDP_CSR[0] = (AT91C_UDP_EPEDS | AT91C_UDP_EPTYPE_CTRL); DebugPrint("-I- A reset has been detected by the UDP\n\r"); /* ************************************************ */ /* Generate traffic between UHP and UDP */ /* ************************************************ */ // UHP: Notify the Hc that the Control list is filled pUhp->UHP_HcCommandStatus = 0x02; // UDP: Wait for a Setup packet AT91F_InitTimeout(&timeout, 2); while ( !(pUdp->UDP_CSR[0] & AT91C_UDP_RXSETUP)) { if ( !AT91F_TestTimeout(&timeout)) { DebugPrint("-E- No setup packet has been received by the UDP\n\r"); goto error; } } while (iterations--) { DebugPrint("Iteration: "); DebugPrintHex(2, iterations); DebugPrint("\n\r"); for (i = 0; i < 8; ++i) pUDPSetup[i] = pUdp->UDP_FDR[0]; pUdp->UDP_CSR[0] |= AT91C_UDP_DIR; // Data stage will be DATA IN transactions pUdp->UDP_CSR[0] &= ~(AT91C_UDP_RXSETUP); DebugPrint("-I- A setup packet has been sent by UDP and received by UHP\n\r"); // UDP: Send several Data packets for (i = 0; i < DataSIZE; ++ i) { pUdp->UDP_FDR[0] = pUDPData[i]; // UDP: Detect a packet frontier, send it and wait for the end of transmition if ( !((i+1) % 8) || (i == (DataSIZE - 1))) { pUdp->UDP_CSR[0] |= AT91C_UDP_TXPKTRDY; AT91F_InitTimeout(&timeout, 2); while ( !(pUdp->UDP_CSR[0] & AT91C_UDP_TXCOMP)) { if ( !AT91F_TestTimeout(&timeout)) { DebugPrint("-E- A data packet has not been acknowledged by the UHP\n\r"); goto error; } } pUdp->UDP_CSR[0] &= ~AT91C_UDP_TXCOMP; DebugPrint("-I- A data packet has been sent by UDP and received by UHP\n\r"); } } // UDP: Wait for the status sent by the host AT91F_InitTimeout(&timeout, 2); while ( !(pUdp->UDP_CSR[0] & AT91C_UDP_RX_DATA_BK0)) { if ( !AT91F_TestTimeout(&timeout)) { DebugPrint("-E- No status packet has been sent by the UHP\n\r"); goto error; } } pUdp->UDP_CSR[0] = ~AT91C_UDP_RX_DATA_BK0; DebugPrint("-I- A status data packet has been sent by UHP and received by UDP\n\r"); /* ************************************************ */ /* Compare data sent and received */ /* ************************************************ */ DebugPrint("-I- Compare sent/received setup packet ..."); for (i = 0; i < 8; ++i) { if (pUHPSetup[i] != pUDPSetup[i]) { DebugPrint("Failed\n\r"); goto error; } } DebugPrint(" Success\n\r"); DebugPrint("-I- Compare sent/received data packet ..."); for (i = 0; i < DataSIZE; ++i) { if (pUHPData[i] != pUDPData[i]) { DebugPrint("Failed\n\r"); goto error; } } DebugPrint(" Success\n\r"); } DebugPrint("-I- Test successfull...\n\r"); return ; error: DebugPrint("-F- Test failed...\n\r"); }
//*-------------------------------------------------------------------------------------- //* Function Name : Main //* Object : Software entry point //* Input Parameters : none. //* Output Parameters : none. //*-------------------------------------------------------------------------------------- int main(void) { char data[MSG_SIZE]; unsigned int length; int stepCnt = 0; unsigned char str[10]; /**** System init ****/ //InitFrec(); Init_CP_WP(); //chek for CP and WP //CP - card present while(((AT91C_BASE_PIOA->PIO_PDSR) & BIT15)) { /*put your card present event here*/ } //WP - write protect //while(((AT91C_BASE_PIOA->PIO_PDSR) & BIT16)) { /*put your write protect event here*/ } if (initMMC() == MMC_SUCCESS) { //card_state |= 1; memset(&mmc_buffer,0,512); mmcReadRegister (10, 16); mmc_buffer[7]=0; } flashInit(); Init_PWM(); // 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); // Led init // First, enable the clock of the PIOB AT91F_PMC_EnablePeriphClock ( AT91C_BASE_PMC, 1 << AT91C_ID_PIOA ) ; //* to be outputs. No need to set these pins to be driven by the PIO because it is GPIO pins only. AT91F_PIO_CfgOutput( AT91C_BASE_PIOA, OUTPUT_MASK ); //* Clear the LED's. /* AT91F_PIO_SetOutput( AT91C_BASE_PIOA, OUTPUT_MASK ); AT91F_PIO_ClearOutput( AT91C_BASE_PIOA, OUTPUT_MASK ); */ // Init USB device AT91F_USB_Open(); AT91F_PIO_ClearOutput( AT91C_BASE_PIOA, OUTPUT_MASK ); // Init USB device // Wait for the end of enumeration setForce(40000); int pCDCEnablingCounter = 0; while (!pCDC.IsConfigured(&pCDC) && pCDCEnablingCounter < 2500000){ pCDCEnablingCounter++; }; if (pCDCEnablingCounter < 2500000) { CDC = 1; } setForce(0); // Set Usart in interrupt //Usart_init(); //Read and set settings memcpy(settings, OUR_FLASH_ADDR, 128); int i;memset(&mmc_buffer, 0x00, 512); int j; char *settingsBlocks[50]; char settingsDelim[] = "~"; char *settingsParts = strtok( settings, settingsDelim ); i = 0; while( settingsParts != NULL ) { settingsBlocks[i++] = settingsParts; settingsParts = strtok( NULL, settingsDelim ); } for (j = 0; j < i; j++) { parseSettings(settingsBlocks[j]); } InitADC(); Init_PWM(); AT91F_PIO_CfgInput(AT91C_BASE_PIOA, SW1_MASK); AT91F_PIO_CfgInput(AT91C_BASE_PIOA, SW2_MASK); AT91F_PIO_SetOutput( AT91C_BASE_PIOA, LED_GREEN); AT91F_PIO_SetOutput( AT91C_BASE_PIOA, LED_YELLOW); setForce(0); //startBlinking(250000); /**** MMC CARD ****/ init_extint(); while (1) { cnt++; if (cnt > 50000) { cnt = 0; printTrace("COUNTER RESET\n"); } } }
void led_init(void) { // turn off LEDs AT91F_PIO_CfgOutput(LED_PIO, LED_MASK); AT91F_PIO_SetOutput(LED_PIO, LED_MASK); }