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);
}
