void dc_init(void) { #ifdef ENCODER pid_init(&pid, PID_K_P_DEFAULT, PID_K_I_DEFAULT, PID_K_D_DEFAULT, PID_SAMPLE_TIME_DEFAULT, PID_MAX_OUT_DEFAULT, PID_MIN_OUT_DEFAULT); encoder_init(); #endif Pin dc_pins[] = {PINS_DC}; PIO_Configure(dc_pins, PIO_LISTSIZE(dc_pins)); // Configure and enable power measurements Pin dc_power_management_pins[] = {VOLTAGE_STACK_PIN, VOLTAGE_EXTERN_PIN, VOLTAGE_STACK_SWITCH_PIN, CURRENT_CONSUMPTION_PIN}; PIO_Configure(dc_power_management_pins, PIO_LISTSIZE(dc_power_management_pins)); // Initialize PWM PMC->PMC_PCER0 = 1 << ID_PWM; dc_update_pwm_frequency(); adc_channel_enable(VOLTAGE_EXTERN_CHANNEL); adc_channel_enable(VOLTAGE_STACK_CHANNEL); adc_channel_enable(CURRENT_CONSUMPTION_CHANNEL); }
void SensorsTestInit() { char pinDirection = 0; int i; PIO_Configure(aDigitalOuts, PIO_LISTSIZE(aDigitalOuts)); PIO_Configure(digitalIns, PIO_LISTSIZE(digitalIns)); PIO_Configure(sensorsPower, PIO_LISTSIZE(sensorsPower)); PMC_EnablePeripheral(AT91C_ID_PIOB); PMC_EnablePeripheral(AT91C_ID_PIOA); SelectAng0(); // select analog port 0 to be mesured instead of BattVoltage SensorPowerOn(); // turn on the Vcc line if(PMC_IsPeriphEnabled(AT91C_ID_TWI) == 0){ PIO_Configure(twiPortPins, PIO_LISTSIZE(twiPortPins)); PMC_EnablePeripheral(AT91C_ID_TWI); TWI_ConfigureMaster(AT91C_BASE_TWI,TWCK,MCK); } // set all pins on pullup chip to output WritePullupData(0x00,&pinDirection,1); WritePullupData(0x01,&pinDirection,1); for(i = 0;i < 8;i++){ if(i>1) AnalogPullup(i,0); // disable Analog pullups for output test DigitalPullup(i,1); // enable all digital pullups } }
//------------------------------------------------------------------------------ void SdSpi::begin() { PIO_Configure( g_APinDescription[PIN_SPI_MOSI].pPort, g_APinDescription[PIN_SPI_MOSI].ulPinType, g_APinDescription[PIN_SPI_MOSI].ulPin, g_APinDescription[PIN_SPI_MOSI].ulPinConfiguration); PIO_Configure( g_APinDescription[PIN_SPI_MISO].pPort, g_APinDescription[PIN_SPI_MISO].ulPinType, g_APinDescription[PIN_SPI_MISO].ulPin, g_APinDescription[PIN_SPI_MISO].ulPinConfiguration); PIO_Configure( g_APinDescription[PIN_SPI_SCK].pPort, g_APinDescription[PIN_SPI_SCK].ulPinType, g_APinDescription[PIN_SPI_SCK].ulPin, g_APinDescription[PIN_SPI_SCK].ulPinConfiguration); pmc_enable_periph_clk(ID_SPI0); #if USE_SAM3X_DMAC pmc_enable_periph_clk(ID_DMAC); dmac_disable(); DMAC->DMAC_GCFG = DMAC_GCFG_ARB_CFG_FIXED; dmac_enable(); #if USE_SAM3X_BUS_MATRIX_FIX MATRIX->MATRIX_WPMR = 0x4d415400; MATRIX->MATRIX_MCFG[1] = 1; MATRIX->MATRIX_MCFG[2] = 1; MATRIX->MATRIX_SCFG[0] = 0x01000010; MATRIX->MATRIX_SCFG[1] = 0x01000010; MATRIX->MATRIX_SCFG[7] = 0x01000010; #endif // USE_SAM3X_BUS_MATRIX_FIX #endif // USE_SAM3X_DMAC }
// hardware SPI void HAL::spiBegin() { // Configre SPI pins PIO_Configure( g_APinDescription[SCK_PIN].pPort, g_APinDescription[SCK_PIN].ulPinType, g_APinDescription[SCK_PIN].ulPin, g_APinDescription[SCK_PIN].ulPinConfiguration); PIO_Configure( g_APinDescription[MOSI_PIN].pPort, g_APinDescription[MOSI_PIN].ulPinType, g_APinDescription[MOSI_PIN].ulPin, g_APinDescription[MOSI_PIN].ulPinConfiguration); PIO_Configure( g_APinDescription[MISO_PIN].pPort, g_APinDescription[MISO_PIN].ulPinType, g_APinDescription[MISO_PIN].ulPin, g_APinDescription[MISO_PIN].ulPinConfiguration); // set master mode, peripheral select, fault detection SPI_Configure(SPI0, ID_SPI0, SPI_MR_MSTR | SPI_MR_MODFDIS | SPI_MR_PS); SPI_Enable(SPI0); PIO_Configure( g_APinDescription[SPI_PIN].pPort, g_APinDescription[SPI_PIN].ulPinType, g_APinDescription[SPI_PIN].ulPin, g_APinDescription[SPI_PIN].ulPinConfiguration); spiInit(1); }
/************************************************************************* Initialization of the I2C bus interface. Need to be called only once *************************************************************************/ void HAL::i2cInit(unsigned long clockSpeedHz) { // enable TWI pmc_enable_periph_clk(TWI_ID); // Configure pins #if SDA_PIN >= 0 PIO_Configure(g_APinDescription[SDA_PIN].pPort, g_APinDescription[SDA_PIN].ulPinType, g_APinDescription[SDA_PIN].ulPin, g_APinDescription[SDA_PIN].ulPinConfiguration); #endif #if SCL_PIN >= 0 PIO_Configure(g_APinDescription[SCL_PIN].pPort, g_APinDescription[SCL_PIN].ulPinType, g_APinDescription[SCL_PIN].ulPin, g_APinDescription[SCL_PIN].ulPinConfiguration); #endif /* // Set to Master mode with known state TWI_INTERFACE->TWI_CR = TWI_CR_SVEN; TWI_INTERFACE->TWI_CR = TWI_CR_SWRST; //TWI_INTERFACE->TWI_RHR; // no action??? TWI_INTERFACE->TWI_IMR = 0; TWI_INTERFACE->TWI_CR = TWI_CR_SVDIS; TWI_INTERFACE->TWI_CR = TWI_CR_MSDIS; TWI_INTERFACE->TWI_CR = TWI_CR_MSEN; */ // Set to Master mode with known state TWI_INTERFACE->TWI_CR = TWI_CR_SWRST;// Reset TWI_INTERFACE->TWI_CR = TWI_CR_SVDIS;// Slave disable TWI_INTERFACE->TWI_CR = TWI_CR_MSEN; //Master enable i2cSetClockspeed(clockSpeedHz); }
unsigned char AccelInit(void) { PIO_Configure(accIntPins, PIO_LISTSIZE(accIntPins)); if(PMC_IsPeriphEnabled(AT91C_ID_TWI) == 0){ PIO_Configure(twiPins, PIO_LISTSIZE(twiPins)); PMC_EnablePeripheral(AT91C_ID_TWI); TWI_ConfigureMaster(AT91C_BASE_TWI,TWCK,MCK); } usleep(10000); #ifdef STACCEL // ST Accelerometer char setup[4]; setup[0] = (1<<5)|(2<<3)|7; // Normal power, data rate = 400Hz, ZYX axis enabled setup[1] = 0; // Do not add filter stuff setup[2] = (2<<0); // Data ready interrupt on INT 2 pad setup[3] = (0<<4); // do update between reads, and set scale to +/- 2g's WriteAccelData(0x20|(1<<7),setup,4); #else // Freescale Accelerometer //AccelCalibration(); AccelSetScale(2); AccelSetCalibration(); #endif SetPitCallback(AccelCallback,3); return 0; }
//--------------------------- void glcd_init(void) { unsigned int tcmr,tfmr; unsigned char i; PIO_Configure(GLcdpins,PIO_LISTSIZE(GLcdpins)); PIO_Configure(sscPins, PIO_LISTSIZE(sscPins)); PIO_Set(&GLcdpins[3]); PIO_Set(&GLcdpins[4]); SSC_Configure(AT91C_BASE_SSC,AT91C_ID_SSC,500000,BOARD_MCK); tcmr=AT91C_SSC_CKS_TK|AT91C_SSC_CKO_DATA_TX|AT91C_SSC_START_CONTINOUS; tfmr=SSC_DATLEN(8)|SSC_DATNB(15)|SSC_FSLEN(16)|AT91C_SSC_FSOS_LOW|AT91C_SSC_FSDEN ; SSC_ConfigureTransmitter(AT91C_BASE_SSC,tcmr,tfmr); SSC_EnableTransmitter(AT91C_BASE_SSC); PIO_Set(&GLcdpins[5]); //PIO_Clear(&GLcdpins[5]); for(i = 0; i < 3; i++); GLCD_WriteCommand((DISPLAY_ON_CMD | ON), i); }
/** * \brief ILI9488 Hardware Initialization for SPI/SMC LCD. */ static void _ILI9488_Spi_HW_Initialize(void) { /* Pin configurations */ PIO_Configure(&lcd_spi_reset_pin, 1); PIO_Configure(&lcd_spi_cds_pin, 1); PIO_Configure(lcd_pins, PIO_LISTSIZE(lcd_pins)); PIO_Configure(&lcd_spi_pwm_pin, 1); /* Enable PWM peripheral clock */ PMC_EnablePeripheral(ID_PWM0); PMC_EnablePeripheral(ID_SPI0); /* Set clock A and clock B */ // set for 14.11 KHz for CABC control //mode = PWM_CLK_PREB(0x0A) | (PWM_CLK_DIVB(110)) | //PWM_CLK_PREA(0x0A) | (PWM_CLK_DIVA(110)); PWMC_ConfigureClocks(PWM0, 14200, 0, BOARD_MCK); /* Configure PWM channel 1 for LED0 */ PWMC_DisableChannel(PWM0, CHANNEL_PWM_LCD); PWMC_ConfigureChannel(PWM0, CHANNEL_PWM_LCD, PWM_CMR_CPRE_CLKA, 0, PWM_CMR_CPOL); PWMC_SetPeriod(PWM0, CHANNEL_PWM_LCD, 16); PWMC_SetDutyCycle(PWM0, CHANNEL_PWM_LCD, 8); PWMC_EnableChannel(PWM0, CHANNEL_PWM_LCD); SPI_Configure(ILI9488_SPI, ID_SPI0, (SPI_MR_MSTR | SPI_MR_MODFDIS | SPI_PCS(SMC_EBI_LCD_CS))); SPI_ConfigureNPCS(ILI9488_SPI, SMC_EBI_LCD_CS, SPI_CSR_CPOL | SPI_CSR_BITS_8_BIT | SPI_DLYBS(6, BOARD_MCK) | SPI_DLYBCT(100, BOARD_MCK) | SPI_SCBR(20000000, BOARD_MCK)); SPI_Enable(ILI9488_SPI); }
/** * \brief Initialization of the SPI for communication with ADS7843 component. */ extern void ADS7843_Initialize( void ) { volatile uint32_t uDummy; /* Configure pins */ PIO_Configure(pinsSPI, PIO_LISTSIZE(pinsSPI)); PIO_Configure(pinBusy, PIO_LISTSIZE(pinBusy)); SPI_Configure(BOARD_TSC_SPI_BASE, BOARD_TSC_SPI_ID, SPI_MR_MSTR | SPI_MR_MODFDIS | SPI_PCS(BOARD_TSC_NPCS) /* Value of the SPI configuration register. */ ); SPI_ConfigureNPCS(BOARD_TSC_SPI_BASE, BOARD_TSC_NPCS, SPI_CSR_NCPHA | SPI_CSR_DLYBS(DELAY_BEFORE_SPCK) | SPI_CSR_DLYBCT(DELAY_BETWEEN_CONS_COM) | SPI_CSR_SCBR(0xC8) ); SPI_Enable(BOARD_TSC_SPI_BASE); for (uDummy=0; uDummy<100000; uDummy++); uDummy = REG_SPI_SR; uDummy = REG_SPI_RDR; SendCommand(CMD_ENABLE_PENIRQ); }
void stepper_set_output_current(const uint16_t current) { Pin pin = PIN_PWR_DAC; const uint16_t new_current = BETWEEN(VREF_RES_MIN_CURRENT, current, VREF_MAX_CURRENT); if(new_current < VREF_RES_MAX_CURRENT) { pin.type = PIO_OUTPUT_0; pin.attribute = PIO_DEFAULT; PIO_Configure(&pin, 1); DACC_SetConversionData(DACC, SCALE(new_current, VREF_RES_MIN_CURRENT, VREF_RES_MAX_CURRENT, VOLTAGE_MIN_VALUE, VOLTAGE_MAX_VALUE)); } else { DACC_SetConversionData(DACC, SCALE(new_current, VREF_MIN_CURRENT, VREF_MAX_CURRENT, VOLTAGE_MIN_VALUE, VOLTAGE_MAX_VALUE)); pin.type = PIO_INPUT;; pin.attribute = PIO_DEFAULT; PIO_Configure(&pin, 1); } stepper_output_current = new_current; }
//------------------------------------------------------------------------------ void spiBegin(uint8_t csPin) { pinMode(csPin,OUTPUT); digitalWrite(csPin,HIGH); PIO_Configure( g_APinDescription[PIN_SPI_MOSI].pPort, g_APinDescription[PIN_SPI_MOSI].ulPinType, g_APinDescription[PIN_SPI_MOSI].ulPin, g_APinDescription[PIN_SPI_MOSI].ulPinConfiguration); PIO_Configure( g_APinDescription[PIN_SPI_MISO].pPort, g_APinDescription[PIN_SPI_MISO].ulPinType, g_APinDescription[PIN_SPI_MISO].ulPin, g_APinDescription[PIN_SPI_MISO].ulPinConfiguration); PIO_Configure( g_APinDescription[PIN_SPI_SCK].pPort, g_APinDescription[PIN_SPI_SCK].ulPinType, g_APinDescription[PIN_SPI_SCK].ulPin, g_APinDescription[PIN_SPI_SCK].ulPinConfiguration); pmc_enable_periph_clk(ID_SPI0); #if USE_SAM3X_DMAC pmc_enable_periph_clk(ID_DMAC); dmac_disable(); DMAC->DMAC_GCFG = DMAC_GCFG_ARB_CFG_FIXED; dmac_enable(); #if USE_SAM3X_BUS_MATRIX_FIX MATRIX->MATRIX_WPMR = 0x4d415400; MATRIX->MATRIX_MCFG[1] = 1; MATRIX->MATRIX_MCFG[2] = 1; MATRIX->MATRIX_SCFG[0] = 0x01000010; MATRIX->MATRIX_SCFG[1] = 0x01000010; MATRIX->MATRIX_SCFG[7] = 0x01000010; #endif // USE_SAM3X_BUS_MATRIX_FIX #endif // USE_SAM3X_DMAC }
void motors_init() { PIO_Configure(&pin_m0_en, 1); PIO_Configure(&pin_m1_en, 1); PIO_Configure(&pin_m2_en, 1); PIO_Configure(&pin_m_brake, 1); PIO_Configure(&pin_m0_dir, 1); PIO_Configure(&pin_m1_dir, 1); PIO_Configure(&pin_m2_dir, 1); PMC_EnablePeripheral(ID_PWM); // power up pwm controller plz PIO_Configure(&pin_m0_vref, 1); // PWML0 PIO_Configure(&pin_m1_vref, 1); // PWMH1 PIO_Configure(&pin_m2_vref, 1); // PWMH3 PWM->PWM_CH_NUM[0].PWM_CMR = 0; // pass-through divider. 64 MHz clock. PWM->PWM_CH_NUM[0].PWM_CPRD = 255; // 8-bit current control, 125 kHz cycle PWM->PWM_CH_NUM[0].PWM_CDTY = 0; // zero duty for now PWM->PWM_CH_NUM[1].PWM_CMR = 0; PWM->PWM_CH_NUM[1].PWM_CPRD = 255; PWM->PWM_CH_NUM[1].PWM_CDTY = 255; PWM->PWM_CH_NUM[3].PWM_CMR = 0; PWM->PWM_CH_NUM[3].PWM_CPRD = 255; PWM->PWM_CH_NUM[3].PWM_CDTY = 255; PWM->PWM_ENA = 0xb; // enable channels 0,1,3 PIO_Set(&pin_m_brake); PIO_Set(&pin_m0_en); PIO_Set(&pin_m1_en); PIO_Set(&pin_m2_en); }
static void ILI9488_InitInterface(void) { PIO_Configure(ILI9488_Reset, PIO_LISTSIZE(ILI9488_Reset)); PIO_Configure(spi_pins, PIO_LISTSIZE(spi_pins)); PIO_Configure(ILI9488_Pwm, PIO_LISTSIZE(ILI9488_Pwm)); /* Enable PWM peripheral clock */ PMC_EnablePeripheral(ID_PWM0); /* Set clock A and clock B */ // set for 14.11 KHz for CABC control // mode = PWM_CLK_PREB(0x0A) | (PWM_CLK_DIVB(110)) | // PWM_CLK_PREA(0x0A) | (PWM_CLK_DIVA(110)); PWMC_ConfigureClocks(PWM0, 14200, 0, BOARD_MCK); /* Configure PWM channel 1 for LED0 */ PWMC_DisableChannel(PWM0, CHANNEL_PWM_LCD); PWMC_ConfigureChannel(PWM0, CHANNEL_PWM_LCD, PWM_CMR_CPRE_CLKA,0,PWM_CMR_CPOL); PWMC_SetPeriod(PWM0, CHANNEL_PWM_LCD, 16); PWMC_SetDutyCycle(PWM0, CHANNEL_PWM_LCD, 8); PWMC_EnableChannel(PWM0, CHANNEL_PWM_LCD); SPI_Configure(ILI9488, ILI9488_ID, (SPI_MR_MSTR | SPI_MR_MODFDIS | SPI_PCS( ILI9488_cs ))); SPI_ConfigureNPCS( ILI9488, ILI9488_cs, SPI_CSR_CPOL | SPI_CSR_BITS_9_BIT | SPI_DLYBS(100, BOARD_MCK) | SPI_DLYBCT(100, BOARD_MCK) | SPI_SCBR( 35000000, BOARD_MCK) ) ; SPI_Enable(ILI9488); }
extern void UART_Configure( uint32_t baudrate, uint32_t masterClock) { #if 0 const Pin pPins[] = CONSOLE_PINS; /* Configure PIO */ PIO_Configure(pPins, PIO_LISTSIZE(pPins)); uint32_t mode = US_MR_USART_MODE_RS485 | US_MR_USCLKS_MCK | US_MR_CHRL_8_BIT | US_MR_PAR_NO | US_MR_NBSTOP_1_BIT | US_MR_CHMODE_NORMAL; PMC->PMC_PCER0 = 1 << CONSOLE_ID; USART_Configure( USART1, mode, CONSOLE_BAUDRATE, BOARD_MCK ) ; USART1->US_IDR = 0xFFFFFFFF ; NVIC_EnableIRQ( USART1_IRQn ) ; USART_SetTransmitterEnabled( USART1, 1 ) ; #else #ifdef CONSOLE_USART_USE_UART1 const Pin pPins[] = {{1 << 3, PIOB, ID_PIOB, PIO_PERIPH_A, PIO_DEFAULT}}; Uart *pUart = CONSOLE_USART; #else const Pin pPins[] = CONSOLE_PINS; Uart *pUart = (Uart *)CONSOLE_USART; #endif /* Configure PIO */ PIO_Configure(pPins, PIO_LISTSIZE(pPins)); /* Configure PMC */ #ifdef CONSOLE_USART_USE_UART1 PMC->PMC_PCER0 = 1 << ID_UART1; #else PMC->PMC_PCER0 = 1 << CONSOLE_ID; #endif /* Reset and disable receiver & transmitter */ pUart->UART_CR = UART_CR_RSTRX | UART_CR_RSTTX | UART_CR_RXDIS | UART_CR_TXDIS; /* Configure mode */ pUart->UART_MR = UART_MR_PAR_NO | US_MR_CHRL_8_BIT; /* Configure baudrate */ /* Asynchronous, no oversampling */ pUart->UART_BRGR = (masterClock / baudrate) / 16; /* Disable PDC channel */ pUart->UART_PTCR = UART_PTCR_RXTDIS | UART_PTCR_TXTDIS; /* Enable receiver and transmitter */ pUart->UART_CR = UART_CR_RXEN | UART_CR_TXEN; #endif }
// Initialize ADC channels void HAL::analogStart(void) { #if MOTHERBOARD == 500 || MOTHERBOARD == 501 PIO_Configure( g_APinDescription[58].pPort, g_APinDescription[58].ulPinType, g_APinDescription[58].ulPin, g_APinDescription[58].ulPinConfiguration); PIO_Configure( g_APinDescription[59].pPort, g_APinDescription[59].ulPinType, g_APinDescription[59].ulPin, g_APinDescription[59].ulPinConfiguration); #endif // (MOTHERBOARD==500) || (MOTHERBOARD==501) // ensure we can write to ADC registers ADC->ADC_WPMR = 0x41444300u; //ADC_WPMR_WPKEY(0); pmc_enable_periph_clk(ID_ADC); // enable adc clock for (int i = 0; i < ANALOG_INPUTS; i++) { osAnalogInputValues[i] = 0; adcSamplesMin[i] = 100000; adcSamplesMax[i] = 0; adcEnable |= (0x1u << osAnalogInputChannels[i]); osAnalogSamplesSum[i] = 2048 * ANALOG_INPUT_MEDIAN; for (int j = 0; j < ANALOG_INPUT_MEDIAN; j++) osAnalogSamples[i][j] = 2048; // we want to prevent early error from bad starting values } // enable channels ADC->ADC_CHER = adcEnable; ADC->ADC_CHDR = !adcEnable; // Initialize ADC mode register (some of the following params are not used here) // HW trigger disabled, use external Trigger, 12 bit resolution // core and ref voltage stays on, normal sleep mode, normal not free-run mode // startup time 16 clocks, settling time 17 clocks, no changes on channel switch // convert channels in numeric order // set prescaler rate MCK/((PRESCALE+1) * 2) // set tracking time (TRACKTIM+1) * clock periods // set transfer period (TRANSFER * 2 + 3) ADC->ADC_MR = ADC_MR_TRGEN_DIS | ADC_MR_TRGSEL_ADC_TRIG0 | ADC_MR_LOWRES_BITS_12 | ADC_MR_SLEEP_NORMAL | ADC_MR_FWUP_OFF | ADC_MR_FREERUN_OFF | ADC_MR_STARTUP_SUT64 | ADC_MR_SETTLING_AST17 | ADC_MR_ANACH_NONE | ADC_MR_USEQ_NUM_ORDER | ADC_MR_PRESCAL(AD_PRESCALE_FACTOR) | ADC_MR_TRACKTIM(AD_TRACKING_CYCLES) | ADC_MR_TRANSFER(AD_TRANSFER_CYCLES); ADC->ADC_IER = 0; // no ADC interrupts ADC->ADC_CGR = 0; // Gain = 1 ADC->ADC_COR = 0; // Single-ended, no offset // start first conversion ADC->ADC_CR = ADC_CR_START; }
pio_type platform_pio_op( unsigned port, pio_type pinmask, int op ) { Pin* pin; pio_type retval = 1; pin = pio_port_desc + port; pin->mask = pinmask; switch( op ) { case PLATFORM_IO_PORT_SET_VALUE: case PLATFORM_IO_PIN_SET: PIO_Set( pin ); break; case PLATFORM_IO_PIN_CLEAR: PIO_Clear( pin ); break; case PLATFORM_IO_PORT_DIR_INPUT: pin->mask = 0x7FFFFFFF; case PLATFORM_IO_PIN_DIR_INPUT: pin->type = PIO_INPUT; PIO_Configure( pin, 1 ); break; case PLATFORM_IO_PORT_DIR_OUTPUT: pin->mask = 0x7FFFFFFF; case PLATFORM_IO_PIN_DIR_OUTPUT: pin->type = PIO_OUTPUT_0; PIO_Configure( pin, 1 ); break; case PLATFORM_IO_PORT_GET_VALUE: pin->mask = 0x7FFFFFFF; pin->type = PIO_INPUT; retval = PIO_Get( pin ); break; case PLATFORM_IO_PIN_GET: retval = PIO_Get( pin ) & pinmask ? 1 : 0; break; case PLATFORM_IO_PIN_PULLUP: pin->pio->PIO_PPUER = pinmask; break; case PLATFORM_IO_PIN_NOPULL: pin->pio->PIO_PPUDR = pinmask; break; default: retval = 0; break; } return retval; }
void GPIO_Init(void) { PIO_Configure( pinsSwitches, PIO_LISTSIZE(pinsSwitches) ); PIO_Configure( pinsGpios, PIO_LISTSIZE(pinsGpios) ); //PIO_InitializeInterrupts( AT91C_AIC_PRIOR_LOWEST ); //LED_Configure(LED_DS1); //LED_Configure(LED_DS2); }
extern void pinMode( uint32_t ulPin, uint32_t ulMode ) { if ( g_APinDescription[ulPin].ulPinType == PIO_NOT_A_PIN ) { return ; } /* Added by Y.Ishioka */ if( ulPin == 13 ) { led_init() ; led_set( 1 ) ; return ; } switch ( ulMode ) { case INPUT: /* Enable peripheral for clocking input */ pmc_enable_periph_clk( g_APinDescription[ulPin].ulPeripheralId ) ; PIO_Configure( g_APinDescription[ulPin].pPort, PIO_INPUT, g_APinDescription[ulPin].ulPin, 0 ) ; break ; case INPUT_PULLUP: /* Enable peripheral for clocking input */ pmc_enable_periph_clk( g_APinDescription[ulPin].ulPeripheralId ) ; PIO_Configure( g_APinDescription[ulPin].pPort, PIO_INPUT, g_APinDescription[ulPin].ulPin, PIO_PULLUP ) ; break ; case OUTPUT: PIO_Configure( g_APinDescription[ulPin].pPort, PIO_OUTPUT_1, g_APinDescription[ulPin].ulPin, g_APinDescription[ulPin].ulPinConfiguration ) ; /* if all pins are output, disable PIO Controller clocking, reduce power consumption */ if ( g_APinDescription[ulPin].pPort->PIO_OSR == 0xffffffff ) { pmc_disable_periph_clk( g_APinDescription[ulPin].ulPeripheralId ) ; } break ; default: break ; } }
static uint32_t _WFE_PushButtons_Initialize( void ) { /* Configure PIO */ PIO_Configure(&gPinButton1, 1); PIO_Configure(&gPinButton2, 1); /* Enable PIO interrupt */ PIO_EnableIt(&gPinButton1); PIO_EnableIt(&gPinButton2); return SAMGUI_E_OK ; }
void HAL::spiBegin() { #if MOTHERBOARD == 500 || MOTHERBOARD == 501 if (spiInitMaded == false) { #endif // Configre SPI pins PIO_Configure( g_APinDescription[SCK_PIN].pPort, g_APinDescription[SCK_PIN].ulPinType, g_APinDescription[SCK_PIN].ulPin, g_APinDescription[SCK_PIN].ulPinConfiguration); PIO_Configure( g_APinDescription[MOSI_PIN].pPort, g_APinDescription[MOSI_PIN].ulPinType, g_APinDescription[MOSI_PIN].ulPin, g_APinDescription[MOSI_PIN].ulPinConfiguration); PIO_Configure( g_APinDescription[MISO_PIN].pPort, g_APinDescription[MISO_PIN].ulPinType, g_APinDescription[MISO_PIN].ulPin, g_APinDescription[MISO_PIN].ulPinConfiguration); // set master mode, peripheral select, fault detection SPI_Configure(SPI0, ID_SPI0, SPI_MR_MSTR | SPI_MR_MODFDIS | SPI_MR_PS); SPI_Enable(SPI0); #if MOTHERBOARD == 500 || MOTHERBOARD == 501 SET_OUTPUT(DAC0_SYNC); #if NUM_EXTRUDER > 1 SET_OUTPUT(DAC1_SYNC); WRITE(DAC1_SYNC, HIGH); #endif SET_OUTPUT(SPI_EEPROM1_CS); SET_OUTPUT(SPI_EEPROM2_CS); SET_OUTPUT(SPI_FLASH_CS); WRITE(DAC0_SYNC, HIGH); WRITE(SPI_EEPROM1_CS, HIGH ); WRITE(SPI_EEPROM2_CS, HIGH ); WRITE(SPI_FLASH_CS, HIGH ); WRITE(SDSS , HIGH ); #endif// MOTHERBOARD == 500 || MOTHERBOARD == 501 PIO_Configure( g_APinDescription[SPI_PIN].pPort, g_APinDescription[SPI_PIN].ulPinType, g_APinDescription[SPI_PIN].ulPin, g_APinDescription[SPI_PIN].ulPinConfiguration); spiInit(1); #if (MOTHERBOARD==500) || (MOTHERBOARD==501) spiInitMaded = true; } #endif }
/** * \brief Do a HW initialize to the PHY (via RSTC) and set up clocks & PIOs * This should be called only once to initialize the PHY pre-settings. * The PHY address is reset status of CRS,RXD[3:0] (the emacPins' pullups). * The COL pin is used to select MII mode on reset (pulled up for Reduced MII) * The RXDV pin is used to select test mode on reset (pulled up for test mode) * The above pins should be predefined for corresponding settings in resetPins * The GMAC peripheral pins are configured after the reset done. * \param pMacb Pointer to the MACB instance * \param mck Main clock setting to initialize clock * \param resetPins Pointer to list of PIOs to configure before HW RESET * (for PHY power on reset configuration latch) * \param nbResetPins Number of PIO items that should be configured * \param emacPins Pointer to list of PIOs for the EMAC interface * \param nbEmacPins Number of PIO items that should be configured * \return 1 if RESET OK, 0 if timeout. */ uint8_t GMACB_InitPhy(GMacb *pMacb, uint32_t mck, const Pin *pResetPins, uint32_t nbResetPins, const Pin *pGmacPins, uint32_t nbGmacPins) { sGmacd *pDrv = pMacb->pGmacd; Gmac *pHw = pDrv->pHw; uint8_t rc = 1; uint8_t phy; /* Perform RESET */ TRACE_DEBUG("RESET PHY\n\r"); if (pResetPins) { /* Configure PINS */ PIO_Configure(pResetPins, nbResetPins); TRACE_INFO(" Hard Reset of GMACD Phy\n\r"); PIO_Clear(pResetPins); Wait(100); PIO_Set(pResetPins); } /* Configure GMAC runtime pins */ if (rc) { PIO_Configure(pGmacPins, nbGmacPins); rc = GMAC_SetMdcClock(pHw, mck); if (!rc) { TRACE_ERROR("No Valid MDC clock\n\r"); return 0; } /* Check PHY Address */ phy = GMACB_FindValidPhy(pMacb); if (phy == 0xFF) { TRACE_ERROR("PHY Access fail\n\r"); return 0; } if (phy != pMacb->phyAddress) { pMacb->phyAddress = phy; GMACB_ResetPhy(pMacb); } } else TRACE_ERROR("PHY Reset Timeout\n\r"); return rc; }
//Sets up PWM output //use_accelerator pwm should generally not be turned on un void act_driver_init() { //sets up driver pins if (use_normal_pwm) { PIO_Configure(&pwm0_pin, 1); } else { PIO_Configure(&pwm2_pin, 1); } PIO_Configure(&pwm1_pin, 1); // Enable PWMC peripheral clock AT91C_BASE_PMC->PMC_PCER = 1 << AT91C_ID_PWMC; // Power up PWM Controller. if (use_normal_pwm) { AT91C_BASE_PWMC->PWMC_DIS = AT91C_PWMC_CHID0; //disable channel 0 - ACT_DRIVER_CHANNEL_CLOCKWISE } else { AT91C_BASE_PWMC->PWMC_DIS = AT91C_PWMC_CHID2; // disable channel 2 - ACT_DRIVER_ALTERNATE_PWM } AT91C_BASE_PWMC->PWMC_DIS = AT91C_PWMC_CHID1; //disable channel 1 - ACT_DRIVER_CHANNEL_ANTICLOCKWISE AT91C_BASE_PWMC->PWMC_MR = 0; // Clear mode register. if (use_normal_pwm) { AT91C_BASE_PWMC->PWMC_CH[0].PWMC_CMR = 0x00 | AT91C_PWMC_CPOL; // use board frequency and polarity 0. AT91C_BASE_PWMC->PWMC_CH[0].PWMC_CPRDR = FULL_DUTY_PERIOD; //set the period set_pwm_duty_percent(/*channel*/ACT_DRIVER_CHANNEL_CLOCKWISE,0); } else { AT91C_BASE_PWMC->PWMC_CH[2].PWMC_CMR = 0x00 | AT91C_PWMC_CPOL; // MCK and polarity 0. AT91C_BASE_PWMC->PWMC_CH[2].PWMC_CPRDR = FULL_DUTY_PERIOD; //set the period set_pwm_duty_percent(/*channel*/ACT_DRIVER_CHANNEL_ALTERNATE,0); } AT91C_BASE_PWMC->PWMC_CH[1].PWMC_CMR = 0x00 | AT91C_PWMC_CPOL; // MCK and polarity 0. AT91C_BASE_PWMC->PWMC_CH[1].PWMC_CPRDR = FULL_DUTY_PERIOD; //set the period set_pwm_duty_percent(/*channel*/ACT_DRIVER_CHANNEL_ANTICLOCKWISE,0); if (use_normal_pwm) { AT91C_BASE_PWMC->PWMC_ENA = AT91C_PWMC_CHID0; // Enable channel 0. } else { AT91C_BASE_PWMC->PWMC_ENA = AT91C_PWMC_CHID2; // Enable channel 2 } AT91C_BASE_PWMC->PWMC_ENA = AT91C_PWMC_CHID1; // Enable channel 1 }
/** * @brief Configures the buttons to generate interrupts when pressed. */ void ConfigureButtons(void) { // Configure PIO PIO_Configure(&pinPB1, 1); PIO_Configure(&pinPB2, 1); // Initialize interrupts PIO_InitializeInterrupts(AT91C_AIC_PRIOR_LOWEST); PIO_ConfigureIt(&pinPB1, (void (*)(const Pin *)) ISR_Bp1); PIO_ConfigureIt(&pinPB2, (void (*)(const Pin *)) ISR_Bp2); PIO_EnableIt(&pinPB1); PIO_EnableIt(&pinPB2); }
//------------------------------------------------------------------------------ /// Initializes the CCID driver and runs it. /// \return Unused (ANSI-C compatibility) //------------------------------------------------------------------------------ int main( void ) { // Initialize traces TRACE_CONFIGURE(DBGU_STANDARD, 115200, BOARD_MCK); printf("-- USB Device CCID Project %s --\n\r", SOFTPACK_VERSION); printf("-- %s\n\r", BOARD_NAME); printf("-- Compiled: %s %s --\n\r", __DATE__, __TIME__); // If they are present, configure Vbus & Wake-up pins PIO_InitializeInterrupts(0); // Configure IT on Smart Card ConfigureCardDetection(); // Configure ISO7816 driver PIO_Configure(pinsISO7816, PIO_LISTSIZE(pinsISO7816)); PIO_Configure(pinsPower, PIO_LISTSIZE(pinsPower)); /* power up the card */ PIO_Set(&pinsPower[0]); ISO7816_Init( pinIso7816RstMC ); // USB audio driver initialization CCIDDriver_Initialize(); // connect if needed VBUS_CONFIGURE(); while (USBD_GetState() < USBD_STATE_CONFIGURED); CCID_Insertion(); // Infinite loop while (1) { if( USBState == STATE_SUSPEND ) { TRACE_DEBUG("suspend !\n\r"); LowPowerMode(); USBState = STATE_IDLE; } if( USBState == STATE_RESUME ) { // Return in normal MODE TRACE_DEBUG("resume !\n\r"); NormalPowerMode(); USBState = STATE_IDLE; } CCID_SmartCardRequest(); } return 0; }
/** * \brief Set the backlight of the LCD. * * \param level Backlight brightness level [1..16], 1 means maximum brightness. */ void LCDD_SetBacklight (uint32_t level) { uint32_t i; const Pin pPins[] = {BOARD_BACKLIGHT_PIN}; /* Ensure valid level */ level = (level < 1) ? 1 : level; level = (level > 16) ? 16 : level; /* Enable pins */ PIO_Configure(pPins, PIO_LISTSIZE(pPins)); /* Switch off backlight */ PIO_Clear(pPins); i = 600 * (BOARD_MCK / 1000000); /* wait for at least 500us */ while(i--); /* Set new backlight level */ for (i = 0; i < level; i++) { PIO_Clear(pPins); PIO_Clear(pPins); PIO_Clear(pPins); PIO_Set(pPins); PIO_Set(pPins); PIO_Set(pPins); } }
/* maybe this can be optimized */ static void i2c_init(void) { i2c_sda_pin_desc = &(g_APinDescription[i2c_sda_pin]); i2c_scl_pin_desc = &(g_APinDescription[i2c_scl_pin]); pinMode(i2c_sda_pin, OUTPUT); digitalWrite(i2c_sda_pin, HIGH); pinMode(i2c_scl_pin, OUTPUT); digitalWrite(i2c_scl_pin, HIGH); PIO_Configure( i2c_sda_pin_desc->pPort, PIO_OUTPUT_0, i2c_sda_pin_desc->ulPin, PIO_OPENDRAIN ); PIO_Configure( i2c_scl_pin_desc->pPort, PIO_OUTPUT_0, i2c_scl_pin_desc->ulPin, PIO_OPENDRAIN ); PIO_Clear( i2c_sda_pin_desc->pPort, i2c_sda_pin_desc->ulPin) ; PIO_Clear( i2c_scl_pin_desc->pPort, i2c_scl_pin_desc->ulPin) ; PIO_Configure( i2c_sda_pin_desc->pPort, PIO_INPUT, i2c_sda_pin_desc->ulPin, PIO_DEFAULT ) ; PIO_Configure( i2c_scl_pin_desc->pPort, PIO_INPUT, i2c_scl_pin_desc->ulPin, PIO_DEFAULT ) ; i2c_delay(); }
/** * \brief usart-hard-handshaking Application entry point.. * * Configures USART0 in hardware handshaking mode and * Timer Counter 0 to generate an interrupt every second. Then, starts the first * transfer on the USART and wait in an endless loop. * * \return Unused (ANSI-C compatibility). * \callgraph */ extern int main( void ) { /* Disable watchdog*/ WDT_Disable( WDT ) ; /* Configure pins*/ PIO_Configure( pins, PIO_LISTSIZE( pins ) ) ; /* Configure USART and display startup trace*/ _ConfigureUsart() ; printf( "-- USART Hardware Handshaking Example %s --\n\r", SOFTPACK_VERSION ) ; printf( "-- %s\n\r", BOARD_NAME ) ; printf( "-- Compiled: %s %s --\n\r", __DATE__, __TIME__ ) ; /* Configure TC0 to generate a 1s tick*/ _ConfigureTc0() ; /* Start receiving data and start timer*/ USART_ReadBuffer( BOARD_USART_BASE, pBuffer, BUFFER_SIZE ) ; BOARD_USART_BASE->US_IER = US_IER_RXBUFF ; TC_Start( TC0, 0 ) ; /* Infinite loop*/ while ( 1 ) ; }
static void prvConfigureVBus( void ) { const Pin xVBusPin = PIN_USB_VBUS; const uint32_t ulPriority = 7; /* Highest. */ /* Configure PIO to generate an interrupt on status change. */ PIO_Configure( &xVBusPin, 1 ); PIO_ConfigureIt( &xVBusPin ); /* Ensure interrupt is disabled before setting the mode and installing the handler. The priority of the tick interrupt should always be set to the lowest possible. */ AIC->AIC_SSR = ID_PIOE; AIC->AIC_IDCR = AIC_IDCR_INTD; AIC->AIC_SMR = AIC_SMR_SRCTYPE_EXT_POSITIVE_EDGE | ulPriority; AIC->AIC_SVR = ( uint32_t ) prvVBusISRHandler; /* Start with the interrupt clear. */ AIC->AIC_ICCR = AIC_ICCR_INTCLR; PIO_EnableIt( &xVBusPin ); AIC_EnableIT( ID_PIOE ); /* Check current level on VBus */ if( PIO_Get( &xVBusPin ) != pdFALSE ) { /* If VBUS present, force the connect */ USBD_Connect(); } else { USBD_Disconnect(); } }
void Ruler_Power_Switch( unsigned char onoff ) { pinsGpios[5].type = (onoff == 0) ? PIO_OUTPUT_0 : PIO_OUTPUT_1 ; PIO_Configure(&pinsGpios[5], 1); }
void usb_init() { // If they are present, configure Vbus & Wake-up pins unsigned int priority = 0; #ifdef AT91C_ID_PIOD_E AT91C_BASE_PMC->PMC_PCER = 1 << AT91C_ID_PIOD_E; AT91C_BASE_PIOD->PIO_ISR; AT91C_BASE_PIOD->PIO_IDR = 0xFFFFFFFF; AT91C_BASE_PIOE->PIO_ISR; AT91C_BASE_PIOE->PIO_IDR = 0xFFFFFFFF; IRQ_ConfigureIT(AT91C_ID_PIOD_E, priority, PIO_IT_InterruptHandler); IRQ_EnableIT(AT91C_ID_PIOD_E); #endif // If there is on board power, switch it off #ifdef PIN_USB_POWER_ENB { const Pin pinUsbPwr = PIN_USB_POWER_ENB; PIO_Configure(&pinUsbPwr, 1); } #endif // BOT driver initialization CDCDSerialDriver_Initialize(); // connect if needed VBUS_CONFIGURE(); // Connect pull-up, wait for configuration USBD_Connect(); }