288 lines
6.3 KiB
C
288 lines
6.3 KiB
C
#include "cmsis_os.h"
|
|
#include "ads8321.h"
|
|
|
|
#include "main.h"
|
|
#include "Param/param.h"
|
|
|
|
|
|
#include <stdio.h>
|
|
#include <stdarg.h>
|
|
#include <stdint.h>
|
|
#include <string.h>
|
|
|
|
|
|
#define DPRINT(fmt, args...) printf(fmt, ##args)
|
|
//#define DPRINT(fmt, args...)
|
|
|
|
extern UART_HandleTypeDef huart4;
|
|
extern TIM_HandleTypeDef htim3;
|
|
extern TIM_HandleTypeDef htim1;
|
|
|
|
extern SPI_HandleTypeDef hspi3;
|
|
extern SPI_HandleTypeDef hspi2;
|
|
|
|
|
|
int _giSampleInProgress = 0;
|
|
|
|
uint32_t _gaulAdcValue[2];
|
|
int _gaiFlag[2];
|
|
|
|
volatile uint32_t _gulSamplePosUm = 0;
|
|
volatile uint32_t _gulSampleTimeUs = 0;
|
|
volatile adcDataQueueDef gtAdcDataQueue;
|
|
volatile uint32_t gulAdcSampleIndex;
|
|
volatile uint32_t ulSampleStartTime = 0;
|
|
volatile uint32_t ulSampleDuration = 0;
|
|
|
|
typedef struct {
|
|
uint32_t ulTick;
|
|
uint32_t ulCnt;
|
|
} tickTimeDef;
|
|
|
|
volatile int32_t _gslEncCnt = 0;
|
|
tickTimeDef _gtLastTrigTime;
|
|
int _giEncoderTrigFlag = 0;
|
|
uint32_t gulEncoderSpeed = 0; /// 0.1mm/s
|
|
|
|
int giScanDirection = 0;
|
|
|
|
uint32_t gulPacketIndex = 0;
|
|
uint32_t gulPacketAck = 0;
|
|
|
|
static uint32_t _gaulAdcBuf[100];
|
|
static uint32_t _gaulAdcBuf2[100];
|
|
static uint32_t _gulAdcIndex = 0;
|
|
static uint32_t _gulAdcSampleCount = 0;
|
|
|
|
static void adcDataQueueReset(void);
|
|
void adcUpdateParam(void);
|
|
|
|
int getAdcValue(uint32_t adc_val)
|
|
{
|
|
uint32_t rxDataOK = adc_val >> 2;
|
|
int16_t val;
|
|
memcpy(&val, &rxDataOK, sizeof(val));
|
|
|
|
int ret = val + 32767;
|
|
if (ret < 0) {
|
|
ret = 0;
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
static void spiTransmitReceiveOnce(int index)
|
|
{
|
|
static uint32_t dummy = 0;
|
|
_gaiFlag[0] = 0;
|
|
_gaiFlag[1] = 0;
|
|
HAL_SPI_Receive_IT(&hspi2, (uint8_t *)&_gaulAdcBuf[index], 1);
|
|
HAL_SPI_TransmitReceive_IT(&hspi3, (uint8_t *)&dummy, (uint8_t *)&_gaulAdcBuf2[index], 1);
|
|
}
|
|
|
|
static void data_average()
|
|
{
|
|
uint32_t ulData1 = 0;
|
|
uint32_t ulData2 = 0;
|
|
for (int i = 0; i < _gulAdcSampleCount; i++) {
|
|
ulData1 += getAdcValue(_gaulAdcBuf[i]);
|
|
ulData2 += getAdcValue(_gaulAdcBuf2[i]);
|
|
}
|
|
_gaulAdcValue[0] = ulData1 / _gulAdcSampleCount;
|
|
_gaulAdcValue[1] = ulData2 / _gulAdcSampleCount;
|
|
}
|
|
|
|
static void adcDataQueuePut(void);
|
|
|
|
static void checkDataReady()
|
|
{
|
|
if (_gaiFlag[0] && _gaiFlag[1]) {
|
|
_gulAdcIndex++;
|
|
if (_gulAdcIndex < _gulAdcSampleCount) {
|
|
spiTransmitReceiveOnce(_gulAdcIndex);
|
|
return;
|
|
} else if (_gulAdcIndex == _gulAdcSampleCount) {
|
|
data_average();
|
|
adcDataQueuePut();
|
|
// printf("%d\r\n", adcDataQueueLen());
|
|
}
|
|
}
|
|
}
|
|
|
|
void HAL_SPI_RxCpltCallback(SPI_HandleTypeDef *hspi)
|
|
{
|
|
if (hspi == &hspi2) {
|
|
_gaiFlag[0] = 1;
|
|
checkDataReady();
|
|
}
|
|
}
|
|
|
|
void HAL_SPI_TxRxCpltCallback(SPI_HandleTypeDef *hspi)
|
|
{
|
|
if (hspi == &hspi3) {
|
|
_gaiFlag[1] = 1;
|
|
checkDataReady();
|
|
}
|
|
}
|
|
|
|
static void adcStart(int avrg_count)
|
|
{
|
|
_gtLastTrigTime.ulCnt = TIM13->CNT;
|
|
_gtLastTrigTime.ulTick = uwTick;
|
|
|
|
if (avrg_count > 100) {
|
|
avrg_count = 100;
|
|
}
|
|
|
|
_gulAdcSampleCount = avrg_count;
|
|
_gulAdcIndex = 0;
|
|
|
|
spiTransmitReceiveOnce(_gulAdcIndex);
|
|
}
|
|
|
|
static void adcDataQueuePut(void)
|
|
{
|
|
uint32_t ulData1 = _gaulAdcValue[0];
|
|
uint32_t ulData2 = _gaulAdcValue[1];
|
|
|
|
volatile adcDataUnitDef *ptData = >AdcDataQueue.atQueue[gtAdcDataQueue.ulWritePos];
|
|
|
|
gulAdcSampleIndex++;
|
|
|
|
if (gulAdcSampleIndex >= 5) {
|
|
ptData->aulData[0] = (uint16_t)ulData1;
|
|
ptData->aulData[1] = (uint16_t)ulData2;
|
|
|
|
gtAdcDataQueue.ulWritePos++;
|
|
if (gtAdcDataQueue.ulWritePos >= ADC_QUEUE_LEN) {
|
|
gtAdcDataQueue.ulWritePos = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
void setTimerPeriod(uint32_t ulPeriod)
|
|
{
|
|
htim3.Init.Period = ulPeriod - 1;
|
|
|
|
if (HAL_TIM_Base_Init(&htim3) != HAL_OK)
|
|
{
|
|
Error_Handler();
|
|
}
|
|
}
|
|
|
|
void adcDataQueueReset(void)
|
|
{
|
|
gtAdcDataQueue.ulReadPos = 0;
|
|
gtAdcDataQueue.ulWritePos = 0;
|
|
}
|
|
|
|
uint16_t adcDataQueueLen(void)
|
|
{
|
|
uint16_t ulLength = 0;
|
|
|
|
if (gtAdcDataQueue.ulWritePos == gtAdcDataQueue.ulReadPos) {
|
|
return 0;
|
|
}
|
|
|
|
if (gtAdcDataQueue.ulWritePos > gtAdcDataQueue.ulReadPos)
|
|
{
|
|
ulLength = gtAdcDataQueue.ulWritePos - gtAdcDataQueue.ulReadPos;
|
|
}
|
|
else
|
|
{
|
|
ulLength = ADC_QUEUE_LEN - gtAdcDataQueue.ulReadPos + gtAdcDataQueue.ulWritePos;
|
|
}
|
|
|
|
return ulLength;
|
|
}
|
|
|
|
void adcSampleStart(void)
|
|
{
|
|
if (_giSampleInProgress) {
|
|
return;
|
|
}
|
|
printf("sample start \r\n");
|
|
adcUpdateParam();
|
|
__disable_irq();
|
|
adcDataQueueReset();
|
|
|
|
gulAdcSampleIndex = 0;
|
|
ulSampleStartTime = osKernelGetTickCount();
|
|
__enable_irq();
|
|
_gslEncCnt = 0;
|
|
|
|
if (gptSysParam->ucUseEncoder == 0) {
|
|
printf("time sample \r\n");
|
|
HAL_TIM_OC_Stop_IT(&htim1, TIM_CHANNEL_3);
|
|
HAL_TIM_OC_Stop_IT(&htim1, TIM_CHANNEL_4);
|
|
HAL_TIM_Base_Start_IT(&htim3);
|
|
} else {
|
|
HAL_TIM_Base_Stop_IT(&htim3);
|
|
TIM1->CNT = 10000;
|
|
HAL_TIM_OC_Start_IT(&htim1, TIM_CHANNEL_3);
|
|
HAL_TIM_OC_Start_IT(&htim1, TIM_CHANNEL_4);
|
|
printf("start encoder\n");
|
|
}
|
|
|
|
_giSampleInProgress = 1;
|
|
}
|
|
|
|
void adcSampleStop(void)
|
|
{
|
|
if (!_giSampleInProgress) {
|
|
return;
|
|
}
|
|
|
|
printf("sample stop \r\n");
|
|
|
|
HAL_TIM_Base_Stop_IT(&htim3);
|
|
HAL_TIM_OC_Stop_IT(&htim1, TIM_CHANNEL_3);
|
|
HAL_TIM_OC_Stop_IT(&htim1, TIM_CHANNEL_4);
|
|
_giEncoderTrigFlag = 0;
|
|
|
|
_giSampleInProgress = 0;
|
|
}
|
|
|
|
void setEncoderInterval(uint16_t usPeriod)
|
|
{
|
|
TIM_OC_InitTypeDef sConfigOC = {0};
|
|
sConfigOC.OCMode = TIM_OCMODE_TIMING;
|
|
sConfigOC.Pulse = 10000 - usPeriod;
|
|
sConfigOC.OCPolarity = TIM_OCPOLARITY_HIGH;
|
|
sConfigOC.OCFastMode = TIM_OCFAST_DISABLE;
|
|
if (HAL_TIM_OC_ConfigChannel(&htim1, &sConfigOC, TIM_CHANNEL_3) != HAL_OK)
|
|
{
|
|
Error_Handler();
|
|
}
|
|
sConfigOC.Pulse = 10000 + usPeriod;
|
|
if (HAL_TIM_OC_ConfigChannel(&htim1, &sConfigOC, TIM_CHANNEL_4) != HAL_OK)
|
|
{
|
|
Error_Handler();
|
|
}
|
|
TIM1->CNT = 10000;
|
|
}
|
|
|
|
void adcUpdateParam(void)
|
|
{
|
|
setEncoderInterval(gptSysParam->usAdcinterval);
|
|
|
|
setTimerPeriod(gptSysParam->usAdcPeriod);
|
|
}
|
|
|
|
void TIM3_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
|
|
{
|
|
adcStart(gptSysParam->ucAverageCount);
|
|
}
|
|
|
|
void HAL_TIM_PWM_PulseFinishedCallback(TIM_HandleTypeDef *htim)
|
|
{
|
|
if (htim->Instance == TIM1) {
|
|
/**
|
|
* @brief 编码器中断
|
|
*/
|
|
TIM1->CNT = 10000;
|
|
adcStart(gptSysParam->ucAverageCount);
|
|
}
|
|
}
|
|
|