mirror of
https://github.com/ADElectronics/RTL00_WEB_VS.git
synced 2024-11-22 07:14:14 +00:00
291 lines
7.2 KiB
C
291 lines
7.2 KiB
C
/*
|
|
* adc_tst.c
|
|
*
|
|
* Created on: 04/04/2017.
|
|
* Author: pvvx
|
|
*/
|
|
|
|
#include <platform_opts.h>
|
|
#include "rtl8195a.h"
|
|
#include "FreeRTOS.h"
|
|
#include "rtl8195a/rtl_libc.h"
|
|
|
|
//------------------------------------------------------------------------------
|
|
#include "objects.h"
|
|
#include "PinNames.h"
|
|
#include "hal_adc.h"
|
|
#include "analogin_api.h"
|
|
#include "strproc.h"
|
|
//------------------------------------------------------------------------------
|
|
analogin_t adc;
|
|
|
|
static void fATADI(int argc, char *argv[])
|
|
{
|
|
int count = 8;
|
|
int channel = 2;
|
|
union
|
|
{
|
|
unsigned int ui[2];
|
|
unsigned short us[4];
|
|
} x;
|
|
|
|
uint16_t adcdat;
|
|
memset(&adc, 0, sizeof(adc));
|
|
|
|
|
|
// ConfigDebugErr |= (_DBG_ADC_|_DBG_GDMA_);
|
|
// ConfigDebugInfo |= (_DBG_ADC_|_DBG_GDMA_);
|
|
|
|
if (argc > 1)
|
|
{
|
|
channel = atoi(argv[1]);
|
|
channel &= 0x03;
|
|
if(!channel) channel = 2;
|
|
}
|
|
|
|
if (argc > 2)
|
|
{
|
|
count = atoi(argv[2]);
|
|
}
|
|
|
|
analogin_init(&adc, (channel+1) | (PORT_V << 4));
|
|
|
|
PSAL_ADC_HND pSalADCHND = &((&(adc.SalADCMngtAdpt))->pSalHndPriv->SalADCHndPriv);
|
|
|
|
uint32_t sum = 0;
|
|
for (uint32_t i = 1; i <= count; i++)
|
|
{
|
|
RtkADCReceiveBuf(pSalADCHND, &x.ui);
|
|
adcdat = x.us[channel];
|
|
if((i % 8) == 0 || (i == count))
|
|
{
|
|
printf("0x%04x\n", adcdat);
|
|
}
|
|
else
|
|
{
|
|
printf("0x%04x, ", adcdat);
|
|
}
|
|
sum += adcdat;
|
|
}
|
|
analogin_deinit(&adc);
|
|
printf("ADC%d = 0x%04x\n", channel, sum / count);
|
|
// sys_adc_calibration(0, &channel, &count);
|
|
}
|
|
|
|
static void fATADD(int argc, char *argv[])
|
|
{
|
|
int count = 64;
|
|
int channel = 2;
|
|
uint16_t adcdat;
|
|
memset(&adc, 0, sizeof(adc));
|
|
|
|
// ConfigDebugErr |= (_DBG_ADC_|_DBG_GDMA_);
|
|
// ConfigDebugInfo |= (_DBG_ADC_|_DBG_GDMA_);
|
|
|
|
if (argc > 1)
|
|
{
|
|
channel = atoi(argv[1]);
|
|
channel &= 0x03;
|
|
if(!channel) channel = 1;
|
|
}
|
|
|
|
if (argc > 2)
|
|
{
|
|
count = atoi(argv[2]);
|
|
if (count <= 2)
|
|
{
|
|
count = 64;
|
|
}
|
|
};
|
|
|
|
analogin_init(&adc, (channel+1) | (PORT_V << 4));
|
|
SAL_ADC_TRANSFER_BUF trbuf;
|
|
trbuf.pDataBuf = zalloc(count*4);
|
|
if(trbuf.pDataBuf)
|
|
{
|
|
trbuf.DataLen = count/2; // x32 bit ?
|
|
trbuf.RSVD = 0;
|
|
adc.SalADCHndPriv.SalADCHndPriv.pRXBuf = &trbuf;
|
|
adc.SalADCHndPriv.SalADCHndPriv.OpType = ADC_DMA_TYPE;
|
|
|
|
adc.HalADCInitData.ADCEndian = ADC_DATA_ENDIAN_LITTLE; //ADC endian selection,
|
|
//but actually it's for 32-bit ADC data swap control
|
|
//1'b0: no swap,
|
|
//1'b1: swap the upper 16-bit and the lower 16-bit
|
|
// adc.HalADCInitData.ADCCompOnly = ADC_FEATURE_DISABLED; //ADC compare mode only enable (without FIFO enable)
|
|
// adc.HalADCInitData.ADCEnManul = ADC_FEATURE_ENABLED; // ADC_FEATURE_DISABLED; //ADC enable manually
|
|
// adc.HalADCInitData.ADCIdx = channel+1; //ADC index used (1..3 ?)
|
|
// adc.HalADCInitData.ADCBurstSz = 8; //ADC DMA operation threshold
|
|
// adc.HalADCInitData.ADCOneShotTD = 8; //ADC one shot mode threshold
|
|
// adc.HalADCInitData.ADCDataRate = 0; // 0xff; // ADC down sample data rate ??
|
|
adc.HalADCInitData.ADCAudioEn = ADC_FEATURE_ENABLED; //ADC audio mode enable // ADC_FEATURE_DISABLED
|
|
// adc.HalADCInitData.ADCOneShotEn = ADC_FEATURE_DISABLED; //ADC one shot mode threshold
|
|
adc.HalADCInitData.ADCInInput = ADC_FEATURE_ENABLED; //ADC Input is internal?
|
|
// adc.HalADCInitData.ADCEn = ADC_DISABLE; //ADC_ENABLE;
|
|
|
|
HalADCInit8195a(&adc.HalADCInitData);
|
|
/* Read Content */
|
|
HAL_ADC_READ32(REG_ADC_FIFO_READ);
|
|
HAL_ADC_READ32(REG_ADC_INTR_STS);
|
|
RtkADCReceive(&adc.SalADCHndPriv.SalADCHndPriv);
|
|
while(adc.SalADCHndPriv.SalADCHndPriv.DevSts != ADC_STS_IDLE);
|
|
uint16 * ptr = (uint16 *) trbuf.pDataBuf;
|
|
// RtkADCDMAInit(&adc.SalADCHndPriv.SalADCHndPriv);
|
|
for (uint32_t i = 1; i <= count; i++)
|
|
{
|
|
if((i % 16) == 0 || (i == count))
|
|
{
|
|
printf("%04x\n", *ptr);
|
|
}
|
|
else
|
|
{
|
|
printf("%04x ", *ptr);
|
|
}
|
|
ptr++;
|
|
}
|
|
uint32_t sum = 0;
|
|
ptr = (uint16 *) trbuf.pDataBuf;
|
|
for (uint32_t i = 1; i <= count; i++)
|
|
{
|
|
printf("%d\n", *ptr);
|
|
sum += *ptr;
|
|
ptr++;
|
|
if((i%512)==0) vTaskDelay(10);
|
|
}
|
|
/*
|
|
printf("OpType:\t\t%p\n", adc.SalADCHndPriv.SalADCHndPriv.OpType);
|
|
printf("pRXBuf:\t\t%p\n", adc.SalADCHndPriv.SalADCHndPriv.pRXBuf);
|
|
printf("pDataBuf:\t%p\n", adc.SalADCHndPriv.SalADCHndPriv.pRXBuf->pDataBuf);
|
|
printf("DataLen:\t%p\n", adc.SalADCHndPriv.SalADCHndPriv.pRXBuf->DataLen);
|
|
printf("ADCDataRate:\t%p\n", adc.HalADCInitData.ADCDataRate);
|
|
printf("ADCData:\t%p\n", adc.HalADCInitData.ADCData);
|
|
printf("ADCIdx:\t\t%p\n", adc.HalADCInitData.ADCIdx);
|
|
printf("ADCPWCtrl:\t%p\n", adc.HalADCInitData.ADCPWCtrl);
|
|
printf("ADCAnaParAd3:\t%p\n", adc.HalADCInitData.ADCAnaParAd3);
|
|
printf("ADC%d = 0x%04x\n", channel, analogin_read_u16(&adc));
|
|
printf("ADC%d = 0x%04x\n", channel, analogin_read_u16(&adc));
|
|
*/
|
|
analogin_deinit(&adc);
|
|
free(trbuf.pDataBuf);
|
|
printf("ADC%d = 0x%04x\n", channel, sum / count);
|
|
|
|
}
|
|
else
|
|
{
|
|
error_printf("%s: malloc failed!\n", __func__);
|
|
};
|
|
|
|
// sys_adc_calibration(0, &channel, &count);
|
|
}
|
|
|
|
static void fATADC(int argc, char *argv[]) {
|
|
|
|
int count = 8;
|
|
int channel = 2;
|
|
uint16_t adcdat;
|
|
memset(&adc, 0, sizeof(adc));
|
|
|
|
|
|
// ConfigDebugErr |= (_DBG_ADC_|_DBG_GDMA_);
|
|
// ConfigDebugInfo |= (_DBG_ADC_|_DBG_GDMA_);
|
|
|
|
if (argc > 1)
|
|
{
|
|
channel = atoi(argv[1]);
|
|
channel &= 0x03;
|
|
if(!channel) channel = 1;
|
|
}
|
|
|
|
if (argc > 2)
|
|
{
|
|
count = atoi(argv[2]);
|
|
}
|
|
|
|
analogin_init(&adc, (channel+1) | (PORT_V << 4));
|
|
|
|
uint32_t sum = 0;
|
|
for (uint32_t i = 1; i <= count; i++)
|
|
{
|
|
adcdat = analogin_read_u16(&adc);
|
|
if((i % 8) == 0 || (i == count))
|
|
{
|
|
printf("0x%04x\n", adcdat);
|
|
}
|
|
else
|
|
{
|
|
printf("0x%04x, ", adcdat);
|
|
}
|
|
sum += adcdat;
|
|
}
|
|
analogin_deinit(&adc);
|
|
printf("ADC%d = 0x%04x\n", channel, sum / count);
|
|
// sys_adc_calibration(0, &channel, &count);
|
|
}
|
|
|
|
static void fATSA(int argc, char *argv[])
|
|
{
|
|
// uint32_t tConfigDebugInfo = ConfigDebugInfo;
|
|
int channel;
|
|
char *ptmp;
|
|
uint16_t offset, gain, adcdat;
|
|
memset(&adc, 0, sizeof(adc));
|
|
|
|
if (argc < 2)
|
|
{
|
|
printf("Usage: ATSA=CHANNEL(0~2)\n");
|
|
printf("Usage: ATSA=k_get\n");
|
|
printf("Usage: ATSA=k_set[offet(hex),gain(hex)]\n");
|
|
return;
|
|
}
|
|
|
|
if (strcmp(argv[1], "k_get") == 0)
|
|
{
|
|
sys_adc_calibration(0, &offset, &gain);
|
|
// printf("[ATSA] offset = 0x%04X, gain = 0x%04X", offset, gain);
|
|
}
|
|
else if (strcmp(argv[1], "k_set") == 0)
|
|
{
|
|
if (argc != 4)
|
|
{
|
|
printf("Usage: ATSA=k_set[offet(hex),gain(hex)]\n");
|
|
return;
|
|
}
|
|
offset = strtoul(argv[2], &ptmp, 16);
|
|
gain = strtoul(argv[3], &ptmp, 16);
|
|
sys_adc_calibration(1, &offset, &gain);
|
|
// printf("[ATSA] offset = 0x%04X, gain = 0x%04X", offset, gain);
|
|
}
|
|
else
|
|
{
|
|
channel = atoi(argv[1]);
|
|
if (channel < 0 || channel > 2)
|
|
{
|
|
printf("Usage: ATSA=CHANNEL(0~2)\n");
|
|
return;
|
|
}
|
|
// Remove debug info massage
|
|
// ConfigDebugInfo = 0;
|
|
if (channel == 0)
|
|
analogin_init(&adc, AD_1);
|
|
else if (channel == 1)
|
|
analogin_init(&adc, AD_2);
|
|
else
|
|
analogin_init(&adc, AD_3);
|
|
// analogin_read_u16(&adc);
|
|
adcdat = analogin_read_u16(&adc) >> 4;
|
|
analogin_deinit(&adc);
|
|
// Recover debug info massage
|
|
// ConfigDebugInfo = tConfigDebugInfo;
|
|
|
|
printf("A%d = 0x%04X\n", channel, adcdat);
|
|
}
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
MON_RAM_TAB_SECTION COMMAND_TABLE console_commands_adc[] =
|
|
{
|
|
{ "ATADC", 0, fATADC, ": ADC Test" },
|
|
{ "ATADD", 0, fATADD, ": ADC DMA Test" },
|
|
{ "ATADI", 0, fATADI, ": ADC Irq Test" },
|
|
{ "ATSA" , 0, fATSA , ": ADC at" }
|
|
};
|