rusefi
/
RabbitECUTeensyMCUXpresso
mirror of https://github.com/rusefi/RabbitECUTeensyMCUXpresso.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
RabbitECUTeensyMCUXpresso/source/Peripherals/PERADC.c

408 lines
13 KiB
C
Raw Permalink Blame History

/******************************************************************************/
/* Copyright (c) 2016 MD Automotive Controls. Original Work. */
/* License: http://www.gnu.org/licenses/gpl.html GPL version 2 or higher */
/******************************************************************************/
/* CONTEXT:KERNEL */
/* PACKAGE TITLE: XXX */
/* DESCRIPTION: XXX */
/* FILE NAME: XXX.c */
/* REVISION HISTORY: 19-08-2016 | 1.0 | Initial revision */
/* */
/******************************************************************************/
#include <string.h>
#include <stddef.h>
#include "CPUAbstract.h"
#include "IOAPI.h"
#include "ADCAPI.h"
#include "types.h"
#include "ADCHA.h"
#include "PERADC.h"
#include "client.h"
#include "CQUEUE.h"
#include "CRC16.h"
#include "declarations.h"
#include "FEE.h"
#include "IRQ.h"
#include "MSG.h"
#include "regset.h"
#include "SIM.h"
#include "sys.h"
ADCHA_tstADCConversion ADC_astADCConversions[ADCHA_enQueueCount][ADC_nConversionsMax];
CQUEUE_tstQueue ADC_astConversionQueue[ADCHA_enQueueCount];
bool ADC_boCyclicQueuePending;
ADC_tstADCResult ADC_astResult[ADCHA_enQueueCount][ADC_nConversionsMax];
MSG_tstMBX* ADC_apstMBX[ADCHA_enQueueCount][ADC_nConversionsMax];
sint32 ADC_i32CyclicQueueIDX;
/* Array to determine which queue triggered the last module conversion. Allows
same AD channel to appear in different queues! */
ADCHA_tenQueue ADC_astADCActiveQueue[ADCHA_enADCModuleCount];
static bool ADC_boInitiateConversion(ADCHA_tstADCConversion*, ADCHA_tenQueue, uint32);
#ifdef ADC_CALIBRATE
static void ADC_vCalibrate(tstADCModule*, uint32, uint32);
#endif //ADC_CALIBRATE
#ifdef BUILD_MK60
static void ADC_vInitInterrupts(IRQn_Type);
#endif //BUILD_MK60
static void ADC_vRunConversionQueues(void);
void ADC_vStart(uint32* const pu32Stat)
{
uint32 u32QueueIDX;
uint32 u32QueueElementIDX;
for (u32QueueIDX = 0; u32QueueIDX < ADCHA_enQueueCount; u32QueueIDX++)
{
for (u32QueueElementIDX = 0; u32QueueElementIDX < ADC_nConversionsMax; u32QueueElementIDX++)
{
/* NULL the mailbox pointer array */
ADC_apstMBX[u32QueueIDX][u32QueueElementIDX] = NULL;
}
}
for (u32QueueIDX = 0; u32QueueIDX < 0xff; u32QueueIDX++)
{
;/* Waste some time *///matthew review
}
ADCHA_vStart(pu32Stat);
CQUEUE_xInit(ADC_astConversionQueue, ADC_nConversionsMax, ADC_astADCConversions);
CQUEUE_xInit(ADC_astConversionQueue + 1, ADC_nConversionsMax, (uint32)ADC_astADCConversions + sizeof(ADCHA_tstADCConversion) * ADC_nConversionsMax * 1);
CQUEUE_xInit(ADC_astConversionQueue + 2, ADC_nConversionsMax, (uint32)ADC_astADCConversions + sizeof(ADCHA_tstADCConversion) * ADC_nConversionsMax * 2);
CQUEUE_xInit(ADC_astConversionQueue + 3, ADC_nConversionsMax, (uint32)ADC_astADCConversions + sizeof(ADCHA_tstADCConversion) * ADC_nConversionsMax * 3);
CQUEUE_xInit(ADC_astConversionQueue + 4, ADC_nConversionsMax, (uint32)ADC_astADCConversions + sizeof(ADCHA_tstADCConversion) * ADC_nConversionsMax * 4);
ADC_i32CyclicQueueIDX = -1;
ADC_boCyclicQueuePending = FALSE;
OS_xModuleStartOK(*pu32Stat);
}
void ADC_vRun(uint32* const pu32Stat)
{
uint32 u32CyclicQueueIDX;
static uint32 u32ADCQueueStuckCount;
ADCHA_tenQueue enQueue;
if ((ADC_astConversionQueue[ADCHA_enQueueCyclic].u32Tail > ADC_astConversionQueue[ADCHA_enQueueCyclic].u32Head) && (-1 == ADC_i32CyclicQueueIDX))
{
for (u32CyclicQueueIDX = ADC_astConversionQueue[ADCHA_enQueueCyclic].u32Head;
u32CyclicQueueIDX <= ADC_astConversionQueue[ADCHA_enQueueCyclic].u32Tail;
u32CyclicQueueIDX++)
{
if (0 < ADC_astADCConversions[ADCHA_enQueueCyclic][u32CyclicQueueIDX].u32ControlCount)
{
ADC_astADCConversions[ADCHA_enQueueCyclic][u32CyclicQueueIDX].u32ControlCount -= 1;
}
}
/* EC - don't want AD conversion complete interrupting here */
CPU_xEnterCritical();
for (u32CyclicQueueIDX = ADC_astConversionQueue[0].u32Head;
u32CyclicQueueIDX <= ADC_astConversionQueue[0].u32Tail;
u32CyclicQueueIDX++)
{
if (0 == ADC_astADCConversions[ADCHA_enQueueCyclic][u32CyclicQueueIDX].u32ControlCount)
{
ADC_i32CyclicQueueIDX = u32CyclicQueueIDX;
//ADC_boCyclicQueuePending = ADC_boInitiateConversion(&ADC_astADCConversions[ADCHA_enQueueCyclic][ADC_astConversionQueue[ADCHA_enQueueCyclic].u32Head], ADCHA_enQueueCyclic, ADC_astConversionQueue[0].u32Tail);
break;
}
}
CPU_xExitCritical();
}
/* Check if the ADC queues are stuck */
for (enQueue = ADCHA_enQueueCyclic; enQueue < ADCHA_enQueueCount; enQueue++)
{
if (ADC_astConversionQueue[enQueue].u32Head != ADC_astConversionQueue[enQueue].u32Tail)
{
u32ADCQueueStuckCount++;
}
}
if (5 < u32ADCQueueStuckCount)
{
ADCHA_vReset(ADCHA_enADC0);
u32ADCQueueStuckCount = 0;
}
}
bool ADC_boBackupCalibrations(void)
{
return ADCHA_boBackupCalibrations();
}
SYSAPI_tenSVCResult ADC_vInitADCResource(IOAPI_tenEHIOResource enIOResource, IOAPI_tenEHIOType enEHIOType, ADCAPI_tstADCCB* pstADCCB)
{
uint32 u32QueueIDX;
SYSAPI_tenSVCResult enResult = SYSAPI_enOK;
ADCHA_tstADCConversion* pstADCConversion;
u32QueueIDX = (ADCAPI_enTrigger1 > pstADCCB->enTrigger) ? 0 : pstADCCB->enTrigger - ADCAPI_en1Hz;
if (!CQUEUE_xIsFull(ADC_astConversionQueue + u32QueueIDX))
{
CPU_xEnterCritical();
pstADCConversion = &ADC_astADCConversions[u32QueueIDX][0] +
ADC_astConversionQueue[u32QueueIDX].u32Tail;
ADCHA_vInitConversion(enIOResource, pstADCConversion, pstADCCB, u32QueueIDX);
switch (pstADCCB->enTrigger)
{
case ADCAPI_en1000Hz: pstADCConversion->u32ResetCount = 1; break;
case ADCAPI_en500Hz: pstADCConversion->u32ResetCount = 2; break;
case ADCAPI_en250Hz: pstADCConversion->u32ResetCount = 4; break;
case ADCAPI_en125Hz: pstADCConversion->u32ResetCount = 8; break;
case ADCAPI_en64Hz: pstADCConversion->u32ResetCount = 31; break;
case ADCAPI_en32Hz: pstADCConversion->u32ResetCount = 32; break;
case ADCAPI_en16Hz: pstADCConversion->u32ResetCount = 63; break;
case ADCAPI_en8Hz: pstADCConversion->u32ResetCount = 125; break;
case ADCAPI_en4Hz: pstADCConversion->u32ResetCount = 250; break;
case ADCAPI_en2Hz: pstADCConversion->u32ResetCount = 500; break;
case ADCAPI_en1Hz: pstADCConversion->u32ResetCount = 1000; break;
default: pstADCConversion->u32ResetCount = 1000; break;
}
CQUEUE_xAddItem(ADC_astConversionQueue + u32QueueIDX);
/* Remove to leave it in the queue but exhaust the queue */
CQUEUE_xRemoveItem(ADC_astConversionQueue + u32QueueIDX);
if (IOAPI_enADD == enEHIOType)
{
ADCHA_vInitADCResourcePGA(pstADCConversion);
}
ADCHA_vInitChannel(enIOResource);
CPU_xExitCritical();
}
else
{
enResult = SYSAPI_enQueueFull;
}
return enResult;
}
void ADC_vTerminate(uint32* const u32Stat)
{
}
void ADC_vInterruptHandler(IOAPI_tenEHIOResource enEHIOResource, void* pvData)
{
uint32 enADCModule;
uint32 u32ADCChannel;
MSG_tstMBX* pstMBX;
uint32 u32QueueIDX;
ADCHA_tenQueue enQueue;
CLIENT_tenErr enErr;
tpfClientCB pfClientCB;
uint32 u32ADCResult;
tstADCModule* pstADC;
uint32 u32ADCResultAvailableCount;
uint32 u32DequeueIDX;
enADCModule = enEHIOResource - EH_VIO_ADC0;
/* Which queue initiated this conversion? */
u32QueueIDX = (ADCHA_enQueueCyclic == ADC_astADCActiveQueue[enADCModule]) ?
(uint32)ADC_i32CyclicQueueIDX :
ADC_astConversionQueue[ADC_astADCActiveQueue[enADCModule]].u32Head;
pstADC = ADCHA_pstGetADCModule(enADCModule);
u32ADCResultAvailableCount = ADCHA_u32GetAvailableResultCount(pstADC);
u32ADCResultAvailableCount = MIN(u32ADCResultAvailableCount, ADC_astConversionQueue[ADC_astADCActiveQueue[enADCModule]].u32Tail);
for (u32DequeueIDX = u32QueueIDX; u32DequeueIDX < u32QueueIDX + u32ADCResultAvailableCount; u32DequeueIDX++)
{
enQueue = ADC_astADCActiveQueue[enADCModule];
u32ADCChannel = ADC_astADCConversions[enQueue][u32DequeueIDX].stADCChannel.u32ADChannel;
enEHIOResource = ADCHA_enGetResourceAndResult(enADCModule, pstADC, u32ADCChannel, &u32ADCResult);
/* Populate the result array - the reference of the element will
be posted to the client MBX* queue for callback to user */
ADC_astResult[enQueue][u32DequeueIDX].u32Result = u32ADCResult;
ADC_astResult[enQueue][u32DequeueIDX].enEHIOResource = enEHIOResource;
pstMBX = ADC_apstMBX[enQueue][u32DequeueIDX];
MSG_vMBXPost(pstMBX, (void*)&ADC_astResult[enQueue][u32DequeueIDX]);
pfClientCB = (tpfClientCB)ADC_astADCConversions[enQueue][u32DequeueIDX].pfResultCB;
if ((NULL != pfClientCB) && (MSG_boMBXValid(pstMBX)))
{
enErr = CLIENT_enEnqueueCB(pstMBX, pfClientCB);
}
if (ADCHA_enQueueCyclic == enQueue)
{
while (-1 != ADC_i32CyclicQueueIDX)
{
ADC_i32CyclicQueueIDX = ((ADC_astConversionQueue[ADCHA_enQueueCyclic].u32Tail - 1) > ADC_i32CyclicQueueIDX) ? ADC_i32CyclicQueueIDX + 1 : -1;
if (-1 != ADC_i32CyclicQueueIDX)
{
if (0 == ADC_astADCConversions[ADCHA_enQueueCyclic][ADC_i32CyclicQueueIDX].u32ControlCount)
{
break;
}
}
}
}
else
{
CQUEUE_xRemoveItem(ADC_astConversionQueue + enQueue);
if (ADC_astConversionQueue[enQueue].u32Head == ADC_astConversionQueue[enQueue].u32Tail)
{
/* Release the ADC module now the conversion queue has been processed */
ADCHA_vClearModuleBusy(enADCModule);
}
}
}
ADC_vRunConversionQueues();
/* TODO suppress warning */
(void)enErr;
}
bool ADC_vTriggerQueue(ADCAPI_tenTrigger enTrigger)
{
ADCHA_tenQueue enQueue;
bool boResult = FALSE;
if ((ADCAPI_enTrigger1 <= enTrigger) && (ADCAPI_enTriggerCount > enTrigger))
{
enQueue = (ADCHA_tenQueue)(enTrigger - ADCAPI_enTrigger1 + 1);
if (false == ADCHA_boGetModuleBusy(ADCHA_enADC0))
{
ADC_astConversionQueue[enQueue].u32Head = 0;
ADC_vRunConversionQueues();
boResult = TRUE;
}
}
return boResult;
}
static bool ADC_boInitiateConversion(ADCHA_tstADCConversion* pstADCConversion, ADCHA_tenQueue enQueue, uint32 u32QueueTail)
{
bool boADCInitPending = TRUE;
uint32 u32QueueIDX;
MSG_tenMBXErr enMBXErr = MSG_enOK;
uint32 u32ConversionIDX;
u32QueueIDX = (ADCHA_enQueueCyclic == enQueue) ? ADC_i32CyclicQueueIDX :
ADC_astConversionQueue[enQueue].u32Head;
for (u32ConversionIDX = u32QueueIDX; u32ConversionIDX < u32QueueTail; u32ConversionIDX++)
{
/* Check if a mailbox is allocated for this conversion */
if (NULL == ADC_apstMBX[enQueue][u32ConversionIDX])
{
enMBXErr = MSG_enMBXNew((MSG_tstMBX**)&ADC_apstMBX[enQueue][u32ConversionIDX],
MSG_enADCResult);
}
}
if (MSG_enOK == enMBXErr)
{
/* Remember which queue initiated this conversion */
ADC_astADCActiveQueue[pstADCConversion->stADCChannel.enADCModule] = enQueue;
boADCInitPending = ADCHA_boInitiateConversion(pstADCConversion, enQueue, u32QueueTail, FALSE);
pstADCConversion->u32ControlCount = pstADCConversion->u32ResetCount;
}
return boADCInitPending;
}
#ifdef ADC_CALIBRATE
static void ADC_vCalibrate(tstADCModule* pstADC, uint32 u32ADCIDX, uint32 u32CalFlag)
{
ADCHA_vCalibrate(pstADC, u32ADCIDX, u32CalFlag);
}
#endif //ADC_CALIBRATE
static void ADC_vRunConversionQueues(void)
{
ADCHA_tenQueue enQueue;
bool boModuleBusy[ADCHA_enADCModuleCount];
ADCHA_tenADCModule enADCModule;
bool boConversionPending;
ADCHA_tstADCConversion* pstConversion;
uint32 u32QueueIDX;
for(enADCModule = ADCHA_enADC0; enADCModule < ADCHA_enADCModuleCount; enADCModule++)
{
boModuleBusy[enADCModule] = ADCHA_boGetModuleBusy(enADCModule);
}
for (enQueue = ADCHA_enQueueCyclic; enQueue < ADCHA_enQueueCount; enQueue++)
{
switch (enQueue)
{
case ADCHA_enQueueCyclic:
{
if (-1 < ADC_i32CyclicQueueIDX)
{
pstConversion = &ADC_astADCConversions[enQueue][ADC_i32CyclicQueueIDX];
enADCModule = pstConversion->stADCChannel.enADCModule;
if (FALSE == boModuleBusy[enADCModule])
{
boConversionPending = ADC_boInitiateConversion(pstConversion, enQueue, ADC_astConversionQueue[enQueue].u32Tail);
if (!boConversionPending)
{
boModuleBusy[enADCModule] = TRUE;
}
}
}
break;
}
case ADCHA_enQueueTriggered1:
case ADCHA_enQueueTriggered2:
case ADCHA_enQueueTriggered3:
case ADCHA_enQueueTriggered4:
{
if (false == CQUEUE_xIsEmpty((CQUEUE_tstQueue*)&ADC_astConversionQueue + enQueue))
{
u32QueueIDX = ADC_astConversionQueue[enQueue].u32Head;
pstConversion = &ADC_astADCConversions[enQueue][u32QueueIDX];
enADCModule = pstConversion->stADCChannel.enADCModule;
if (FALSE == boModuleBusy[enADCModule])
{
boConversionPending = ADC_boInitiateConversion(pstConversion, enQueue, ADC_astConversionQueue[enQueue].u32Tail);
if (!boConversionPending)
{
boModuleBusy[enADCModule] = TRUE;
}
}
}
break;
}
default:
{
break;
}
}
}
}
Reference in New Issue View Git Blame Copy Permalink