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();
}
}
}
//------------------------------------------------------------------------------
// EnableChannel (Channel) активирует выбранный канал
// Входной параметр Channel - номер канала 1, 2, 3, 4.
//------------------------------------------------------------------------------
void Mez_EnableChannel(mezonin *MezStruct)
{
switch (MezStruct->ActiveChannel) {
case 1:
AT91F_PIO_ClearOutput(MezStruct->LineA0.PIO_ctrl_ptr, MezStruct->LineA0.PIO_Line | MezStruct->LineA1.PIO_Line);
//Конфигурация канала: 0 0
// А1 А0
break;
case 2:
AT91F_PIO_ClearOutput(MezStruct->LineA1.PIO_ctrl_ptr, MezStruct->LineA1.PIO_Line);
AT91F_PIO_SetOutput(MezStruct->LineA0.PIO_ctrl_ptr, MezStruct->LineA0.PIO_Line);
//Конфигурация канала: 0 1
// А1 А0
break;
case 3:
AT91F_PIO_ClearOutput(MezStruct->LineA0.PIO_ctrl_ptr, MezStruct->LineA0.PIO_Line);
AT91F_PIO_SetOutput(MezStruct->LineA1.PIO_ctrl_ptr, MezStruct->LineA1.PIO_Line);
//Конфигурация канала: 1 0
// А1 А0
break;
case 4:
AT91F_PIO_SetOutput(MezStruct->LineA0.PIO_ctrl_ptr, MezStruct->LineA0.PIO_Line | MezStruct->LineA1.PIO_Line);
//Конфигурация канала: 1 1
// А1 А0
break;
}
vTaskDelay(2);
}
//*--------------------------------------------------------------------------------------
//* 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();
}
}
}
////////////////////////////////////////////////////////////////////////////////
// Odebranie ramki obrazu z kamery // po optymalizacji //
// podzielnik = 2 -> klatka 320 x 200
// podzielnik = 4 -> klatka 160 x 100
////////////////////////////////////////////////////////////////////////////////
void GetFrame(register char PodzielnikX, register char PodzielnikY,
char transmit) {
register unsigned int x = 0, y = 0, wsk = 0;
register char x2 = 0, y2 = 0, CamClockEnable = 0;
// 1-sza klatka do odrzutu
CamClockEnable = 1;
AT91F_PIO_ClearOutput(AT91C_BASE_PIOA, DIODA2);
while (AT91F_PIO_GetInput(AT91C_BASE_PIOA) & VSYNC) {
AT91F_PIO_ClearOutput(AT91C_BASE_PIOA, MCLK);
AT91F_PIO_SetOutput(AT91C_BASE_PIOA, MCLK);
}
// printf("-- Poza petla --\n\r");
AT91F_PIO_SetOutput(AT91C_BASE_PIOA, DIODA2);
CamClockEnable = 1;
wsk = 0;
register int pclkJump;
register int enter = 0;
// 2-ga klatka dobra
AT91C_BASE_PIOA->PIO_CODR = DIODA1;
while (CamClockEnable) {
for (pclkJump = 0; pclkJump < PodzielnikX; pclkJump++) {
AT91C_BASE_PIOA->PIO_CODR = MCLK;
AT91C_BASE_PIOA->PIO_SODR = MCLK;
// AT91F_PIO_ClearOutput( AT91C_BASE_PIOA, MCLK );
// AT91F_PIO_SetOutput( AT91C_BASE_PIOA, MCLK );
}
// VSYNC = 1 (podczas aktywnej czesci klatki)
if (AT91C_BASE_PIOA->PIO_PDSR & VSYNC) {
// AT91F_PIO_ClearOutput( AT91C_BASE_PIOA, DIODA1 );
// HSYNC = 1 (podczas aktywnej czesci linii)
if (AT91C_BASE_PIOA->PIO_PDSR & HSYNC) {
enter = 1;
if (PodzielnikX < 8) {
if (x < (640. / PodzielnikX) && y < (400. / PodzielnikY)) {
// printf(".");
x++;
mem[wsk] = (AT91C_BASE_PIOA->PIO_PDSR & (CAM_D2
| CAM_D3 | CAM_D4 | CAM_D5 | CAM_D6 | CAM_D7))
>> 14;
if (AT91C_BASE_PIOA->PIO_PDSR & CAM_D0) {
mem[wsk] += 1;
}
if (AT91C_BASE_PIOA->PIO_PDSR & CAM_D1) {
mem[wsk] += 2;
}
wsk++;
} else if (y >= 400 / PodzielnikY)
CamClockEnable = 0;
if (CamClockEnable == 1) {
CamClockEnable = 2;
}
} else {
if (x < 1280 && y < 800) {
// функция - обработчик прерывания от timer1
void timer1_c_irq_handler(void)
{
AT91PS_TC TC_pt = AT91C_BASE_TC1;
unsigned int dummy;
//* определение состояния прерывания
dummy = TC_pt->TC_SR;
dummy = dummy; //чтобы не генерировалось замечание о неиспольз переменной
//* действия при прерывании
opros_kn1(); // опрос кнопки 1
opros_kn2(); // опрос кнопки 2
opros_kn3(); // опрос кнопки 3
opros_kn4(); // опрос кнопки 4
//смена состояния выхода генерации отриц напр для LCD
if (U_NEG_old_state==OFF)
{
AT91F_PIO_ClearOutput( AT91C_BASE_PIOA, U_NEG); // сброс U_NEG
U_NEG_old_state=ON;
}
else
{
AT91F_PIO_SetOutput( AT91C_BASE_PIOA, U_NEG); // уст U_NEG
U_NEG_old_state=OFF;
}
}
//*----------------------------------------------------------------------------
//* \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 spi_low_set_ram_addr(int num)
{
int set_mask = (num & 0x7) << SPI_RAM_A0_PIN;
AT91F_PIO_SetOutput( AT91C_BASE_PIOA, set_mask );
int clr_mask = ((num ^ 0x7) & 0x7) << SPI_RAM_A0_PIN;
AT91F_PIO_ClearOutput( AT91C_BASE_PIOA, clr_mask );
}
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 );
}
}
void turn_of_angle(double angle) {
AT91F_PIO_ClearOutput(AT91C_BASE_PIOA, 0x1 << 29);
L3G4200D_Reset(&twid);
PWM_Set(0, 15);
waitms(1000);
if (angle < 0) {
TRACE_INFO("-- w lewo -- \r\n");
Kierunek(RIGHT_ENGINES, FORWARD_GEAR);
Kierunek(LEFT_ENGINES, REVERSE_GEAR);
} else {
TRACE_INFO("-- w prawo -- \r\n");
Kierunek(RIGHT_ENGINES, REVERSE_GEAR);
Kierunek(LEFT_ENGINES, FORWARD_GEAR);
}
while (ABS(angle) - ABS(L3G4200D_GetData().sAngle_z) > 0) {
L3G4200D_ReadData(&twid);
}
L3G4200D_Reset(&twid);
Kierunek(RIGHT_ENGINES, STOP_GEAR);
Kierunek(LEFT_ENGINES, STOP_GEAR);
AT91F_PIO_SetOutput(AT91C_BASE_PIOA, 0x1 << 29);
}
void poti_reset(void)
{
volatile int i;
AT91F_PIO_ClearOutput(AT91C_BASE_PIOA, OPENPICC_PIO_nSLAVE_RESET);
for (i = 0; i < 0xff; i++) { }
AT91F_PIO_SetOutput(AT91C_BASE_PIOA, OPENPICC_PIO_nSLAVE_RESET);
}
void nRFLL_CSN(unsigned char enable)
{
if(enable)
AT91F_PIO_SetOutput(AT91C_BASE_PIOA,CSN_PIN);
else
AT91F_PIO_ClearOutput(AT91C_BASE_PIOA,CSN_PIN);
}
void nRFCMD_CE(unsigned char enable)
{
if(enable)
AT91F_PIO_SetOutput(AT91C_BASE_PIOA,CE_PIN);
else
AT91F_PIO_ClearOutput(AT91C_BASE_PIOA,CE_PIN);
}
void lowerDown(int force)
{
setForce(force);
AT91F_PIO_SetOutput( AT91C_BASE_PIOA, DIRD);
AT91F_PIO_ClearOutput( AT91C_BASE_PIOA, DIRC);
direction = 1;
}
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 liftUp(int force)
{
setForce(force);
AT91F_PIO_SetOutput( AT91C_BASE_PIOA, DIRC);
AT91F_PIO_ClearOutput( AT91C_BASE_PIOA, DIRD);
direction = -1;
}
void blinkingGreen(int delay)
{
/*LED3 - GREEN*/
AT91F_PIO_SetOutput( AT91C_BASE_PIOA, LED3);
Delay(delay);
AT91F_PIO_ClearOutput( AT91C_BASE_PIOA, LED3);
Delay(delay);
}
static inline void
led_set(AT91PS_PIO pio, const u_int32_t led, const bool_t on)
{
if (on)
AT91F_PIO_ClearOutput(pio, led);
else
AT91F_PIO_SetOutput(pio, led);
}
////////////////////////////////////////////////////////////////////////////////
// Sterowanie kierunkiem obrotu silnikow
// silnik = 1 - silniki lewe, 2 - silniki prawe
// kierunek = 0 - stop, 1 - przod, 2 - tyl
////////////////////////////////////////////////////////////////////////////////
inline void Kierunek(int silnik, int kierunek) {
if (silnik == 1) {
switch (kierunek) {
case 0:
AT91F_PIO_ClearOutput(AT91C_BASE_PIOA, PIO_PA7);
AT91F_PIO_ClearOutput(AT91C_BASE_PIOA, PIO_PA8);
break;
case 1:
AT91F_PIO_SetOutput(AT91C_BASE_PIOA, PIO_PA7);
AT91F_PIO_ClearOutput(AT91C_BASE_PIOA, PIO_PA8);
break;
case 2:
AT91F_PIO_ClearOutput(AT91C_BASE_PIOA, PIO_PA7);
AT91F_PIO_SetOutput(AT91C_BASE_PIOA, PIO_PA8);
break;
}
}
if (silnik == 2) {
switch (kierunek) {
case 0:
AT91F_PIO_ClearOutput(AT91C_BASE_PIOA, PIO_PA9);
AT91F_PIO_ClearOutput(AT91C_BASE_PIOA, PIO_PA10);
break;
case 1:
AT91F_PIO_SetOutput(AT91C_BASE_PIOA, PIO_PA9);
AT91F_PIO_ClearOutput(AT91C_BASE_PIOA, PIO_PA10);
break;
case 2:
AT91F_PIO_ClearOutput(AT91C_BASE_PIOA, PIO_PA9);
AT91F_PIO_SetOutput(AT91C_BASE_PIOA, PIO_PA10);
break;
}
}
switch (kierunek) {
case 0:
// LcdClear();
// LcdPrint("STOP!");
break;
case 1:
// LcdClear();
// LcdPrint("Do przodu!");
break;
case 2:
// LcdClear();
// LcdPrint("Do tylu!");
break;
}
}
void startBlinking(int delay)
{
/* START BLINKING LED */
/*LED1 - RED*/
AT91F_PIO_SetOutput( AT91C_BASE_PIOA, LED1);
Delay(delay);
AT91F_PIO_ClearOutput( AT91C_BASE_PIOA, LED1);
Delay(delay);
/*LED2 - YELLOW*/
AT91F_PIO_SetOutput( AT91C_BASE_PIOA, LED2);
Delay(delay);
AT91F_PIO_ClearOutput( AT91C_BASE_PIOA, LED2);
Delay(delay);
/*LED3 - GREEN*/
AT91F_PIO_SetOutput( AT91C_BASE_PIOA, LED3);
Delay(delay);
AT91F_PIO_ClearOutput( AT91C_BASE_PIOA, LED3);
Delay(delay);
}
//инициализация основных узлов системы
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 inline void HaltBlinking(void)
{
while(1)
{
vTaskDelay (portTICK_RATE_MS * 500);
AT91F_PIO_ClearOutput( AT91C_BASE_PIOA, LED_MASK );
vTaskDelay (portTICK_RATE_MS * 500);
AT91F_PIO_SetOutput( AT91C_BASE_PIOA, LED_MASK );
}
}
void US0_Send(int Count)
{
pUS0->US_TPR = (unsigned int)&(US0_SendBuf[0]);
pUS0->US_TCR = Count;
AT91F_PIO_SetOutput( AT91C_BASE_PIOA, AT91C_PIO_PA1); //Led off
while (pUS0->US_TCR != 0) {}; //wait end of transmission
AT91F_PIO_ClearOutput( AT91C_BASE_PIOA, AT91C_PIO_PA1); //Led on
}
void DBGU_SendBuf(int Count)
{
pDBGU->DBGU_TPR = (unsigned int)&(DBGU_Buf[0]);
pDBGU->DBGU_TCR = Count;
AT91F_PIO_SetOutput( AT91C_BASE_PIOA, AT91C_PIO_PA1); //Led off
while (pDBGU->DBGU_TCR != 0) {}; //wait end of transmission
AT91F_PIO_ClearOutput( AT91C_BASE_PIOA, AT91C_PIO_PA1); //Led on
}
void poti_comp_carr(u_int8_t position)
{
volatile int i;
while (!(spi->SPI_SR & AT91C_SPI_TDRE)) { }
AT91F_PIO_ClearOutput(AT91C_BASE_PIOA, OPENPICC_PIO_SS2_DT_THRESH);
/* shift one left, since it is a seven-bit value written as 8 bit xfer */
spi->SPI_TDR = position & 0x7f;
while (!(spi->SPI_SR & AT91C_SPI_TDRE)) { }
for (i = 0; i < 0xff; i++) { }
AT91F_PIO_SetOutput(AT91C_BASE_PIOA, OPENPICC_PIO_SS2_DT_THRESH);
}
void vParTestSetLED( unsigned portBASE_TYPE uxLED, signed portBASE_TYPE xValue )
{
if( uxLED < ( portBASE_TYPE ) NB_LED )
{
if( xValue )
{
AT91F_PIO_SetOutput( AT91C_BASE_PIOB, ulLED_MASK[ uxLED ] );
}
else
{
AT91F_PIO_ClearOutput( AT91C_BASE_PIOB, ulLED_MASK[ uxLED ]);
}
}
}
void vParTestToggleLED( unsigned portBASE_TYPE uxLED )
{
if( uxLED < ( portBASE_TYPE ) NB_LED )
{
if( AT91F_PIO_GetInput( AT91C_BASE_PIOB ) & ulLED_MASK[ uxLED ] )
{
AT91F_PIO_ClearOutput( AT91C_BASE_PIOB, ulLED_MASK[ uxLED ]);
}
else
{
AT91F_PIO_SetOutput( AT91C_BASE_PIOB, ulLED_MASK[ uxLED ] );
}
}
}
unsigned char nRFLL_ReadWrite(unsigned char byte)
{
int bit;
for(bit=0;bit<8;bit++)
{
if(byte & 0x80)
AT91F_PIO_SetOutput(AT91C_BASE_PIOA,MOSI_PIN);
else
AT91F_PIO_ClearOutput(AT91C_BASE_PIOA,MOSI_PIN);
AT91F_PIO_SetOutput(AT91C_BASE_PIOA,SCK_PIN);
byte<<=1;
if(AT91F_PIO_GetInput(AT91C_BASE_PIOA)&MISO_PIN)
byte|=1;
AT91F_PIO_ClearOutput(AT91C_BASE_PIOA,SCK_PIN);
}
AT91F_PIO_ClearOutput(AT91C_BASE_PIOA,MOSI_PIN);
return byte;
}
void vParTestToggleLED( unsigned portBASE_TYPE uxLED )
{
if( uxLED < ( portBASE_TYPE ) NB_LED )
{
if( AT91F_PIO_GetInput( AT91C_BASE_PIOA ) & led_mask[ uxLED ] )
{
AT91F_PIO_ClearOutput( AT91C_BASE_PIOA, led_mask[ uxLED ]);
}
else
{
AT91F_PIO_SetOutput( AT91C_BASE_PIOA, led_mask[ uxLED ] );
}
}
}
void sendBeaconStat( portTickType diff) {
/* send Stats */
if( xTaskGetTickCount()-ob_int_mgmt.stat_time>1) {
AT91F_PIO_SetOutput( AT91C_BASE_PIOA, LED_GREEN );
}
if( xTaskGetTickCount()-ob_int_mgmt.stat_time>diff ) {
ob_int_mgmt.stat_time = xTaskGetTickCount();
MemBlock *h = pullFreeBlock();
if(h!=NULL) {
OBD2HW_Header* c2ob_h;
char* bh=(char*)h->pValue;
c2ob_h =(OBD2HW_Header*)bh;
c2ob_h->length = sizeof(StatusOpenbeacon_V1);
c2ob_h->type = STATUS_OPENBEACON_V1;
StatusOpenbeacon_V1* sbv1 =(StatusOpenbeacon_V1*)(bh+sizeof(OBD2HW_Header));
char i;
// Statistik eintragen
for(i=0; i<OPENBEACON_MACSIZE; i++) sbv1->NetID[i]=ob_int_mgmt.NetID[i];
sbv1->TxChannel = ob_int_mgmt.TxChannel;
sbv1->TxPowerLevel = ob_int_mgmt.TxPowerLevel;
sbv1->TxRate = ob_int_mgmt.TxRate;
for(i=0; i<4; i++) {
sbv1->rx_beacons[i] = ob_int_mgmt.rx_beacons[i];
sbv1->fail_rx_beacons[i] = ob_int_mgmt.fail_rx_beacons[i];
sbv1->tx_beacons[i] = ob_int_mgmt.tx_beacons[i];
sbv1->fail_tx_beacons[i] = ob_int_mgmt.fail_tx_beacons[i];
}
vUSBSendPriPacket(h, sizeof(OBD2HW_Header)+c2ob_h->length );
h=NULL;
// reset stat
for(i=0; i<4; i++) {
ob_int_mgmt.rx_beacons[i] = 0;
ob_int_mgmt.fail_rx_beacons[i] = 0;
ob_int_mgmt.tx_beacons[i] = 0;
ob_int_mgmt.fail_tx_beacons[i] = 0;
}
AT91F_PIO_ClearOutput( AT91C_BASE_PIOA, LED_GREEN );
}
}
}
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;
}
