2CH_PULSEGEN/APP/maincpp.cpp

/*
 * maincpp.cpp
 *
 *  Created on: 22 Jun 2022
 *      Author: Garth Seale
 */

#include "main.h"
#include "gpio.h"
#include "tim.h"
#include "extra.h"
#include "usart.h"
#include "string.h"

/*Version Number*/
#define MAJOR	0
#define MINOR	1
#define PATCH		0

#define STREAMLENTH 8


uint8_t rxbuff[64];
uint8_t txbuff[STREAMLENTH];

enum {
	DATASIZE,
	PORT1STAT,
	PORT1VAL_H,
	PORT1VAL_L,
	PORT2STAT,
	PORT2VAL_H,
	PORT2VAL_L,
	CHECKSUM
};

struct PWMOUT {
	uint8_t portStat;
	uint16_t freq;
	uint16_t duty;
	TIM_HandleTypeDef timport;
	uint32_t timchan;
	void Init(TIM_HandleTypeDef *port, uint32_t tchan);
	void output(uint16_t freq);
	uint32_t setupoutput(uint32_t freq);

};

uint8_t chsum(uint8_t * data);
uint8_t txdata(uint8_t * data);

PWMOUT port1freq;
PWMOUT port2freq;

uint16_t numberofdigits = 0;
uint8_t count = 0;

//#include "STM_ENC28_J60.h"
//volatile uint16_t pwm1freq = 0;
//volatile uint16_t pwm1freqnew = 100;
//volatile uint16_t pwm2freq = 0;
//volatile uint16_t pwm2freqnew = 9999;
//volatile uint16_t val;
//volatile uint32_t pwm1counter;
//volatile uint32_t pwm1period;
void maincpp()
{
//	numberofdigits = pwm2freqnew;
//	while(numberofdigits != 0) {
//		numberofdigits=numberofdigits/10;
//		count++;
//	}
	HAL_UARTEx_ReceiveToIdle_IT(&huart1, rxbuff, 64);
	port1freq.Init(&htim1, TIM_CHANNEL_1);
	port2freq.Init(&htim3, TIM_CHANNEL_4);
	//	HAL_TIM_PWM_Start(&htim1, TIM_CHANNEL_1);
	//	HAL_TIM_PWM_Start(&htim3, TIM_CHANNEL_4);

	port1freq.setupoutput(50);
	port2freq.setupoutput(50);

//	port1freq.freq = (360000/10)-1;
//	port1freq.duty = port1freq.freq/2;
//	htim1.Instance->CCR1 = port1freq.duty;
//	htim1.Instance->ARR = port1freq.freq;
//	port2freq.freq = (360000/2000)-1;
//	port2freq.duty = port2freq.freq/2;
//	//	htim3.Instance->CCR1
//	htim3.Instance->CCR4 = port2freq.duty;
//	htim3.Instance->ARR = port2freq.freq;

	//	HAL_TIM_Base_Start_IT(&htim17);

	while(1)
	{

		txdata(txbuff);
		HAL_Delay(1000);
		//		if(pwm1freq != pwm1freqnew)
		//		{
		//			pwm1freq = pwm1freqnew;
		////			val =  (map(pwm1freq, 1, 10000, 10000, 1))-1;
		//			htim1.Instance->CCR1 = (pwm1freq/2);
		//			htim1.Instance->ARR = pwm1freq;
		//
		//		}
		//		if(pwm2freq != pwm2freqnew)
		//		{
		//			val = (360000/pwm2freqnew)-1;
		//			pwm1freqnew = val;
		//			pwm2freq = pwm2freqnew;
		//
		//
		//		}
	}
}

void PWMOUT::Init(TIM_HandleTypeDef *port, uint32_t tchan) {
	timport = *port;
	timchan = tchan;
	HAL_TIM_PWM_Start(&timport, timchan);
}

uint32_t PWMOUT::setupoutput(uint32_t pwmfreq) {

	uint32_t scale = 360000;
	uint32_t autoreloadr = scale/pwmfreq;

	switch (timchan)
	{
	case TIM_CHANNEL_1:
		timport.Instance->CCR1 = autoreloadr/2;
		break;
	case TIM_CHANNEL_2:
		timport.Instance->CCR2 = autoreloadr/2;
		break;
	case TIM_CHANNEL_3:
		timport.Instance->CCR3 = autoreloadr/2;
		break;
	case TIM_CHANNEL_4:
		timport.Instance->CCR4 = autoreloadr/2;
		break;
	}
	timport.Instance->ARR = autoreloadr;
	freq = pwmfreq;
	return freq;
}

uint8_t txdata(uint8_t * data) {
	txbuff[DATASIZE]	= STREAMLENTH;
	txbuff[PORT1STAT]	= port1freq.portStat;
	txbuff[PORT1VAL_H]	= port1freq.freq>>8;
	txbuff[PORT1VAL_L]	= port1freq.freq & 0x0F;
	txbuff[PORT2STAT]	= port2freq.portStat;
	txbuff[PORT2VAL_H]	= port2freq.freq>>8;
	txbuff[PORT2VAL_L]	= port2freq.freq & 0x0F;
	txbuff[CHECKSUM]	= chsum(data);
	HAL_UART_Transmit(&huart1, data, STREAMLENTH, HAL_MAX_DELAY);
	return 1;
}

uint8_t chsum(uint8_t * data) {
	uint8_t result = 0;
	for(int i = 0; i < STREAMLENTH-1; i++)
	{
		result ^= data[i];
	}
	return result;
}

void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
{
	/* Prevent unused argument(s) compilation warning */
//	if(htim->Instance == TIM17)
//	{
//		pwm1counter++;
//		if(pwm1counter >= pwm1period)
//		{
//			//		  HAL_GPIO_TogglePin(LED1_GPIO_Port, LED1_Pin);
//			pwm1counter = 0;
//		}

//	}

}

void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
{
  /* Prevent unused argument(s) compilation warning */
  UNUSED(huart);
  __NOP();

  /* NOTE : This function should not be modified, when the callback is needed,
            the HAL_UART_RxCpltCallback can be implemented in the user file.
   */
}

void HAL_UARTEx_RxEventCallback(UART_HandleTypeDef *huart, uint16_t Size)
{
  /* Prevent unused argument(s) compilation warning */
  UNUSED(huart);
  UNUSED(Size);
  __NOP();
  HAL_UARTEx_ReceiveToIdle_IT(&huart1, rxbuff, 64);
  /* NOTE : This function should not be modified, when the callback is needed,
            the HAL_UARTEx_RxEventCallback can be implemented in the user file.
   */
}