ESCUELA POLITÉCNICA NACIONAL

FACULTAD DE INGENIERÍA ELÉCTRICA

Y ELECTRÓNICA

LABORATORIO DE
CONTROL CON MICROPROCESADORES

TRABAJO PREPARATORIO

Práctica No: 10

Tema: CONVERSIÓN D/A TIPO PWM

Grupo: GR-6

Realizado por: Sebástian Sánchez

Fecha de Entrega: 03/09/2020

Semestre 2020A
Trabajo preparatorio:
1. Consultar las características de un filtro activo de 2do orden de Butterworth.

Un filtro es un sistema que permite el paso de señales eléctricas a un rango de frecuencias

determinadas e impide el paso del resto. Se utilizan para:

o Acondicionamiento de señal de entrada.

o Digitalización de señales.
o Acondicionamiento de señal producida.

De acuerdo con la función de transferencia se clasifican en:

o Paso bajo.
o Paso alto.
o Paso banda.
o Elimina banda.

Un filtro activo es un circuito que contiene amplificadores operacionales. Normalmente un filtro

de segundo orden contiene un amplificador operacional y un circuito RC.

El filtro activo pasa bajo de Butterworth, debido a su respuesta plana, se suele usar en los filtros
anti-aliasing y en aplicaciones de conversión de datos; en general, donde sea necesario
conseguir una buena precisión de medida en la banda de paso.

Fig. 1 Respuesta en frecuencia del filtro activo pasa baja de Butterworth para distintos
órdenes.

El filtro de Butterworth es uno de los filtros electrónicos más básicos y es diseñado para producir
la respuesta más plana que sea posible hasta la frecuencia de corte. Es decir, la salida se
mantiene constante casi hasta la frecuencia de corte, luego disminuye a razón de 20n dB por
década (o ~6n dB por octava), donde n es el número de polos del filtro.

La respuesta en frecuencia de un filtro Butterworth es muy plana (no posee ondulaciones) en la

banda pasante, y se aproxima del cero en la banda rechazada. Los filtros Butterworth poseen
una caída en su magnitud como una función lineal con ω.

El Butterworth es el único filtro que mantiene el mismo formato para órdenes más elevadas (sin
embargo, con una inclinación más empinada en la banda atenuada) mientras otras variedades
de filtros (Bessel, Chevyshev, elíptico) poseen formatos diferentes para órdenes más elevadas.
Una de las desventajas de este tipo de filtro es que la transición entre la banda pasante y la
banda de corte puede ser muy extensa. Por tal motivo, para mejorar el corte del filtro es
necesario implementar un filtro de mayor orden.

Fig. 2 Respuesta en frecuencia del filtro activo pasa baja de Butterworth para distintos órdenes.

La función de transferencia para un filtro de Butterworth es la siguiente (únicamente posee

polos):
1
|𝐻(Ω)|2 = (1)
1 + (Ω/Ω𝑐 )2𝑁

Donde:

• N: es el orden del filtro.

• Ωc: es la frecuencia de corte (en la que la respuesta cae 3 dB por debajo de la banda
pasante).
• Ω: es la frecuencia analógica compleja (Ω=jw).

Figura 3. Esquema de un filtro de Butterworth de segundo orden.

2. Realizar el diagrama circuital completo y el programa de control para un sistema

microprocesado que realice lo siguiente:
• Genere una onda triangular de 240 Hz, la cual podrá ser visualizada utilizando un
osciloscopio de Proteus.
• Genere una onda senoidal de 60 Hz, sincronizada con la triangular.
 • Genere una señal SPWM por un pin del microcontrolador, la variación del ancho de
pulso se lo realiza utilizando un potenciómetro el cual variará la amplitud de la
senoidal.
• Opcional: Realizar la variación de la frecuencia de la senoidal (mejorar nota de
prácticas anteriores)
Código Principal:
/* USER CODE BEGIN Header
*/
/**
**************************
**************************
**************************
* @file : uint16_t adc_val [2];
main.c
* @brief : Main
program body
**************************
**************************
**************************
*/
/* USER CODE END Header */
/* Includes --------------
--------------------------
--------------------------
*/
#include "main.h"
/* Private includes ------
--------------------------
--------------------------
*/
/* USER CODE BEGIN
Includes */
#include <math.h>
/* USER CODE END Includes
*/
/* Private typedef -------
--------------------------
--------------------------
*/
/* USER CODE BEGIN PTD */
#define pi 3.141592654
/* USER CODE END PTD */
/* Private define --------
--------------------------
--------------------------
*/
/* USER CODE BEGIN PD */
/* USER CODE END PD */
/* Private macro ---------
--------------------------
--------------------------
*/
/* USER CODE BEGIN PM */
/* USER CODE END PM */
/* Private variables -----
--------------------------
--------------------------
*/
ADC_HandleTypeDef hadc1;
TIM_HandleTypeDef htim1;
TIM_HandleTypeDef htim2;
TIM_HandleTypeDef htim4; valor=HAL_ADC_GetValue(&ha
TIM_HandleTypeDef htim11; dc1);
/* USER CODE BEGIN PV */ static uint8_t adc_index
uint8_t tabla_sen[100]; = 0;
uint8_t sine=0;
if(hadc->Instance ==
uint16_t delta = 0; ADC1)
/* USER CODE END PV */ {
if
/* Private function (adc_index==0)adc_val[0]=H
prototypes --------------- AL_ADC_GetValue(&hadc1);
-------------------------- if
------*/ (adc_index==1)adc_val[1]=H
void AL_ADC_GetValue(&hadc1);
SystemClock_Config(void);
static void //INCREMENTAR CONTADOR
MX_GPIO_Init(void); adc_index++;
static void if(adc_index==2)
MX_ADC1_Init(void); adc_index=0;
static void
MX_TIM1_Init(void);
static void HAL_ADC_Start_IT(&hadc1);
MX_TIM2_Init(void); //si no esta activo el
static void modo continuo
MX_TIM4_Init(void); }
static void }
MX_TIM11_Init(void);
/* USER CODE BEGIN PFP */ //FUNCION ADC 2
POTENCIOMETRO
/* USER CODE END PFP */
long map(long x, long
/* Private user code ----- in_min, long in_max, long
-------------------------- out_min, long out_max) {
-------------------------- return (x - in_min) *
*/ (out_max - out_min) /
/* USER CODE BEGIN 0 */ (in_max - in_min) +
int tempo=72, aux, out_min;
triangular; }
float amplitud;
uint16_t valor=0;
//FUNCION ADC
void
HAL_ADC_ConvCpltCallback(A /*
DC_HandleTypeDef* hadc) if(GPIO_Pin==BOTON_Pin){
{
/* Prevent unused
argument(s) compilation amplitud=0.0089*valor;
warning */
UNUSED(hadc); for(uint8_t
/* NOTE : This function i=0;i<73;i++){
Should not be modified,
when the callback is tabla_sen[i]=36.5
needed, + amplitud *
the sin(i*(360.0/73.0)*(pi/180
HAL_ADC_ConvCpltCallback .0));
could be implemented in }
the user file
*/ }*/
 __HAL_TIM_SET_COMPARE(&hti }else{
/* USER CODE END 0 */ m4,TIM_CHANNEL_1,73-1);
__HAL_TIM_SET_COMP
/** ARE(&htim11,TIM_CHANNEL_1,
* @brief The HAL_TIM_Base_Start(&htim2) tempo);
application entry point. ; }
* @retval int }
*/
int main(void) //HAL_ADC_Start_IT(&hadc1)
{ ; if(aux==1 &&
/* USER CODE BEGIN 1 */ __HAL_TIM_GET_COUNTER(&hti
/* USER CODE END 2 */ m1)>90){
for(uint8_t
i=0;i<73;i++){ /* Infinite loop */ tempo++;
/* USER CODE BEGIN WHILE
tabla_sen[i]=36.5 */ if(tempo==73){
+ 36.5 * while (1)
sin(i*(360.0/73.0)*(pi/180 { aux=0;
.0)); /* USER CODE END WHILE
} */ tempo--;

/* USER CODE END 1 */ /* USER CODE BEGIN 3 }else{

/* MCU Configuration----
--------------------------
--------------------------
*/
/* Reset of all
peripherals, Initializes
the Flash interface and
the Systick. */
HAL_Init();
/* USER CODE BEGIN Init
*/
/* USER CODE END Init */
/* Configure the system
clock */
SystemClock_Config();
/* USER CODE BEGIN
SysInit */
*/
__HAL_TIM_SET_COMP
/*HAL_ADC_Start(&hadc1); ARE(&htim11,TIM_CHANNEL_1,
tempo);
HAL_ADC_PollForConversion(
&hadc1, 1024); }
}
valor=HAL_ADC_GetValue(&ha
dc1);
if(valor>128){ if(__HAL_TIM_GET_COUNTER(&
htim2)==0){
HAL_GPIO_WritePin(GPIOA,
GPIO_PIN_4, GPIO_PIN_SET); __HAL_TIM_SET_COMPARE(&hti
m4,TIM_CHANNEL_1,tabla_sen
HAL_GPIO_WritePin(GPIOA, [sine]);
GPIO_PIN_5,
GPIO_PIN_RESET); sine++;
HAL_ADC_Stop(&hadc1); triangular=-1*(tempo-73);
} if(valor<128){
if(tabla_sen[sine]>triangu
HAL_GPIO_WritePin(GPIOA, lar){
GPIO_PIN_5, GPIO_PIN_SET);

/* USER CODE END SysInit HAL_GPIO_WritePin(GPIOA, HAL_GPIO_WritePin(GPIOB,

*/ GPIO_PIN_4, GPIO_PIN_8, 1);
GPIO_PIN_RESET);
/* Initialize all }else{
configured peripherals */ HAL_ADC_Stop(&hadc1);
MX_GPIO_Init(); }*/
MX_ADC1_Init(); HAL_GPIO_WritePin(GPIOB,
MX_TIM1_Init(); /*for(uint8_t GPIO_PIN_8, 0);
MX_TIM2_Init(); i=0;i<73;i++){
MX_TIM4_Init(); }
MX_TIM11_Init(); tabla_sen[i]=36.5
/* USER CODE BEGIN 2 */ + 36.5 * if(sine==73){
sin(i*(360.0/73.0)*(pi/180
HAL_TIM_PWM_Start(&htim11, .0)); sine=0;
TIM_CHANNEL_1); }*/
}
__HAL_TIM_SET_COMPARE(&hti if(aux==0 && }
m11,TIM_CHANNEL_1,73-1); __HAL_TIM_GET_COUNTER(&hti
m1)>90){
}
HAL_TIM_Base_Start(&htim1) tempo--; /* USER CODE END 3 */
; }
if(tempo==-1){
/**
HAL_TIM_PWM_Start(&htim4, aux=1; * @brief System Clock
TIM_CHANNEL_1); Configuration
tempo++; * @retval None
 */ { /** Configure for the
void Error_Handler(); selected ADC regular
SystemClock_Config(void) } channel its corresponding
{ } rank in the sequencer and
RCC_OscInitTypeDef its sample time.
RCC_OscInitStruct = {0}; /** */
RCC_ClkInitTypeDef * @brief ADC1 sConfig.Channel =
RCC_ClkInitStruct = {0}; Initialization Function ADC_CHANNEL_0;
* @param None sConfig.Rank = 1;
/** Configure the main * @retval None sConfig.SamplingTime =
internal regulator output */ ADC_SAMPLETIME_480CYCLES;
voltage static void if
*/ MX_ADC1_Init(void) (HAL_ADC_ConfigChannel(&ha
{ dc1, &sConfig) != HAL_OK)
__HAL_RCC_PWR_CLK_ENABLE() {
; /* USER CODE BEGIN Error_Handler();
ADC1_Init 0 */ }
__HAL_PWR_VOLTAGESCALING_C /** Configure for the
ONFIG(PWR_REGULATOR_VOLTAG /* USER CODE END selected ADC regular
E_SCALE2); ADC1_Init 0 */ channel its corresponding
/** Initializes the CPU, rank in the sequencer and
AHB and APB busses clocks ADC_ChannelConfTypeDef its sample time.
*/ sConfig = {0}; */
sConfig.Channel =
RCC_OscInitStruct.Oscillat /* USER CODE BEGIN ADC_CHANNEL_1;
orType = ADC1_Init 1 */ sConfig.Rank = 2;
RCC_OSCILLATORTYPE_HSI; if
/* USER CODE END (HAL_ADC_ConfigChannel(&ha
RCC_OscInitStruct.HSIState ADC1_Init 1 */ dc1, &sConfig) != HAL_OK)
= RCC_HSI_ON; /** Configure the global {
features of the ADC Error_Handler();
RCC_OscInitStruct.HSICalib (Clock, Resolution, Data }
rationValue = Alignment and number of /* USER CODE BEGIN
RCC_HSICALIBRATION_DEFAULT conversion) ADC1_Init 2 */
; */
hadc1.Instance = ADC1; /* USER CODE END
RCC_OscInitStruct.PLL.PLLS ADC1_Init 2 */
tate = RCC_PLL_NONE; hadc1.Init.ClockPrescaler
if = }
(HAL_RCC_OscConfig(&RCC_Os ADC_CLOCK_SYNC_PCLK_DIV2;
cInitStruct) != HAL_OK) hadc1.Init.Resolution = /**
{ ADC_RESOLUTION_8B; * @brief TIM1
Error_Handler(); hadc1.Init.ScanConvMode Initialization Function
} = ENABLE; * @param None
/** Initializes the CPU, * @retval None
AHB and APB busses clocks hadc1.Init.ContinuousConvM */
*/ ode = DISABLE; static void
MX_TIM1_Init(void)
RCC_ClkInitStruct.ClockTyp hadc1.Init.DiscontinuousCo {
e = nvMode = DISABLE;
RCC_CLOCKTYPE_HCLK|RCC_CLO /* USER CODE BEGIN
CKTYPE_SYSCLK hadc1.Init.ExternalTrigCon TIM1_Init 0 */
vEdge =
|RCC_CLOCKTYPE_PCLK1|RCC_C ADC_EXTERNALTRIGCONVEDGE_N /* USER CODE END
LOCKTYPE_PCLK2; ONE; TIM1_Init 0 */

RCC_ClkInitStruct.SYSCLKSo hadc1.Init.ExternalTrigCon TIM_ClockConfigTypeDef

urce = v = ADC_SOFTWARE_START; sClockSourceConfig = {0};
RCC_SYSCLKSOURCE_HSI; hadc1.Init.DataAlign = TIM_MasterConfigTypeDef
ADC_DATAALIGN_RIGHT; sMasterConfig = {0};
RCC_ClkInitStruct.AHBCLKDi
vider = RCC_SYSCLK_DIV1; hadc1.Init.NbrOfConversion /* USER CODE BEGIN
= 2; TIM1_Init 1 */
RCC_ClkInitStruct.APB1CLKD
ivider = RCC_HCLK_DIV1; hadc1.Init.DMAContinuousRe /* USER CODE END
quests = DISABLE; TIM1_Init 1 */
RCC_ClkInitStruct.APB2CLKD hadc1.Init.EOCSelection htim1.Instance = TIM1;
ivider = RCC_HCLK_DIV1; = ADC_EOC_SINGLE_CONV; htim1.Init.Prescaler =
if (HAL_ADC_Init(&hadc1) 0;
if != HAL_OK) htim1.Init.CounterMode =
(HAL_RCC_ClockConfig(&RCC_ { TIM_COUNTERMODE_UP;
ClkInitStruct, Error_Handler(); htim1.Init.Period = 100-
FLASH_LATENCY_0) != } 1;
HAL_OK)
 htim1.Init.ClockDivision TIM_ClockConfigTypeDef
= TIM_CLOCKDIVISION_DIV1; /* USER CODE END sClockSourceConfig = {0};
TIM2_Init 1 */ TIM_MasterConfigTypeDef
htim1.Init.RepetitionCount htim2.Instance = TIM2; sMasterConfig = {0};
er = 0; htim2.Init.Prescaler = TIM_OC_InitTypeDef
0; sConfigOC = {0};
htim1.Init.AutoReloadPrelo htim2.Init.CounterMode =
ad = TIM_COUNTERMODE_UP; /* USER CODE BEGIN
TIM_AUTORELOAD_PRELOAD_DIS htim2.Init.Period = 160- TIM4_Init 1 */
ABLE; 1;
if htim2.Init.ClockDivision /* USER CODE END
(HAL_TIM_Base_Init(&htim1) = TIM_CLOCKDIVISION_DIV1; TIM4_Init 1 */
!= HAL_OK) htim4.Instance = TIM4;
{ htim2.Init.AutoReloadPrelo htim4.Init.Prescaler =
Error_Handler(); ad = 15;
} TIM_AUTORELOAD_PRELOAD_DIS htim4.Init.CounterMode =
ABLE; TIM_COUNTERMODE_UP;
sClockSourceConfig.ClockSo if htim4.Init.Period = 72;
urce = (HAL_TIM_Base_Init(&htim2) htim4.Init.ClockDivision
TIM_CLOCKSOURCE_INTERNAL; != HAL_OK) = TIM_CLOCKDIVISION_DIV1;
if {
(HAL_TIM_ConfigClockSource Error_Handler(); htim4.Init.AutoReloadPrelo
(&htim1, } ad =
&sClockSourceConfig) != TIM_AUTORELOAD_PRELOAD_DIS
HAL_OK) sClockSourceConfig.ClockSo ABLE;
{ urce = if
Error_Handler(); TIM_CLOCKSOURCE_INTERNAL; (HAL_TIM_Base_Init(&htim4)
} if != HAL_OK)
(HAL_TIM_ConfigClockSource {
sMasterConfig.MasterOutput (&htim2, Error_Handler();
Trigger = TIM_TRGO_RESET; &sClockSourceConfig) != }
HAL_OK)
sMasterConfig.MasterSlaveM { sClockSourceConfig.ClockSo
ode = Error_Handler(); urce =
TIM_MASTERSLAVEMODE_DISABL } TIM_CLOCKSOURCE_INTERNAL;
E; if
if sMasterConfig.MasterOutput (HAL_TIM_ConfigClockSource
(HAL_TIMEx_MasterConfigSyn Trigger = TIM_TRGO_RESET; (&htim4,
chronization(&htim1, &sClockSourceConfig) !=
&sMasterConfig) != HAL_OK) sMasterConfig.MasterSlaveM HAL_OK)
{ ode = {
Error_Handler(); TIM_MASTERSLAVEMODE_DISABL Error_Handler();
} E; }
/* USER CODE BEGIN if if
TIM1_Init 2 */ (HAL_TIMEx_MasterConfigSyn (HAL_TIM_PWM_Init(&htim4)
chronization(&htim2, != HAL_OK)
/* USER CODE END &sMasterConfig) != HAL_OK) {
TIM1_Init 2 */ { Error_Handler();
Error_Handler(); }
} }
/* USER CODE BEGIN sMasterConfig.MasterOutput
/** TIM2_Init 2 */ Trigger = TIM_TRGO_RESET;
* @brief TIM2
Initialization Function /* USER CODE END sMasterConfig.MasterSlaveM
* @param None TIM2_Init 2 */ ode =
* @retval None TIM_MASTERSLAVEMODE_DISABL
*/ } E;
static void if
MX_TIM2_Init(void) /** (HAL_TIMEx_MasterConfigSyn
{ * @brief TIM4 chronization(&htim4,
Initialization Function &sMasterConfig) != HAL_OK)
/* USER CODE BEGIN * @param None {
TIM2_Init 0 */ * @retval None Error_Handler();
*/ }
/* USER CODE END static void sConfigOC.OCMode =
TIM2_Init 0 */ MX_TIM4_Init(void) TIM_OCMODE_PWM1;
{ sConfigOC.Pulse = 0;
TIM_ClockConfigTypeDef sConfigOC.OCPolarity =
sClockSourceConfig = {0}; /* USER CODE BEGIN TIM_OCPOLARITY_HIGH;
TIM_MasterConfigTypeDef TIM4_Init 0 */ sConfigOC.OCFastMode =
sMasterConfig = {0}; TIM_OCFAST_DISABLE;
/* USER CODE END if
/* USER CODE BEGIN TIM4_Init 0 */ (HAL_TIM_PWM_ConfigChannel
TIM2_Init 1 */
(&htim4, &sConfigOC, if GPIO_InitStruct.Mode =
TIM_CHANNEL_1) != HAL_OK) (HAL_TIM_PWM_ConfigChannel GPIO_MODE_OUTPUT_PP;
{ (&htim11, &sConfigOC, GPIO_InitStruct.Pull =
Error_Handler(); TIM_CHANNEL_1) != HAL_OK) GPIO_NOPULL;
} { GPIO_InitStruct.Speed =
/* USER CODE BEGIN Error_Handler(); GPIO_SPEED_FREQ_LOW;
TIM4_Init 2 */ }
/* USER CODE BEGIN HAL_GPIO_Init(SPWM_GPIO_Po
/* USER CODE END TIM11_Init 2 */ rt, &GPIO_InitStruct);
TIM4_Init 2 */
/* USER CODE END }
HAL_TIM_MspPostInit(&htim4 TIM11_Init 2 */
); /* USER CODE BEGIN 4 */
HAL_TIM_MspPostInit(&htim1
} 1); /* USER CODE END 4 */

/** } /**
* @brief TIM11 * @brief This function
Initialization Function /** is executed in case of
* @param None * @brief GPIO error occurrence.
* @retval None Initialization Function * @retval None
*/ * @param None */
static void * @retval None void Error_Handler(void)
MX_TIM11_Init(void) */ {
{ static void /* USER CODE BEGIN
MX_GPIO_Init(void) Error_Handler_Debug */
/* USER CODE BEGIN { /* User can add his own
TIM11_Init 0 */ GPIO_InitTypeDef implementation to report
GPIO_InitStruct = {0}; the HAL error return state
/* USER CODE END */
TIM11_Init 0 */ /* GPIO Ports Clock
Enable */ /* USER CODE END
TIM_OC_InitTypeDef Error_Handler_Debug */
sConfigOC = {0}; __HAL_RCC_GPIOA_CLK_ENABLE }
();
/* USER CODE BEGIN #ifdef USE_FULL_ASSERT
TIM11_Init 1 */ __HAL_RCC_GPIOD_CLK_ENABLE /**
(); * @brief Reports the
/* USER CODE END name of the source file
TIM11_Init 1 */ __HAL_RCC_GPIOB_CLK_ENABLE and the source line number
htim11.Instance = TIM11; (); * where the
htim11.Init.Prescaler = assert_param error has
15; /*Configure GPIO pin occurred.
htim11.Init.CounterMode Output Level */ * @param file: pointer
= TIM_COUNTERMODE_UP; HAL_GPIO_WritePin(GPIOA, to the source file name
htim11.Init.Period = 72; GPIO_PIN_4|GPIO_PIN_5, * @param line:
GPIO_PIN_RESET); assert_param error line
htim11.Init.ClockDivision source number
= TIM_CLOCKDIVISION_DIV1; /*Configure GPIO pin * @retval None
Output Level */ */
htim11.Init.AutoReloadPrel void assert_failed(uint8_t
oad = HAL_GPIO_WritePin(SPWM_GPI *file, uint32_t line)
TIM_AUTORELOAD_PRELOAD_DIS O_Port, SPWM_Pin, {
ABLE; GPIO_PIN_RESET); /* USER CODE BEGIN 6 */
if /* User can add his own
(HAL_TIM_Base_Init(&htim11 /*Configure GPIO pins : implementation to report
) != HAL_OK) PA4 PA5 */ the file name and line
{ GPIO_InitStruct.Pin = number,
Error_Handler(); GPIO_PIN_4|GPIO_PIN_5; tex: printf("Wrong
} GPIO_InitStruct.Mode = parameters value: file %s
if GPIO_MODE_OUTPUT_PP; on line %d\r\n", file,
(HAL_TIM_PWM_Init(&htim11) GPIO_InitStruct.Pull = line) */
!= HAL_OK) GPIO_NOPULL; /* USER CODE END 6 */
{ GPIO_InitStruct.Speed = }
Error_Handler(); GPIO_SPEED_FREQ_LOW; #endif /* USE_FULL_ASSERT
} HAL_GPIO_Init(GPIOA, */
sConfigOC.OCMode = &GPIO_InitStruct);
TIM_OCMODE_PWM1; /************************
sConfigOC.Pulse = 0; /*Configure GPIO pin : (C) COPYRIGHT
sConfigOC.OCPolarity = SPWM_Pin */ STMicroelectronics
TIM_OCPOLARITY_HIGH; GPIO_InitStruct.Pin = *****END OF FILE****/
sConfigOC.OCFastMode = SPWM_Pin;
TIM_OCFAST_DISABLE;
Diagrama de flujo:

Fig. 4. Diagrama de flujo del programa.

Evidencias:

Fig. 5. Evidencia Funcionamiento.

En la figura de arriba se puede observar el circuito completo.

Fig. 6. Evidencia Funcionamiento.

Al iniciar el programa, se generan las ondas senoidales (amarillo) y triangular (celeste), estas
señales pasaron previamente un filtro Butterworth de 2do orden, la señal SPWM (verde), se
genera de la comparación de las dos señales antes mencionadas.
Cabe recalcar que, al intentar modificar la amplitud de la onda senoidal, debido a que la
simulación ocupa muchos recursos de la CPU, el programa no corre en tiempo real, por lo que
no se puede apreciar el cambio de amplitud, ya que es muy lento el cambio que se puede ver en
el osciloscopio y tarda demasiado tiempo en la vida real.

Fig. 7. Evidencia Funcionamiento.

Como se puede ver en la figura 7, en la vida real ah pasado mas de 5 minutos, mientras que en
la simulación en Proteus ah pasado 1 segundo y medio, es por esto que no se puede apreciar el
cambio de amplitud, y se optó por suprimir esta característica en la simulación.

Referencias:

[1] N. Sotomayor. Control con microprocesadores, abril 2020, Escuela Politécnica Nacional.

[2] St microcontrollers. “Datasheet STM32 F401. [Online]. Available:

https://www.st.com/en/microcontrollers-microprocessors/stm32f401.html

[3] J. GaFernández, "Filtros Butterworth", Filtrosbutterworthw.blogspot.com, 2020. [Online].

Available: http://filtrosbutterworthw.blogspot.com/2011/. [Accessed: 01- Sep- 2020].