restructuring

deprecated/F1/GPS+ultrasonic/main.c

@@ -0,0 +1,271 @@
+/*
+ * main.c
+ *
+ * Copyright 2014 Edward V. Emelianov <eddy@sao.ru, edward.emelianoff@gmail.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+ * MA 02110-1301, USA.
+ */
+
+#include "main.h"
+#include "hardware_ini.h"
+#include "cdcacm.h"
+#include "uart.h"
+#include "GPS.h"
+#include "ultrasonic.h"
+#include "adc.h"
+
+volatile uint32_t Timer = 0; // milliseconds
+volatile uint32_t msctr = 0; // global milliseconds for different purposes
+usbd_device *usbd_dev;
+volatile int32_t systick_val = 0;
+volatile int32_t timer_val = 0;
+volatile int clear_ST_on_connect = 1;
+
+volatile int need_sync = 1;
+
+volatile uint32_t last_corr_time = 0; // time of last PPS correction (seconds from midnight)
+
+// STK_CVR values for all milliseconds (RVR0) and last millisecond (RVR1)
+volatile uint32_t RVR0 = STK_RVR_DEFAULT_VAL, RVR1 = STK_RVR_DEFAULT_VAL;
+
+curtime current_time = {25,61,61};
+
+curtime trigger_time = {25, 61, 61};
+curtime adc_time[ADC_CHANNEL_NUMBER] = {{25, 61, 61}, {25, 61, 61}};
+curtime ultrasonic_time = {25, 61, 61};
+uint32_t trigger_ms = DIDNT_TRIGGERED, adc_ms[ADC_CHANNEL_NUMBER] = {DIDNT_TRIGGERED, DIDNT_TRIGGERED},
+	ultrasonic_ms = DIDNT_TRIGGERED;
+
+void time_increment(){
+	Timer = 0;
+	if(current_time.H == 25) return; // Time not initialized
+	if(++current_time.S == 60){
+		current_time.S = 0;
+		if(++current_time.M == 60){
+			current_time.M = 0;
+			if(++current_time.H == 24)
+				current_time.H = 0;
+		}
+	}
+}
+
+int main(){
+	uint8_t *string;
+	int i;
+	// RCC clocking: 8MHz oscillator -> 72MHz system
+	rcc_clock_setup_in_hse_8mhz_out_72mhz();
+
+	GPIO_init();
+
+	usb_disconnect(); // turn off USB while initializing all
+
+	// USB
+	usbd_dev = USB_init();
+
+	// SysTick is a system timer with 1ms period
+	SysTick_init();
+	UART_init(USART2); // init GPS UART
+
+	tim2_init();
+	// wait a little and then turn on USB pullup
+//	for (i = 0; i < 0x800000; i++)
+//		__asm__("nop");
+
+	usb_connect(); // turn on USB
+
+	GPS_send_start_seq();
+	init_adc_sensor();
+
+	uint32_t trigrtm = 0, adctm[2] = {0, 0}, ultrasonictm = 0;
+	while(1){
+		usbd_poll(usbd_dev);
+		poll_ultrasonic();
+		poll_ADC();
+		if(usbdatalen){ // there's something in USB buffer
+			usbdatalen = parse_incoming_buf(usbdatabuf, usbdatalen);
+		}
+		if((string = check_UART2())){
+		//	P(string);
+			GPS_parse_answer(string);
+		}
+		if(systick_val > 1000){
+			P("Systick differs by ");
+			print_int(systick_val);
+			systick_val = 0;
+			P(", timer value: ");
+			print_int(timer_val);
+			P(", RVR0 = ");
+			print_int(RVR0);
+			P(", RVR1 = ");
+			print_int(RVR1);
+			P("\n");
+			print_curtime();
+		}
+		if(trigger_ms != DIDNT_TRIGGERED && trigger_ms != Timer){
+			if(msctr - trigrtm > 500 || trigrtm > msctr){
+				trigrtm = msctr;
+				P("Trigger time: ");
+				print_time(&trigger_time, trigger_ms);
+			}
+			trigger_ms = DIDNT_TRIGGERED;
+		}
+		for(i = 0; i < ADC_CHANNEL_NUMBER; ++i){
+			if(adc_ms[i] != DIDNT_TRIGGERED && adc_ms[i] != Timer){
+				if(msctr - adctm[i] > 500 || adctm[i] > msctr){
+					/*int16_t diff = ADC_trig_val[i] - ADC_value[i];
+					if(diff < 0) diff = -diff;
+					if(diff < ADC_WDG_THRES/2){ // omit noice
+					*/
+					adctm[i] = msctr;
+					P("ADC");
+					usb_send('0'+i);
+					if(adc_status[i] == ADWD_HI) P("hi");
+					else if(adc_status[i] == ADWD_LOW) P("lo");
+					P(": value = ");
+					print_int(ADC_trig_val[i]);
+					P(" (now: ");
+					print_int(ADC_value[i]);
+					P("), time = ");
+					print_time(&adc_time[i], adc_ms[i]);
+					//}
+				}
+				adc_ms[i] = DIDNT_TRIGGERED;
+			}
+		}
+		if(ultrasonic_ms != DIDNT_TRIGGERED && ultrasonic_ms != Timer){
+			if(msctr - ultrasonictm > 500 || ultrasonictm > msctr){
+				ultrasonictm = msctr;
+				P("Ultrasonic time: ");
+				print_time(&ultrasonic_time, ultrasonic_ms);
+			}
+			ultrasonic_ms = DIDNT_TRIGGERED;
+		}
+	}
+}
+
+
+/**
+ * SysTick interrupt: increment global time & send data buffer through USB
+ */
+void sys_tick_handler(){
+	++Timer;
+	++msctr;
+	if(Timer == 999){
+		STK_RVR = RVR1;
+	}else if(Timer == 1000){
+		STK_RVR = RVR0;
+		time_increment();
+	}
+	usb_send_buffer();
+}
+// STK_CVR - current systick val
+// STK_RVR - ticks till interrupt - 1
+
+// PA4 interrupt - PPS signal
+void exti4_isr(){
+	uint32_t t = 0, ticks;
+	static uint32_t ticksavr = 0, N = 0;
+	if(EXTI_PR & EXTI4){
+		// correct
+		systick_val = STK_CVR;
+		STK_CVR = RVR0;
+		timer_val = Timer;
+		Timer = 0;
+		systick_val = STK_RVR + 1 - systick_val; // Systick counts down!
+		if(timer_val < 10) timer_val += 1000; // our closks go faster than real
+		else if(timer_val < 990){ // something wrong
+			RVR0 = RVR1 = STK_RVR_DEFAULT_VAL;
+			STK_RVR = RVR0;
+			need_sync = 1;
+			goto theend;
+		}else
+			time_increment(); // ms counter less than 1000 - we need to increment time
+		t = current_time.H * 3600 + current_time.M * 60 + current_time.S;
+		if(clear_ST_on_connect){
+			clear_ST_on_connect = 0;
+		}else{
+			//  || (last_corr_time == 86399 && t == 0)
+			if(t - last_corr_time == 1){ // PPS interval == 1s
+				ticks =  systick_val + (timer_val-1)*(RVR0 + 1) + RVR1 + 1;
+				++N;
+				ticksavr += ticks;
+				if(N > 20){
+					ticks = ticksavr / N;
+					RVR0 = ticks / 1000 - 1; // main RVR value
+					STK_RVR = RVR0;
+					RVR1 = RVR0 + ticks % 1000; // last millisecond RVR value (with fine correction)
+					N = 0;
+					ticksavr = 0;
+					need_sync = 0;
+				}
+			}else{
+				N = 0;
+				ticksavr = 0;
+			}
+		}
+	theend:
+		last_corr_time = t;
+		EXTI_PR = EXTI4;
+	}
+}
+
+// pause function, delay in ms
+void Delay(uint16_t time){
+	uint32_t waitto = msctr + time;
+	while(msctr != waitto);
+}
+
+/**
+ * set current time by buffer hhmmss
+ */
+void set_time(uint8_t *buf){
+	inline uint8_t atou(uint8_t *b){
+		return (b[0]-'0')*10 + b[1]-'0';
+	}
+	uint8_t H = atou(buf) + TIMEZONE_GMT_PLUS;
+	if(H > 23) H -= 24;
+	current_time.H = H;
+	current_time.M = atou(&buf[2]);
+	current_time.S = atou(&buf[4]);
+}
+
+/**
+ * print time: Tm - time structure, T - milliseconds
+ */
+void print_time(curtime *Tm, uint32_t T){
+	int S = Tm->S, M = Tm->M, H = Tm->H;
+	if(H < 10) usb_send('0');
+	print_int(H); usb_send(':');
+	if(M < 10) usb_send('0');
+	print_int(M); usb_send(':');
+	if(S < 10) usb_send('0');
+	print_int(S); usb_send('.');
+	if(T < 100) usb_send('0');
+	if(T < 10) usb_send('0');
+	print_int(T);
+	if(GPS_status == GPS_NOT_VALID) P(" (not valid)");
+	if(need_sync) P(" need synchronisation");
+	newline();
+}
+
+void print_curtime(){
+	uint32_t T = Timer;
+	if(current_time.H < 24 && GPS_status != GPS_WAIT){
+		P("Current time: ");
+		print_time(&current_time, T);
+	}else
+		P("Waiting for satellites\n");
+}