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
}
}
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);
}
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);
}
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);
}
/**
* \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);
}
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
}
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);
}
//------------------------------------------------------------------------------
/// 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;
}
static unsigned char ShallEraseBootstrap()
{
const Pin pButtons[] = {PINS_PUSHBUTTONS};
unsigned char buttonIdx;
// Configure all PIO corresponding to buttons in input
PIO_Configure(pButtons, PIO_LISTSIZE(pButtons));
for (buttonIdx = 0; buttonIdx < PIO_LISTSIZE(pButtons); ++buttonIdx) {
// Check if button is pressed
if (!PIO_Get(&(pButtons[buttonIdx]))) {
return 1;
}
}
return 0;
}
void USART1_UART_Init(unsigned int baudrate) {
unsigned int mode = AT91C_US_USMODE_NORMAL
| AT91C_US_CLKS_CLOCK
| AT91C_US_CHRL_8_BITS
| AT91C_US_PAR_NONE
| AT91C_US_NBSTOP_1_BIT
| AT91C_US_CHMODE_NORMAL;
// Configure pins
PIO_Configure(pins, PIO_LISTSIZE(pins));
// Enable the peripheral clock in the PMC
PMC_EnablePeripheral(AT91C_ID_US0);
// Configure the USART in the desired mode
USART_Configure(AT91C_BASE_US0, mode, baudrate, BOARD_MCK);
// Configure the RXBUFF interrupt
AT91C_BASE_US0->US_IER = AT91C_US_RXRDY;
AIC_ConfigureIT(AT91C_ID_US0, 0, ISR_Usart0);
AIC_EnableIT(AT91C_ID_US0);
// Enable receiver & transmitter
USART_SetTransmitterEnabled(AT91C_BASE_US0, 1);
USART_SetReceiverEnabled(AT91C_BASE_US0, 1);
}
/**
* Initialize PIOs
*/
static void _ConfigurePIOs(void)
{
/* Configure SDcard pins */
PIO_Configure(pinsSd, PIO_LISTSIZE(pinsSd));
/* Configure SD card detection */
CardDetectConfigure();
}
/**
* \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);
}
}
void i2c_eeprom_slave_init(void) {
uint64_t uid = uid_get_uid64();
memcpy(eeprom.memory, &uid, sizeof(uint64_t));
eeprom.offset = 0;
eeprom.acquire = 0;
eeprom.page = 0;
const Pin twi_pins[] = {PINS_TWI_STACK};
// Configure TWI pins
PIO_Configure(twi_pins, PIO_LISTSIZE(twi_pins));
// Enable TWI peripheral clock
PMC->PMC_PCER0 = 1 << ID_TWI1;
// Configure TWI interrupts
NVIC_DisableIRQ(TWI1_IRQn);
NVIC_ClearPendingIRQ(TWI1_IRQn);
NVIC_SetPriority(TWI1_IRQn, PRIORITY_EEPROM_SLAVE_TWI1);
NVIC_EnableIRQ(TWI1_IRQn);
// Configure TWI as slave, with address I2C_EEPROM_SLAVE_ADDRESS
TWI_ConfigureSlave(TWI_STACK, I2C_EEPROM_SLAVE_ADDRESS);
// Enable TWI interrupt
TWI_EnableIt(TWI_STACK, TWI_IER_SVACC);
}
void imu_startblink(void) {
imu_leds_on(true);
Pin pins[] = {PINS_IMU_LED};
for(uint8_t i = 0; i < 6; i++) {
pins[i].type = PIO_OUTPUT_1;
}
PIO_Configure(pins, PIO_LISTSIZE(pins));
for(uint8_t i = 0; i < 41; i++) {
TC0->TC_CHANNEL[0].TC_RA = blink_lookup[i];
TC0->TC_CHANNEL[1].TC_RA = blink_lookup[i];
TC0->TC_CHANNEL[2].TC_RB = blink_lookup[i];
PWMC_SetDutyCycle(PWM, 3, blink_lookup[40-i]);
SLEEP_MS(6);
}
for(uint8_t i = 0; i < 41; i++) {
TC0->TC_CHANNEL[0].TC_RA = blink_lookup[40-i];
TC0->TC_CHANNEL[1].TC_RA = blink_lookup[40-i];
TC0->TC_CHANNEL[2].TC_RB = blink_lookup[40-i];
PWMC_SetDutyCycle(PWM, 3, blink_lookup[i]);
SLEEP_MS(6);
}
for(uint8_t i = 0; i < 41; i++) {
TC0->TC_CHANNEL[0].TC_RA = blink_lookup[i];
TC0->TC_CHANNEL[1].TC_RA = blink_lookup[i];
TC0->TC_CHANNEL[2].TC_RB = blink_lookup[i];
PWMC_SetDutyCycle(PWM, 3, blink_lookup[40-i]);
SLEEP_MS(6);
}
imu_leds_on(false);
}
/**
* \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 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 ) ;
}
/**
* \brief Configures an USART peripheral with the specified parameters.
*
* \param baudrate Baudrate at which the USART should operate (in Hz).
* \param masterClock Frequency of the system master clock (in Hz).
*/
extern void UART_Configure( uint32_t dwBaudRate, uint32_t dwMasterClock )
{
const Pin pPins[] = CONSOLE_PINS ;
Uart *pUart = CONSOLE_USART ;
/* Configure PIO */
PIO_PinConfigure( pPins, PIO_LISTSIZE( pPins ) ) ;
/* Enable clock for UART */
/* In SAM3X, the clock for UART is always enabled. */
/* PMC->PMC_PCER0 = 1 << CONSOLE_ID ; */
/* 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 ;
/* Configure baudrate */
/* Asynchronous, no oversampling */
pUart->UART_BRGR = (dwMasterClock / dwBaudRate) / 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 ;
_ucIsConsoleInitialized=1 ;
/* Disable buffering for printf(). */
#if ( defined (__GNUC__) && !defined (__SAMBA__) )
setvbuf(stdout, (char *)NULL, _IONBF, 0);
#endif
}
/**
* \brief Configures an UART peripheral with the specified parameters.
*
* \param baudrate Baudrate at which the UART should operate (in Hz).
* \param masterClock Frequency of the system master clock (in Hz).
*/
extern void UART_Configure( uint32_t baudrate, uint32_t masterClock)
{
const Pin pPins[] = {PINS_UART};
Uart *pUart = UART_UART;
/* Configure PIO */
PIO_Configure(pPins, PIO_LISTSIZE(pPins));
/* Configure PMC */
PMC->PMC_PCER0 = 1 << UART_ID;
/* 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;
/* 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;
_ucIsConsoleInitialized=1 ;
}
//------------------------------------------------------------------------------
/// Set the backlight of the LCD.
/// \param level Backlight brightness level [1..32], 32 is maximum level.
//------------------------------------------------------------------------------
void LCDD_SetBacklight (unsigned int level)
{
unsigned int i;
const Pin pPins[] = {BOARD_BACKLIGHT_PIN};
// 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);
// PIO_Clear(pPins);
// PIO_Clear(pPins);
// PIO_Clear(pPins);
}
// PIO_Set(pPins);
}
void StartUPInitKBD(void)
{
// PIO Init
AT91C_BASE_PMC->PMC_PCER = 1 << (AT91C_ID_PIOB);
//INPUT
//--PIOB_BASE->PIO_OER = LINES_MASK ;//* Defines the PIOs as output
AT91C_BASE_PIOB->PIO_ODR = (unsigned long)COLUMNS_MASK;//LINES_MASK;
AT91C_BASE_PIOB->PIO_CODR = (unsigned long)COLUMNS_MASK;
AT91C_BASE_PIOB->PIO_IFER = (unsigned long)COLUMNS_MASK;
//OUTPUT
// PIOB_BASE->PIO_ODR = COLUMNS_MASK;
AT91C_BASE_PIOB->PIO_OER = (unsigned long)LINES_MASK;//COLUMNS_MASK;
AT91C_BASE_PIOB->PIO_CODR = (unsigned long)LINES_MASK;//COLUMNS_MASK;
// PIO Init
AT91C_BASE_PIOB->PIO_IDR = (unsigned long)(LINES_MASK|COLUMNS_MASK);
AT91C_BASE_PIOB->PIO_MDDR = (unsigned long)(LINES_MASK|COLUMNS_MASK);
AT91C_BASE_PIOB->PIO_PER = (unsigned long)(LINES_MASK|COLUMNS_MASK);
AT91C_BASE_PIOB->PIO_SODR = (unsigned long)LINES_MASK;
PIO_Configure(pinsKbdAux, PIO_LISTSIZE(pinsKbdAux));
}
/**
* \brief Application entry point for ssc_dam_audio example.
*
* \return Unused (ANSI-C compatibility).
*/
int main( void )
{
uint16_t data = 0;
/* Disable watchdog */
WDT_Disable( WDT ) ;
/* Enable I and D cache */
SCB_EnableICache();
SCB_EnableDCache();
/* Output example information */
printf("-- SSC DMA Audio Example %s --\n\r", SOFTPACK_VERSION);
printf("-- %s\n\r", BOARD_NAME);
printf("-- Compiled: %s %s --\n\r", __DATE__, __TIME__);
/* Configure systick for 1 ms. */
printf( "Configure system tick to get 1ms tick period.\n\r" ) ;
if ( TimeTick_Configure( ) )
{
printf("-F- Systick configuration error\n\r" ) ;
}
/* Configure all pins */
PIO_Configure(pinsSsc, PIO_LISTSIZE(pinsSsc));
/* Configure SSC */
SSC_Configure(AUDIO_IF , 0 , SSC_MCK );
SSC_ConfigureReceiver(AUDIO_IF,I2S_SLAVE_RX_SETTING,I2S_SLAVE_RX_FRM_SETTING);
SSC_DisableReceiver(AUDIO_IF);
SSC_ConfigureTransmitter(AUDIO_IF,I2S_SLAVE_TX_SETTING,I2S_SLAVE_TX_FRM_SETTING);
SSC_DisableTransmitter(AUDIO_IF);
/* Configure DMA */
Dma_configure();
/* Configure and enable the TWI (required for accessing the DAC) */
PMC_EnablePeripheral(ID_TWIHS0);
TWI_ConfigureMaster(TWIHS0, TWI_CLOCK, BOARD_MCK);
TWID_Initialize(&twid, TWIHS0);
/* Configure TWI interrupts */
NVIC_ClearPendingIRQ(TWIHS0_IRQn);
NVIC_EnableIRQ(TWIHS0_IRQn);
/* check that WM8904 is present */
WM8904_Write(&twid, WM8904_SLAVE_ADDRESS, 22, 0);
data=WM8904_Read(&twid, WM8904_SLAVE_ADDRESS, 0);
if( data != 0x8904){
printf("WM8904 not found!\n\r");
while(1);
}
/* Initialize the audio DAC */
WM8904_Init(&twid, WM8904_SLAVE_ADDRESS, PMC_MCKR_CSS_SLOW_CLK);
/* Enable the DAC master clock */
PMC_ConfigurePCK2(PMC_MCKR_CSS_SLOW_CLK, PMC_MCKR_PRES_CLK_1 );
printf("Insert Line-in cable with PC Headphone output\n\r");
PlayRecording();
while ( 1 );
}
/**
* Initializes the DBGU Console
*
* \param dwBaudRate U(S)ART baudrate.
* \param dwMCk Master clock frequency.
*/
extern void TRACE_CONFIGURE( uint32_t dwBaudRate, uint32_t dwMCk )
{
const Pin pinsDBUG[] = { PINS_DBGU } ;
PIO_Configure( pinsDBUG, PIO_LISTSIZE( pinsDBUG ) ) ;
DBGU_Configure( dwBaudRate, dwMCk ) ;
}
/**
* Initializes the U(S)ART Console
*
* \param dwBaudRate U(S)ART baudrate.
* \param dwMCk Master clock frequency.
*/
extern void TRACE_CONFIGURE( uint32_t dwBaudRate, uint32_t dwMCk )
{
const Pin pinsUART0[] = { PINS_UART } ;
PIO_Configure( pinsUART0, PIO_LISTSIZE( pinsUART0 ) ) ;
UART_Configure( dwBaudRate, dwMCk ) ;
}
static void init(void) {
const Pin pinsDbgu[] = {PINS_DBGU};
PMC_EnablePeripheral(AT91C_ID_DBGU);
PIO_Configure(pinsDbgu, PIO_LISTSIZE(pinsDbgu));
DBGU_Configure(AT91C_US_PAR_NONE, 115200, BOARD_MCK);
SysTick_Configure(1, BOARD_MCK / 1000, SysTick_Handler);
}
/********************
Стартові налаштування периферії для ZigBee
********************/
void settings_for_ZigBee(void)
{
//Включаємо USART для роботи як прийомопередавач ZigBee
AT91C_BASE_PMC->PMC_PCER = (1 << AT91C_ID_US_ZIGBEE);
// Pin pPins_ZigBee_Tx[1] = {{1 << 4, AT91C_BASE_PIOB, AT91C_ID_PIOB, PIO_OUTPUT_0, PIO_DEFAULT}};
// Pin pPins_ZigBee_Rx[1] = {{1 << 5, AT91C_BASE_PIOB, AT91C_ID_PIOB, PIO_OUTPUT_0, PIO_DEFAULT}};
// PIO_Configure(pPins_ZigBee_Tx, PIO_LISTSIZE(pPins_ZigBee_Tx));
// PIO_Configure(pPins_ZigBee_Rx, PIO_LISTSIZE(pPins_ZigBee_Rx));
//
// while (test == 0)
// {
// PIO_Set(pPins_ZigBee_Tx);
// PIO_Set(pPins_ZigBee_Rx);
//
// PIO_Clear(pPins_ZigBee_Tx);
// PIO_Clear(pPins_ZigBee_Rx);
// }
//Настроюємо піни TXD, RXD ZigBee як периферію
Pin pPins_ZigBee[2] = {PIN_ZIGBEE_TXD, PIN_ZIGBEE_RXD};
PIO_Configure(pPins_ZigBee, PIO_LISTSIZE(pPins_ZigBee));
//Скидаємо обмін по PDC для USART0
AT91C_BASE_US_ZIGBEE->US_PTCR = AT91C_PDC_RXTDIS | AT91C_PDC_TXTDIS;
AT91C_BASE_US_ZIGBEE->US_TCR = 0;
AT91C_BASE_US_ZIGBEE->US_TNCR = 0;
AT91C_BASE_US_ZIGBEE->US_RCR = 0;
AT91C_BASE_US_ZIGBEE->US_RNCR = 0;
//Відключаємо генерацію переривань від USART ZigBee
AT91C_BASE_AIC->AIC_IDCR = 1 << AT91C_ID_US_ZIGBEE;
//Забороняємо генерацію переривань від USART ZigBee
AT91C_BASE_US_ZIGBEE->US_IDR = 0xffffffff;
//Конфігуруємо USART ZigBee
USART_Configure(AT91C_BASE_US_ZIGBEE,
((AT91C_US_USMODE & AT91C_US_USMODE_NORMAL)
|(AT91C_US_CLKS & AT91C_US_CLKS_CLOCK)
|(AT91C_US_CHRL & AT91C_US_CHRL_8_BITS)
|(AT91C_US_PAR & PARE_ZIGBEE)
|(AT91C_US_NBSTOP & STOP_BITS_ZIGBEE)
/*| AT91C_US_OVER*/),
SPEED_ZIGBEE,
BOARD_MCK);
// //Дозволяємо передавач і приймач
AT91C_BASE_US_ZIGBEE->US_CR = AT91C_US_TXEN | AT91C_US_RXEN;
//Дозволяємо передавач
AT91C_BASE_US_ZIGBEE->US_CR = AT91C_US_TXEN;
//Дозволяємо приймач
AT91C_BASE_US_ZIGBEE->US_CR = AT91C_US_RXEN;
//Запиуск очікування нового фрейиму
restart_monitoring_ZigBee();
}
void initadc(int autos)
{
// printf("-- Basic ADC Project %s --\n\r", SOFTPACK_VERSION);
// printf("-- %s\n\r", BOARD_NAME);
// printf("-- Compiled: %s %s --\n\r", __DATE__, __TIME__);
if(autos)
autosample=1;
#ifdef PINS_ADC
PIO_Configure(pinsADC, PIO_LISTSIZE(pinsADC));
#endif
ADC12_Initialize( AT91C_BASE_ADC,
AT91C_ID_ADC,
AT91C_ADC_TRGEN_DIS,
0,
AT91C_ADC_SLEEP_NORMAL_MODE,
AT91C_ADC_LOWRES_12_BIT,
BOARD_MCK,
BOARD_ADC_FREQ,
10,
1200);
//int i;
/* for(i=0;i<7;i++)
if ((1<<chns[i]) & enchan)
ADC12_EnableChannel(AT91C_BASE_ADC, chns[i]);
*/
ADC12_EnableChannel(AT91C_BASE_ADC, ADC_NUM_1);
ADC12_EnableChannel(AT91C_BASE_ADC, ADC_NUM_2);
ADC12_EnableChannel(AT91C_BASE_ADC, ADC_NUM_3);
// ADC12_EnableChannel(AT91C_BASE_ADC, ADC_NUM_4);
ADC12_EnableChannel(AT91C_BASE_ADC, ADC_NUM_5);
// ADC12_EnableChannel(AT91C_BASE_ADC, ADC_NUM_6);
// ADC12_EnableChannel(AT91C_BASE_ADC, ADC_NUM_7);
IRQ_ConfigureIT(AT91C_ID_ADC, ADCC0_IRQ_PRIORITY, ADCC0_IrqHandler);
IRQ_EnableIT(AT91C_ID_ADC);
ADC12_EnableIt(AT91C_BASE_ADC, 1<<ADC_NUM_1);
ADC12_EnableIt(AT91C_BASE_ADC, 1<<ADC_NUM_2);
ADC12_EnableIt(AT91C_BASE_ADC, 1<<ADC_NUM_3);
// ADC12_EnableIt(AT91C_BASE_ADC, 1<<ADC_NUM_4);
ADC12_EnableIt(AT91C_BASE_ADC, 1<<ADC_NUM_5);
// ADC12_EnableIt(AT91C_BASE_ADC, 1<<ADC_NUM_6);
// ADC12_EnableIt(AT91C_BASE_ADC, 1<<ADC_NUM_7);
/*
for(i=0;i<7;i++)
if ((1<<chns[i]) & enchan)
ADC12_EnableIt(AT91C_BASE_ADC, 1<<chns[i]);
*/
conversionDone=0;
ADC12_StartConversion(AT91C_BASE_ADC);
//printf("adc init done\n");
}
static void prvSetupHardware( void )
{
const Pin xPins[] = { PIN_USART0_RXD, PIN_USART0_TXD };
/* Setup the LED outputs. */
vParTestInitialise();
/* Setup the pins for the UART. */
PIO_Configure( xPins, PIO_LISTSIZE( xPins ) );
}
//------------------------------------------------------------------------------
/// Configure the PIO for SD
//------------------------------------------------------------------------------
static void ConfigurePIO(unsigned char mciID)
{
#ifdef BOARD_SD_PINS
const Pin pinSd0[] = {BOARD_SD_PINS};
#endif
#ifdef BOARD_SD_MCI1_PINS
const Pin pinSd1[] = {BOARD_SD_MCI1_PINS};
#endif
if(mciID == 0) {
#ifdef BOARD_SD_PINS
PIO_Configure(pinSd0, PIO_LISTSIZE(pinSd0));
#endif
} else {
#ifdef BOARD_SD_MCI1_PINS
PIO_Configure(pinSd1, PIO_LISTSIZE(pinSd1));
#endif
}
}
u32 platform_uart_setup( unsigned id, u32 baud, int databits, int parity, int stopbits )
{
unsigned int mode;
AT91S_USART* base = id == 0 ? AT91C_BASE_US0 : AT91C_BASE_US1;
// Setup mode
mode = AT91C_US_USMODE_NORMAL | AT91C_US_CHMODE_NORMAL | AT91C_US_CLKS_CLOCK;
switch( databits )
{
case 5:
mode |= AT91C_US_CHRL_5_BITS;
break;
case 6:
mode |= AT91C_US_CHRL_6_BITS;
break;
case 7:
mode |= AT91C_US_CHRL_7_BITS;
break;
case 8:
mode |= AT91C_US_CHRL_8_BITS;
break;
}
if( parity == PLATFORM_UART_PARITY_EVEN )
mode |= AT91C_US_PAR_EVEN;
else if( parity == PLATFORM_UART_PARITY_ODD )
mode |= AT91C_US_PAR_ODD;
else if( parity == PLATFORM_UART_PARITY_MARK )
mode |= AT91C_US_PAR_MARK;
else if( parity == PLATFORM_UART_PARITY_SPACE )
mode |= AT91C_US_PAR_SPACE;
else
mode |= AT91C_US_PAR_NONE;
if( stopbits == PLATFORM_UART_STOPBITS_1 )
mode |= AT91C_US_NBSTOP_1_BIT;
else if( stopbits == PLATFORM_UART_STOPBITS_1_5 )
mode |= AT91C_US_NBSTOP_15_BIT;
else
mode |= AT91C_US_NBSTOP_2_BIT;
// Configure pins
PIO_Configure(platform_uart_pins[ id ], PIO_LISTSIZE(platform_uart_pins[ id ]));
// Configure the USART in the desired mode @115200 bauds
baud = USART_Configure( base, mode, baud, BOARD_MCK );
// Enable receiver & transmitter
USART_SetTransmitterEnabled(base, 1);
USART_SetReceiverEnabled(base, 1);
// Return actual baud
return baud;
}
