Simulador de Señales
Ingeniero Kevin Alexander Reyna Guarderas
November 27, 2025
1 Introducción
El objetivo de este proyecto es crear un simulador de señales PWM uti-
lizando la ESP32, que controla las señales de voltaje, corriente, potencia
activa (P) y potencia reactiva (Q) mediante la lectura de valores de cua-
tro potenciometros. Las señales generadas por la ESP32 son filtradas para
obtener una señal suavizada que se acerque a un comportamiento casi DC.
Este informe describe el proceso de implementación del simulador, la elección
de los parámetros para la generación de las señales, el filtro RC utilizado, la
frecuencia de operación de 20 kHz y la asignación de los pines en la ESP32.
2 Hardware Utilizado
El sistema utiliza la ESP32, que se encarga de generar las señales PWM a
partir de las lecturas de los potenciometros. Los pines de la ESP32 utilizados
son los siguientes:
Pin de Entrada Descripción
GPIO34 Potenciómetro de voltaje (Entrada analógica)
GPIO35 Potenciómetro de corriente (Entrada analógica)
GPIO32 Potenciómetro de potencia activa (P) (Entrada analógica)
GPIO33 Potenciómetro de potencia reactiva (Q) (Entrada analógica)
Table 1: Pines de entrada utilizados para la lectura de potenciometros
3 Implementación del Código
El código de la ESP32 está diseñado para leer los valores de los potenciomet-
ros y generar señales PWM en los pines de salida correspondientes. La
1
Pin de Salida Descripción
GPIO4 Señal PWM de voltaje
GPIO0 Señal PWM de corriente
GPIO2 Señal PWM de potencia activa (P)
GPIO15 Señal PWM de potencia reactiva (Q)
Table 2: Pines de salida utilizados para las señales PWM
frecuencia de la señal PWM se establece en 20 kHz para garantizar que
las señales sean suficientemente rápidas para ser suavizadas por el filtro
pasa-bajos RC. A continuación se muestra el código utilizado en la imple-
mentación.
Listing 1: Código para la generación de señales PWM
#i n c l u d e <Arduino . h>
const int potPinVoltage = 34; // Pin ADC para e l p o t e n c i m e t r o de v
const int potPinCurrent = 3 5 ; // Pin ADC para e l p o t e n c i m e t r o de c
const int potPinP = 3 2 ; // Pin ADC para e l p o t e n c i m e t r o de p o
const int potPinQ = 3 3 ; // Pin ADC para e l p o t e n c i m e t r o de p o
// Pinos de s a l i d a ( para mostrar l a s l e c t u r a s o u t i l i z a r l a s )
const i n t outPinVoltage = 4 ; // GPIO4
c o n s t i n t outPinCurrent = 0 ; // GPIO0
c o n s t i n t outPinP = 2 ; // GPIO2
c o n s t i n t outPinQ = 1 5 ; // GPIO15
// C o n f i g u r a c i n de PWM
c o n s t i n t pwmFreq = 2 0 0 0 0 ; // F r e c u e n c i a de PWM 20 kHz
c o n s t i n t pwmResolution = 8 ; // R e s o l u c i n d e l PWM (0 −255)
void setup ( ) {
S e r i a l . begin (115200); // I n i c i a l i z a l a c o m u n i c a c i n s e r i a l
// C o n f i g u r a r l o s p i n e s de s a l i d a PWM con f r e c u e n c i a de 20 kHz
l e d c S e t u p ( 0 , pwmFreq , pwmResolution ) ; // Canal 0 para GPIO4
l e d c A t t a c h P i n ( outPinVoltage , 0 ) ; // A s i g n a r GPIO4 a l c a n a l 0
l e d c S e t u p ( 1 , pwmFreq , pwmResolution ) ; // Canal 1 para GPIO0
l e d c A t t a c h P i n ( outPinCurrent , 1 ) ; // A s i g n a r GPIO0 a l c a n a l 1
2
l e d c S e t u p ( 2 , pwmFreq , pwmResolution ) ; // Canal 2 para GPIO2
l e d c A t t a c h P i n ( outPinP , 2 ) ; // A s i g n a r GPIO2 a l c a n a l 2
l e d c S e t u p ( 3 , pwmFreq , pwmResolution ) ; // Canal 3 para GPIO15
l e d c A t t a c h P i n ( outPinQ , 3 ) ; // A s i g n a r GPIO15 a l c a n a l 3
}
void loop ( ) {
// Leer l o s v a l o r e s de l o s p o t e n c i o m e t r o s (0 −4095)
i n t v o l t a g e V a l u e = analogRead ( p o t P i n V o l t a g e ) ; // Valor de v o l t a j e (0
i n t c u r r e n t V a l u e = analogRead ( potPinCurrent ) ; // Valor de corriente
i n t pValue = analogRead ( potPinP ) ; // Valor de potencia
i n t qValue = analogRead ( potPinQ ) ; // Valor de potencia
// Mapea l o s v a l o r e s para a j u s t a r l o s s e g n e l rango que n e c e s i t e s p
i n t v o lt a ge Ou t pu t = map( v o l t a g e V a l u e , 0 , 4095 , 0 , 2 5 5 ) ;
i n t currentOutput = map( c u r r e n t V a l u e , 0 , 4095 , 0 , 2 5 5 ) ;
i n t pOutput = map( pValue , 0 , 4 0 9 5 , 0 , 255);
i n t qOutput = map( qValue , 0 , 4 0 9 5 , 0 , 255);
// Mostrar v a l o r e s en e l monitor s e r i a l
S e r i a l . p r i n t ( ” V o l t a g e ( GPIO34 ) : ” ) ;
S e r i a l . print ( voltageValue ) ;
S e r i a l . p r i n t ( ” −> Output (GPIO4 ) : ” ) ;
S e r i a l . p r i n t l n ( v o lt a ge Ou t pu t ) ;
Serial . p r i n t ( ” Current ( GPIO35 ) : ” ) ;
Serial . print ( currentValue ) ;
Serial . p r i n t ( ” −> Output (GPIO0 ) : ” ) ;
Serial . p r i n t l n ( currentOutput ) ;
Serial . p r i n t ( ”P ( GPIO32 ) : ” ) ;
Serial . p r i n t ( pValue ) ;
Serial . p r i n t ( ” −> Output (GPIO2 ) : ” ) ;
Serial . p r i n t l n ( pOutput ) ;
Serial . p r i n t ( ”Q ( GPIO33 ) : ” ) ;
Serial . p r i n t ( qValue ) ;
Serial . p r i n t ( ” −> Output ( GPIO15 ) : ” ) ;
Serial . p r i n t l n ( qOutput ) ;
3
// Enviar l a s s e a l e s de s a l i d a PWM ( 20 kHz ) a l o s p i n e s c o r r e s p o n d
l e d c W r i t e ( 0 , vo l ta g eO ut p ut ) ; // Enviar v a l o r de v o l t a j e a l GPIO4
l e d c W r i t e ( 1 , currentOutput ) ; // Enviar v a l o r de c o r r i e n t e a l GPIO0
l e d c W r i t e ( 2 , pOutput ) ; // Enviar v a l o r de P a l GPIO2
l e d c W r i t e ( 3 , qOutput ) ; // Enviar v a l o r de Q a l GPIO15
delay (500); // E s p e r a r 500ms a n t e s de h a c e r l a s i g u i e n t e l e c t u r a
}
4 Justificación del Filtro RC
Para suavizar la señal PWM y convertirla en una señal cercana a DC, se
utilizó un filtro pasa-bajos RC con los siguientes componentes:
• Resistencia (R): 1 kΩ
• Condensador (C): 0.2 µF
La frecuencia de corte fc del filtro se calcula utilizando la siguiente fórmula:
1
fc =
2πRC
Sustituyendo los valores de R = 1 kΩ y C = 0.2 µF , obtenemos una
frecuencia de corte de aproximadamente:
fc ≈ 795 Hz
Esta frecuencia de corte es suficiente para atenuar las componentes de
alta frecuencia de la señal PWM de 20 kHz, logrando una señal de salida
suavizada.
5 Frecuencia de 20 kHz para PWM
La frecuencia de 20 kHz fue elegida por las siguientes razones:
• Evitar la percepción del sonido por el oı́do humano, ya que las señales
PWM con frecuencias menores a 20 kHz pueden ser audibles.
• Una frecuencia mayor a 20 kHz mejora la precisión en el control sin
aumentar significativamente el consumo de energı́a.
• 20 kHz es un estándar comúnmente utilizado en aplicaciones de control
y es adecuada para ser filtrada por un filtro RC simple.
4
6 Diseño del Esquemático y la PCB
El diseño del esquemático y la PCB fueron realizados utilizando Altium De-
signer. El esquemático incluye todos los componentes necesarios para la
lectura de los potenciometros, la generación de señales PWM y los filtros
de salida. La PCB fue diseñada con los pines correspondientes a los poten-
ciometros, pines de salida PWM y filtro RC.
A continuación se muestran las imágenes del diseño del esquemático, PCB
y la PCB 3D:
Figure 1: Esquemático del circuito diseñado en Altium
Figure 2: Diseño de la PCB realizada en Altium
5
Figure 3: Vista 3D de la PCB
7 Conclusiones
Se implementó un simulador de señales PWM utilizando la ESP32 para
generar señales de voltaje, corriente, potencia activa (P) y potencia reac-
tiva (Q). Estas señales fueron procesadas mediante un filtro pasa-bajos RC,
obteniendo una señal suavizada cercana a DC. La elección de la frecuencia
de 20 kHz para la señal PWM fue adecuada, ya que se mantiene fuera del
rango audible y es lo suficientemente alta para ser eficaz en la mayorı́a de las
aplicaciones de control.
El sistema fue configurado con pines especı́ficos en la ESP32 para la lec-
tura de los potenciometros y la salida de las señales PWM. El diseño del
filtro RC garantiza una atenuación efectiva de las componentes de alta fre-
cuencia de la señal PWM, asegurando una señal de salida estable y contro-
lada. Además, el diseño del esquemático y la PCB fue realizado con Altium
Designer, y las imágenes del esquemático, PCB y PCB 3D fueron incluidas
para ilustrar el proceso de diseño.
