ArduinoMega2560_SPI 1.0
Cargando...
Buscando...
Nada coincide
Referencia del archivo main.cpp

Firmware principal del sistema. Configura diagnósticos, pines, UART, SPI, I2C, interrupciones, entradas analógicas, PWM, GPIO, motor paso a paso y PID. Más...

#include <Arduino.h>
#include "main.h"
Gráfico de dependencias incluidas en main.cpp:

Ir al código fuente de este archivo.

Funciones

void setup ()
 Arduino setup function (runs once at startup).
void loop ()
 Arduino main loop. Ejecuta continuamente la configuración de pines, lectura analógica, control PID y movimiento del motor paso a paso.

Descripción detallada

Firmware principal del sistema. Configura diagnósticos, pines, UART, SPI, I2C, interrupciones, entradas analógicas, PWM, GPIO, motor paso a paso y PID.

Definición en el archivo main.cpp.

Documentación de funciones

◆ loop()

void loop ( )

Arduino main loop. Ejecuta continuamente la configuración de pines, lectura analógica, control PID y movimiento del motor paso a paso.

UART: Asynchronous serial communication

Variable | Pin array | Descripción -------------------------------------—|-------------------------------------—|-------------------------------------—

SPI: Synchronous master-slave communication

I2C / TWI: Two-wire communication

External interrupts

ANALOG: Pins with analog input capability (ADC)

PWM: Pins with pulse-width modulation capability

GPIO: General-purpose digital pins

Definición en la línea 60 del archivo main.cpp.

60 {
61 /**
62 * @brief UART: Asynchronous serial communication
63 *
64 * Variable | Pin array | Descripción
65 * ----------------------------------------|----------------------------------------|----------------------------------------
66 */
67 [[maybe_unused]] PinInfo uartRx0 = Pins::UART_RX[0]; // RX0 → UART0 via USB
68 [[maybe_unused]] PinInfo uartRx1 = Pins::UART_RX[1]; // RX1 → UART1 + INT4
69 [[maybe_unused]] PinInfo uartRx2 = Pins::UART_RX[2]; // RX2 → UART2
70 [[maybe_unused]] PinInfo uartRx3 = Pins::UART_RX[3]; // RX3 → UART3
71 [[maybe_unused]] PinInfo uartTx0 = Pins::UART_TX[0]; // TX0 → UART0 via USB
72 [[maybe_unused]] PinInfo uartTx1 = Pins::UART_TX[1]; // TX1 → UART1 + INT5
73 [[maybe_unused]] PinInfo uartTx2 = Pins::UART_TX[2]; // TX2 → UART2
74 [[maybe_unused]] PinInfo uartTx3 = Pins::UART_TX[3]; // TX3 → UART3
75
76 /**
77 * @brief SPI: Synchronous master-slave communication
78 */
79 [[maybe_unused]] PinInfo spiMiso = Pins::SPI[0]; // MISO → pin 50
80 [[maybe_unused]] PinInfo spiMosi = Pins::SPI[1]; // MOSI → pin 51
81 [[maybe_unused]] PinInfo spiSck = Pins::SPI[2]; // SCK → pin 52
82 [[maybe_unused]] PinInfo spiSs = Pins::SPI[3]; // SS → pin 53
83
84 /**
85 * @brief I2C / TWI: Two-wire communication
86 */
87 [[maybe_unused]] PinInfo i2cSda = Pins::I2C[0]; // SDA → pin 20
88 [[maybe_unused]] PinInfo i2cScl = Pins::I2C[1]; // SCL → pin 21
89
90 /**
91 * @brief External interrupts
92 */
93 [[maybe_unused]] PinInfo int0 = Pins::INTERRUPTS[0]; // INT0 → pin 2
94 [[maybe_unused]] PinInfo int1 = Pins::INTERRUPTS[1]; // INT1 → pin 3
95 [[maybe_unused]] PinInfo int2 = Pins::INTERRUPTS[2]; // INT2 → pin 21
96 [[maybe_unused]] PinInfo int3 = Pins::INTERRUPTS[3]; // INT3 → pin 20
97 [[maybe_unused]] PinInfo int4 = Pins::INTERRUPTS[4]; // INT4 → pin 19
98 [[maybe_unused]] PinInfo int5 = Pins::INTERRUPTS[5]; // INT5 → pin 18
99
100 /**
101 * @brief ANALOG: Pins with analog input capability (ADC)
102 */
103 [[maybe_unused]] PinInfo analog0 = Pins::ANALOG[0]; /* A0 → pin 54*/ pinMode(analog0.number, INPUT);
104 [[maybe_unused]] PinInfo analog1 = Pins::ANALOG[1]; /* A1 → pin 55*/ pinMode(analog1.number, INPUT);
105 [[maybe_unused]] PinInfo analog2 = Pins::ANALOG[2]; /* A2 → pin 56*/ pinMode(analog2.number, INPUT);
106 [[maybe_unused]] PinInfo analog3 = Pins::ANALOG[3]; /* A3 → pin 57*/ pinMode(analog3.number, INPUT);
107 [[maybe_unused]] PinInfo analog4 = Pins::ANALOG[4]; /* A4 → pin 58*/ pinMode(analog4.number, INPUT);
108 [[maybe_unused]] PinInfo analog5 = Pins::ANALOG[5]; /* A5 → pin 59*/ pinMode(analog5.number, INPUT);
109 [[maybe_unused]] PinInfo analog6 = Pins::ANALOG[6]; /* A6 → pin 60*/ pinMode(analog6.number, INPUT);
110 [[maybe_unused]] PinInfo analog7 = Pins::ANALOG[7]; /* A7 → pin 61*/ pinMode(analog7.number, INPUT);
111 [[maybe_unused]] PinInfo analog8 = Pins::ANALOG[8]; /* A8 → pin 62*/ pinMode(analog8.number, INPUT);
112 [[maybe_unused]] PinInfo analog9 = Pins::ANALOG[9]; /* A9 → pin 63*/ pinMode(analog9.number, INPUT);
113 [[maybe_unused]] PinInfo analog10 = Pins::ANALOG[10]; /* A10 → pin 64*/ pinMode(analog10.number, INPUT);
114 [[maybe_unused]] PinInfo analog11 = Pins::ANALOG[11]; /* A11 → pin 65*/ pinMode(analog11.number, INPUT);
115 [[maybe_unused]] PinInfo analog12 = Pins::ANALOG[12]; /* A12 → pin 66*/ pinMode(analog12.number, INPUT);
116 [[maybe_unused]] PinInfo analog13 = Pins::ANALOG[13]; /* A13 → pin 67*/ pinMode(analog13.number, INPUT);
117 [[maybe_unused]] PinInfo analog14 = Pins::ANALOG[14]; /* A14 → pin 68*/ pinMode(analog14.number, INPUT);
118 [[maybe_unused]] PinInfo analog15 = Pins::ANALOG[15]; /* A15 → pin 69*/ pinMode(analog15.number, INPUT);
119
120 /**
121 * @brief PWM: Pins with pulse-width modulation capability
122 */
123 [[maybe_unused]] PinInfo pwm0 = Pins::PWM[0]; /* PWM02 → pin 2*/ pinMode(pwm0.number, OUTPUT);
124 [[maybe_unused]] PinInfo pwm1 = Pins::PWM[1]; /* PWM03 → pin 3*/ pinMode(pwm1.number, OUTPUT);
125 [[maybe_unused]] PinInfo pwm2 = Pins::PWM[2]; /* PWM04 → pin 4*/ pinMode(pwm2.number, OUTPUT);
126 [[maybe_unused]] PinInfo pwm3 = Pins::PWM[3]; /* PWM05 → pin 5*/ pinMode(pwm3.number, OUTPUT);
127 [[maybe_unused]] PinInfo pwm4 = Pins::PWM[4]; /* PWM06 → pin 6*/ pinMode(pwm4.number, OUTPUT);
128 [[maybe_unused]] PinInfo pwm5 = Pins::PWM[5]; /* PWM07 → pin 7*/ pinMode(pwm5.number, OUTPUT);
129 [[maybe_unused]] PinInfo pwm6 = Pins::PWM[6]; /* PWM08 → pin 8*/ pinMode(pwm6.number, OUTPUT);
130 [[maybe_unused]] PinInfo pwm7 = Pins::PWM[7]; /* PWM09 → pin 9*/ pinMode(pwm7.number, OUTPUT);
131 [[maybe_unused]] PinInfo pwm8 = Pins::PWM[8]; /* PWM10 → pin 10*/ pinMode(pwm8.number, OUTPUT);
132 [[maybe_unused]] PinInfo pwm9 = Pins::PWM[9]; /* PWM11 → pin 11*/ pinMode(pwm9.number, OUTPUT);
133 [[maybe_unused]] PinInfo pwm10 = Pins::PWM[10]; /* PWM12 → pin 12*/ pinMode(pwm10.number, OUTPUT);
134 [[maybe_unused]] PinInfo pwm11 = Pins::PWM[11]; /* PWM44 → pin 44*/ pinMode(pwm11.number, OUTPUT);
135 [[maybe_unused]] PinInfo pwm12 = Pins::PWM[12]; /* PWM45 → pin 45*/ pinMode(pwm12.number, OUTPUT);
136 [[maybe_unused]] PinInfo pwm13 = Pins::PWM[13]; /* PWM46 → pin 46*/ pinMode(pwm13.number, OUTPUT);
137
138 /**
139 * @brief GPIO: General-purpose digital pins
140 */
141 [[maybe_unused]] PinInfo gpio0 = Pins::GPIO[0]; /* GPIO13 → pin 13 */ pinMode(gpio0.number, OUTPUT);
142 [[maybe_unused]] PinInfo gpio1 = Pins::GPIO[1]; /* GPIO22 → pin 22 */ pinMode(gpio1.number, OUTPUT);
143 [[maybe_unused]] PinInfo gpio2 = Pins::GPIO[2]; /* GPIO23 → pin 23 */ pinMode(gpio2.number, OUTPUT);
144 [[maybe_unused]] PinInfo gpio3 = Pins::GPIO[3]; /* GPIO24 → pin 24 */ pinMode(gpio3.number, OUTPUT);
145 [[maybe_unused]] PinInfo gpio4 = Pins::GPIO[4]; /* GPIO25 → pin 25 */ pinMode(gpio4.number, OUTPUT);
146 [[maybe_unused]] PinInfo gpio5 = Pins::GPIO[5]; /* GPIO26 → pin 26 */ pinMode(gpio5.number, OUTPUT);
147 [[maybe_unused]] PinInfo gpio6 = Pins::GPIO[6]; /* GPIO27 → pin 27 */ pinMode(gpio6.number, OUTPUT);
148 [[maybe_unused]] PinInfo gpio7 = Pins::GPIO[7]; /* GPIO28 → pin 28 */ pinMode(gpio7.number, OUTPUT);
149 [[maybe_unused]] PinInfo gpio8 = Pins::GPIO[8]; /* GPIO29 → pin 29 */ pinMode(gpio8.number, OUTPUT);
150 [[maybe_unused]] PinInfo gpio9 = Pins::GPIO[9]; /* GPIO30 → pin 30 */ pinMode(gpio9.number, OUTPUT);
151 [[maybe_unused]] PinInfo gpio10 = Pins::GPIO[10]; /* GPIO31 → pin 31 */ pinMode(gpio10.number, OUTPUT);
152 [[maybe_unused]] PinInfo gpio11 = Pins::GPIO[11]; /* GPIO32 → pin 32 */ pinMode(gpio11.number, OUTPUT);
153 [[maybe_unused]] PinInfo gpio12 = Pins::GPIO[12]; /* GPIO33 → pin 33 */ pinMode(gpio12.number, OUTPUT);
154 [[maybe_unused]] PinInfo gpio13 = Pins::GPIO[13]; /* GPIO34 → pin 34 */ pinMode(gpio13.number, OUTPUT);
155 [[maybe_unused]] PinInfo gpio14 = Pins::GPIO[14]; /* GPIO35 → pin 35 */ pinMode(gpio14.number, OUTPUT);
156 [[maybe_unused]] PinInfo gpio15 = Pins::GPIO[15]; /* GPIO36 → pin 36 */ pinMode(gpio15.number, OUTPUT);
157 [[maybe_unused]] PinInfo gpio16 = Pins::GPIO[16]; /* GPIO37 → pin 37 */ pinMode(gpio16.number, OUTPUT);
158 [[maybe_unused]] PinInfo gpio17 = Pins::GPIO[17]; /* GPIO38 → pin 38 */ pinMode(gpio17.number, OUTPUT);
159 [[maybe_unused]] PinInfo gpio18 = Pins::GPIO[18]; /* GPIO39 → pin 39 */ pinMode(gpio18.number, OUTPUT);
160 [[maybe_unused]] PinInfo gpio19 = Pins::GPIO[19]; /* GPIO40 → pin 40 */ pinMode(gpio19.number, OUTPUT);
161 [[maybe_unused]] PinInfo gpio20 = Pins::GPIO[20]; /* GPIO41 → pin 41 */ pinMode(gpio20.number, OUTPUT);
162 [[maybe_unused]] PinInfo gpio21 = Pins::GPIO[21]; /* GPIO42 → pin 42 */ pinMode(gpio21.number, OUTPUT);
163 [[maybe_unused]] PinInfo gpio22 = Pins::GPIO[22]; /* GPIO43 → pin 43 */ pinMode(gpio22.number, OUTPUT);
164 [[maybe_unused]] PinInfo gpio23 = Pins::GPIO[23]; /* GPIO44 → pin 44 */ pinMode(gpio23.number, OUTPUT);
165 [[maybe_unused]] PinInfo gpio24 = Pins::GPIO[24]; /* GPIO45 → pin 45 */ pinMode(gpio24.number, OUTPUT);
166 [[maybe_unused]] PinInfo gpio25 = Pins::GPIO[25]; /* GPIO46 → pin 46 */ pinMode(gpio25.number, OUTPUT);
167 [[maybe_unused]] PinInfo gpio26 = Pins::GPIO[26]; /* GPIO47 → pin 47 */ pinMode(gpio26.number, OUTPUT);
168 [[maybe_unused]] PinInfo gpio27 = Pins::GPIO[27]; /* GPIO48 → pin 48 */ pinMode(gpio27.number, OUTPUT);
169 [[maybe_unused]] PinInfo gpio28 = Pins::GPIO[28]; /* GPIO49 → pin 49 */ pinMode(gpio28.number, OUTPUT);
170 [[maybe_unused]] PinInfo gpio29 = Pins::GPIO[29]; /* GPIO50 → pin 50 */ pinMode(gpio29.number, OUTPUT);
171 [[maybe_unused]] PinInfo gpio30 = Pins::GPIO[30]; /* GPIO51 → pin 51 */ pinMode(gpio30.number, OUTPUT);
172 [[maybe_unused]] PinInfo gpio31 = Pins::GPIO[31]; /* GPIO52 → pin 52 */ pinMode(gpio31.number, OUTPUT);
173 [[maybe_unused]] PinInfo gpio32 = Pins::GPIO[32]; /* GPIO53 → pin 53 */ pinMode(gpio32.number, OUTPUT);
174
175 // Motor de pasos: Control de motores paso a paso
176 static MotorPaso motor(gpio10.number, gpio12.number, gpio14.number, gpio16.number);
177 motor.fijarVelocidad(15.0); // Establece la velocidad a 20 RPM
178
179 // Configuración de PID: Control de sistemas con retroalimentación
180 static PID pid(2.0, 0.5, 1.0, 0.0, 360.0, 0.5, 0.5); // Kp=2.0, Ki=0.5, Kd=1.0, output limits [-255, 255], dt=0.1s, slew-rate=50
181
182 Serial.println(analogRead(analog0.number));
183 motor.movimientoPosicionRelativo(pid.calculoPID(450, analogRead(analog0.number), true), true);
184
185 delay(1000); // Pequeña pausa para evitar saturar el loop
186};
MotorPaso
Controlador para motores paso a paso 28BYJ-48 con driver ULN2003.
Definition motorStep.h:22
PID
Controlador PID con anti-windup, derivative-on-measurement y limitación de cambio de salida (slew-rat...
Definition pid.h:15
Pins::GPIO
constexpr PinInfo GPIO[]
Pines GPIO (entrada/salida digital general).
Definition pinout.h:140
Pins::INTERRUPTS
constexpr PinInfo INTERRUPTS[]
Pines de interrupciones externas.
Definition pinout.h:86
Pins::SPI
constexpr PinInfo SPI[]
Pines SPI (comunicación síncrona maestro-esclavo).
Definition pinout.h:68
Pins::UART_RX
constexpr PinInfo UART_RX[]
Pines UART RX (recepción serie asíncrona).
Definition pinout.h:48
Pins::UART_TX
constexpr PinInfo UART_TX[]
Pines UART TX (transmisión serie asíncrona).
Definition pinout.h:58
Pins::PWM
constexpr PinInfo PWM[]
Pines PWM (modulación por ancho de pulso).
Definition pinout.h:120
Pins::I2C
constexpr PinInfo I2C[]
Pines I2C / TWI (comunicación de dos hilos).
Definition pinout.h:78
Pins::ANALOG
constexpr PinInfo ANALOG[]
Pines analógicos (ADC).
Definition pinout.h:98
PinInfo
Representa un pin del sistema con nombre simbólico, número físico y familia funcional.
Definition pinout.h:18
PinInfo::number
int number
Definition pinout.h:20
Gráfico de llamadas de esta función:

◆ setup()

void setup ( )

Arduino setup function (runs once at startup).

Config System

Byte 0 (bits 0–7):

  • Bit 0: debugMode
  • Bit 1: fullDiagnosticsPins
  • Bit 2: diagnoseAnalog
  • Bit 3: diagnoseGPIO
  • Bit 4: diagnosePWM
  • Bit 5: diagnoseUART
  • Bit 6: diagnoseEEPROM
  • Bit 7: version

Definición en la línea 13 del archivo main.cpp.

13 { // Arduino setup function (runs once at startup)
14
15 // Otherwise, run in normal execution mode
16 Serial.begin(57600); // start serial communication at 57600 baud
17 while (!Serial);
18
19 /**
20 * @brief Config System
21 *
22 * Byte 0 (bits 0–7):
23 * - Bit 0: debugMode
24 * - Bit 1: fullDiagnosticsPins
25 * - Bit 2: diagnoseAnalog
26 * - Bit 3: diagnoseGPIO
27 * - Bit 4: diagnosePWM
28 * - Bit 5: diagnoseUART
29 * - Bit 6: diagnoseEEPROM
30 * - Bit 7: version
31 */
32 configuracionMain systemConfiguration = {
33 // Byte 0 (bits 0–7)
34 .debugMode = false, // Enable debug mode | Byte 0, Bit 0 (LSB)
35 .fullDiagnosticsPins = true, // Run full pin diagnostics | Byte 0, Bit 1
36 .diagnoseAnalog = false, // Disable analog diagnostics | Byte 0, Bit 2
37 .diagnoseGPIO = false, // Disable GPIO diagnostics | Byte 0, Bit 3
38 .diagnosePWM = false, // Disable PWM diagnostics | Byte 0, Bit 4
39 .diagnoseUART = true, // Enable UART diagnostics | Byte 0, Bit 5
40 .diagnoseEEPROM = true, // Disable EEPROM diagnostics | Byte 0, Bit 6
41 .version = true // Byte 0, Bit 7 → reservado o libre (MSB) | Byte 0, Bit 7
42 };
43
44 if (systemConfiguration.fullDiagnosticsPins) fullDiagnosticsPins();
45 if (systemConfiguration.diagnoseAnalog) diagnoseAnalog();
46 if (systemConfiguration.diagnoseGPIO) diagnoseGPIO();
47 if (systemConfiguration.diagnosePWM) diagnosePWM();
48 if (systemConfiguration.diagnoseUART) diagnoseAllUART();
49 if (systemConfiguration.diagnoseEEPROM) DiagnosticsEEPROM::runTest();
50 if (systemConfiguration.debugMode) debug_init();
51 if (systemConfiguration.version) printVersion(FIRMWARE_VERSION, FIRMWARE_NAME, FIRMWARE_DATE, FIRMWARE_AUTHOR, FIRMWARE_VERSION_APP, FIRMWARE_NAME_APP, FIRMWARE_DATE_APP);
52};
debug_init
void debug_init(void)
DiagnosticsEEPROM::runTest
static bool runTest(int address=0)
Runs a diagnostic test on the EEPROM at the specified address. Writes a test value,...
Definition diagnosticsEEPROM.cpp:16
systemConfiguration
configuracionMain systemConfiguration
diagnoseAllUART
void diagnoseAllUART()
Runs a complete diagnostic on all available UART ports.
Definition diagnosticsUART.cpp:15
FIRMWARE_DATE_APP
#define FIRMWARE_DATE_APP
Firmware compilation date.
Definition main.h:52
FIRMWARE_VERSION_APP
#define FIRMWARE_VERSION_APP
Firmware version for application.
Definition main.h:50
FIRMWARE_DATE
#define FIRMWARE_DATE
Firmware compilation date.
Definition main.h:48
FIRMWARE_NAME
#define FIRMWARE_NAME
Firmware name.
Definition main.h:47
FIRMWARE_AUTHOR
#define FIRMWARE_AUTHOR
Firmware author.
Definition main.h:49
FIRMWARE_VERSION
#define FIRMWARE_VERSION
Includes del sistema y librerías necesarias para el firmware.
Definition main.h:46
FIRMWARE_NAME_APP
#define FIRMWARE_NAME_APP
Firmware name.
Definition main.h:51
printVersion
void printVersion(const char *fwVersion, const char *fwName, const char *fwDate, const char *fwAuthor, const char *appVersion, const char *appName, const char *appDate)
Prints firmware version details to the serial monitor.
Definition msg.cpp:248
diagnosePWM
void diagnosePWM()
Diagnóstico de pines PWM.
Definition pinout.cpp:126
diagnoseAnalog
void diagnoseAnalog()
Diagnóstico de pines analógicos.
Definition pinout.cpp:37
fullDiagnosticsPins
void fullDiagnosticsPins()
Ejecuta todos los diagnósticos de pines.
Definition pinout.cpp:16
diagnoseGPIO
void diagnoseGPIO()
Diagnóstico de pines GPIO.
Definition pinout.cpp:85
configuracionMain
Main configuration structure for the project.
Definition config.h:13
Gráfico de llamadas de esta función: