/** @brief The main top level init
*
* The main init function to be called from main.c before entering the main
* loop. This function is simply a delegator to the finer grained special
* purpose init functions.
*/
void init(){
ATOMIC_START(); /* Disable ALL interrupts while we configure the board ready for use */
initPLL(); /* Set up the PLL and use it */
initGPIO();
initPWM();
initADC();
initAllPagedRAM(); /* Copy table and config blocks of data from flash to the paged RAM blocks for fast data lookup */
initVariables(); /* Initialise the rest of the running variables etc */
initFlash(); /* TODO, finalise this */
initECTTimer(); /* TODO move this to inside config in an organised way. Set up the timer module and its various aspects */
// initPITTimer(); /* TODO ditto... */
initSCIStuff(); /* Setup the sci module(s) that we will use. */
initConfiguration(); /* TODO Set user/feature/config up here! */
#ifdef XGATE
initXgate(); /* Fred is a legend, for good reason as of now */
#endif
initInterrupts(); /* still last, reset timers, enable interrupts here TODO move this to inside config in an organised way. Set up the rest of the individual interrupts */
ATOMIC_END(); /* Re-enable any configured interrupts */
}
/* GPS */
static void usart_device_init_2(size_t bits, size_t parity,
size_t stopBits, size_t baud)
{
volatile struct usart_info* ui = usart_data + UART_GPS;
RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART2, ENABLE);
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOD, ENABLE);
initGPIO(GPIOD, (GPIO_Pin_5 | GPIO_Pin_6));
GPIO_PinAFConfig(GPIOD, GPIO_PinSource5, GPIO_AF_USART2);
GPIO_PinAFConfig(GPIOD, GPIO_PinSource6, GPIO_AF_USART2);
init_usart(ui->usart, bits, parity, stopBits, baud);
/* No TX DMA here becasue I2C is using that stream */
enableRxTxIrq(ui->usart, USART2_IRQn, UART_GPS_IRQ_PRIORITY,
UART_TX_IRQ);
enable_dma_rx(RCC_AHB1Periph_DMA1, DMA1_Stream5_IRQn,
DMA_IRQ_PRIORITY, DMA_IT_TC | DMA_IT_HT, ui);
}
/* Auxilary port */
static void usart_device_init_1(size_t bits, size_t parity,
size_t stopBits, size_t baud)
{
volatile struct usart_info* ui = usart_data + UART_AUX;
RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART3, ENABLE);
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOD, ENABLE);
initGPIO(GPIOD, (GPIO_Pin_8 | GPIO_Pin_9));
GPIO_PinAFConfig(GPIOD, GPIO_PinSource8, GPIO_AF_USART3);
GPIO_PinAFConfig(GPIOD, GPIO_PinSource9, GPIO_AF_USART3);
init_usart(ui->usart, bits, parity, stopBits, baud);
enable_dma_rx(RCC_AHB1Periph_DMA1, DMA1_Stream1_IRQn,
DMA_IRQ_PRIORITY, DMA_IT_TC | DMA_IT_HT, ui);
enable_dma_tx(RCC_AHB1Periph_DMA1, DMA1_Stream3_IRQn,
DMA_IRQ_PRIORITY, DMA_IT_TC, ui);
}
//*****************************************************************************
// Main
//*****************************************************************************
void main (void)
{
// Stop watchdog timer
WDT_A_hold( WDT_A_BASE );
// Initialize GPIO
initGPIO();
// Initialize clocks
initClocks();
// Initialize timers
initTimers();
__bis_SR_register( GIE ); // Enable interrupts globally
while(1) {
__no_operation(); // Placeholder for while loop (not required)
}
}
/**************************************************************************//**
* @brief Main function
*****************************************************************************/
int main(void)
{
/* Initialize chip */
CHIP_Init();
SegmentLCD_Init(true);
initRTC();
initGPIO();
/* Initial LCD content */
SegmentLCD_Number(time);
while (1)
{
/* Go to EM2 */
EMU_EnterEM2(true);
/* Wait for interrupts */
}
}
void LCDInit(int line_size){
LineSize = 20;
CurStr = 0;
CurX = 0;
KeyTime = 0;
RepeatTime = REPEAT_TIME;
Key = 0;
initGPIO();
RS_Off;
RS_On;
setData(0xFF);
RS_Off;
RS_On;
_LCDSendCommand(0x38); // 8-bit,double string,5x8
delay_us(1000);//for(i = 0;i<1000 MULT;i++);
_LCDSendCommand(0b1100); // Display on
delay_us(1000);//for(i = 0;i<1000 MULT;i++);
_LCDSendCommand(1); // Reset
_LCDSendCommand(0x6); // Increment cursor to 1
}
/* Cellular */
static void usart_device_init_3(size_t bits, size_t parity,
size_t stopBits, size_t baud)
{
volatile struct usart_info* ui = usart_data + UART_TELEMETRY;
RCC_APB1PeriphClockCmd(RCC_APB1Periph_UART4, ENABLE);
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOA, ENABLE);
initGPIO(GPIOA, (GPIO_Pin_0 | GPIO_Pin_1));
GPIO_PinAFConfig(GPIOA, GPIO_PinSource0, GPIO_AF_UART4);
GPIO_PinAFConfig(GPIOA, GPIO_PinSource1, GPIO_AF_UART4);
init_usart(ui->usart, bits, parity, stopBits, baud);
enable_dma_rx(RCC_AHB1Periph_DMA1, DMA1_Stream2_IRQn,
DMA_IRQ_PRIORITY, DMA_IT_TC | DMA_IT_HT, ui);
enable_dma_tx(RCC_AHB1Periph_DMA1, DMA1_Stream4_IRQn,
DMA_IRQ_PRIORITY, DMA_IT_TC, ui);
}
/* Bluetooth */
static void usart_device_init_0(size_t bits, size_t parity,
size_t stopBits, size_t baud)
{
volatile struct usart_info* ui = usart_data + UART_WIRELESS;
RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1, ENABLE);
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOA, ENABLE);
initGPIO(GPIOA, (GPIO_Pin_9 | GPIO_Pin_10));
GPIO_PinAFConfig(GPIOA, GPIO_PinSource9, GPIO_AF_USART1);
GPIO_PinAFConfig(GPIOA, GPIO_PinSource10, GPIO_AF_USART1);
init_usart(ui->usart, bits, parity, stopBits, baud);
enable_dma_rx(RCC_AHB1Periph_DMA2, DMA2_Stream5_IRQn,
DMA_IRQ_PRIORITY, DMA_IT_TC | DMA_IT_HT, ui);
enable_dma_tx(RCC_AHB1Periph_DMA1, DMA2_Stream7_IRQn,
DMA_IRQ_PRIORITY, DMA_IT_TC, ui);
}
static void initSPI(void) {
SPI_InitTypeDef SPI_InitStructure;
initGPIO();
/* Set up SPI in bi-directional mode */
SPI_InitStructure.SPI_Direction = SPI_Direction_1Line_Tx;
SPI_InitStructure.SPI_Mode = SPI_Mode_Master;
SPI_InitStructure.SPI_DataSize = SPI_DataSize_8b;
SPI_InitStructure.SPI_CPOL = SPI_CPOL_High;
SPI_InitStructure.SPI_CPHA = SPI_CPHA_2Edge;
SPI_InitStructure.SPI_NSS = SPI_NSS_Soft;
SPI_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_256;
SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB;
SPI_InitStructure.SPI_CRCPolynomial = 7;
SPI_Init(SWD_SPI, &SPI_InitStructure);
SPI_Cmd(SWD_SPI, ENABLE);
}
int main(int argc, char **argv)
{
printf("myGPIP main called!\n");
int err = local_init();
if (!err) {
// init GPIO 17 as output
initGPIO(gpio_direction_output, 17);
// ...and start toggling
while(1) {
setGPIO(17, 1);
sleep(1);
setGPIO(17, 0);
sleep(1);
}
}
return 0;
}
/**************************************************************************//**
* @brief Main function
*****************************************************************************/
int main(void)
{
CHIP_Init();
// initializations
initGPIO();
/* Enable LCD without voltage boost */
SegmentLCD_Init(false);
setupSWOForPrint();
updateLCD(getCapsenseCurrent());
while (1)
{
updateGPIO();
if (getCapsensePrevious() != getCapsenseCurrent())
{
updateLCD(getCapsenseCurrent());
updateSWO();
}
}
}
int main(){
u8 res;
initRCC();
initGPIO();
initTIM2();
initUSART3();
initI2C1();
__enable_irq(); // глобальное включение прерывания
// I2C1_tx(0xD0,0x6B,0x00);
// I2C1_tx(0xD0,0x1B,0xE0);
// I2C1_tx(0xD0,0x1C,0xE0);
read_I2C1(GY521_ADRESS,WHO_I_AM);
// read_data_acc();
green_on();
while(1){
while(!number_of_tasks)
{}
(*buffer_of_tasks[head_of_tasks])();
deleteTask();
}
return 0;
}
//int main()
void initStepper(void)
{
initGPIO(); //initialize GPIO ports 0-3
initMotor(); //initialize stepper motors
MYTIMER_init(); //initialize mytimer (hardware timer)
//MYTIMER_setOverflowVal(T1_FREQ);
//MYTIMER_setCompareVal(10000); // 75% duty cycle
MYTIMER_enable_overflowInt(); //enable overflow interrupts
//MYTIMER_enable_compareInt();
//MYTIMER_enable_allInterrupts();
NVIC_EnableIRQ(Fabric_IRQn); //enable fabric interrupt
MYTIMER_enable(); //start hardware timer
//Fastest seen: 100 accel, 23 speed, 2000000 Tclk
//move(step,accel,decel,speed); //move motor based on function call
return;
}
static void CAN_device_init_2(int baud)
{
CAN_DeInit(CAN2);
/* CAN GPIOs configuration ************************************************* */
/* Enable GPIO clock */
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOB, ENABLE);
/* Connect CAN pins to Alternate Function */
GPIO_PinAFConfig(GPIOB, GPIO_PinSource12, GPIO_AF_CAN2);
GPIO_PinAFConfig(GPIOB, GPIO_PinSource13, GPIO_AF_CAN2);
initGPIO(GPIOB, GPIO_Pin_12 | GPIO_Pin_13);
/* CAN configuration ******************************************************* */
/* Enable CAN clock */
RCC_APB1PeriphClockCmd(RCC_APB1Periph_CAN2, ENABLE);
initCAN(CAN2, baud);
/* Enable FIFO 0 message pending Interrupt */
CAN_ITConfig(CAN2, CAN_IT_FMP1, ENABLE);
initCANInterrupts(CAN2, CAN2_RX1_IRQn);
}
/**
* @brief Main program.
* @param None
* @retval None
*/
int main(void)
{
uint8_t currentLED=0,idx;
uint16_t xx,yy;
uint16_t testWord;
uint8_t shifter=0;
/* Initialize LEDs on STM32F4-Discovery --------------------*/
__IO uint32_t i = 0;
uint8_t buf[255];
uint8_t len;
STM_EVAL_LEDInit(LED4);
STM_EVAL_LEDInit(LED3);
// You can use these for LEDs if you use the upper 8 bits of the 16b FSMC bus to talk to the ILI9238.
// STM_EVAL_LEDInit(LED5); //GPIOD 14 -> FSMC D0. Do not use for LED, we need them to talk to the ILI9238
// STM_EVAL_LEDInit(LED6); //GPIOD 14 -> FSMC D1.
// flash the LEDs in a circle to test delayMillis(uint32_t timedelay)
STM_EVAL_LEDToggle(currentLED);
for (idx=0;idx<8;idx++)
{
STM_EVAL_LEDToggle(currentLED);
currentLED=(currentLED+1)%2;
STM_EVAL_LEDToggle(currentLED);
delayMillis(250);
}
//
// USBD_Init(&USB_OTG_dev, USB_OTG_FS_CORE_ID, &USR_desc, &USBD_CDC_cb, &USR_cb);
// init the printf
init_printf(0,tft_putc);
// init_tft_printf(NULL,tft_putc);
// Get the 32F4 ready to talk to the TFTLCD using FSMC
initGPIO();
initFSMC();
uDelay(1000); // probably don't need this
reset();
initDisplay();
// ** Do the adafruit Demo **
// fillScreen(BLACK);
// setCursor(0, 0);
// setTextColor(CYAN);
// setTextSize(1);
// setRotation(1);
// tft_printf("Please connect to virtual COM port...");
delayMillis(2000);
testlines(CYAN);
delayMillis(2500);
testfastlines(RED, BLUE);
delayMillis(2500);
testdrawrects(GREEN);
delayMillis(2500);
testfillrects(YELLOW, MAGENTA);
delayMillis(2500);
fillScreen(BLACK);
testfillcircles(10, MAGENTA);
testdrawcircles(10, WHITE);
delayMillis(2500);
testtriangles();
delayMillis(2500);
testfilltriangles();
delayMillis(2500);
testRoundRect();
delayMillis(2500);
testFillRoundRect();
delayMillis(2500);
fillScreen(GREEN);
delayMillis(2500);
// fsmcData = 0x60020000; // sets a16
// fsmcRegister = 0x60000000; // clears a16
// printf("fsmcData:\t0x%08X\r\n",fsmcData);
// printf("fsmcRegister:\t0x%08X\r\n",fsmcRegister);
// fillScreen(BLACK);
// setCursor(0, 20);
// setTextColor(color);
// setTextSize(1);
// write("Hello World!");
// setTextSize(2);
// write(1234.56);
// setTextSize(3);
//
// println(0xDEADBEEF, HEX);
// printf("0xFF00>>8 0x%04X\r\n",0xff00>>8);
// VCP_send_str(&buf[0]);
// printf("SysTick_Config(SystemCoreClock/1000)\t %d\r\n",SysTick_Config(SystemCoreClock/1000));
// millisecondCounter=0;
// for (idx=0;idx<100;idx++)
// {
// printf("millisecondCounter:\t%d",millisecondCounter);
// }
// void delayMillis(uint32_t millis)
// {
// uint32_t target;
//
// target=millisecondCounter+millis;
// while(millisecondCounter<target);
// }
// From stm32f4_discovery.h:
// typedef enum
// {
// LED4 = 0,
// LED3 = 1,
// LED5 = 2,
// LED6 = 3
// } Led_TypeDef;
while(1)
{
for (idx=0;idx<8;idx++)
{
setRotation(idx%4);
testtext(RED);
delayMillis(1500);
}
}
}
void main (void) {
T_UWORD luw_i;
T_UBYTE lub_CountIndice = 0;
initModesAndClock(); /* Initialize mode entries and system clock */
INTC_InstallINTCInterruptHandler(isr,59,1);
INTC.CPR.R = 0;
initGPIO();
initPIT(ValTMR_0, ValTMR_1);
while (1) {
if(rub_FlagValUpAut || rub_FlagValUpMan){
if(rub_Fled){
rub_Fled = 0;
SIU.GPDO[lub_CountIndice].B.PDO = 1;
SIU.GPDO[10].B.PDO = 0;
SIU.GPDO[11].B.PDO = 1;
lub_CountIndice++;
if(lub_CountIndice >= 10){
lub_CountIndice = 10;
rub_FlagValUpAut = 0;
rub_FValAutUP = 0;
}
}
}
/******************************************************************************/
else if(rub_FlagValDownAut || rub_FlagValDownMan){
if(rub_Fled){
rub_Fled = 0;
if(lub_CountIndice <= 1) {
lub_CountIndice = 1;
rub_FlagValDownAut = 0;
rub_FValAutDown = 0;
SIU.GPDO[11].B.PDO = 1;
}
SIU.GPDO[lub_CountIndice-1].B.PDO = 0;
SIU.GPDO[10].B.PDO = 1;
SIU.GPDO[11].B.PDO = 0;
lub_CountIndice--;
if(lub_CountIndice == 0 && rub_FlagValAnPi){
SIU.GPDO[11].B.PDO = 1;
PIT.CH[1].TCTRL.B.TEN = 0;
PIT.CH[1].TCTRL.B.TEN = 1;
PIT.CH[1].LDVAL.R = ValTMR_1;
PIT.CH[1].TFLG.B.TIF = 1;
rub_FlagValAnPi = 0;
while(!PIT.CH[1].TFLG.B.TIF);
PIT.CH[1].TFLG.B.TIF = 1;
rub_Fled = 0;
rub_FlagValDownAut = 0;
rub_FlagValDownMan = 0;
rub_FlagValUpAut = 0;
rub_FlagValUpMan = 0;
rub_FValAutDown = 0;
rub_FValAutUP = 0;
}
}
}
////////////////////////////////////////////////
else if(!rub_FlagValUpAut && !rub_FlagValUpMan && !rub_FlagValDownAut && !rub_FlagValDownMan){
rub_Fled = 0;
SIU.GPDO[10].B.PDO = 1;
SIU.GPDO[11].B.PDO = 1;
}
}
}
// Main function
void main(void) {
reset_peripheral(); initClock(); initTimer(); initDisplay(); initPin();
initGPIO(); initADC(); initConsole(); int i = 0;
//init_password();
send_data();
initCircBuf (&speed_buffer, BUF_SIZE); init_set_speed_data(&speed_set_data);
int screen = 0; int screen_prev = 0; float speed = 0; float buffed_speed = 0;
int fake_speed = 0; float acc = 0; float max_acc = 0; //float fuel_eco = 0;
float distance = 0;
bool fix = 0; uint8_t satillite = 0; float quality = 0; clock time;
int aim_pos = 0; unsigned long adc = 0; //int error_stepper = 0;
IntMasterEnable();
while(1){
//reading data
read_data = split_data(UART_char_data_old, read_data); // decode data
speed = read_speed(); //read data into variables
adc = run_adc()/7;
//calculations
aim_pos = speed_feedback(buffed_speed, encoder_1/40, speed_set_data.speed);
if (speed_set_data.enable == 1){
step_motor_control(encoder_1/40, aim_pos);
}
//sending fake data
fake_speed = (int)adc;//= random_at_most(100/1.852);
send_info(fake_speed);//knots
//storing data
store_speed(speed);
buffed_speed = analysis_speed();
acc = read_acceleration(buffed_speed);
max_acc = max_acc_func(acc, max_acc);
time = read_time();
satillite = read_satillite();
fix = read_fix();
quality = read_quality();
debounce_button(); // debounce buttons
screen = read_button_screen(screen, fix);
distance = read_distance();
select_read(); //need a mosfet for turning power off
// select adds a an on and off switch yo
if (screen == 1){
if(screen_prev != 1 && screen == 1){
speed_set_data.speed = buffed_speed;
}
speed_set_data.speed = set_speed(speed_set_data.speed); // set the speed to cruise at
}
if (screen == 2){ //0 to 100
acceleration_test(speed);
}
// refresh chainging
if (fix == 1 && speed_set_data.old == speed_set_data.speed && refresh_rate < 4){
UARTSend((unsigned char *)PMTK_SET_NMEA_UPDATE_5HZ, 18, 0);
refresh_rate += 1;
}
if (i >= 50){
display(screen, buffed_speed, acc, max_acc, speed_set_data.speed, satillite,
encoder_1/40, time, distance, quality, UART_char_data_old, aim_pos, adc, acc_times);
i = 0;
}
screen_prev = screen;
i++;
}
}
RemoteTransmitter::RemoteTransmitter(unsigned int periodusec, unsigned short repeats) {
_periodusec=periodusec;
_repeats=repeats;
initGPIO();
}
void initSR() {
initGPIO(SERIAL_SR_DATA);
initGPIO(SERIAL_SR_LATCH);
initGPIO(SERIAL_SR_CLK);
}
void *startDisplayThread(void *args)
{
int n,col,row;
struct timespec sleepTime = { 0, 5000000 };
struct timespec onTime = { 0, 200000 };
uint32_t *pixelData;
initGPIO();
buildGreyCode();
// Set up buffer pointers.
PixelsF = Pixels1;
PixelsB = Pixels2;
// Set row bits to zero to start with.
ClearBits( 15 << ROWA);
row = 0;
while(displayRunning)
{
// Cycle through the rows in a grey code order to minimise changes on address lines.
// Changing the address lines seems to a part of the cause of the ghosting problems.
if(greyCodeSet[row])
{
SetBits(greyCodeChange[row] << ROWA); // Set a bit for the current row
}
else
{
ClearBits(greyCodeChange[row] << ROWA); // Clear a bit for the current row
}
settleTime(5);
// Clock one rows worth of pixels into the display
pixelData = &PixelsF[32*greyCode[row]];
for(col=0;col<32;col++)
{
ClearBits(pixelClkMask); // Clk low
settleTime(5);
SetBits(*pixelData++ & pixelMask);
settleTime(5);
SetBits(1<<CLK); // Clk high
settleTime(5);
}
SetBits(1<<STB); // Strobe
//settleTime(5);
ClearBits(1<<STB);
settleTime(50);
ClearBits(1<<OE); // turn display on
nanosleep(&onTime, NULL); // Fixed on time
SetBits(1<<OE); // turn off the display
settleTime(5);
row += 1;
row &= 15;
#if 1
// Pause at the end of the frame
if(row == 0)
{
SetBits(1<<OE);
nanosleep(&sleepTime, NULL);
}
#endif
}
// Make sure display is off when we exit the thread
SetBits(1<<OE);
}
int main()
{
int socketServeur;
int socketClient = -1;
int clientConnecte = 0;
int i;
int ecrit = 0;
int lu = -1;
int speed = 500;
int stopCount = 0;
int distance = 0;
int distance_32bits = 0;
struct sockaddr_in addrServeur;
socklen_t longueurAdresse; // Nombre d'octets de la structure sockaddr_in
char nomDuClient[1024], portDuClient[32];
char commande = 'X';
char clientONOFF = 'o';
pthread_t thread1;
pthread_t thread2;
// Initialisation des GPIO
initGPIO();
// Initialisation Mutex
if(pthread_mutex_init(&lock, NULL) != 0)
{
perror("mutex");
exit(-1);
}
pthread_create(&thread1, NULL, thread_distance, &socketClient);
pthread_create(&thread2, NULL, thread_speed, &socketClient);
printf("creation du thread1 et 2\n");
// Cree un socket de communication
socketServeur = socket(PF_INET, SOCK_STREAM, 0);
if(socketServeur == -1)
{
perror("Socket");
exit(-1);
}
printf("Socket crée avec succès ! (%d)\n", socketServeur);
addrServeur.sin_addr.s_addr = INADDR_ANY; //toutes
addrServeur.sin_family = PF_INET;
addrServeur.sin_port = htons(PORT);
// lose the pesky "Address already in use" error message
int yes = 1;
if( setsockopt(socketServeur, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(int)) == -1 )
{
perror("setsockopt");
exit(errno);
}
// Demande l'attachement local de la socket
longueurAdresse = sizeof(addrServeur);
if( bind(socketServeur, (struct sockaddr *)&addrServeur, longueurAdresse) == -1 )
{
perror("bind");
exit(-2);
}
printf("Socket attachée avec succès!\n");
if (listen(socketServeur, CLIENT_MAX) == -1)
{
perror("listen");
exit(errno);
}
printf("Socket placée en écoute passive...\n");
printf("Attente d'une demande de connexion (quitter avec Cltrl-C)\n\n");
while(1)
{
if(clientConnecte == 0)
{
socketClient = accept4(socketServeur, (struct sockaddr *)&addrServeur, &longueurAdresse, SOCK_NONBLOCK);
if(socketClient == -1 )
{
printf("errno : %d\n", errno);
perror("accept");
close(socketClient);
close(socketServeur);
exit(errno);
}
printf("Nouveau client !\n");
if ( getnameinfo((struct sockaddr*)&addrServeur, sizeof(addrServeur), nomDuClient, sizeof(nomDuClient), portDuClient,
sizeof(portDuClient), NI_NUMERICHOST | NI_NUMERICSERV) == 0)
{
printf("client=%s, port=%s\n", nomDuClient, portDuClient);
}
clientConnecte = 1;
//ecrits = write(socketClient, &clientONOFF, 1);
}
// nanosleep((struct timespec[]){{0, 10000000}}, NULL);
lu = read(socketClient, &commande, 1);
if(lu == -1)
{
if(errno == EAGAIN) // Nothing to read
{
continue;
}
else
{
printf("Error reading from socketClient ! \n");
printf("errno = %d \n", errno);
break;
}
}
if(lu == 0)
{
printf("Socket closed ! \n");
speed = 500;
avancer(0);
commande = 's';
close(socketClient);
clientConnecte = 0;
continue;
}
printf("lu = %d\n", lu);
printf("commande = %c\n", commande);
switch(commande)
{
case 'a' :
//printf("AVANCE\n");
avancer(speed);
break;
case 'r' :
//printf("RECULE\n");
reculer(speed);
break;
case 'd' :
//printf("DROITE\n");
tourner(DROITE, speed);
break;
case 'g' :
//printf("GAUCHE\n");
tourner(GAUCHE, speed);
break;
case '+' :
speed = speedChange(UP, speed);
break;
case '-' :
speed = speedChange(DOWN, speed);
break;
case 's' :
//printf("REPOS\n");
avancer(0);
}
//distance = ultrason();
}
close(socketClient);
close(socketServeur);
return 0;
}
// main loop
int main(void){
uint8_t stateDS18=DS18B20_STATUS_READY;
#ifdef USE_WDT
WDT_init(WDTO_8S);
#endif
initGPIO();
LCD_init();
showLcdSplash();
setLcdInitialFields();
paramLoadFromEeprom();
USART1_config(USART1_MY_UBBRN,USART_DATA_FORMAT_8BITS|USART_STOP_BITS_1,USART_TRANSMIT_ENABLE|USART_RECEIVE_ENABLE| USART_INTERRUPT_ENABLE);
USART1_sendStr("Hello");
schedulerInit();
// check for the default values
#ifdef USE_WDT
WDT_init(WDTO_8S);
#endif
sei(); //enable interrups
// loop while
while(1){
// cintrol zone
if(flagTaskControl){
#ifdef USE_WDT
WDT_reset();
#endif
LED_RUN_OFF;
// fire the DS
if(stateDS18==DS18B20_STATUS_READY){
DS18B20_startConv();
stateDS18=DS18B20_STATUS_CONV;
// check if convertion ended
}else if(stateDS18==DS18B20_STATUS_CONV){
if(DS18B20_convComplete()){
stateDS18=DS18B20_STATUS_END_CONV;
}
// convertion ready
}else if (stateDS18==DS18B20_STATUS_END_CONV){
LED_RUN_ON;
currentTemp=DS18B20_getTemp();
stateDS18=DS18B20_STATUS_READY;
currentStatus = checkTempError(currentTemp,currentTempSetPoint,currentHistSetPoint); // chec the out
setOutputRelay(currentStatus);
_delay_ms(50);
LED_RUN_OFF;
}
flagTaskControl=0;
}
// user bottons area
if(flagTaskReadButtons){
#ifdef USE_WDT
WDT_reset();
#endif
uint8_t portVal = readButtons();
uint8_t code = decodeButton(portVal);
code = debounceKey(code);
#ifdef MAIN_DEBUG
sprintf(debugBuffer,"Key %d",code);
USART1_sendStr(debugBuffer);
#endif
stateMachine(code); // go to machine
flagTaskReadButtons=0;
}
// lcd update area
if(flagTaskUpdateLcd){
#ifdef USE_WDT
WDT_reset();
#endif
//showLcdSavedMessage();
updateLcd(); // update the lcd
flagTaskUpdateLcd=0;
}
// save to eeprom
if(flagSaveParametersEeprom){
#ifdef USE_WDT
WDT_reset();
#endif
paramSavetoEeprom(); // save value sto eeprom
showLcdSavedMessage();
setLcdInitialFields();
updateLcd();
flagSaveParametersEeprom=0;
}
}
}
//***** Main Function *********************************************************
void main (void)
{
uint16_t i = 0;
uint16_t val = 0;
uint16_t loc = 0;
uint16_t status = 0;
// Stop watchdog timer
WDT_A_hold( WDT_A_BASE );
// Initialize GPIO
initGPIO();
if ( erase != 0 ) // This lets you easily erase the flash by changing the value
erase_infoB(); // of the "erase" variable before reaching this point in the code
if ( fill != 0 ) // This lets you easily fill the flash by changing the value
fill_infoB(); // of the "fill" variable before reaching this point in the code
if (count[ 0 ] == 0xffff )
{
val = 1;
loc = 0;
}
else if ( count[ NUMBER_OF_WORDS-1 ] != 0xFFFF )
{
val = count[ NUMBER_OF_WORDS-1 ];
erase_infoB();
loc = 0;
}
else
{
for ( i = 1; i < NUMBER_OF_WORDS-2; i++ )
{
if ( count[ i ] == 0xffff )
{
val = count[ i - 1 ];
val++;
loc = i;
break;
}
}
}
status = write_infoB_location( val, loc );
if ( status == 0 )
while( 1 );
// Inform the programmer how many times the board has been power-on reset
// which isn't possible without some form of non-volaile memory
printf( "This program has been power cycled %d times\n", val );
// Flash the LED 'count' number of times ... this way you can 'see' how many
// times a power-on reset has occured, even if you can't read the printf()
for ( i = 0; i < val; i++ )
{
// Turn on LED
GPIO_setOutputHighOnPin( GPIO_PORT_P1, GPIO_PIN0 );
// Wait about a second
__delay_cycles( ONE_SECOND );
// Turn off LED
GPIO_setOutputLowOnPin( GPIO_PORT_P1, GPIO_PIN0 );
// Wait another second
__delay_cycles( HALF_SECOND );
}
// Trap program here
while(1);
}
int main () {
CHIP_Init(); //Initialize Chip
initMCU();
initGPIO(); //Initialize GPIO
sdi2c_Init(); //Initialize I2C
initTimer(); //initialize timer for timer interuprt
/* Setup SysTick Timer for 10 msec interrupts */
if (SysTick_Config(CMU_ClockFreqGet(cmuClock_CORE) / 1000)) {
while (1) ;
}
/*Enable all sensors and GPS */
GPIO_PinOutSet(GPS_PORT, ENABLE); //Enable GPS Sensor board
BMP180_GetCalData(); //Enable and get calibration data from BMP180
initLSM303_LowPower(); //Enable Accel in low power mode
initL3GD20H_Normal(); //Enable Gyro in normal mode
GPIO_PinOutToggle(EXT_LED, YEL_LED);
/* Acceleromter Data */
Delay(10);
LSM303_GetAccelData();
LSM303_PowerOff();
GPIO_PinOutToggle(EXT_LED, YEL_LED);
/*Gyroscope Data */
Delay(10);
L3GD20H_GetGyroData();
L3GD20H_PowerOff();
GPIO_PinOutToggle(EXT_LED, YEL_LED);
/*Temperature/Barometric Pressure */
Delay(10);
BMP180_GetTemp();
BMP180_GetPressure();
BMP180_CalcRealTemperature();
BMP180_CalcRealPressure();
GPIO_PinOutToggle(EXT_LED, YEL_LED);
/*Power Sensor*/
INA219_GetVoltage();
GPIO_PinOutClear(EXT_LED, YEL_LED);
GPIO_PinOutToggle(EXT_LED, GRE_LED);
Delay(100);
GPIO_PinOutToggle(EXT_LED, GRE_LED);
/* GPS Information */
timeout = 0; //reset timeout
initGPS(); //Initialize GPS UART
coldrestart(); //Send cold restart command
while(fullread == 0) { //while not a full read, do the following
if(satfix == 1) { //if there is a satellite fix, then...
GPIO_PinOutSet(EXT_LED, YEL_LED); //toggle LED for debug
readdata(); //readdata
timeout = 0;
}
if(timeout > 20) {
GPIO_PinOutClear(EXT_LED, YEL_LED);
GPStimeout();
break;
}
}
GPIO_PinOutSet(EXT_LED, GRE_LED);
Delay(500);
printGPS(0); //Print GPS to screen for debug
concact();
/* Infinite loop */
while(1) {
if(GPIO_PinInGet(BUT_PORT, RIGHT_BUT) == 0) {
r = r + 1;
if(r > 2) { //wrap around to beginning
r = 0;
}
printGPS(r);
}
if(GPIO_PinInGet(BUT_PORT, LEFT_BUT) == 0) {
r = r - 1;
if(r < 0) { //wrap around to beginning
r = 2;
}
printSENSORS();
}
// if(GPIO_PinInGet(GPS_PORT, FIX) == 1) {
// GPIO_PinOutToggle(EXT_LED, RED_LED);
// }
}
}
void init() {
initGPIO();
initOTG();
}
int main(){
// unsigned int us_start, t0, t1, t2, t3;
// float x, y, theta;
// float x2, y2, theta2;
// float x3, y3, theta3;
// float beta;
// point pt;
// int i=0;
// float check;
// For IMU
/* double tab_acc[3] = {0.0, 0.0, 0.0},
tab_gyro[3] = {0.0, 0.0, 0.0},
tab_magn[3] = {0.0, 0.0, 0.0};
int i;
*/
pthread_t pthread_prop,
pthread_gpio,
pthread_led,
pthread_com;
//gpio init
initGPIO(GREEN_LED);
initGPIO(ORANGE_LED);
initGPIO(WRNG_RED_LED);
initGPIO(RED_LED_BIC);
initGPIO(GREEN_LED_BIC);
initGPIO(BP_STOP);
idFicI2C = openI2C(FILE_I2C);
setI2C(ADDR_MD25, idFicI2C);
//Create a thread for prop
if(pthread_create(&pthread_prop, NULL, threadProp, NULL)!=0){
printf("ERROR; return code from pthread_create()\n");
getchar();
exit(-1);
}
//Create a thread control gpio
if(pthread_create(&pthread_gpio, NULL, threadGpio, NULL)!=0){
printf("ERROR; return code from pthread_create()\n");
getchar();
exit(-1);
}
//Create a thread control gpio
if(pthread_create(&pthread_led, NULL, threadLed, NULL)!=0){
printf("ERROR; return code from pthread_create()\n");
getchar();
exit(-1);
}
//Create a thread for com
if(pthread_create(&pthread_com, NULL, thread_Com, NULL)!=0){ //&sargThreadSttRover
printf("ERROR; return code from pthread_create()\n");
getchar();
exit(-1);
}
// mpu_init();
while(1){
/* mpu_read(tab_acc, tab_gyro, tab_magn);
printf("\n");
for(i=0; i<3; i++) printf("tab_acc[%d] = %.2lf\n", i, tab_acc[i]);
printf("\n");
for(i=0; i<3; i++) printf("tab_gyro[%d] = %.2lf\n", i, tab_gyro[i]);
printf("\n");
for(i=0; i<3; i++) printf("tab_magn[%d] = %.2lf\n", i, tab_magn[i]);
printf("\n\n");
printf("Distance = %d\n\n", sonar_get_distance_cm());
*/
// Update Info Rover
float x, y, theta;
int dist;
#ifdef I2C_OK
pos3(&x, &y, &theta);
volt = getBatVolt();
pthread_mutex_lock(&mtx_distSonar);
distSonar = sonar_get_distance_cm();
dist = distSonar;
pthread_mutex_unlock(&mtx_distSonar);
printf("distSonar = %d\n", dist);
#else
x = 0, y = 0, theta = 0;
bat = 15;
dist = 1000;
#endif
//printf("x = %.2f; y %.2f; theta = %.2f; bat = %.2f; dist = %d\n", x, y , theta, bat, dist);
updateInfoRover(&argThreadSttRover, &x, &y, &theta, &volt, &dist);
/* printf("argThreadSttRover.sinf.bat = %d\n"
"argThreadSttRover.sinf.son = %.2f\n"
"argThreadSttRover.sinf.pos.x = %.2f\n"
"argThreadSttRover.sinf.pos.y = %.2f\n"
"argThreadSttRover.sinf.ang = %.2f\n\n", (int32_t)argThreadSttRover.sinf.bat, argThreadSttRover.sinf.son, argThreadSttRover.sinf.pos.x, argThreadSttRover.sinf.pos.y, argThreadSttRover.sinf.ang);
*/
}
//old test
/* //trajectoire
while(1){
usleep(10000);
nd1 = dist(1);
nd2 = dist(2);
pos3(&x3, &y3, &theta3);
beta=trajCorr(x3, y3, theta3, 500, 500);
printf("%.2f, %.2f, %.2f°, beta=%f\n", x3, y3, theta3, beta*180./M_PI);
move(100, beta*180./M_PI);
if(((fabs(x3-500.)<10.) && (fabs(y3-500.)<10.)))
{
move(0,0);
printf("fin\n");
return 1;
}
}
*/
/*
while(1){
usleep(10000);
us_start = micros();
nd1 = dist(1);
t0 = micros() - us_start;
nd2 = dist(2);
us_start = micros();
pos(&x, &y, &theta);
t1 = micros() - us_start;
us_start = micros();
pos2(&x2, &y2, &theta2);
t2 = micros() - us_start;
us_start = micros();
pos3(&x3, &y3, &theta3);
t3 = micros() - us_start;
//printf("%u,%u,%u,%u\n", t0, t1, t2, t3);
printf("%.2f, %.2f, %.2f°, %.2f, %.2f, %.2f°, %.2f, %.2f, %.2f°\n", x, y, theta*180./M_PI, x2, y2, theta2*180./M_PI, x3, y3, theta3*180./M_PI);
}
// move(1000,0,idFicI2C);
sleep(1);
move(0,0,idFicI2C);
sleep(1);
printf("d=%f\n",dist(0));
*/
/* close(idFicI2C);
printf("Fermeture du bus i2c\n");
*/
return 0;
}
