void epa_On()
{
GPIO_SetBits(GPIOC, GPIO_Pin_2); //вкл епа
{
//инициализируем порты управления аналоговыми ключами выбора канала
GPIO_InitTypeDef port;
GPIO_StructInit(&port);
port.GPIO_Pin = GPIO_Pin_12;
port.GPIO_Mode = GPIO_Mode_OUT;
port.GPIO_OType = GPIO_OType_PP;
port.GPIO_PuPd = GPIO_PuPd_UP;
port.GPIO_Speed = GPIO_Speed_2MHz;
GPIO_Init(GPIOC, &port);
port.GPIO_Pin = GPIO_Pin_5 | GPIO_Pin_7;
GPIO_Init(GPIOB, &port);
RCC_AHB1PeriphClockCmd(RCC_AHB1ENR_GPIODEN, ENABLE);
port.GPIO_Pin = GPIO_Pin_7;
GPIO_Init(GPIOD, &port);
}
switchOn(100); //выключаем все ключи
initSpi1();
vTaskDelay(2);
initAdc();
}
void initAdcs (void)
{
int idx;
for (idx = 1; idx < (sizeof (adc) / sizeof (adc_t)); ++idx)
initAdc (adc[idx]);
}
/*! \brief Starts the passed program
*
* \param programIndex Index of the program to start.
*/
void start(uint8_t programIndex)
{
// initialize and start the passed 'program'
switch (programIndex)
{
case 0:
lcd_clear();
helloWorld();
break;
case 1:
activateLedMask = 0xFFFF; // use all LEDs
initLedBar();
initClock();
displayClock();
break;
case 2:
activateLedMask = 0xFFFE; // don't use led 0
initLedBar();
initAdc();
displayAdc();
break;
default:
break;
}
// do not resume to the menu until all buttons are released
os_waitForNoInput();
}
/**
* this function test the lightsensor
* first init the rgbled and then setAdcThresh
*/
void testlightsensor(){
int lightsensor;
initAdc();
for(int i=0;i<1000;i++){
lightsensor = getLightReading();
printf("the value from lightsensor: %d\n",lightsensor);
}
}
/** Entry point. This is the first thing which is called after startup code.
* This never returns. */
int main(void)
{
initUsart();
initAdc();
initLcdAndInput();
do
{
processPacket();
} while (true);
}
void adc_main(void){
#else
void main(void){
#endif
JOYSTICK_DIRECTION joystickDirection = CENTRED;
INT8 adc_value;
UINT8 potVoltage = 0;
BOOL updateLCD = TRUE;
initAdc();
while( !stopApplication() ){
ADC_ENABLE_CHANNEL(7);
ADC_SINGLE_CONVERSION(ADC_REF_AVDD | ADC_8_BIT | ADC_AIN7);
ADC_SAMPLE_SINGLE();
while(!ADC_SAMPLE_READY());
ADC_DISABLE_CHANNEL(7);
adc_value = ADCH;
if (potVoltage != scaleValue(adc_value)){
//potVoltage changed since last sample
potVoltage = scaleValue(adc_value);
updateLCD = TRUE;
}
if (joystickDirection != getJoystickDirection()){
//joystickDirection change since last sample
joystickDirection = getJoystickDirection();
updateLCD = TRUE;
}
if (updateLCD){
updateVoltageLCD(potVoltage, adc_value);
updateJoystickDirectionLCD(joystickDirection);
updateLCD = FALSE;
}
updateCounter(adc_value);
}
LED1 = LED3 = LED_OFF;
return;
}
int main(void)
{
halInit();
chSysInit();
initLed();
dacInit();
initAdc();
initRelay();
cpu_io_init();
while (TRUE)
{
cpu_io_process();
/*
DacCfg dac;
setLeds( 1 );
dac.dac1 = 0;
dac.dac2 = 0;
dacSet( &dac );
chThdSleepMilliseconds( 3000 );
setLeds( 2 );
dac.dac1 = 2047;
dac.dac2 = 2047;
dacSet( &dac );
chThdSleepMilliseconds( 3000 );
setLeds( 4 );
dac.dac1 = 3063;
dac.dac2 = 3063;
dacSet( &dac );
chThdSleepMilliseconds( 3000 );
setLeds( 4 );
dac.dac1 = 4095;
dac.dac2 = 4095;
dacSet( &dac );
chThdSleepMilliseconds( 3000 );
*/
}
return 0;
}
int main(void)
{
//Init Motor
/*
BYTE_SET(DDRD,0xFE);
PORTB = 0xFF;
PORTB = 0xC0;
DDRA = 0x10;
PORTA = 0x00;
*/
initAdc();
initUART();
initTimer();
// DDRC=0xFF;
//Enable interrupt after all init else Infinite loop
sei();
calibration();
//Enable_watchdog(WDTO_500MS);
for (;;)
{ /* loop forever */
// lireTelecommande();
/* if(timerOvf == 1)
{
*/
Vitesse_D = getUartVitesse();
Angle_D = getUartAngle();
Vg = getAvgSpeedMoteurGauche();
Vd = getAvgSpeedMoteurDroit();
CalculPWM(Vitesse_D,Angle_D,Vg,Vd,&Duty_G,&Duty_D);
/* timerOvf = 0;
}
*/
}
}
int main(void)
{
DDRF = 0x00;
DDRA = 0xFF;
DDRB = 0xFF;
sei();
initAdc();
/* Replace with your application code */
while (1)
{
_delay_ms(10);
AdcConvert();
}
return 1;
}
void IRQbspInit()
{
//Enable all gpios, as well as AFIO, SPI1, TIM3
RCC->APB2ENR |= RCC_APB2ENR_IOPAEN | RCC_APB2ENR_IOPBEN |
RCC_APB2ENR_IOPCEN | RCC_APB2ENR_IOPDEN |
RCC_APB2ENR_AFIOEN | RCC_APB2ENR_SPI1EN;
RCC->APB1ENR |= RCC_APB1ENR_TIM3EN | RCC_APB1ENR_PWREN;
RCC_SYNC();
//Board has no JTAG nor SWD, and those pins are used
//HSE is not used, remap PD0/PD1 in order to avoid leaving them floating
AFIO->MAPR |= AFIO_MAPR_SWJ_CFG_2 | AFIO_MAPR_PD01_REMAP;
//Note: all OUT pins speed limited to 2MHz except SPI and UART, that are
//limited to 10MHz. This has been done to reduce power supply "noise"
//PA5 AF out, PA6 AF out, PA7 in pulldown, PA9 AF out, PA10 in pu, other OUT
GPIOA->CRL=0x98912222;
GPIOA->CRH=0x22222892;
GPIOA->ODR=0x0410; //Enable pullup on PA10, and set PA4 high (SPI CS)
GPIOB->CRL=0x22222222; //Port B : all out
GPIOB->CRH=0x22222222;
GPIOB->ODR=0x0f00; //Keep display off at boot
GPIOC->CRH=0x22222222; //PC13 through PC15: all out
GPIOD->CRL=0x22222222; //PD0 and PD1 all out
initAdc();
configureLowVoltageDetect();
DefaultConsole::instance().IRQset(intrusive_ref_ptr<Device>(
new STM32Serial(defaultSerial,defaultSerialSpeed,
defaultSerialFlowctrl ? STM32Serial::RTSCTS : STM32Serial::NOFLOWCTRL)));
//The serial port drver reconfigures PA9 to 50MHz AF out and PA10 to
//floating in, but we want them as configured previously, so override
GPIOA->CRH=0x22222892;
GPIOA->ODR=0x0410; //Enable pullup on PA10, and set PA4 high (SPI CS)
}
int main (void) {
passedCenterFlag = 0;
configClock ();
PORTE.DIR = 0b11000000;
PORTF.DIR = 0b00001111;
PMIC.CTRL |= PMIC_HILVLEN_bm;
PMIC.CTRL |= PMIC_LOLVLEN_bm;
TCF0.CCABUF = STARTUP_PWM;
TCF0.CCBBUF = STARTUP_PWM;
TCF0.CCCBUF = STARTUP_PWM;
TCF0.CCDBUF = STARTUP_PWM;
TCE0.CCABUF = STARTUP_PWM/2;
TCE0.CCBBUF = STARTUP_PWM/2;
TCE0.CCCBUF = STARTUP_PWM/2;
TCE0.CCDBUF = STARTUP_PWM/2;
configPWM (&TCF0, &HIRESF, 5000);
configHalfPWMTimer (&TCE0, &HIRESE, 5000);
TCF0.CNT = 0;
TCE0.CNT = 0;
configDelayTimer (&TCC0);
initAdc (&ADCA);
initAdc (&ADCB);
sei();
startup();
//~ autoCommutationFlag = 1;
// float everything
//~ SET_phaseOutputsEHigh(0);
//~ SET_phaseOutputsEHigh(0);
//~
//~ SET_phaseOutputsELow(0);
//~ SET_phaseOutputsELow(0);
//~
//~ SET_phaseOutputsFHigh(0);
//~ SET_phaseOutputsFHigh(0);
//~
//~ SET_phaseOutputsFLow(0);
//~ SET_phaseOutputsFLow(0);
//~
//~ PORTE.OUT = 0;
//~ PORTF.OUT = 0;
_delay_ms(1000);
_delay_ms(1000);
TCF0.CCBBUF = 1600;
TCE0.CCBBUF = 1600/2;
spiInit ();
while (1) {}
}
int main() {
AdcChannel channel[] = {
ADC_BATTERY_VOLTAGE,
ADC_WHITE_LINE1,
ADC_WHITE_LINE2,
ADC_WHITE_LINE3,
ADC_IR_PROXIMITY1,
ADC_IR_PROXIMITY2,
ADC_IR_PROXIMITY3,
ADC_IR_PROXIMITY4,
ADC_IR_PROXIMITY5,
ADC_IR_RANGE1,
ADC_IR_RANGE2,
ADC_IR_RANGE3,
ADC_IR_RANGE4,
ADC_IR_RANGE5,
ADC_SERVO_POD1,
ADC_SERVO_POD1,
ADC_LAST
};
char strChannel[17][20] = {
"ADC_BATTERY_VOLTAGE",
"ADC_WHITE_LINE1",
"ADC_WHITE_LINE2",
"ADC_WHITE_LINE3",
"ADC_IR_PROXIMITY1",
"ADC_IR_PROXIMITY2",
"ADC_IR_PROXIMITY3",
"ADC_IR_PROXIMITY4",
"ADC_IR_PROXIMITY5",
"ADC_IR_RANGE1",
"ADC_IR_RANGE2",
"ADC_IR_RANGE3",
"ADC_IR_RANGE4",
"ADC_IR_RANGE5",
"ADC_SERVO_POD1",
"ADC_SERVO_POD2",
"ADC_LAST"
};
char buf[17];
UINT value, idx;
initAdc();
initLcd();
for(idx = 0; idx < (sizeof(channel)/sizeof(channel[0])); idx ++) {
lcdClear();
lcdCursor(1,1);
lcdString(strChannel[idx]);
lcdCursor(2,1);
if(getAdcValue(channel[idx], &value) == STATUS_OK) {
snprintf(buf, sizeof(buf), "%d", value);
lcdString(buf);
}
else {
lcdString("Error");
}
_delay_ms(DELAY_COUNT);
}
return 0;
}
int main(void) {
volatile uint32_t valore = 0, i, blink = 0, contatore, lampeggio_led;
volatile int32_t arrot;
volatile int16_t val1 = 0, x, y, z;
distanza DIST;
//--------------------------//
///definizione strutture/////
//-------------------------//
//volatile double d = 1.9845637456;
gyro G;
accelerazione A;
cinematica CIN;
/// servono differenti PID, almeno uno per la rotazione ed uno per lo spostamento
/// per la rotazione sarebbero interessante usarne 2, uno per la ortazione soft ed uno per la rotazione
/// brusca.
pid CTRL[3], * pidPtr;
/// descrittore della sintassi dei comandi
syn_stat synSTATO;
/// modulo zigbee per telemetria
xbee XB;
/// pwm servi e motori
pwm PWM, pwmServi;
/// struttura del sensore di colore
colore COL;
/// sensore di temperatura ad infrarossi
temperatura TEMP;
TEMPER sensIR;
/// indormazioni sul sopravvissuto
survivor SUR;
//inizializzazione struttura per qei
qei QEI;
/// oggetto che riallinea il mezzo
allineamento AL;
/// disabilita le interruzioni
DI();
pidPtr = CTRL;
dPtr = &DIST;
TEMPptr = &TEMP;
CIN.Aptr = &A;
CIN.distPTR = &DIST;
CIN.vel = 0.0;
dati DATA;
//passaggio degli indirizzi delle strutture alla struttura generale
dati_a_struttura(&G, &DIST, &CIN, &COL, &TEMP, &SUR, &DATA);
/// commento per provare il merge su server remoto
/// setup di base
setupMCU();
/// imposta i parametri del PID
setupPID(CTRL);
/// imposta le UART
setupUART();
//inizializzo l'i2c
InitI2C0();
/// messaggio d'inizio
PRINT_WELCOME();
/// inizializza il giroscopio
initGyro(&G, Z_AXIS);
/// inizializza il timer 0 e genera un tick da 10 ms
initTimer0(10, &G);
/// inizializza il timer 1
initTimer1(100);
/// inizializza il contatore della persistenza del comando
synSTATO.tick = 0;
/// inizializza il pwm
pwmMotInit(&PWM);
// TODO: //pwmServoInit (&pwmServi);
/// inizializza l'adc e lo prepara a funzionare ad interruzioni.
initAdc(&DIST);
/// reset dell'automa di analisi della sintassi
resetAutoma(&synSTATO);
//servo = (pwm *) &pwmServi;
/// iniziailizzazione del lettore encoder
qei_init(&QEI);
/// abilita le interruzioni
EI();
/// attende che il sensore vada a regime
if (G.IsPresent == OK){
PRINTF("\nAzzeramento assi giroscopio\n");
while (blink < 70){
if (procCom == 1){
procCom = 0;
blink++;
}
}
blink = 0;
/// azzeramento degli assi
azzeraAssi(&G);
}
/// test della presenza del modulo zig-bee
/// il modulo zig-be si attiva con al sequnza '+++' e risponde con 'OK' (maiuscolo)
if (testXbee() == 0){
// ok;
XB.present = 1;
PRINTF("Modulo xbee presente.\n");
}
else{
XB.present = 0;
PRINTF("Modulo xbee non presente.\n");
}
pwm_power(&PWM);
contatore = 0;
//// inizializza l'accelrometro
//stato = writeI2CByte(CTRL_REG1_A, ODR1 + ODR0 + ZaxEN + YaxEN + XaxEN);
// scrivo nel registro 0x20 il valore 0x0F, cioe' banda minima, modulo on e assi on
/// sintassi: indirizzo slave, num parm, indirizzo reg, valore da scrivere
//I2CSend(ACCEL_ADDR, 2, CTRL_REG1_A, ODR1 + ODR0 + ZaxEN + YaxEN + XaxEN);
A.isPresent = testAccel();
if (A.isPresent)
impostaAccel(&A);
/// taratura sul sensore di luminosita'
whiteBal(&COL);
/// taratura del sensore di temepratura
taraturaTemp(&TEMP);
///
qei_test(&QEI);
/// task principale
while(1){
/// invia la risposta per i comandi di rotazione, quando sono stati eseguiti
if(pidPtr->rispondi == TRUE){
rispostaRotazione(pidPtr, &synSTATO);
pidPtr->rispondi = FALSE;
}
if (procCom == 1 ){
//UARTCharPutNonBlocking(UART1_BASE, 'c');
procCom = 0;
contatore++;
lampeggio_led++;
if(lampeggio_led >= 50)
{
lampeggio_led = 0;
if(DATA.surPtr->isSurvivor == TRUE )
{
if(HWREG(GPIO_PORTF_BASE + (GPIO_O_DATA + (GREEN_LED << 2))) != GREEN_LED )
HWREG(GPIO_PORTF_BASE + (GPIO_O_DATA + (RED_LED << 2))) = 0;
HWREG(GPIO_PORTF_BASE + (GPIO_O_DATA + (GREEN_LED | RED_LED << 2))) ^= GREEN_LED | RED_LED;
}
HWREG(GPIO_PORTF_BASE + (GPIO_O_DATA + (GREEN_LED << 2))) ^= GREEN_LED;
}
/* LETTURA DEL COMANDO */
/// restituisce l'indirizzo del PID da utilizzare nel successivo processo di calcolo
pidPtr = leggiComando(&synSTATO, CTRL, pidPtr, &DATA);
/* LETTURA SENSORI */
/// effettua i calcoli solo se il giroscopio e' presente
/// TODO: il PID viene calcolato ongi 10ms oppure ogni 20ms? Come è meglio?
/* misura gli encoder e calcola spostameti e velocità */
/* misura i sensori di distanza */
if (DIST.run == true)
/// TODO controllare se riesce a funzionare mentre legge le accelerazioni su I2C
ROM_ADCProcessorTrigger(ADC0_BASE, 0);
/// misura i dati forniti dall'accelerometro se disponibili
if(A.isPresent)
misuraAccelerazioni(&A);
/// le misure del giroscopio invece sono effettuate solo dall'apposito pid
/*if(G.IsPresent == OK)
if( contatore == 1){
/// ogni 10 ms effettua il calcolo del PID
contatore = 0;
HWREG(GPIO_PORTB_BASE + (GPIO_O_DATA + (GPIO_PIN_0 << 2))) |= GPIO_PIN_0;
PID(&G, pidPtr, &PWM, &CIN);
setXPWM(&CTRL[1], &PWM);
procCom = 0;
HWREG(GPIO_PORTB_BASE + (GPIO_O_DATA + (GPIO_PIN_0 << 2))) &= ~GPIO_PIN_0;
blink++;
/// lampeggio del led con periodo di 2 s.
if (blink >= 100){
HWREG(GPIO_PORTF_BASE + (GPIO_O_DATA + ((GPIO_PIN_2 | GPIO_PIN_1) << 2))) = 0;
HWREG(GPIO_PORTF_BASE + (GPIO_O_DATA + (GPIO_PIN_3 << 2))) ^= GPIO_PIN_3;
blink = 0;
}
///provvede ad integrare la misura della velcita' angolare ogni 10 ms
//misuraAngoli(&G);
//PRINTF("asse x: %d\t", G.pitch);
//PRINTF("\tasse y: %d\t", G.roll);
//PRINTF("\tasse z: %d\n", G.yaw);
//PRINTF("uscita PID: %d\n", C.uscita);
}*/
/* RISPOSTA AL COMANDO */
inviaSensore(&synSTATO, &DATA);
}
}
}
