AUTOM/workspace/AUTOM10/Core/Src/main.c

/* USER CODE BEGIN Header */
/**
 ******************************************************************************
 * @file           : main.c
 * @brief          : Main program body
 ******************************************************************************
 * @attention
 *
 * Copyright (c) 2025 STMicroelectronics.
 * All rights reserved.
 *
 * This software is licensed under terms that can be found in the LICENSE file
 * in the root directory of this software component.
 * If no LICENSE file comes with this software, it is provided AS-IS.
 *
 ******************************************************************************
 */
/* USER CODE END Header */
/* Includes ------------------------------------------------------------------*/
#include "main.h"
#include "usb_device.h"

/* Private includes ----------------------------------------------------------*/
/* USER CODE BEGIN Includes */
#include "usbd_cdc_if.h"
#include "cdc_int.h"
#include "eeprom.h"
#include "pwm.h"
#include "adc.h"
#include "debug.h"
#include "mot.h"
#include <stdbool.h>
/* USER CODE END Includes */

/* Private typedef -----------------------------------------------------------*/
/* USER CODE BEGIN PTD */

typedef enum {
	bzoff, bzmoving, bzwarning,
} stBuz_st;

/* USER CODE END PTD */

/* Private define ------------------------------------------------------------*/
/* USER CODE BEGIN PD */

/* USER CODE END PD */

/* Private macro -------------------------------------------------------------*/
/* USER CODE BEGIN PM */

/* USER CODE END PM */

/* Private variables ---------------------------------------------------------*/
ADC_HandleTypeDef hadc1;
DMA_HandleTypeDef hdma_adc1;

TIM_HandleTypeDef htim2;
TIM_HandleTypeDef htim4;

UART_HandleTypeDef huart1;

/* USER CODE BEGIN PV */

extern volatile uint16_t adc_dma_buf[];
extern uint16_t ch4;
extern uint16_t ch5;
extern uint16_t ch6;
extern uint16_t ch7;
extern uint16_t ch8;

uint8_t pulsanti = 0;
volatile uint8_t rtP1 = 200;
volatile uint8_t rtP2 = 200;
volatile uint8_t rtTLC = 100;
volatile uint16_t rtramp[4];
volatile uint16_t rtCiclo;
volatile uint16_t rtAnem;
uint16_t m1pwmap;
uint16_t m1pwmch;
uint16_t m2pwmap;
uint16_t m2pwmch;
uint16_t m3pwmap;
uint16_t m3pwmch;
uint16_t m4pwmap;
uint16_t m4pwmch;
uint16_t t1ap;
uint16_t t2ap;
uint16_t t3ap;
uint16_t t4ap;
uint16_t twap;
uint16_t m1TimeoutMan;
uint16_t m2TimeoutMan;
uint16_t m3TimeoutMan;
uint16_t m4TimeoutMan;
uint16_t twch;
uint16_t tramp;
uint16_t tanem;
uint16_t thanem;

uint16_t trampman;
uint16_t m1pwmMan;
uint16_t m2pwmMan;
uint16_t m3pwmMan;
uint16_t m4pwmMan;

uint16_t apM1start;
uint16_t apM1stop;
uint16_t apM2start;
uint16_t apM2stop;
uint16_t apM3start;
uint16_t apM3stop;
uint16_t apM4start;
uint16_t apM4stop;
uint16_t chM1start;
uint16_t chM1stop;
uint16_t chM2start;
uint16_t chM2stop;
uint16_t chM3start;
uint16_t chM3stop;
uint16_t chM4start;
uint16_t chM4stop;

uint16_t flagPar;

uint16_t mrampstart[4];
uint16_t stPulsanti = 0;
omCiclo_st stCiclo = omchiuso;
omCiclo_st memstCiclo = omchiuso;
volatile stBuz_st stBuz = bzoff;
bool nobuz = false;
bool fchiuso = false;
/* USER CODE END PV */

/* Private function prototypes -----------------------------------------------*/
void SystemClock_Config(void);
static void MX_GPIO_Init(void);
static void MX_DMA_Init(void);
static void MX_TIM2_Init(void);
static void MX_TIM4_Init(void);
static void MX_ADC1_Init(void);
static void MX_USART1_UART_Init(void);
/* USER CODE BEGIN PFP */

/* USER CODE END PFP */

/* Private user code ---------------------------------------------------------*/
/* USER CODE BEGIN 0 */
void HAL_SYSTICK_Callback(void) {
	static unsigned char c10ms = 0;
	static uint8_t c100ms = 0;
	static uint8_t c1s = 0;
	static uint8_t inidx = 0;
	static uint8_t inbuf[4];
	uint8_t i;

	if (++c10ms >= 10) {               // 10 ms
		c10ms = 0;
		if (rtP1)
			rtP1--;
		if (rtP2)
			rtP2--;
		if (rtTLC)
			rtTLC--;
//**** legge i tasti********************************************************************************
		inidx++;
		inidx &= 0x03;
		if (HAL_GPIO_ReadPin(P1_GPIO_Port, P1_Pin) == GPIO_PIN_RESET)
			inbuf[inidx] |= INP1;
		else
			inbuf[inidx] &= (~INP1);
		if (HAL_GPIO_ReadPin(P2_GPIO_Port, P2_Pin) == GPIO_PIN_RESET)
			inbuf[inidx] |= INP2;
		else
			inbuf[inidx] &= (~INP2);
		if (HAL_GPIO_ReadPin(CH1_GPIO_Port, CH1_Pin) == GPIO_PIN_RESET)
			inbuf[inidx] |= INCH1;
		else
			inbuf[inidx] &= (~INCH1);
		if (HAL_GPIO_ReadPin(CH2_GPIO_Port, CH2_Pin) == GPIO_PIN_RESET)
			inbuf[inidx] |= INCH2;
		else
			inbuf[inidx] &= (~INCH2);
		if (HAL_GPIO_ReadPin(CH3_GPIO_Port, CH3_Pin) == GPIO_PIN_RESET)
			inbuf[inidx] |= INCH3;
		else
			inbuf[inidx] &= (~INCH3);
		if (HAL_GPIO_ReadPin(CH4_GPIO_Port, CH4_Pin) == GPIO_PIN_RESET)
			inbuf[inidx] |= INCH4;
		else
			inbuf[inidx] &= (~INCH4);

		pulsanti |= (inbuf[0] & inbuf[1] & inbuf[2] & inbuf[3]);
		pulsanti &= (inbuf[0] | inbuf[1] | inbuf[2] | inbuf[3]);
//**** legge adc ***********************************************************************************
		readAdc();
		if (++c100ms >= 10) {               // 10 ms
			c100ms = 0;	//flag_10ms = 1;                // set a flag; do real work in main loop
			for (i = 0; i < 4; i++) {
				if (rtramp[i])
					rtramp[i]--;
			}
			if (rtCiclo < 0xffff)rtCiclo++;
			if (rtAnem)rtAnem--;
//**** gestione buzzer *****************************************************************************
			if (stBuz == bzmoving) {
				if (nobuz) {
					if (c1s >= 5)
						HAL_GPIO_WritePin(LED2_GPIO_Port, LED2_Pin,
								GPIO_PIN_RESET);
					else
						HAL_GPIO_WritePin(LED2_GPIO_Port, LED2_Pin,
								GPIO_PIN_SET);
				} else {
					if (c1s >= 5)
						HAL_GPIO_WritePin(GPIOA, BUZ_Pin, GPIO_PIN_RESET);
					else
						HAL_GPIO_WritePin(GPIOA, BUZ_Pin, GPIO_PIN_SET);
				}
			} else if (stBuz == bzwarning) {
				if (nobuz) {
					if (c1s & 1)
						HAL_GPIO_WritePin(LED2_GPIO_Port, LED2_Pin,
								GPIO_PIN_RESET);
					else
						HAL_GPIO_WritePin(LED2_GPIO_Port, LED2_Pin,
								GPIO_PIN_SET);
				} else {
					if (c1s & 1)
						HAL_GPIO_WritePin(GPIOA, BUZ_Pin, GPIO_PIN_RESET);
					else
						HAL_GPIO_WritePin(GPIOA, BUZ_Pin, GPIO_PIN_SET);
				}
			} else {	    //bzoff
				HAL_GPIO_WritePin(GPIOA, BUZ_Pin, GPIO_PIN_RESET);
			}
//**************************************************************************************************
			if (++c1s >= 10) {               // 1 s
				c1s = 0;
				//HAL_GPIO_TogglePin(LED2_GPIO_Port, LED2_Pin);
			}
		}
	}
}

void managePulsanti(void) {
	if (pulsanti & INP1) {
		if (rtP1 == 0)
			stPulsanti |= P1START;
		else {
			HAL_GPIO_WritePin(LED2_GPIO_Port, LED2_Pin, GPIO_PIN_SET);
		}
	} else {
		if (stPulsanti & P1START) {
			stPulsanti &= (~P1START);
			stPulsanti|=P1RELEASED;
			HAL_GPIO_WritePin(LED2_GPIO_Port, LED2_Pin, GPIO_PIN_RESET);
		} else if (rtP1 <= 190) {
			stPulsanti |= P1STOP;
			HAL_GPIO_WritePin(LED2_GPIO_Port, LED2_Pin, GPIO_PIN_RESET);
		}
		rtP1 = 200;
	}
	if (pulsanti & INP2) {
		if (rtP2 == 0)
			stPulsanti |= P2START;
	} else {
		if (stPulsanti & P2START)
			stPulsanti &= (~P2START);
		else if (rtP2 <= 190)
			stPulsanti |= P2STOP;
		rtP2 = 200;
	}
	stPulsanti &= (P1START | P1STOP | P2START | P2STOP |P1RELEASED);
	if (stPulsanti == 0) {
		switch (pulsanti & 0x3c) {
		case 0x00:
			rtTLC = 100;
			stPulsanti &= (!(M1FW | M1BW | M3FW | M3BW | M4FW | M4BW));
			break;
		case 0x08:               //tlc1
			if (rtTLC == 0)
				stPulsanti |= M1FW;
			break;
		case 0x10:               //tlc2
			if (rtTLC == 0)
				stPulsanti |= M1BW;
			break;
		case 0x20:               //tlc3
			if (rtTLC == 0)
				stPulsanti |= M3FW;
			break;
		case 0x04:               //tlc4
			if (rtTLC == 0)
				stPulsanti |= M3BW;
			break;
		case 0x30:               //tlc5
			if (rtTLC == 0)
				stPulsanti |= M4FW;
			break;
		case 0x0c:               //tlc6
			if (rtTLC == 0)
				stPulsanti |= M4BW;
			break;
		default:
			rtTLC = 100;
			stPulsanti &= (!(M1FW | M1BW | M3FW | M3BW | M4FW | M4BW));
			break;
		}
	}
}

void manageCiclo(void) {
	motMov_st m1, m2, m3, m4;
	switch (stCiclo) {
	case omchiuso:
		stPulsanti &= (~P1RELEASED);
		if (stPulsanti & P1START) {
			stBuz = bzwarning;
			rtCiclo = 0;
			stCiclo = omapertura0;
			fchiuso = false;
			(void) m1ap();
			(void) m2ap();
			(void) m3ap();
			(void) m4ap();
		} else if (stPulsanti & P1STOP) {
			fchiuso = false;
			stCiclo = omstopapertura;
		}
#ifdef ANEMCH
		fchiuso = false;
#endif
		if ((ch8 > thanem) && (fchiuso == false)) {
			HAL_GPIO_WritePin(LED1_GPIO_Port, LED1_Pin, GPIO_PIN_SET);
			if (rtAnem == 0) {
				rtCiclo=0;
				stBuz = bzmoving;
				stCiclo = omemergenza1;
				(void) m1ch();
				(void) m2ch();
				(void) m3ch();
				(void) m4ch();
			}
		} else{
			HAL_GPIO_WritePin(LED1_GPIO_Port, LED1_Pin, GPIO_PIN_RESET);
			rtAnem = tanem;
		}
		break;
	case omM1fw1:
		(void) ramp(M1, FW, mrampstart[M1 - 1], m1pwmMan, trampman, RAMPRUN);
		if (rtCiclo >= m1TimeoutMan)
			stCiclo = omStopMan;
		if (pulsanti == 0)
			stCiclo = omM1fw2;
		break;
	case omM1fw2:
		(void) ramp(M1, FW, mrampstart[M1 - 1], m1pwmMan, trampman, RAMPRUN);
		if (rtCiclo >= m1TimeoutMan)
			stCiclo = omStopMan;
		if (pulsanti)
			stCiclo = omStopMan;
		break;
	case omM1bw1:
		(void) ramp(M1, BW, mrampstart[M1 - 1], m1pwmMan, trampman, RAMPRUN);
		if (rtCiclo >= m1TimeoutMan)
			stCiclo = omStopMan;
		if (pulsanti == 0)
			stCiclo = omM1bw2;
		break;
	case omM1bw2:
		(void) ramp(M1, BW, mrampstart[M1 - 1], m1pwmMan, trampman, RAMPRUN);
		if (rtCiclo >= m1TimeoutMan)
			stCiclo = omStopMan;
		if (pulsanti)
			stCiclo = omStopMan;
		break;
	case omM2fw1:
		(void) ramp(M2, FW, mrampstart[M2 - 1], m2pwmMan, trampman, RAMPRUN);
		if (rtCiclo >= m2TimeoutMan)
			stCiclo = omStopMan;
		if (pulsanti == 0)
			stCiclo = omM2fw2;
		break;
	case omM2fw2:
		(void) ramp(M2, FW, mrampstart[M2 - 1], m2pwmMan, trampman, RAMPRUN);
		if (rtCiclo >= m2TimeoutMan)
			stCiclo = omStopMan;
		if (pulsanti)
			stCiclo = omStopMan;
		break;
	case omM2bw1:
		(void) ramp(M2, BW, mrampstart[M2 - 1], m2pwmMan, trampman, RAMPRUN);
		if (rtCiclo >= m2TimeoutMan)
			stCiclo = omStopMan;
		if (pulsanti == 0)
			stCiclo = omM2bw2;
		break;
	case omM2bw2:
		(void) ramp(M2, BW, mrampstart[M2 - 1], m2pwmMan, trampman, RAMPRUN);
		if (rtCiclo >= m2TimeoutMan)
			stCiclo = omStopMan;
		if (pulsanti)
			stCiclo = omStopMan;
		break;
	case omM3fw1:
		(void) ramp(M3, FW, mrampstart[M3 - 1], m3pwmMan, trampman, RAMPRUN);
		if (rtCiclo >= m3TimeoutMan)
			stCiclo = omStopMan;
		if (pulsanti == 0)
			stCiclo = omM3fw2;
		break;
	case omM3fw2:
		(void) ramp(M3, FW, mrampstart[M3 - 1], m3pwmMan, trampman, RAMPRUN);
		if (rtCiclo >= m3TimeoutMan)
			stCiclo = omStopMan;
		if (pulsanti)
			stCiclo = omStopMan;
		break;
	case omM3bw1:
		(void) ramp(M3, BW, mrampstart[M3 - 1], m3pwmMan, trampman, RAMPRUN);
		if (rtCiclo >= m3TimeoutMan)
			stCiclo = omStopMan;
		if (pulsanti == 0)
			stCiclo = omM3bw2;
		break;
	case omM3bw2:
		(void) ramp(M3, BW, mrampstart[M3 - 1], m3pwmMan, trampman, RAMPRUN);
		if (rtCiclo >= m3TimeoutMan)
			stCiclo = omStopMan;
		if (pulsanti)
			stCiclo = omStopMan;
		break;
	case omM4fw1:
		(void) ramp(M4, FW, mrampstart[M4 - 1], m4pwmMan, trampman, RAMPRUN);
		if (rtCiclo >= m4TimeoutMan)
			stCiclo = omStopMan;
		if (pulsanti == 0)
			stCiclo = omM4fw2;
		break;
	case omM4fw2:
		(void) ramp(M4, FW, mrampstart[M4 - 1], m4pwmMan, trampman, RAMPRUN);
		if (rtCiclo >= m4TimeoutMan)
			stCiclo = omStopMan;
		if (pulsanti)
			stCiclo = omStopMan;
		break;
	case omM4bw1:
		(void) ramp(M4, BW, mrampstart[M4 - 1], m4pwmMan, trampman, RAMPRUN);
		if (rtCiclo >= m4TimeoutMan)
			stCiclo = omStopMan;
		if (pulsanti == 0)
			stCiclo = omM4bw2;
		break;
	case omM4bw2:
		(void) ramp(M4, BW, mrampstart[M4 - 1], m4pwmMan, trampman, RAMPRUN);
		if (rtCiclo >= m4TimeoutMan)
			stCiclo = omStopMan;
		if (pulsanti)
			stCiclo = omStopMan;
		break;
	case omStopMan:
		SetMotPerc(M1, FW, 0);
		SetMotPerc(M2, FW, 0);
		SetMotPerc(M3, FW, 0);
		SetMotPerc(M4, FW, 0);
		SetMotPerc(M1, BW, 0);
		SetMotPerc(M2, BW, 0);
		SetMotPerc(M3, BW, 0);
		SetMotPerc(M4, BW, 0);
		if (pulsanti == 0) {
			stBuz = bzoff;
			stCiclo = omaperto;
		}
		break;
	case omapertura0:
		if (rtCiclo >= 30) {               //dopo 3 secondi
			stBuz = bzmoving;
			m1 = m1ap();
			m2 = m2ap();
			m3 = m3ap();
			m4 = m4ap();
			if ((m1 == motStop) && (m2 == motStop) && (m3 == motStop)
					&& (m4 == motStop)) {
				stBuz = bzoff;
				stCiclo = omaperto;
			}
		}
		if (stPulsanti & P1STOP)
			stCiclo = omstopapertura;
		if ((stPulsanti & P1START)&&(stPulsanti & P1RELEASED)) {
			stCiclo = omstoprestartchiusura;
			rtCiclo = 0;
		}
		break;
	case omstopapertura:
		SetMotPerc(M1, FW, 0);
		SetMotPerc(M2, FW, 0);
		SetMotPerc(M3, FW, 0);
		SetMotPerc(M4, FW, 0);
		SetMotPerc(M1, BW, 0);
		SetMotPerc(M2, BW, 0);
		SetMotPerc(M3, BW, 0);
		SetMotPerc(M4, BW, 0);
		if (pulsanti == 0) {
			stBuz = bzoff;
			stCiclo = omchiuso;
			stPulsanti &= (~P1STOP);
		}
		break;
	case omstoprestartchiusura:
		SetMotPerc(M1, FW, 0);
		SetMotPerc(M2, FW, 0);
		SetMotPerc(M3, FW, 0);
		SetMotPerc(M4, FW, 0);
		SetMotPerc(M1, BW, 0);
		SetMotPerc(M2, BW, 0);
		SetMotPerc(M3, BW, 0);
		SetMotPerc(M4, BW, 0);
		stBuz = bzoff;
		if (rtCiclo >= 20)
			stCiclo = omaperto;
		break;
	case omaperto:
		stPulsanti &= (~P1RELEASED);
		rtCiclo = 0;
		if (stPulsanti & P1START) {
			stBuz = bzmoving;
			//(void)ramp(M1,BW,mrampstart[M1-1],m1pwmch,tramp,RAMPINIT);
			stCiclo = omchiusura1;
			(void) m1ch();
			(void) m2ch();
			(void) m3ch();
			(void) m4ch();
		}
		if (ch8 > thanem) {
			HAL_GPIO_WritePin(LED1_GPIO_Port, LED1_Pin, GPIO_PIN_SET);
			if (rtAnem == 0) {
				stBuz = bzmoving;
				stCiclo = omemergenza1;
				(void) m1ch();
				(void) m2ch();
				(void) m3ch();
				(void) m4ch();
			}
		} else{
			HAL_GPIO_WritePin(LED1_GPIO_Port, LED1_Pin, GPIO_PIN_RESET);
			rtAnem = tanem;
		}

		if (stPulsanti & P1STOP)
			stCiclo = omstopchiusura;
		else if (stPulsanti & M1FW) {
			stBuz = bzmoving;
			(void) ramp(M1, FW, mrampstart[M1 - 1], m1pwmMan, trampman,
					RAMPINIT);
			stCiclo = omM1fw1;
		} else if (stPulsanti & M1BW) {
			stBuz = bzmoving;
			(void) ramp(M1, BW, mrampstart[M1 - 1], m1pwmMan, trampman,
					RAMPINIT);
			stCiclo = omM1bw1;
		} else if (stPulsanti & M2FW) {
			stBuz = bzmoving;
			(void) ramp(M2, FW, mrampstart[M2 - 1], m2pwmMan, trampman,
					RAMPINIT);
			stCiclo = omM2fw1;
		} else if (stPulsanti & M2BW) {
			stBuz = bzmoving;
			(void) ramp(M2, BW, mrampstart[M2 - 1], m2pwmMan, trampman,
					RAMPINIT);
			stCiclo = omM2bw1;
		} else if (stPulsanti & M3FW) {
			stBuz = bzmoving;
			(void) ramp(M3, FW, mrampstart[M3 - 1], m3pwmMan, trampman,
					RAMPINIT);
			stCiclo = omM3fw1;
		} else if (stPulsanti & M3BW) {
			stBuz = bzmoving;
			(void) ramp(M3, BW, mrampstart[M3 - 1], m3pwmMan, trampman,
					RAMPINIT);
			stCiclo = omM3bw1;
		} else if (stPulsanti & M4FW) {
			stBuz = bzmoving;
			(void) ramp(M4, FW, mrampstart[M4 - 1], m3pwmMan, trampman,
					RAMPINIT);
			stCiclo = omM4fw1;
		} else if (stPulsanti & M4BW) {
			stBuz = bzmoving;
			(void) ramp(M4, BW, mrampstart[M4 - 1], m3pwmMan, trampman,
					RAMPINIT);
			stCiclo = omM4bw1;
		}
		break;
	case omchiusura1:
		if (rtCiclo >= 10) {               //doppo 1 secondi
			m1 = m1ch();
			m2 = m2ch();
			m3 = m3ch();
			m4 = m4ch();
			if ((m1 == motStop) && (m2 == motStop) && (m3 == motStop)
					&& (m4 == motStop)) {
				stBuz = bzoff;
				stCiclo = omchiuso;
				fchiuso = true;
			}
		}
		if (stPulsanti & P1STOP)
			stCiclo = omstopchiusura;
		if ((stPulsanti & P1START)&&(stPulsanti & P1RELEASED)) {
			stCiclo = omstoprestartapertura;
			rtCiclo = 0;
		}
		break;
	case omemergenza1:
		if (rtCiclo >= 10) {               //doppo 1 secondi
			m1 = m1ch();
			m2 = m2ch();
			m3 = m3ch();
			m4 = m4ch();
			if ((m1 == motStop) && (m2 == motStop) && (m3 == motStop)
					&& (m4 == motStop)) {
				stBuz = bzoff;
				stCiclo = omchiuso;
				fchiuso = true;
			}
		}

		break;
	case omstoprestartapertura:
		SetMotPerc(M1, FW, 0);
		SetMotPerc(M2, FW, 0);
		SetMotPerc(M3, FW, 0);
		SetMotPerc(M4, FW, 0);
		SetMotPerc(M1, BW, 0);
		SetMotPerc(M2, BW, 0);
		SetMotPerc(M3, BW, 0);
		SetMotPerc(M4, BW, 0);
		stBuz = bzoff;
		if (rtCiclo >= 20)
			stCiclo = omchiuso;
		break;
	case omstopchiusura:
		SetMotPerc(M1, FW, 0);
		SetMotPerc(M2, FW, 0);
		SetMotPerc(M3, FW, 0);
		SetMotPerc(M4, FW, 0);
		SetMotPerc(M1, BW, 0);
		SetMotPerc(M2, BW, 0);
		SetMotPerc(M3, BW, 0);
		SetMotPerc(M4, BW, 0);
		if (pulsanti == 0) {
			stBuz = bzoff;
			stCiclo = omaperto;
			stPulsanti &= (~P1STOP);
		}
		break;
	}
}

/* USER CODE END 0 */

/**
 * @brief  The application entry point.
 * @retval int
 */
int main(void) {

	/* USER CODE BEGIN 1 */

	/* USER CODE END 1 */

	/* MCU Configuration--------------------------------------------------------*/

	/* Reset of all peripherals, Initializes the Flash interface and the Systick. */
	HAL_Init();

	/* USER CODE BEGIN Init */

	/* USER CODE END Init */

	/* Configure the system clock */
	SystemClock_Config();

	/* USER CODE BEGIN SysInit */

	/* USER CODE END SysInit */

	/* Initialize all configured peripherals */
	MX_GPIO_Init();
	MX_DMA_Init();
	MX_USB_DEVICE_Init();
	MX_TIM2_Init();
	MX_TIM4_Init();
	MX_ADC1_Init();
	MX_USART1_UART_Init();
	/* USER CODE BEGIN 2 */
	HAL_ADC_Start_DMA(&hadc1, (uint32_t*) adc_dma_buf, ADC_NUM_CHANNELS);
	StopMot(timMot1, FWMot1);
	StopMot(timMot1, BWMot1);
	StopMot(timMot2, FWMot2);
	StopMot(timMot2, BWMot2);
	StopMot(timMot3, FWMot3);
	StopMot(timMot3, BWMot3);
	StopMot(timMot4, FWMot4);
	StopMot(timMot4, BWMot4);
	//CDC_Transmit_FS((uint8_t*)"Start\r\n", 7);
	//while (CDC_Transmit_FS((uint8_t*)"Start\r\n", 7) == USBD_BUSY);
	if (EE_Init() != EE_OK) {
		for (;;)
			;  //errore eeprom
	}
	loadEE();
	if (flagPar != VERSIONE) {
		HAL_GPIO_WritePin(GPIOA, BUZ_Pin, GPIO_PIN_SET);
		loadDefault();
		loadEE();
		HAL_GPIO_WritePin(GPIOA, BUZ_Pin, GPIO_PIN_RESET);
	}
	/* USER CODE END 2 */

	/* Infinite loop */
	/* USER CODE BEGIN WHILE */
	fchiuso = false;
	while (1) {
		manageCDC();
		manageAdc();
		managePulsanti();
		manageCiclo();
		debug();
//	  while (CDC_Available()) {
		//	  int c = CDC_ReadByte();
		//if (c < 0) break;

//		  uint8_t out = (uint8_t)c;
//		  if (out >= 'a' && out <= 'z') out -= 32; // to upper

//		  unsigned char s[100];
//		  sprintf((char*)s,"\nc=%03d",c);
//		  while (CDC_Transmit_FS(s, 6) == USBD_BUSY) {
//        // tiny spin or yield
//      }
		//   }

		//HAL_Delay(1000);
		// CDC_Transmit_FS((uint8_t*)"Ping\r\n", 6);
		/* USER CODE END WHILE */

		/* USER CODE BEGIN 3 */
	}
	/* USER CODE END 3 */
}

/**
 * @brief System Clock Configuration
 * @retval None
 */
void SystemClock_Config(void) {
	RCC_OscInitTypeDef RCC_OscInitStruct = { 0 };
	RCC_ClkInitTypeDef RCC_ClkInitStruct = { 0 };
	RCC_PeriphCLKInitTypeDef PeriphClkInit = { 0 };

	/** Initializes the RCC Oscillators according to the specified parameters
	 * in the RCC_OscInitTypeDef structure.
	 */
	RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSE;
	RCC_OscInitStruct.HSEState = RCC_HSE_ON;
	RCC_OscInitStruct.HSEPredivValue = RCC_HSE_PREDIV_DIV1;
	RCC_OscInitStruct.HSIState = RCC_HSI_ON;
	RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
	RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;
	RCC_OscInitStruct.PLL.PLLMUL = RCC_PLL_MUL6;
	if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK) {
		Error_Handler();
	}

	/** Initializes the CPU, AHB and APB buses clocks
	 */
	RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK | RCC_CLOCKTYPE_SYSCLK
			| RCC_CLOCKTYPE_PCLK1 | RCC_CLOCKTYPE_PCLK2;
	RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
	RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
	RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV2;
	RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;

	if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_2) != HAL_OK) {
		Error_Handler();
	}
	PeriphClkInit.PeriphClockSelection = RCC_PERIPHCLK_ADC | RCC_PERIPHCLK_USB;
	PeriphClkInit.AdcClockSelection = RCC_ADCPCLK2_DIV6;
	PeriphClkInit.UsbClockSelection = RCC_USBCLKSOURCE_PLL_DIV1_5;
	if (HAL_RCCEx_PeriphCLKConfig(&PeriphClkInit) != HAL_OK) {
		Error_Handler();
	}
}

/**
 * @brief ADC1 Initialization Function
 * @param None
 * @retval None
 */
static void MX_ADC1_Init(void) {

	/* USER CODE BEGIN ADC1_Init 0 */

	/* USER CODE END ADC1_Init 0 */

	ADC_ChannelConfTypeDef sConfig = { 0 };

	/* USER CODE BEGIN ADC1_Init 1 */

	/* USER CODE END ADC1_Init 1 */

	/** Common config
	 */
	hadc1.Instance = ADC1;
	hadc1.Init.ScanConvMode = ADC_SCAN_ENABLE;
	hadc1.Init.ContinuousConvMode = ENABLE;
	hadc1.Init.DiscontinuousConvMode = DISABLE;
	hadc1.Init.ExternalTrigConv = ADC_SOFTWARE_START;
	hadc1.Init.DataAlign = ADC_DATAALIGN_RIGHT;
	hadc1.Init.NbrOfConversion = 5;
	if (HAL_ADC_Init(&hadc1) != HAL_OK) {
		Error_Handler();
	}

	/** Configure Regular Channel
	 */
	sConfig.Channel = ADC_CHANNEL_4;
	sConfig.Rank = ADC_REGULAR_RANK_1;
	sConfig.SamplingTime = ADC_SAMPLETIME_28CYCLES_5;
	if (HAL_ADC_ConfigChannel(&hadc1, &sConfig) != HAL_OK) {
		Error_Handler();
	}

	/** Configure Regular Channel
	 */
	sConfig.Channel = ADC_CHANNEL_5;
	sConfig.Rank = ADC_REGULAR_RANK_2;
	if (HAL_ADC_ConfigChannel(&hadc1, &sConfig) != HAL_OK) {
		Error_Handler();
	}

	/** Configure Regular Channel
	 */
	sConfig.Channel = ADC_CHANNEL_6;
	sConfig.Rank = ADC_REGULAR_RANK_3;
	if (HAL_ADC_ConfigChannel(&hadc1, &sConfig) != HAL_OK) {
		Error_Handler();
	}

	/** Configure Regular Channel
	 */
	sConfig.Channel = ADC_CHANNEL_7;
	sConfig.Rank = ADC_REGULAR_RANK_4;
	if (HAL_ADC_ConfigChannel(&hadc1, &sConfig) != HAL_OK) {
		Error_Handler();
	}

	/** Configure Regular Channel
	 */
	sConfig.Channel = ADC_CHANNEL_8;
	sConfig.Rank = ADC_REGULAR_RANK_5;
	if (HAL_ADC_ConfigChannel(&hadc1, &sConfig) != HAL_OK) {
		Error_Handler();
	}
	/* USER CODE BEGIN ADC1_Init 2 */

	/* USER CODE END ADC1_Init 2 */

}

/**
 * @brief TIM2 Initialization Function
 * @param None
 * @retval None
 */
static void MX_TIM2_Init(void) {

	/* USER CODE BEGIN TIM2_Init 0 */

	/* USER CODE END TIM2_Init 0 */

	TIM_ClockConfigTypeDef sClockSourceConfig = { 0 };
	TIM_MasterConfigTypeDef sMasterConfig = { 0 };
	TIM_OC_InitTypeDef sConfigOC = { 0 };

	/* USER CODE BEGIN TIM2_Init 1 */

	/* USER CODE END TIM2_Init 1 */
	htim2.Instance = TIM2;
	htim2.Init.Prescaler = 0;
	htim2.Init.CounterMode = TIM_COUNTERMODE_UP;
	htim2.Init.Period = 17999;
	htim2.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
	htim2.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;
	if (HAL_TIM_Base_Init(&htim2) != HAL_OK) {
		Error_Handler();
	}
	sClockSourceConfig.ClockSource = TIM_CLOCKSOURCE_INTERNAL;
	if (HAL_TIM_ConfigClockSource(&htim2, &sClockSourceConfig) != HAL_OK) {
		Error_Handler();
	}
	if (HAL_TIM_PWM_Init(&htim2) != HAL_OK) {
		Error_Handler();
	}
	sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET;
	sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;
	if (HAL_TIMEx_MasterConfigSynchronization(&htim2, &sMasterConfig)
			!= HAL_OK) {
		Error_Handler();
	}
	sConfigOC.OCMode = TIM_OCMODE_PWM1;
	sConfigOC.Pulse = 1000;
	sConfigOC.OCPolarity = TIM_OCPOLARITY_HIGH;
	sConfigOC.OCFastMode = TIM_OCFAST_ENABLE;
	if (HAL_TIM_PWM_ConfigChannel(&htim2, &sConfigOC, TIM_CHANNEL_1)
			!= HAL_OK) {
		Error_Handler();
	}
	sConfigOC.Pulse = 2000;
	if (HAL_TIM_PWM_ConfigChannel(&htim2, &sConfigOC, TIM_CHANNEL_2)
			!= HAL_OK) {
		Error_Handler();
	}
	sConfigOC.Pulse = 3000;
	sConfigOC.OCFastMode = TIM_OCFAST_DISABLE;
	if (HAL_TIM_PWM_ConfigChannel(&htim2, &sConfigOC, TIM_CHANNEL_3)
			!= HAL_OK) {
		Error_Handler();
	}
	sConfigOC.Pulse = 4000;
	sConfigOC.OCFastMode = TIM_OCFAST_ENABLE;
	if (HAL_TIM_PWM_ConfigChannel(&htim2, &sConfigOC, TIM_CHANNEL_4)
			!= HAL_OK) {
		Error_Handler();
	}
	/* USER CODE BEGIN TIM2_Init 2 */

	/* USER CODE END TIM2_Init 2 */
	HAL_TIM_MspPostInit(&htim2);

}

/**
 * @brief TIM4 Initialization Function
 * @param None
 * @retval None
 */
static void MX_TIM4_Init(void) {

	/* USER CODE BEGIN TIM4_Init 0 */

	/* USER CODE END TIM4_Init 0 */

	TIM_ClockConfigTypeDef sClockSourceConfig = { 0 };
	TIM_MasterConfigTypeDef sMasterConfig = { 0 };
	TIM_OC_InitTypeDef sConfigOC = { 0 };

	/* USER CODE BEGIN TIM4_Init 1 */

	/* USER CODE END TIM4_Init 1 */
	htim4.Instance = TIM4;
	htim4.Init.Prescaler = 0;
	htim4.Init.CounterMode = TIM_COUNTERMODE_UP;
	htim4.Init.Period = 17999;
	htim4.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
	htim4.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;
	if (HAL_TIM_Base_Init(&htim4) != HAL_OK) {
		Error_Handler();
	}
	sClockSourceConfig.ClockSource = TIM_CLOCKSOURCE_INTERNAL;
	if (HAL_TIM_ConfigClockSource(&htim4, &sClockSourceConfig) != HAL_OK) {
		Error_Handler();
	}
	if (HAL_TIM_PWM_Init(&htim4) != HAL_OK) {
		Error_Handler();
	}
	sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET;
	sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;
	if (HAL_TIMEx_MasterConfigSynchronization(&htim4, &sMasterConfig)
			!= HAL_OK) {
		Error_Handler();
	}
	sConfigOC.OCMode = TIM_OCMODE_PWM1;
	sConfigOC.Pulse = 5000;
	sConfigOC.OCPolarity = TIM_OCPOLARITY_HIGH;
	sConfigOC.OCFastMode = TIM_OCFAST_ENABLE;
	if (HAL_TIM_PWM_ConfigChannel(&htim4, &sConfigOC, TIM_CHANNEL_1)
			!= HAL_OK) {
		Error_Handler();
	}
	sConfigOC.Pulse = 6000;
	if (HAL_TIM_PWM_ConfigChannel(&htim4, &sConfigOC, TIM_CHANNEL_2)
			!= HAL_OK) {
		Error_Handler();
	}
	sConfigOC.Pulse = 7000;
	if (HAL_TIM_PWM_ConfigChannel(&htim4, &sConfigOC, TIM_CHANNEL_3)
			!= HAL_OK) {
		Error_Handler();
	}
	sConfigOC.Pulse = 8000;
	if (HAL_TIM_PWM_ConfigChannel(&htim4, &sConfigOC, TIM_CHANNEL_4)
			!= HAL_OK) {
		Error_Handler();
	}
	/* USER CODE BEGIN TIM4_Init 2 */

	/* USER CODE END TIM4_Init 2 */
	HAL_TIM_MspPostInit(&htim4);

}

/**
 * @brief USART1 Initialization Function
 * @param None
 * @retval None
 */
static void MX_USART1_UART_Init(void) {

	/* USER CODE BEGIN USART1_Init 0 */

	/* USER CODE END USART1_Init 0 */

	/* USER CODE BEGIN USART1_Init 1 */

	/* USER CODE END USART1_Init 1 */
	huart1.Instance = USART1;
	huart1.Init.BaudRate = 115200;
	huart1.Init.WordLength = UART_WORDLENGTH_8B;
	huart1.Init.StopBits = UART_STOPBITS_1;
	huart1.Init.Parity = UART_PARITY_NONE;
	huart1.Init.Mode = UART_MODE_TX_RX;
	huart1.Init.HwFlowCtl = UART_HWCONTROL_NONE;
	huart1.Init.OverSampling = UART_OVERSAMPLING_16;
	if (HAL_UART_Init(&huart1) != HAL_OK) {
		Error_Handler();
	}
	/* USER CODE BEGIN USART1_Init 2 */

	/* USER CODE END USART1_Init 2 */

}

/**
 * Enable DMA controller clock
 */
static void MX_DMA_Init(void) {

	/* DMA controller clock enable */
	__HAL_RCC_DMA1_CLK_ENABLE();

	/* DMA interrupt init */
	/* DMA1_Channel1_IRQn interrupt configuration */
	HAL_NVIC_SetPriority(DMA1_Channel1_IRQn, 0, 0);
	HAL_NVIC_EnableIRQ(DMA1_Channel1_IRQn);

}

/**
 * @brief GPIO Initialization Function
 * @param None
 * @retval None
 */
static void MX_GPIO_Init(void) {
	GPIO_InitTypeDef GPIO_InitStruct = { 0 };
	/* USER CODE BEGIN MX_GPIO_Init_1 */

	/* USER CODE END MX_GPIO_Init_1 */

	/* GPIO Ports Clock Enable */
	__HAL_RCC_GPIOC_CLK_ENABLE();
	__HAL_RCC_GPIOD_CLK_ENABLE();
	__HAL_RCC_GPIOA_CLK_ENABLE();
	__HAL_RCC_GPIOB_CLK_ENABLE();

	/*Configure GPIO pin Output Level */
	HAL_GPIO_WritePin(LED2_GPIO_Port, LED2_Pin, GPIO_PIN_RESET);

	/*Configure GPIO pin Output Level */
	HAL_GPIO_WritePin(GPIOB,
			INH1_Pin | INH2_Pin | INH3_Pin | INH4_Pin | EXP1_Pin | EXP2_Pin
					| EXP3_Pin, GPIO_PIN_RESET);

	/*Configure GPIO pin Output Level */
	HAL_GPIO_WritePin(GPIOA, BUZ_Pin | LED1_Pin, GPIO_PIN_RESET);

	/*Configure GPIO pin : LED2_Pin */
	GPIO_InitStruct.Pin = LED2_Pin;
	GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
	GPIO_InitStruct.Pull = GPIO_NOPULL;
	GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
	HAL_GPIO_Init(LED2_GPIO_Port, &GPIO_InitStruct);

	/*Configure GPIO pins : P1_Pin P2_Pin */
	GPIO_InitStruct.Pin = P1_Pin | P2_Pin;
	GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
	GPIO_InitStruct.Pull = GPIO_NOPULL;
	HAL_GPIO_Init(GPIOC, &GPIO_InitStruct);

	/*Configure GPIO pin : AIN1_Pin */
	GPIO_InitStruct.Pin = AIN1_Pin;
	GPIO_InitStruct.Mode = GPIO_MODE_ANALOG;
	HAL_GPIO_Init(AIN1_GPIO_Port, &GPIO_InitStruct);

	/*Configure GPIO pins : INH1_Pin INH2_Pin INH3_Pin INH4_Pin
	 EXP1_Pin EXP2_Pin EXP3_Pin */
	GPIO_InitStruct.Pin = INH1_Pin | INH2_Pin | INH3_Pin | INH4_Pin | EXP1_Pin
			| EXP2_Pin | EXP3_Pin;
	GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
	GPIO_InitStruct.Pull = GPIO_NOPULL;
	GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
	HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);

	/*Configure GPIO pins : CH1_Pin CH2_Pin CH3_Pin CH4_Pin */
	GPIO_InitStruct.Pin = CH1_Pin | CH2_Pin | CH3_Pin | CH4_Pin;
	GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
	GPIO_InitStruct.Pull = GPIO_NOPULL;
	HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);

	/*Configure GPIO pins : BUZ_Pin LED1_Pin */
	GPIO_InitStruct.Pin = BUZ_Pin | LED1_Pin;
	GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
	GPIO_InitStruct.Pull = GPIO_NOPULL;
	GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
	HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);

	/* USER CODE BEGIN MX_GPIO_Init_2 */

	/* USER CODE END MX_GPIO_Init_2 */
}

/* USER CODE BEGIN 4 */

/* USER CODE END 4 */

/**
 * @brief  This function is executed in case of error occurrence.
 * @retval None
 */
void Error_Handler(void) {
	/* USER CODE BEGIN Error_Handler_Debug */
	/* User can add his own implementation to report the HAL error return state */
	__disable_irq();
	while (1) {
	}
	/* USER CODE END Error_Handler_Debug */
}
#ifdef USE_FULL_ASSERT
/**
  * @brief  Reports the name of the source file and the source line number
  *         where the assert_param error has occurred.
  * @param  file: pointer to the source file name
  * @param  line: assert_param error line source number
  * @retval None
  */
void assert_failed(uint8_t *file, uint32_t line)
{
  /* USER CODE BEGIN 6 */
  /* User can add his own implementation to report the file name and line number,
     ex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */
  /* USER CODE END 6 */
}
#endif /* USE_FULL_ASSERT */