//------------------------------------------------------------------------------
// Global Functions
//------------------------------------------------------------------------------
void debug_init(char *software_name){
TRACE_CONFIGURE(DBGU_STANDARD, DEBUG_SPEED, BOARD_MCK);
//printf("-- Mariokart - %s Board %s --\n\r", SOFTWARE_NAME, SOFTPACK_VERSION);
printf("-- Mariokart - %s Board %s --\n\r", software_name, SOFTPACK_VERSION);
printf("-- %s\n\r", BOARD_NAME);
printf("-- Compiled: %s %s --\n\r", __DATE__, __TIME__);
}
int main(void)
{
/// Init DBGU
TRACE_CONFIGURE(DBGU_STANDARD, 115200, BOARD_MCK);
printf("-- %s: blink-interrupt Project with at91lib v%s --\n\r", BOARD_NAME, SOFTPACK_VERSION);
printf("-- Compiled: %s %s --\n\r", __DATE__, __TIME__);
/// Init PIOA & PIOB interrupt
PIO_InitializeInterrupts(0);
/// Init LED
PIO_Configure(&pinLed, 1);
TRACE_INFO("LED:\n\r");
/// Configure and enable the interrupt
PIO_ConfigureIt(&pinButton, (void (*)(const Pin *)) User_InterruptHandler);
PIO_EnableIt(&pinButton);
while (1)
{
PIO_Set(&pinLed);
delay(1000);
PIO_Clear(&pinLed);
delay(1000);
}
}
int main (void) {
TRACE_CONFIGURE(TRACE_DBGU, 115200, BOARD_MCK);
TRACE_INFO("entered main\n\n\n");
xTaskCreate(fib_task_func, (signed portCHAR *)"fibt", 400,
NULL, 1, &fib_task_handle);
xTaskCreate(rad_task_func, (signed portCHAR *)"radt", 400,
NULL, 1, &rad_task_handle);
vTaskStartScheduler();
}
//------------------------------------------------------------------------------
/// 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;
}
void main(void)
{
unsigned int channel = CHANNEL;
unsigned char data = 0x07;
// DBGU output configuration
TRACE_CONFIGURE(DBGU_STANDARD, 115200, BOARD_MCK);
// Configuration PIT (Periodic Interrupt Timer)
ConfigurePit();
// Configuration TC (Timer Counter)
ConfigureTc();
// Configuration PIO (Paralell In and Out port), Init Interrupt on PIO
ConfigureButtons();
ConfigureLeds();
// Configuration Radio Module nRF24L (PIO and SPI), ConfigureButtons must be executed before
ConfigureNRF24L();
ConfigureUSART0();
ConfigureUSART1();
//initialize proximity sensor
ir_init();
Global_Variable_Init();
while(Timer0Tick<2); // wait until NRF24L01 power up
nrf24l01_power_up(True);
while(Timer0Tick<4); // wait until NRF24L01 stand by
Timer0Tick = 0;
//initialize the 24L01 to the debug configuration as RX and auto-ack disabled
nrf24l01_initialize_debug(True, nrf_TX_RX_SIZE, False);
nrf24l01_write_register(0x06, &data, 1);
nrf24l01_set_as_rx(True);
Delay_US(130);
nrf24l01_set_rf_ch(channel);
nrf24l01_flush_rx();
Delay_US(300);
while (1) {
if(Timer0Tick!=0){
Timer0Tick = 0;
Check_Battery(0);
odometry(0);
ProxRead_m();
Send_Coord();
Delay_US(10000);//give time for the coming message
feedbackController(goalx, goaly, goaldist);
}
Check_Wireless();
}//while
}//main
void SLCK_UtilSetSlowClockMode(unsigned int timeInSlowClockMode)
{
unsigned int oldPll;
unsigned int oldMck;
unsigned int timeout = 0;
// Save previous values for PLL A and Master Clock configuration
oldPll = AT91C_BASE_CKGR->CKGR_PLLAR;
oldMck = AT91C_BASE_PMC->PMC_MCKR;
// Slow clock is selected for Master Clock
// 32kKz / 64 = 500Hz
// PCK = 500Hz, MCK = 500 Hz
AT91C_BASE_PMC->PMC_MCKR = (oldMck & AT91C_PMC_PRES) | AT91C_PMC_CSS_SLOW_CLK;
timeout = 0;
while ( !(AT91C_BASE_PMC->PMC_SR & AT91C_PMC_MCKRDY) && timeout++ < CLOCK_TIMEOUT);
// Stop PLL A
// MULA: PLL A Multiplier 0 = The PLL A is deactivated.
AT91C_BASE_CKGR->CKGR_PLLAR = 0x00003f00;
// Stop Main Oscillator
AT91C_BASE_CKGR->CKGR_MOR = AT91C_BASE_CKGR->CKGR_MOR & (~AT91C_CKGR_MOSCXTEN);
// Wait a while. The clock is at 500Hz...
while( timeInSlowClockMode-- );
// End !
// Restart Main Oscillator
AT91C_BASE_CKGR->CKGR_MOR = AT91C_BASE_CKGR->CKGR_MOR | (AT91C_CKGR_MOSCXTST & (0x32<<8) );
AT91C_BASE_CKGR->CKGR_MOR = AT91C_BASE_CKGR->CKGR_MOR | (AT91C_CKGR_MOSCXTEN);
// Restart PLL A
AT91C_BASE_CKGR->CKGR_PLLAR = oldPll;
timeout = 0;
while( !(AT91C_BASE_PMC->PMC_SR & AT91C_PMC_LOCKA) && timeout++ < CLOCK_TIMEOUT);
// Selection of Master Clock MCK (so Processor Clock PCK)
AT91C_BASE_PMC->PMC_MCKR = oldMck;
timeout = 0;
while( !(AT91C_BASE_PMC->PMC_SR & AT91C_PMC_MCKRDY) && timeout++ < CLOCK_TIMEOUT);
// Reconfigure DBGU
TRACE_CONFIGURE(DBGU_STANDARD, 115200, BOARD_MCK);
}
//------------------------------------------------------------------------------
/// Power configuration
//------------------------------------------------------------------------------
static unsigned char configure_AT73C224(void)
{
unsigned char buff;
TRACE_CONFIGURE(DBGU_STANDARD, 115200, BOARD_MCK);
//TRACE_INFO("configure_AT73C224\n\r");
BOARD_AT73C224_initialize();
// Check that we are communicating with the good device
BOARD_AT73C224_Read(&buff, 0x01, AT73C223_SLAVEADDRESS_U4);
//TRACE_INFO("device adresse = 0x%X\n\r", buff);
if(buff != 0x48) {
TRACE_ERROR("Wrong device adressed\n\r");
return 0;
}
// Check that the BUCK default voltage is 0x09 (1.8V)
BOARD_AT73C224_Read(&buff, 0x15, AT73C223_SLAVEADDRESS_U4); // BCK_VOLT : 0x15 ;
//TRACE_INFO("BCK_VOLT = 0x%X\n\r", buff);
if(buff != 0x09) {
TRACE_ERROR("Wrong default output voltage\r\n");
return 0;
}
// Check that the BUCK converter is started
BOARD_AT73C224_Read(&buff, 0x13, AT73C223_SLAVEADDRESS_U4); // BCK_CTRL : 0x13 ;
//TRACE_INFO("BCK_CTRL = 0x%X\n\r", buff);
if(buff != 0x01) {
TRACE_ERROR("BUCK converter is started\n\r");
return 0;
}
// Check that all interrupts are masked
BOARD_AT73C224_Read(&buff, 0x32, AT73C223_SLAVEADDRESS_U4); // IRQ_MSK : 0x32 ;
//TRACE_INFO("IRQ_MSK = 0x%X\n\r", buff);
if(buff != 0x00) {
TRACE_ERROR("not all interrupts are masked\n\r");
return 0;
}
// Check that the boost output voltage is configured in 5V mode
BOARD_AT73C224_Read(&buff, 0x12, AT73C223_SLAVEADDRESS_U4); // BST_VOLT : 0x12 ;
//TRACE_INFO("BST_VOLT = 0x%X\n\r", buff);
// resut: BST_VOLT = 0x28
// Check that the current limitation is not too low
BOARD_AT73C224_Read(&buff, 0x11, AT73C223_SLAVEADDRESS_U4); // BST_CFG : 0x11 ;
//TRACE_INFO("BST_CFG = 0x%X\n\r", buff);
// result: BST_CFG = 0x1B
if(buff < 0x01) {
TRACE_ERROR("Too low current limitation\n\r");
return 0;
}
// Setting the ramp for optimal operation for the application CAP
BOARD_AT73C224_Write(0x40, 0x72, AT73C223_SLAVEADDRESS_U4); // RTRIM : 0x72 ;
// 0x0B @ 0x11 : on 2 chips
BOARD_AT73C224_Write(0x0B, 0x11, AT73C223_SLAVEADDRESS_U4);
BOARD_AT73C224_Write(0x0B, 0x11, AT73C223_SLAVEADDRESS_U5);
// Passage of Buck in PWM mode
// Write 0xD8 @ 0x14
BOARD_AT73C224_Write(0xD8, 0x14, AT73C223_SLAVEADDRESS_U4);
// Setting the ramp for optimal operation for the application CAP
BOARD_AT73C224_Write(0x40, 0x72, AT73C223_SLAVEADDRESS_U5); // RTRIM : 0x72 ;
// Passage of Buck in PWM mode
// Write 0xD8 @ 0x14
BOARD_AT73C224_Write(0xD8, 0x14, AT73C223_SLAVEADDRESS_U5);
// Init for USB Host
/*
// At the start-up, it is recommended to put 1Amp over current threshold
// in order not to generate a reset of the product.
BOARD_AT73C224_Write(0x01, 0x11, AT73C223_SLAVEADDRESS_U4);
// setting VBOOST = 5V
BOARD_AT73C224_Write(0x28, 0x12, AT73C223_SLAVEADDRESS_U4);
// Start VBOOST
BOARD_AT73C224_Write(0x01, 0x10, AT73C223_SLAVEADDRESS_U4);
// put 6Amp over current threshold.
BOARD_AT73C224_Write(0x0B, 0x11, AT73C223_SLAVEADDRESS_U4);
*/
return 1;
}
//------------------------------------------------------------------------------
/// Initializes drivers and start the USB <-> Serial bridge.
//------------------------------------------------------------------------------
int main()
{
TRACE_CONFIGURE(DBGU_STANDARD, 115200, BOARD_MCK);
TRACE_INFO("-- USB Device CDC Serial Project %s --\n\r", SOFTPACK_VERSION);
TRACE_INFO("-- %s\n\r", BOARD_NAME);
TRACE_INFO("-- Compiled: %s %s --\n\r", __DATE__, __TIME__);
// If they are present, configure Vbus & Wake-up pins
PIO_InitializeInterrupts(0);
// Configure USART
PIO_Configure(pins, PIO_LISTSIZE(pins));
AT91C_BASE_PMC->PMC_PCER = 1 << AT91C_ID_US0;
AT91C_BASE_US0->US_IDR = 0xFFFFFFFF;
USART_Configure(AT91C_BASE_US0,
USART_MODE_ASYNCHRONOUS,
115200,
BOARD_MCK);
USART_SetTransmitterEnabled(AT91C_BASE_US0, 1);
USART_SetReceiverEnabled(AT91C_BASE_US0, 1);
AIC_ConfigureIT(AT91C_ID_US0, 0, ISR_Usart0);
AIC_EnableIT(AT91C_ID_US0);
// Configure timer 0
AT91C_BASE_PMC->PMC_PCER = (1 << AT91C_ID_TC0);
AT91C_BASE_TC0->TC_CCR = AT91C_TC_CLKDIS;
AT91C_BASE_TC0->TC_IDR = 0xFFFFFFFF;
AT91C_BASE_TC0->TC_CMR = AT91C_TC_CLKS_TIMER_DIV5_CLOCK
| AT91C_TC_CPCSTOP
| AT91C_TC_CPCDIS
| AT91C_TC_WAVESEL_UP_AUTO
| AT91C_TC_WAVE;
AT91C_BASE_TC0->TC_RC = 0x00FF;
AT91C_BASE_TC0->TC_IER = AT91C_TC_CPCS;
AIC_ConfigureIT(AT91C_ID_TC0, 0, ISR_Timer0);
AIC_EnableIT(AT91C_ID_TC0);
// BOT driver initialization
CDCDSerialDriver_Initialize();
// connect if needed
VBus_Configure();
// Driver loop
while (1) {
// Device is not configured
if (USBD_GetState() < USBD_STATE_CONFIGURED) {
// Connect pull-up, wait for configuration
USBD_Connect();
while (USBD_GetState() < USBD_STATE_CONFIGURED);
// Start receiving data on the USART
usartCurrentBuffer = 0;
USART_ReadBuffer(AT91C_BASE_US0, usartBuffers[0], DATABUFFERSIZE);
USART_ReadBuffer(AT91C_BASE_US0, usartBuffers[1], DATABUFFERSIZE);
AT91C_BASE_US0->US_IER = AT91C_US_ENDRX
| AT91C_US_FRAME
| AT91C_US_OVER;
AT91C_BASE_TC0->TC_CCR = AT91C_TC_CLKEN | AT91C_TC_SWTRG;
// Start receiving data on the USB
CDCDSerialDriver_Read(usbBuffer,
DATABUFFERSIZE,
(TransferCallback) UsbDataReceived,
0);
}
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;
}
}
}
//------------------------------------------------------------------------------
/// Main function
//------------------------------------------------------------------------------
int main(void)
{
unsigned char key;
unsigned char isValid;
// Configure all pins
PIO_Configure(pins, PIO_LISTSIZE(pins));
LED_Configure(0);
LED_Set(0);
LED_Configure(1);
LED_Set(1);
// Initialize the DBGU
TRACE_CONFIGURE(DBGU_STANDARD, 115200, BOARD_MCK);
// Switch to Main clock
AT91C_BASE_PMC->PMC_MCKR = (AT91C_BASE_PMC->PMC_MCKR & ~AT91C_PMC_CSS) | AT91C_PMC_CSS_MAIN_CLK;
while ((AT91C_BASE_PMC->PMC_SR & AT91C_PMC_MCKRDY) == 0);
// Configure PLL to 98.285MHz
*AT91C_CKGR_PLLR = ((1 << 29) | (171 << AT91C_CKGR_MUL_SHIFT) \
| (0x0 << AT91C_CKGR_OUT_SHIFT) |(0x3f << AT91C_CKGR_PLLCOUNT_SHIFT) \
| (21 << AT91C_CKGR_DIV_SHIFT));
while ((AT91C_BASE_PMC->PMC_SR & AT91C_PMC_LOCK) == 0);
// Configure master clock in two operations
AT91C_BASE_PMC->PMC_MCKR = (( AT91C_PMC_PRES_CLK_2 | AT91C_PMC_CSS_PLLA_CLK) & ~AT91C_PMC_CSS) | AT91C_PMC_CSS_MAIN_CLK;
while ((AT91C_BASE_PMC->PMC_SR & AT91C_PMC_MCKRDY) == 0);
AT91C_BASE_PMC->PMC_MCKR = ( AT91C_PMC_PRES_CLK_2 | AT91C_PMC_CSS_PLLA_CLK);
while ((AT91C_BASE_PMC->PMC_SR & AT91C_PMC_MCKRDY) == 0);
// DBGU reconfiguration
DBGU_Configure(DBGU_STANDARD, 115200, SSC_MCK);
// Configure and enable the TWI (required for accessing the DAC)
*AT91C_PMC_PCER = (1<< AT91C_ID_TWI0);
TWI_ConfigureMaster(AT91C_BASE_TWI0, TWI_CLOCK, SSC_MCK);
TWID_Initialize(&twid, AT91C_BASE_TWI0);
printf("-- OsmoSDR firmware (" BOARD_NAME ") " GIT_REVISION " --\n\r");
printf("-- Compiled: %s %s --\n\r", __DATE__, __TIME__);
req_ctx_init();
PIO_InitializeInterrupts(0);
cmd_state.out = vprintf;
uart_cmd_reset(&cmd_state);
uart_cmds_register(cmds, sizeof(cmds)/sizeof(cmds[0]));
fastsource_init();
VBus_Configure();
power_peripherals(1);
si570_init(&si570, &twid, SI570_I2C_ADDR);
set_si570_freq(30000000);
sam3u_e4k_init(&e4k, &twid, E4K_I2C_ADDR);
e4k.vco.fosc = 30000000;
osdr_fpga_init(SSC_MCK);
//osdr_fpga_reg_write(OSDR_FPGA_REG_ADC_TIMING, (1 << 8) | 255);
//osdr_fpga_reg_write(OSDR_FPGA_REG_PWM1, (1 << 400) | 800);
osdr_fpga_set_iq_swap(0);
ssc_init();
e4k_init(&e4k);
e4k_init(&e4k);
// Enter menu loop
while (1) {
if (DBGU_IsRxReady()) {
key = DBGU_GetChar();
// Process user input
if (uart_cmd_char(&cmd_state, key) == 1) {
//ssc_stats();
}
}
ssc_dma_start();
fastsource_start();
}
}
int main(void)
{
unsigned char bmButtons = 0;
TRACE_CONFIGURE(DBGU_STANDARD, 115200, BOARD_MCK);
printf("-- USB Device HID Mouse Project %s --\n\r", SOFTPACK_VERSION);
printf("-- %s\n\r", BOARD_NAME);
printf("-- Compiled: %s %s --\n\r", __DATE__, __TIME__);
// SPP +
int i;
button_flag = 0;
//Enable RESET
m_pRSTC->RSTC_RCR = 0xA5000008;
m_pRSTC->RSTC_RMR = 0xA5000001;
Delay(1000);
// Init USB device
//AT91F_USB_Open();
// Configure the RTT:
*AT91C_RTTC_RTMR = BUTTON_SAMPLING;
// Set in PIO mode and Configure in Input
//AT91F_PIOA_CfgPMC();
// InitMAM
InitMMA();
// InitADC
ADCInit();
// UART0 Init
InitUSART0();
// Stat led
s_pPio->PIO_PER = BIT31;
// Configure PA31 as output
s_pPio->PIO_OER = BIT31;
// Set PA31 to HIGH
s_pPio->PIO_SODR = BIT31;
// Test flash
if(TestFlash())
{
for(i=0; i<20; i++)
{
s_pPio->PIO_CODR = BIT31; Delay(150000);
s_pPio->PIO_SODR = BIT31; Delay(150000);
}
}
// Button
// Configure P20 as input
s_pPio->PIO_ODR = BIT20;
// Enable
s_pPio->PIO_PER = BIT20;
Delay(1000);
// CALIBRATE WHEN BUTT IS PRESS
// while((s_pPio->PIO_PDSR&BIT20)==BIT20);
Delay(1000);
// SPP -
// If they are present, configure Vbus & Wake-up pins
PIO_InitializeInterrupts(0);
WAKEUP_CONFIGURE();
// 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
// Initialize key statuses and configure push buttons
#if defined(at91cap9dk)
const Pin pinRow0 = PIN_KEYBOARD_ROW0;
PIO_Configure(&pinRow0, 1);
#endif
PIO_Configure(pinsJoystick, PIO_LISTSIZE(pinsJoystick));
// HID driver initialization
HIDDMouseDriver_Initialize();
// connect if needed
VBUS_CONFIGURE();
// Infinite loop
while (1)
{
// SPP +
#define TIMEOUT 100
static int Timeout = TIMEOUT;
GetCoordinates();
base_y = Coordinates[0]/NSAMPLE;
base_x = Coordinates[1]/NSAMPLE;
base_z = Coordinates[2]/NSAMPLE;
// SPP -
if( USBState == STATE_SUSPEND )
{
TRACE_DEBUG("suspend !\n\r");
USBState = STATE_IDLE;
LowPowerMode();
}
if( USBState == STATE_RESUME )
{
// Return in normal MODE
NormalPowerMode();
USBState = STATE_IDLE;
TRACE_DEBUG("resume !\n\r");
}
if (USBD_GetState() < USBD_STATE_CONFIGURED)
continue;
if (!Timeout)
{
unsigned char status;
do
{
status = HIDDMouseDriver_ChangePoints(bmButtons, base_x, base_y);
}
while (status != USBD_STATUS_SUCCESS);
Timeout = TIMEOUT;
}
else
Timeout--;
}
}
//------------------------------------------------------------------------------
/// Application entry point. Configures the DBGU, PIT, TC0, LEDs and buttons
/// and makes LED\#1 blink in its infinite loop, using the Wait function.
/// \return Unused (ANSI-C compatibility).
//------------------------------------------------------------------------------
int main(void)
{
// DBGU configuration
TRACE_CONFIGURE(DBGU_STANDARD, 115200, BOARD_MCK);
TRACE_INFO_WP("\n\r");
TRACE_INFO("Getting new Started Project --\n\r");
TRACE_INFO("%s\n\r", BOARD_NAME);
TRACE_INFO("Compiled: %s %s --\n\r", __DATE__, __TIME__);
//Configure Reset Controller
AT91C_BASE_RSTC->RSTC_RMR= 0xa5<<24;
// Configure EMAC PINS
PIO_Configure(emacRstPins, PIO_LISTSIZE(emacRstPins));
// Execute reset
RSTC_SetExtResetLength(0xd);
RSTC_ExtReset();
// Wait for end hardware reset
while (!RSTC_GetNrstLevel());
TRACE_INFO("init Flash\n\r");
flash_init();
TRACE_INFO("init Timer\n\r");
// Configure timer 0
ticks=0;
extern void ISR_Timer0();
AT91C_BASE_PMC->PMC_PCER = (1 << AT91C_ID_TC0);
AT91C_BASE_TC0->TC_CCR = AT91C_TC_CLKDIS;
AT91C_BASE_TC0->TC_IDR = 0xFFFFFFFF;
AT91C_BASE_TC0->TC_SR;
AT91C_BASE_TC0->TC_CMR = AT91C_TC_CLKS_TIMER_DIV5_CLOCK | AT91C_TC_CPCTRG;
AT91C_BASE_TC0->TC_RC = 375;
AT91C_BASE_TC0->TC_IER = AT91C_TC_CPCS;
AIC_ConfigureIT(AT91C_ID_TC0, AT91C_AIC_PRIOR_LOWEST, ISR_Timer0);
AIC_EnableIT(AT91C_ID_TC0);
AT91C_BASE_TC0->TC_CCR = AT91C_TC_CLKEN | AT91C_TC_SWTRG;
// Configure timer 1
extern void ISR_Timer1();
AT91C_BASE_PMC->PMC_PCER = (1 << AT91C_ID_TC1);
AT91C_BASE_TC1->TC_CCR = AT91C_TC_CLKDIS; //Stop clock
AT91C_BASE_TC1->TC_IDR = 0xFFFFFFFF; //Disable Interrupts
AT91C_BASE_TC1->TC_SR; //Read Status register
AT91C_BASE_TC1->TC_CMR = AT91C_TC_CLKS_TIMER_DIV4_CLOCK | AT91C_TC_CPCTRG; // Timer1: 2,666us = 48MHz/128
AT91C_BASE_TC1->TC_RC = 0xffff;
AT91C_BASE_TC1->TC_IER = AT91C_TC_CPCS;
AIC_ConfigureIT(AT91C_ID_TC1, 1, ISR_Timer1);
AT91C_BASE_TC1->TC_CCR = AT91C_TC_CLKEN | AT91C_TC_SWTRG;
led_init();
TRACE_INFO("init EEprom\n\r");
eeprom_init();
rb_reset(&TTY_Rx_Buffer);
rb_reset(&TTY_Tx_Buffer);
input_handle_func = analyze_ttydata;
LED_OFF();
LED2_OFF();
LED3_OFF();
spi_init();
fht_init();
tx_init();
#ifdef HAS_ETHERNET
ethernet_init();
#endif
TRACE_INFO("init USB\n\r");
CDCDSerialDriver_Initialize();
USBD_Connect();
wdt_enable(WDTO_2S);
fastrf_on=0;
display_channel = DISPLAY_USB;
TRACE_INFO("init Complete\n\r");
checkFrequency();
// Main loop
while (1) {
CDC_Task();
Minute_Task();
RfAnalyze_Task();
#ifdef HAS_FASTRF
FastRF_Task();
#endif
#ifdef HAS_RF_ROUTER
rf_router_task();
#endif
#ifdef HAS_ASKSIN
rf_asksin_task();
#endif
#ifdef HAS_MORITZ
rf_moritz_task();
#endif
#ifdef HAS_RWE
rf_rwe_task();
#endif
#ifdef HAS_MBUS
rf_mbus_task();
#endif
#ifdef HAS_MAICO
rf_maico_task();
#endif
#ifdef HAS_ETHERNET
Ethernet_Task();
#endif
#ifdef DBGU_UNIT_IN
if(DBGU_IsRxReady()){
unsigned char volatile * const ram = (unsigned char *) AT91C_ISRAM;
unsigned char x;
x=DBGU_GetChar();
switch(x) {
case 'd':
puts("USB disconnect\n\r");
USBD_Disconnect();
break;
case 'c':
USBD_Connect();
puts("USB Connect\n\r");
break;
case 'r':
//Configure Reset Controller
AT91C_BASE_RSTC->RSTC_RMR=AT91C_RSTC_URSTEN | 0xa5<<24;
break;
case 'S':
USBD_Disconnect();
my_delay_ms(250);
my_delay_ms(250);
//Reset
*ram = 0xaa;
AT91C_BASE_RSTC->RSTC_RCR = AT91C_RSTC_PROCRST | AT91C_RSTC_PERRST | AT91C_RSTC_EXTRST | 0xA5<<24;
while (1);
break;
default:
rb_put(&TTY_Tx_Buffer, x);
}
}
#endif
if (USBD_GetState() == USBD_STATE_CONFIGURED) {
if( USBState == STATE_IDLE ) {
CDCDSerialDriver_Read(usbBuffer,
DATABUFFERSIZE,
(TransferCallback) UsbDataReceived,
0);
LED3_ON();
USBState=STATE_RX;
}
}
if( USBState == STATE_SUSPEND ) {
TRACE_INFO("suspend !\n\r");
USBState = STATE_IDLE;
}
if( USBState == STATE_RESUME ) {
TRACE_INFO("resume !\n\r");
USBState = STATE_IDLE;
}
}
}
int main()
{
TRACE_CONFIGURE(DBGU_STANDARD, 115200, BOARD_MCK);
printf("-- USB Device CDC Serial 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);
//-------- Init parameters --------------
printf("INIT Parameters\n\r");
init_parameters();
//-------- Load parameters from Flash --------------
printf("Load parameters from Flash\n\r");
FLASH_LoadSettings();
//-------- Init UART --------------
printf("USB Seriel INIT\n\r");
samserial_init();
//-------- Init ADC without Autostart --------------
printf("Init ADC\n\r");
initadc(0);
//-------- On USB recived byte call this function --------------
printf("Init Callback for USB\n\r");
samserial_setcallback(&usb_characterhandler);
//-------- Init Motor driver --------------
printf("Init Motors\n\r");
motor_setup();
//-------- Init Heater I/O --------------
printf("Init Heaters\n\r");
heaters_setup();
//-------- Start SYSTICK (1ms) --------------
printf("Configuring systick.\n\r");
SysTick_Configure(1, BOARD_MCK/1000, SysTick_Handler);
//-------- Timer 0 for Stepper --------------
printf("Init Stepper IO\n\r");
stepper_setup(); //Timer for Stepper
//-------- Timer 0 for Stepper --------------
printf("Configuring Timer 0 Stepper\n\r");
ConfigureTc0_Stepper(); //Timer for Stepper
//-------- Timer 1 for heater PWM --------------
printf("Configuring Timer 1 PWM.\n\r");
ConfigureTc_1();
//-------- Init Planner Values --------------
printf("Plan Init\n\r");
plan_init();
//-------- Check for SD card presence -------
// sdcard_handle_state();
//motor_enaxis(0,1);
//motor_enaxis(1,1);
while (1)
{
//uncomment to use//sprinter_mainloop();
//main loop events go here
do_periodic();
if(buflen < (BUFSIZE-1))
get_command();
if(buflen > 0)
{
//-------- Check and execute G-CODE --------------
process_commands();
//-------- Increment G-Code FIFO --------------
buflen = (buflen-1);
bufindr++;
if(bufindr == BUFSIZE) bufindr = 0;
}
}
}
//------------------------------------------------------------------------------
/// Performs the low-level initialization of the chip. This includes EFC, master
/// clock, AIC & watchdog configuration, as well as memory remapping.
//------------------------------------------------------------------------------
void LowLevelInit( void )
{
unsigned char i;
// Set flash wait states in the EFC
// 48MHz = 1 wait state
AT91C_BASE_EFC0->EFC_FMR = AT91C_MC_FWS_1FWS;
AT91C_BASE_EFC1->EFC_FMR = AT91C_MC_FWS_1FWS;
// Initialize main oscillator
AT91C_BASE_PMC->PMC_MOR = BOARD_OSCOUNT | AT91C_CKGR_MOSCEN;
while (!(AT91C_BASE_PMC->PMC_SR & AT91C_PMC_MOSCS));
// Initialize PLL at 96MHz and USB clock to 48MHz
AT91C_BASE_PMC->PMC_PLLR = BOARD_USBDIV | BOARD_CKGR_PLL | BOARD_PLLCOUNT
| BOARD_MUL | BOARD_DIV;
while (!(AT91C_BASE_PMC->PMC_SR & AT91C_PMC_LOCK));
// Wait for the master clock if it was already initialized
while (!(AT91C_BASE_PMC->PMC_SR & AT91C_PMC_MCKRDY));
// Switch to slow clock + prescaler
AT91C_BASE_PMC->PMC_MCKR = BOARD_PRESCALER;
while (!(AT91C_BASE_PMC->PMC_SR & AT91C_PMC_MCKRDY));
// Switch to fast clock + prescaler
AT91C_BASE_PMC->PMC_MCKR |= AT91C_PMC_CSS_PLL_CLK;
while (!(AT91C_BASE_PMC->PMC_SR & AT91C_PMC_MCKRDY));
// Initialize AIC
AT91C_BASE_AIC->AIC_IDCR = 0xFFFFFFFF;
// set a handler for each possible irq source
AT91C_BASE_AIC->AIC_SVR[0] = (unsigned int) defaultFiqHandler;
for (i = 1; i < 31; i++) {
AT91C_BASE_AIC->AIC_SVR[i] = (unsigned int) defaultIrqHandler;
}
AT91C_BASE_AIC->AIC_SPU = (unsigned int) defaultSpuriousHandler;
// Unstack nested interrupts
for (i = 0; i < 8 ; i++) {
AT91C_BASE_AIC->AIC_EOICR = 0;
}
// enable all interrupts - done later in the PAL
//AT91C_BASE_AIC->AIC_IECR = AT91C_ALL_INT;
// Enable Debug mode
AT91C_BASE_AIC->AIC_DCR = AT91C_AIC_DCR_PROT;
// Watchdog initialization
AT91C_BASE_WDTC->WDTC_WDMR = AT91C_WDTC_WDDIS;
// Remap the internal SRAM at 0x0
BOARD_RemapRam();
// Disable RTT and PIT interrupts (potential problem when program A
// configures RTT, then program B wants to use PIT only, interrupts
// from the RTT will still occur since they both use AT91C_ID_SYS)
AT91C_BASE_RTTC->RTTC_RTMR &= ~(AT91C_RTTC_ALMIEN | AT91C_RTTC_RTTINCIEN);
AT91C_BASE_PITC->PITC_PIMR &= ~AT91C_PITC_PITIEN;
// switch on DBGU
TRACE_CONFIGURE(DBGU_STANDARD, 115200, BOARD_MCK);
}
void main(void)
{
unsigned int channel = CHANNEL;
unsigned char data = 0x07;
unsigned char t1;
unsigned char t2;
unsigned int tmpcount = 0;
unsigned char wl_data[10];
unsigned char rs_line[20];
unsigned char rs_data[10];
unsigned char tmp_data[50];
// DBGU output configuration
TRACE_CONFIGURE(DBGU_STANDARD, 115200, BOARD_MCK);
// Configuration PIT (Periodic Interrupt Timer)
ConfigurePit();
// Configuration TC (Timer Counter)
ConfigureTc();
// Configuration PIO (Paralell In and Out port), Init Interrupt on PIO
ConfigureButtons();
ConfigureLeds();
// Configuration Radio Module nRF24L (PIO and SPI), ConfigureButtons must be executed before
ConfigureNRF24L();
ConfigureUSART0();
ConfigureUSART1();
while(Timer1Tick<2); // wait until NRF24L01 power up
nrf24l01_power_up(True);
while(Timer1Tick<4); // wait until NRF24L01 stand by
Timer1Tick = 0;
//initialize the 24L01 to the debug configuration as RX and auto-ack disabled
nrf24l01_initialize_debug(True, nrf_TX_RX_SIZE, False);
nrf24l01_write_register(0x06, &data, 1);
nrf24l01_set_as_rx(True);
Delay_US(130);
nrf24l01_set_rf_ch(channel);
nrf24l01_flush_rx();
Delay_US(300);
reset_wl = 1;
while (1) {
if( nrf_Data > 0 ) {
nrf_Data = 0;
for( t1 = 0; t1<8; t1++ ) {
wl_data[t1] = nrfRxMessage.Data[t1];
}
LED_Toggle(LED_Green);
writeByteSequence_8(wl_data);
}
if(messageUSART1){
messageUSART1 = 0;
pmsgRead(tmp_data);
while (tmp_data[tmpcount]!='\n'){
t1 = tmp_data[tmpcount];
tmpcount++;
if( t1 >= '0' && t1 <= '9' ) { // If character is 0-9 convert it to num
if( count < 20) {
rs_line[count] = t1-'0';
count++;
}
}
if( t1 >= 'A' && t1 <= 'F' ) { // If character A-F convert to 10-15
if( count < 20) {
rs_line[count] = t1-'A'+10;
count++;
}
}
}
// If character is a line break send packet
for( count = 0; count <10; count++ ) { // Convert from 16*4 to 8*8
t1 = (rs_line[count*2])<<4;
t2 = rs_line[count*2+1];
rs_data[count] = t1 | t2;
}
count = 0;
tmpcount = 0;
if( nrf_Transmission_Done == 1 ) {
TX_packet_BASE(rs_data); // Send packet.
LED_Toggle(LED_Yellow);
}
}//if msg flag has been raised
}//while
}//main
