PDB_ADC_1920Hz UTILIZANDO FRDMK64 Y SDK 2.0

Toma muestras de una señal a una frecuencia de 1920 muestras/seg.

Objetivo: El objetivo es este programa es generar vía un interrupción PDB, la toma de muestras de forma 
sincronizada de una señal analógica a una frecuencia de 1920 Hz.

En este programa se conjunta la Función de PDB y ADC para generar una señal de muestreo a una frecuencia de 1920 muestras por segundo.

Como nota importante se puede muestrear una señal analógica, si esta señal es de 60 Hz se puede muestrear 32 veces cada segundo.

El siguiente diagrama describe como se habilidad PDB y ADC para la toma de muestras.

A continuación se muestra código.

/*******************************************************************************

* ESTE ES UN PROGRAMA, REALIZA POR INTERRRUPCION DE PDB A UNA FRECUENCIA DE

* 1920 HZ LA TOMA DE MUESTRA DE UNA SEÑAL POR MEDIO DE ADC.

******************************************************************************/

#include "fsl_debug_console.h"

#include "board.h"

#include "fsl_pdb.h"

#include "fsl_adc16.h"

#include "pin_mux.h"

#include "clock_config.h"

/*******************************************************************************

* DEFINICIONES

******************************************************************************/

#define DEMO_PDB_BASE PDB0

#define DEMO_PDB_IRQ_ID PDB0_IRQn

#define DEMO_PDB_IRQ_HANDLER PDB0_IRQHandler

#define DEMO_PDB_ADC_TRIGGER_CHANNEL 0U /* For ADC0. */

#define DEMO_PDB_ADC_PRETRIGGER_CHANNEL 0U /* For ADC0_SC1[0]. */

#define DEMO_ADC_BASE ADC0

#define DEMO_ADC_CHANNEL_GROUP 0U

#define DEMO_ADC_USER_CHANNEL 0U

#define DEMO_ADC_IRQ_ID ADC0_IRQn

#define DEMO_ADC_IRQ_HANDLER ADC0_IRQHandler

/*******************************************************************************

* PROTOTIPOS

******************************************************************************/

static void DEMO_InitPDB_ADC(void);

/*******************************************************************************

* DECLARACIÓN DE VARIABLES

******************************************************************************/

volatile uint32_t g_PdbDelayInterruptCounter; //Contador de interrupciones de pdb.

volatile bool g_PdbDelayInterruptFlag; //Bandera de retardo de interrupción de PDB

volatile uint32_t g_AdcInterruptCounter; //Contador de interrupciones de adc

volatile bool g_AdcInterruptFlag; //Bandera de retardo de interrupción de adc

volatile uint32_t g_AdcConvValue; //Valor de conversión

uint32_t Bus_Clk; //

uint32_t Modulo_PDB; //

uint32_t Sec_Fm; //

/*******************************************************************************

* CODIGO

******************************************************************************/

/*******************************************************************************

* DECLARACIÓN DE FUNCION PDB­ADC

******************************************************************************/

void static DEMO_InitPDB_ADC(void)

{

adc16_config_t adc16ConfigStruct;

adc16_channel_config_t adc16ChannelConfigStruct;

ADC16_GgetDefaultConfig(&adc16ConfigStruct);

ADC16_Init(DEMO_ADC_BASE, &adc16ConfigStruct);

/*

* adc16ConfigStruct.referenceVoltageSource = kADC16_ReferenceVoltageSourceVref;

* adc16ConfigStruct.clockSource = kADC16_ClockSourceAsynchronousClock;

* adc16ConfigStruct.enableAsynchronousClock = true;

* adc16ConfigStruct.clockDivider = kADC16_ClockDivider8;

* adc16ConfigStruct.resolution = kADC16_ResolutionSE12Bit;

* adc16ConfigStruct.longSampleMode = kADC16_LongSampleDisabled;

* adc16ConfigStruct.enableHighSpeed = false;

* adc16ConfigStruct.enableLowPower = false;

* adc16ConfigStruct.enableContinuousConversion = false;

*/

#if defined(FSL_FEATURE_ADC16_HAS_CALIBRATION) &&

FSL_FEATURE_ADC16_HAS_CALIBRATION

ADC16_EnableHardwareTrigger(DEMO_ADC_BASE, false);

ADC16_DoAutoCalibration(DEMO_ADC_BASE);

#endif /* FSL_FEATURE_ADC16_HAS_CALIBRATION */

ADC16_EnableHardwareTrigger(DEMO_ADC_BASE, true);

adc16ChannelConfigStruct.channelNumber = DEMO_ADC_USER_CHANNEL;

adc16ChannelConfigStruct.enableInterruptOnConversionCompleted = true; /* Enable the interrupt. */

#if defined(FSL_FEATURE_ADC16_HAS_DIFF_MODE) && FSL_FEATURE_ADC16_HAS_DIFF_MODE

adc16ChannelConfigStruct.enableDifferentialConversion = false;

#endif /* FSL_FEATURE_ADC16_HAS_DIFF_MODE */

ADC16_SetChannelConfig(DEMO_ADC_BASE, DEMO_ADC_CHANNEL_GROUP,

&adc16ChannelConfigStruct);

}

/*******************************************************************************

* DECLARACIÓN DE MANEJADOR DE INTERRUPCIÓN DE FUNCION PDB

******************************************************************************/

void DEMO_PDB_IRQ_HANDLER(void)

{

PDB_ClearStatusFlags(DEMO_PDB_BASE, kPDB_DelayEventFlag);

g_PdbDelayInterruptCounter++;

g_PdbDelayInterruptFlag = true;

}

/*******************************************************************************

* DECLARACIÓN DE MANEJADOR DE INTERRUPCIÓN DE FUNCION ADC

******************************************************************************/

void DEMO_ADC_IRQ_HANDLER(void)

{

/* Read to clear COCO flag. */

static int i=0;

g_AdcConvValue = ADC16_GetChannelConversionValue(DEMO_ADC_BASE,

DEMO_ADC_CHANNEL_GROUP);

g_AdcInterruptCounter++;

g_AdcInterruptFlag = true;

i++;

i%=1920;

if(i==0)

{

}

}

/*******************************************************************************

* CODIGO DE PROGRAMA PRINCIPAL

******************************************************************************/

Sec_Fm++;

int main(void)

{

//***********************Inicialización_de_funciones_PDB_&_ADC******************

pdb_config_t pdbConfigStruct;

pdb_adc_pretrigger_config_t pdbAdcPreTriggerConfigStruct;

BOARD_InitPins();

BOARD_BootClockRUN();

BOARD_InitDebugConsole();

EnableIRQ(DEMO_PDB_IRQ_ID);

EnableIRQ(DEMO_ADC_IRQ_ID);

//******************Desplega_en_pantalla_una_noticicación***********************

PRINTF("\r\nPDB ADC16 Pre­Trigger Example.\r\n");

//***********************Configuración_de_contador_PDB**************************

PDB_GetDefaultConfig(&pdbConfigStruct);

pdbConfigStruct.prescalerDivider = kPDB_PrescalerDivider128;

pdbConfigStruct.dividerMultiplicationFactor = kPDB_DividerMultiplicationFactor40;

pdbConfigStruct.enableContinuousMode=true;

PDB_Init(DEMO_PDB_BASE, &pdbConfigStruct);

Bus_Clk = CLOCK_GetFreq(kCLOCK_BusClk);

Modulo_PDB = 1*(1969<<pdbConfigStruct.prescalerDivider)*40;

Modulo_PDB = Bus_Clk/Modulo_PDB;

/* Configure the PDB counter.

* pdbConfigStruct.loadValueMode = kPDB_LoadValueImmediately;

* pdbConfigStruct.prescalerDivider = kPDB_PrescalerDivider1;

* pdbConfigStruct.dividerMultiplicationFactor = kPDB_DividerMultiplicationFactor1;

* pdbConfigStruct.triggerInputSource = kPDB_TriggerSoftware;

* pdbConfigStruct.enableContinuousMode = false;

*/

//******************Configure_the_delay_interrupt******************************

PDB_SetModulusValue(DEMO_PDB_BASE, Modulo_PDB);

//*******Habilita_valor_retardo_menor_o_mayor_que_el_valor_del_modulo**********

PDB_SetCounterDelayValue(DEMO_PDB_BASE, Modulo_PDB/2);

PDB_EnableInterrupts(DEMO_PDB_BASE, kPDB_DelayInterruptEnable);

//********************Configure the ADC Pre­Trigger.***************************

pdbAdcPreTriggerConfigStruct.enablePreTriggerMask = 1U <<

DEMO_PDB_ADC_PRETRIGGER_CHANNEL;

pdbAdcPreTriggerConfigStruct.enableOutputMask = 1U <<

DEMO_PDB_ADC_PRETRIGGER_CHANNEL;

pdbAdcPreTriggerConfigStruct.enableBackToBackOperationMask = 0U;

PDB_SetADCPreTriggerConfig(DEMO_PDB_BASE, DEMO_PDB_ADC_TRIGGER_CHANNEL,

&pdbAdcPreTriggerConfigStruct);

PDB_SetADCPreTriggerDelayValue(DEMO_PDB_BASE,

DEMO_PDB_ADC_TRIGGER_CHANNEL,DEMO_PDB_ADC_PRETRIGGER_CHANNEL, Modulo_PDB/2);

//200U

/**The available Pre­Trigger delay value is less than or equal to the modulus value.**/

PDB_DoLoadValues(DEMO_PDB_BASE);

//*************************** Configure the ADC.********************************

DEMO_InitPDB_ADC();

g_PdbDelayInterruptCounter = 0U;

g_AdcInterruptCounter = 0U;

PRINTF("\r\nType any key into terminal to trigger the PDB and then trigger the ADC's conversion ...\r\n");

PDB_DoSoftwareTrigger(DEMO_PDB_BASE);

while (1)

{

GETCHAR();

g_PdbDelayInterruptFlag = false;

g_AdcInterruptFlag = false;

while ((!g_PdbDelayInterruptFlag) || (!g_AdcInterruptFlag))

{

}

//******************Desplega_en_pantalla_una_noticicación***********************

PRINTF("\r\n");

PRINTF("Sec_Fm: %d\r\n", Sec_Fm);

PRINTF("ADC Conversion Interrupt Counter: %d\r\n", g_AdcInterruptCounter);

PRINTF("ADC Conversion Value: %d\r\n", g_AdcConvValue);

}

}

/*******************************************************************************

* FIN DE CODIGO DE PROGRAMA PRINCIPAL.

******************************************************************************/