/*

Anil Kumar M
Banglore-560062
Email:anilkumarofficial01@gmail.com
Mobile No.: 9380042627
LinkedIn: https://www.linkedin.com/in/anilkumar98/
*/
/*
Implementation of the 5boxes project
*Microcontroller STM32F407VG is the main controller for the particular
application. Performance and low cost, availability of pins for different
communication protocols (2 × CAN interfaces (2.0B Active)),1 Mbyte of
Flash memory, and 168Mhz M4 core with DSP and FPU, enable RTOS to
Complete tasks faster.
*Display LCD I2C interface for prototyping.
\*used peripheral Programming*\
RTOS,interrupts,CAN,functions,structure,RTC,I2C Display.
*/

//ALL necessary headers attached in a different file

#include <stdint.h>
#include <stdio.h>
#include <string.h>
//user defined headers
#include "main.h"
#include "cmsis_os.h"
#include "stm32f4xx_hal.h"
#include "FreeRTOS.h"
#include "task.h"
#include "timers.h"
#include "queue.h"
#include "semphr.h"
#include "event_groups.h"
#include "stm32f4xx.h" // Device header
#include "i2c-lcd.h"

void VoltageDISP();
void UARTFUN();
void PINUPDATE();
int BOXES5();

struct Digital
{ uint8_t pack;
uint8_t open;
char DM[20];
} ;

/* CODE END PTD */

typedef struct Digital DL;
DL packag,opened;
DL *ptr;
uint8_t DP1,DO1,DP2,DO2,DP3,DO3,DP4,DO4,DP5,DO5;//Box digital
package(DPx) and opened pins(DOx) respectively
uint16_t A[5];//Box Analog pins 0-5 (Ax) respectively

ADC_HandleTypeDef hadc1;
DMA_HandleTypeDef hdma_adc1;

CAN_HandleTypeDef hcan1;

I2C_HandleTypeDef hi2c1;

RTC_HandleTypeDef hrtc;
RTC_TimeTypeDef sTime;
RTC_DateTypeDef sDate;

TIM_HandleTypeDef htim1;

UART_HandleTypeDef huart1;

osThreadId defaultTaskHandle;
osThreadId myTask02Handle;
osThreadId myTask03Handle;
osThreadId myTask04Handle;
osMutexId UART_MutexHandle;

void SystemClock_Config(void);
static void MX_GPIO_Init(void);
static void MX_DMA_Init(void);
static void MX_ADC1_Init(void);
static void MX_CAN1_Init(void);
static void MX_I2C1_Init(void);
static void MX_RTC_Init(void);
static void MX_TIM1_Init(void);
static void MX_USART1_UART_Init(void);
void Thread0(void const * argument);
void Thread1(void const * argument);
void Thread2(void const * argument);
void Thread3(void const * argument);

/* CODE BEGIN PFP */

CAN_TxHeaderTypeDef TxHeader;
CAN_RxHeaderTypeDef RxHeader;
/* CODE END PFP */
uint8_t TxData[8] ="can INIT";
uint8_t TxData1[8]="BxDtUrt";
uint8_t RxData[8];

uint32_t TxMailbox;
/*---------------------------------------------------------*/
uint8_t txbox1o[20] ="box1 can be opened";
uint8_t txbox1c[20] ="Box1 not closed";
uint8_t txbox1p[20] ="box1 has package";
uint8_t txbox2o[20] ="box2 can be opened";
uint8_t txbox2c[20] ="Box2 not closed";
uint8_t txbox2p[20] ="box2 has package";
uint8_t txbox3o[20] ="box3 can be opened";
uint8_t txbox3c[20] ="Box3 not closed";
uint8_t txbox3p[20] ="box3 has package";
uint8_t txbox4o[20] ="box4 can be opened";
uint8_t txbox4c[20] ="Box4 not closed";
uint8_t txbox4p[20] ="box4 has package";
uint8_t txbox5o[20] ="box5 can be opened";
uint8_t txbox5c[20] ="Box5 not closed";
uint8_t txbox5p[20] ="box5 has package";
uint8_t txpkpr[20]="Package present";
uint8_t txpknp[20]="Package not present";
uint8_t INTU[20]="Interruptpin high";

int main(void)
{ ptr=&packag;
/* BEGIN 1 */
DL packag={1,1,"V2.0"};
char *str;
strcpy(str,packag.DM);
HAL_UART_Transmit(&huart1,str,20,10);

/* END 1 */
HAL_CAN_Start(&hcan1);
//Activate the notification
HAL_CAN_ActivateNotification(&hcan1, CAN_IT_RX_FIFO0_MSG_PENDING);

TxHeader.DLC =2;//data length

TxHeader.IDE=CAN_ID_STD;
TxHeader.RTR=CAN_RTR_DATA;
TxHeader.StdId=0x456;//ID
/* MCU Configuration---------------------------------------------------
-----*/
//HAL_CAN_Init(&hcan1);
/* Reset of all peripherals, Initializes the Flash interface and the
Systick. */
HAL_Init();

/* Configure the system clock */

SystemClock_Config();

/* Initialize all configured peripherals */

MX_GPIO_Init();
MX_DMA_Init();
MX_ADC1_Init();
MX_CAN1_Init();
HAL_CAN_AddTxMessage(&hcan1, &TxHeader,TxData, &TxMailbox);
MX_I2C1_Init();
MX_RTC_Init();
MX_TIM1_Init();
MX_USART1_UART_Init();
/* USER CODE BEGIN 2 */
lcd_init();//initialize the i2c LCD
HAL_ADC_Start_DMA(&hadc1,(uint32_t *)A,5);//start adc in dma mode
HAL_ADC_Start(&hadc1);
//set Time
sTime.Hours=23;
sTime.Minutes=59;
sTime.Seconds=45;
HAL_RTC_SetTime(&hrtc,&sTime,RTC_FORMAT_BIN);
//2 set date
sDate.Date=31;
sDate.Month= RTC_MONTH_DECEMBER;
sDate.WeekDay=RTC_WEEKDAY_SUNDAY;
sDate.Year=17;
HAL_RTC_SetDate(&hrtc,&sDate,RTC_FORMAT_BIN);
//here value is the buffer,where the adc values are going to store
//5 is the number of values going to store

/* Create the mutex(es) */

/* definition and creation of UART_Mutex */
osMutexDef(UART_Mutex);
UART_MutexHandle = osMutexCreate(osMutex(UART_Mutex));

/* Create the thread(s) */

/* definition and creation of defaultTask */
osThreadDef(defaultTask, Thread0, osPriorityNormal, 0, 128);
defaultTaskHandle = osThreadCreate(osThread(defaultTask), NULL);

/* definition and creation of myTask02 */

osThreadDef(myTask02, Thread1, osPriorityIdle, 0, 128);
myTask02Handle = osThreadCreate(osThread(myTask02), NULL);

/* definition and creation of myTask03 */

osThreadDef(myTask03, Thread2, osPriorityIdle, 0, 128);
myTask03Handle = osThreadCreate(osThread(myTask03), NULL);

/* definition and creation of myTask04 */

osThreadDef(myTask04, Thread3, osPriorityIdle, 0, 128);
myTask04Handle = osThreadCreate(osThread(myTask04), NULL);

/* USER CODE BEGIN RTOS_THREADS */

/* add threads, ... */
/* USER CODE END RTOS_THREADS */

/* Start scheduler */
osKernelStart();

while (1)
{ //code in main() for test purpose...
/****
HAL_RTC_GetTime(&hrtc,&sTime,RTC_FORMAT_BIN);
HAL_RTC_GetDate(&hrtc,&sDate,RTC_FORMAT_BIN);
HAL_Delay(200);
USER CODE END WHILE ****/
/* DP1= HAL_GPIO_ReadPin(GPIOD, GPIO_PIN_10);
DO1=HAL_GPIO_ReadPin(GPIOD, GPIO_PIN_11);
DP2=HAL_GPIO_ReadPin(GPIOD, GPIO_PIN_12);
DO2=HAL_GPIO_ReadPin(GPIOD, GPIO_PIN_13);
DP3=HAL_GPIO_ReadPin(GPIOD, GPIO_PIN_14);
DO3=HAL_GPIO_ReadPin(GPIOD, GPIO_PIN_15);
DP4=HAL_GPIO_ReadPin(GPIOC, GPIO_PIN_6);
DO4=HAL_GPIO_ReadPin(GPIOC, GPIO_PIN_7);
DP5=HAL_GPIO_ReadPin(GPIOC, GPIO_PIN_8);
DO5=HAL_GPIO_ReadPin(GPIOC, GPIO_PIN_9);
*/
/**** PINUPDATE();
HAL_CAN_AddTxMessage(&hcan1, &TxHeader,TxData1, &TxMailbox);
switch((int)BOXES5)
{
case 1:

HAL_UART_Transmit(&huart1,txbox1o,20,10);
while(DO1)
 {
PINUPDATE();
HAL_UART_Transmit(&huart1,txbox1c,20,10);
//printf("Box1 not closed");
}
PINUPDATE();
if(DP1)
{HAL_UART_Transmit(&huart1,txpkpr,20,10);
//printf("Package present");
}
else
{HAL_UART_Transmit(&huart1,txpknp,20,10);
//printf("no package");
}
break;
case 2:
HAL_UART_Transmit(&huart1,txbox2o,20,10);
//printf("box2 can be opened");
while(DO2){
PINUPDATE();
HAL_UART_Transmit(&huart1,txbox2c,20,10);
//printf("Box2 not closed");
}
PINUPDATE();
if(DP2)
{HAL_UART_Transmit(&huart1,txpkpr,20,10);
//printf("Package present");
}
else
{HAL_UART_Transmit(&huart1,txpknp,20,10);
//printf("no package");
}
break;
case 3:
HAL_UART_Transmit(&huart1,txbox3o,20,10);
//printf("box3 can be opened");
while(DO3){
PINUPDATE();
HAL_UART_Transmit(&huart1,txbox3c,20,10);
//printf("Box3 not closed");
}
PINUPDATE();
if(DP3)
{HAL_UART_Transmit(&huart1,txpkpr,20,10);
//printf("Package present");
}
else
{HAL_UART_Transmit(&huart1,txpknp,20,10);
//printf("no package");
}
break;
case 4:
HAL_UART_Transmit(&huart1,txbox4o,20,10);
//printf("box4 can be opened");
while(DO4){
PINUPDATE();
HAL_UART_Transmit(&huart1,txbox4c,20,10);
//printf("Box4 not closed");
}
PINUPDATE();
 if(DP4)
{HAL_UART_Transmit(&huart1,txpkpr,20,10);
//printf("Package present");
}
else
{ HAL_UART_Transmit(&huart1,txpknp,20,10);
//printf("no package");
}
break;
case 5:
HAL_UART_Transmit(&huart1,txbox5o,20,10);
//printf("box5 can be opened");
while(DO5){
PINUPDATE();
HAL_UART_Transmit(&huart1,txbox5c,20,10);
//printf("Box5 not closed");
}
PINUPDATE();
if(DP5)
{ HAL_UART_Transmit(&huart1,txpkpr,20,10);
//printf("Package present");
}
else
{HAL_UART_Transmit(&huart1,txpknp,20,10);
//printf("no package");
}
break;
default:
PINUPDATE();
if(DP1|DP2|DP3|DP4|DP5)
{

if(DP1){HAL_UART_Transmit(&huart1,txbox1p,20,10);}if(DP2){HAL_UART_
Transmit(&huart1,txbox2p,20,10);}if(DP3){HAL_UART_Transmit(&huart1,txbox3
p,20,10);}if(DP4){
HAL_UART_Transmit(&huart1,txbox4p,20,10);}if(DP5){HAL_UART_Transmit(&huar
t1,txbox5p,20,10);}
}
break;
}****/
/* USER CODE BEGIN 3 */
}
/* USER CODE END 3 */
}
int BOXES5()
{
if(DP1&&DO1)
{
if(A[0]>=1639 && A[0]<=2459)
{
return 1;
}
}
if(DP2&&DO2)
{
if(A[1]>=1639 && A[1]<=2459)
{
return 2;
}
}
 if(DP3&&DO3)
{
if(A[2]>=1639 && A[2]<=2459)
{
return 3;
}
}
if(DP4&&DO4)
{
if(A[3]>=1639 && A[3]<=2459)
{
return 4;
}
}
if(DP5&&DO5)
{
if(A[4]>=1639 && A[4]<=2459)
{
return 5;
}
}
return 0;
}

void PINUPDATE()
{
DP1= HAL_GPIO_ReadPin(GPIOD, GPIO_PIN_10);
DO1=HAL_GPIO_ReadPin(GPIOD, GPIO_PIN_11);
DP2=HAL_GPIO_ReadPin(GPIOD, GPIO_PIN_12);
DO2=HAL_GPIO_ReadPin(GPIOD, GPIO_PIN_13);
DP3=HAL_GPIO_ReadPin(GPIOD, GPIO_PIN_14);
DO3=HAL_GPIO_ReadPin(GPIOD, GPIO_PIN_15);
DP4=HAL_GPIO_ReadPin(GPIOC, GPIO_PIN_6);
DO4=HAL_GPIO_ReadPin(GPIOC, GPIO_PIN_7);
DP5=HAL_GPIO_ReadPin(GPIOC, GPIO_PIN_8);
DO5=HAL_GPIO_ReadPin(GPIOC, GPIO_PIN_9);
}

void VoltageDISP(){
lcd_send_cmd(0x80);//postion 00
lcd_send_string("CH0 --A1 voltage");
lcd_send_data((A[0]*0.001221));
HAL_Delay(1000);
lcd_clear();
lcd_send_string("CH1 --A2 voltage");
lcd_send_data((A[1]*0.001221));
HAL_Delay(1000);
lcd_clear();
lcd_send_string("CH2 --A3 voltage");
lcd_send_data((A[2]*0.001221));
HAL_Delay(1000);
lcd_clear();
lcd_send_string("CH0 --A4 voltage");
lcd_send_data((A[3]*0.001221));
HAL_Delay(1000);
lcd_clear();
lcd_send_string("CH0 --A5 voltage");
lcd_send_data((A[4]*0.001221));
HAL_Delay(1000);
lcd_clear();
}

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

/** Configure the main internal regulator output voltage

*/
__HAL_RCC_PWR_CLK_ENABLE();
__HAL_PWR_VOLTAGESCALING_CONFIG(PWR_REGULATOR_VOLTAGE_SCALE1);
/** Initializes the RCC Oscillators according to the specified
parameters
* in the RCC_OscInitTypeDef structure.
*/
RCC_OscInitStruct.OscillatorType =
RCC_OSCILLATORTYPE_LSI|RCC_OSCILLATORTYPE_HSE;
RCC_OscInitStruct.HSEState = RCC_HSE_ON;
RCC_OscInitStruct.LSIState = RCC_LSI_ON;
RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;
RCC_OscInitStruct.PLL.PLLM = 8;
RCC_OscInitStruct.PLL.PLLN = 336;
RCC_OscInitStruct.PLL.PLLP = RCC_PLLP_DIV2;
RCC_OscInitStruct.PLL.PLLQ = 7;
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_DIV4;
RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV2;

if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_5) != HAL_OK)

{
Error_Handler();
}
PeriphClkInitStruct.PeriphClockSelection = RCC_PERIPHCLK_RTC;
PeriphClkInitStruct.RTCClockSelection = RCC_RTCCLKSOURCE_LSI;
if (HAL_RCCEx_PeriphCLKConfig(&PeriphClkInitStruct) != HAL_OK)
{
Error_Handler();
}
}

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

/* BEGIN ADC1_Init 0 */

/* END ADC1_Init 0 */

ADC_ChannelConfTypeDef sConfig = {0};

/* BEGIN ADC1_Init 1 */

/* END ADC1_Init 1 */
/** Configure the global features of the ADC (Clock, Resolution, Data
Alignment and number of conversion)
*/
hadc1.Instance = ADC1;
hadc1.Init.ClockPrescaler = ADC_CLOCK_SYNC_PCLK_DIV8;
hadc1.Init.Resolution = ADC_RESOLUTION_8B;
hadc1.Init.ScanConvMode = ENABLE;
hadc1.Init.ContinuousConvMode = ENABLE;
hadc1.Init.DiscontinuousConvMode = DISABLE;
hadc1.Init.ExternalTrigConvEdge = ADC_EXTERNALTRIGCONVEDGE_NONE;
hadc1.Init.ExternalTrigConv = ADC_SOFTWARE_START;
hadc1.Init.DataAlign = ADC_DATAALIGN_RIGHT;
hadc1.Init.NbrOfConversion = 5;
hadc1.Init.DMAContinuousRequests = ENABLE;
hadc1.Init.EOCSelection = ADC_EOC_SINGLE_CONV;
if (HAL_ADC_Init(&hadc1) != HAL_OK)
{
Error_Handler();
}
/** Configure for the selected ADC regular channel its corresponding
rank in the sequencer and its sample time.
*/
sConfig.Channel = ADC_CHANNEL_0;
sConfig.Rank = 1;
sConfig.SamplingTime = ADC_SAMPLETIME_480CYCLES;
if (HAL_ADC_ConfigChannel(&hadc1, &sConfig) != HAL_OK)
{
Error_Handler();
}
/** Configure for the selected ADC regular channel its corresponding
rank in the sequencer and its sample time.
*/
sConfig.Channel = ADC_CHANNEL_1;
sConfig.Rank = 2;
if (HAL_ADC_ConfigChannel(&hadc1, &sConfig) != HAL_OK)
{
Error_Handler();
}
/** Configure for the selected ADC regular channel its corresponding
rank in the sequencer and its sample time.
*/
sConfig.Channel = ADC_CHANNEL_2;
sConfig.Rank = 3;
if (HAL_ADC_ConfigChannel(&hadc1, &sConfig) != HAL_OK)
{
Error_Handler();
}
 /** Configure for the selected ADC regular channel its corresponding
rank in the sequencer and its sample time.
*/
sConfig.Channel = ADC_CHANNEL_0;
sConfig.Rank = 4;
if (HAL_ADC_ConfigChannel(&hadc1, &sConfig) != HAL_OK)
{
Error_Handler();
}
/** Configure for the selected ADC regular channel its corresponding
rank in the sequencer and its sample time.
*/
sConfig.Rank = 5;
if (HAL_ADC_ConfigChannel(&hadc1, &sConfig) != HAL_OK)
{
Error_Handler();
}

static void MX_CAN1_Init(void)

{

hcan1.Instance = CAN1;
hcan1.Init.Prescaler = 16;
hcan1.Init.Mode = CAN_MODE_NORMAL;
hcan1.Init.SyncJumpWidth = CAN_SJW_1TQ;
hcan1.Init.TimeSeg1 = CAN_BS1_1TQ;
hcan1.Init.TimeSeg2 = CAN_BS2_1TQ;
hcan1.Init.TimeTriggeredMode = DISABLE;
hcan1.Init.AutoBusOff = DISABLE;
hcan1.Init.AutoWakeUp = DISABLE;
hcan1.Init.AutoRetransmission = DISABLE;
hcan1.Init.ReceiveFifoLocked = DISABLE;
hcan1.Init.TransmitFifoPriority = DISABLE;
if (HAL_CAN_Init(&hcan1) != HAL_OK)
{
Error_Handler();
}

static void MX_I2C1_Init(void)

{

hi2c1.Instance = I2C1;
hi2c1.Init.ClockSpeed = 100000;
hi2c1.Init.DutyCycle = I2C_DUTYCYCLE_2;
hi2c1.Init.OwnAddress1 = 0;
hi2c1.Init.AddressingMode = I2C_ADDRESSINGMODE_7BIT;
hi2c1.Init.DualAddressMode = I2C_DUALADDRESS_DISABLE;
hi2c1.Init.OwnAddress2 = 0;
hi2c1.Init.GeneralCallMode = I2C_GENERALCALL_DISABLE;
hi2c1.Init.NoStretchMode = I2C_NOSTRETCH_DISABLE;
if (HAL_I2C_Init(&hi2c1) != HAL_OK)
{
Error_Handler();
 }

static void MX_RTC_Init(void)

{

RTC_TimeTypeDef sTime = {0};

RTC_DateTypeDef sDate = {0};

/** Initialize RTC Only

*/
hrtc.Instance = RTC;
hrtc.Init.HourFormat = RTC_HOURFORMAT_24;
hrtc.Init.AsynchPrediv = 127;
hrtc.Init.SynchPrediv = 255;
hrtc.Init.OutPut = RTC_OUTPUT_DISABLE;
hrtc.Init.OutPutPolarity = RTC_OUTPUT_POLARITY_HIGH;
hrtc.Init.OutPutType = RTC_OUTPUT_TYPE_OPENDRAIN;
if (HAL_RTC_Init(&hrtc) != HAL_OK)
{
Error_Handler();
}

/** Initialize RTC and set the Time and Date

*/
sTime.Hours = 23;
sTime.Minutes = 59;
sTime.Seconds = 45;
sTime.DayLightSaving = RTC_DAYLIGHTSAVING_NONE;
sTime.StoreOperation = RTC_STOREOPERATION_RESET;
if (HAL_RTC_SetTime(&hrtc, &sTime, RTC_FORMAT_BIN) != HAL_OK)
{
Error_Handler();
}
sDate.WeekDay = RTC_WEEKDAY_SUNDAY;
sDate.Month = RTC_MONTH_DECEMBER;
sDate.Date = 1;
sDate.Year = 0;

if (HAL_RTC_SetDate(&hrtc, &sDate, RTC_FORMAT_BIN) != HAL_OK)

{
Error_Handler();
}

static void MX_TIM1_Init(void)

{

TIM_ClockConfigTypeDef sClockSourceConfig = {0};

TIM_MasterConfigTypeDef sMasterConfig = {0};
 htim1.Instance = TIM1;
htim1.Init.Prescaler = 0;
htim1.Init.CounterMode = TIM_COUNTERMODE_UP;
htim1.Init.Period = 65535;
htim1.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
htim1.Init.RepetitionCounter = 0;
htim1.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;
if (HAL_TIM_Base_Init(&htim1) != HAL_OK)
{
Error_Handler();
}
sClockSourceConfig.ClockSource = TIM_CLOCKSOURCE_INTERNAL;
if (HAL_TIM_ConfigClockSource(&htim1, &sClockSourceConfig) != HAL_OK)
{
Error_Handler();
}
sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET;
sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;
if (HAL_TIMEx_MasterConfigSynchronization(&htim1, &sMasterConfig) !=
HAL_OK)
{
Error_Handler();
}

static void MX_USART1_UART_Init(void)

{

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();
}

static void MX_DMA_Init(void)

{

/* DMA controller clock enable */

__HAL_RCC_DMA2_CLK_ENABLE();

/* DMA interrupt init */

/* DMA2_Stream0_IRQn interrupt configuration */
HAL_NVIC_SetPriority(DMA2_Stream0_IRQn, 5, 0);
HAL_NVIC_EnableIRQ(DMA2_Stream0_IRQn);
}

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

/* GPIO Ports Clock Enable */

__HAL_RCC_GPIOH_CLK_ENABLE();
__HAL_RCC_GPIOA_CLK_ENABLE();
__HAL_RCC_GPIOE_CLK_ENABLE();
__HAL_RCC_GPIOD_CLK_ENABLE();
__HAL_RCC_GPIOC_CLK_ENABLE();
__HAL_RCC_GPIOB_CLK_ENABLE();

/*Configure GPIO pin : EXT_INT_Pin */

GPIO_InitStruct.Pin = EXT_INT_Pin;
GPIO_InitStruct.Mode = GPIO_MODE_IT_RISING;
GPIO_InitStruct.Pull = GPIO_NOPULL;
HAL_GPIO_Init(EXT_INT_GPIO_Port, &GPIO_InitStruct);

/*Configure GPIO pins : GPIO1_PK_Pin GPIO1_OP_Pin GPIO2_PK_Pin

GPIO2_OP_Pin
GPIO3_PK_Pin GPIO3_OP_Pin */
GPIO_InitStruct.Pin =
GPIO1_PK_Pin|GPIO1_OP_Pin|GPIO2_PK_Pin|GPIO2_OP_Pin
|GPIO3_PK_Pin|GPIO3_OP_Pin;
GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
GPIO_InitStruct.Pull = GPIO_NOPULL;
HAL_GPIO_Init(GPIOD, &GPIO_InitStruct);

/*Configure GPIO pins : GPIO4_PK_Pin GPIO4_OP_Pin GPIO5_PK_Pin

GPIO5_OP_Pin */
GPIO_InitStruct.Pin =
GPIO4_PK_Pin|GPIO4_OP_Pin|GPIO5_PK_Pin|GPIO5_OP_Pin;
GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
GPIO_InitStruct.Pull = GPIO_NOPULL;
HAL_GPIO_Init(GPIOC, &GPIO_InitStruct);

}
void HAL_RTC_AlarmAEventCallback(RTC_HandleTypeDef *hrtc)
{

UNUSED(hrtc);

HAL_GPIO_TogglePin(GPIOD,GPIO_PIN_12);
}
/* USER CODE BEGIN 4 */
void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin)
{
/* Prevent unused argument(s) compilation warning */
UNUSED(GPIO_Pin);

HAL_UART_Transmit(&huart1,INTU,20,10);
volatile uint8_t I=0 ;
 I=I^1;
if(I)
{for(;;){}
}
else
{return ;}
}

void Thread0(void const * argument)

{
/* USER CODE BEGIN 5 */
/* Infinite loop */
for(;;)
{ /* USER CODE END WHILE */
HAL_RTC_GetTime(&hrtc,&sTime,RTC_FORMAT_BIN);//Time update on Rtos
HAL_RTC_GetDate(&hrtc,&sDate,RTC_FORMAT_BIN);//Date update
on rtos
HAL_Delay(200);
osDelay(1);
}
/* USER CODE END 5 */
}

/* USER CODE END Header_Thread1 */

void Thread1(void const * argument)
{
/* USER CODE BEGIN Thread1 */
/* Infinite loop */
for(;;)
{
PINUPDATE();
HAL_CAN_AddTxMessage(&hcan1, &TxHeader,TxData1, &TxMailbox);
switch((int)BOXES5)
{
case 1:

HAL_UART_Transmit(&huart1,txbox1o,20,10);
while(DO1)
{
PINUPDATE();
HAL_UART_Transmit(&huart1,txbox1c,20,10);
//printf("Box1 not closed");
}
PINUPDATE();
if(DP1)
{HAL_UART_Transmit(&huart1,txpkpr,20,10);
//printf("Package present");
}
else
{HAL_UART_Transmit(&huart1,txpknp,20,10);
//printf("no package");
}
break;
case 2:
HAL_UART_Transmit(&huart1,txbox2o,20,10);
//printf("box2 can be opened");
while(DO2){
PINUPDATE();
HAL_UART_Transmit(&huart1,txbox2c,20,10);
 //printf("Box2 not closed");
}
PINUPDATE();
if(DP2)
{HAL_UART_Transmit(&huart1,txpkpr,20,10);
//printf("Package present");
}
else
{HAL_UART_Transmit(&huart1,txpknp,20,10);
//printf("no package");
}
break;
case 3:
HAL_UART_Transmit(&huart1,txbox3o,20,10);
//printf("box3 can be opened");
while(DO3){
PINUPDATE();
HAL_UART_Transmit(&huart1,txbox3c,20,10);
//printf("Box3 not closed");
}
PINUPDATE();
if(DP3)
{HAL_UART_Transmit(&huart1,txpkpr,20,10);
//printf("Package present");
}
else
{HAL_UART_Transmit(&huart1,txpknp,20,10);
//printf("no package");
}
break;
case 4:
HAL_UART_Transmit(&huart1,txbox4o,20,10);
//printf("box4 can be opened");
while(DO4){
PINUPDATE();
HAL_UART_Transmit(&huart1,txbox4c,20,10);
//printf("Box4 not closed");
}
PINUPDATE();
if(DP4)
{HAL_UART_Transmit(&huart1,txpkpr,20,10);
//printf("Package present");
}
else
{ HAL_UART_Transmit(&huart1,txpknp,20,10);
//printf("no package");
}
break;
case 5:
HAL_UART_Transmit(&huart1,txbox5o,20,10);
//printf("box5 can be opened");
while(DO5){
PINUPDATE();
HAL_UART_Transmit(&huart1,txbox5c,20,10);
//printf("Box5 not closed");
}
PINUPDATE();
if(DP5)
{ HAL_UART_Transmit(&huart1,txpkpr,20,10);
//printf("Package present");
 }
else
{HAL_UART_Transmit(&huart1,txpknp,20,10);
//printf("no package");
}
break;
default:
PINUPDATE();
if(DP1|DP2|DP3|DP4|DP5)
{

if(DP1){HAL_UART_Transmit(&huart1,txbox1p,20,10);}if(DP2){HAL_UART_
Transmit(&huart1,txbox2p,20,10);}if(DP3){HAL_UART_Transmit(&huart1,txbox3
p,20,10);}if(DP4){
HAL_UART_Transmit(&huart1,txbox4p,20,10);}if(DP5){HAL_UART_Transmit(&huar
t1,txbox5p,20,10);}
}
break;
}
osDelay(1);
}
/* USER CODE END Thread1 */
}

void Thread2(void const * argument)

{
/* USER CODE BEGIN Thread2 */
/* Infinite loop */
for(;;)
{
osDelay(1);
}
/* USER CODE END Thread2 */
}

void Thread3(void const * argument)

{
/* USER CODE BEGIN Thread3 */
/* Infinite loop */
for(;;)
{
osDelay(1);
}
/* USER CODE END Thread3 */
}

void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)

{
/* USER CODE BEGIN Callback 0 */

/* USER CODE END Callback 0 */

if (htim->Instance == TIM3) {
HAL_IncTick();
}
/* USER CODE BEGIN Callback 1 */

/* USER CODE END Callback 1 */

 HAL_UART_Transmit(&huart1,INTU,20,10);
}

/**
* @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

void assert_failed(uint8_t *file, uint32_t line)

{
}
#endif