ArduinoMega2560_SPI 1.0
Cargando...
Buscando...
Nada coincide
main.cpp
Ir a la documentación de este archivo.
1/**
2 * @file main.cpp
3 * @brief Firmware principal del sistema. Configura diagnósticos, pines, UART, SPI, I2C,
4 * interrupciones, entradas analógicas, PWM, GPIO, motor paso a paso y PID.
5 */
6
7#include <Arduino.h>
8#include "main.h"
9
10/**
11 * @brief Arduino setup function (runs once at startup)
12 */
13void setup() { // 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};
53
54
55
56/**
57 * @brief Arduino main loop. Ejecuta continuamente la configuración de pines,
58 * lectura analógica, control PID y movimiento del motor paso a paso.
59 */
60void loop() {
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};
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
MotorPaso
Controlador para motores paso a paso 28BYJ-48 con driver ULN2003.
Definition motorStep.h:22
MotorPaso::movimientoPosicionRelativo
void movimientoPosicionRelativo(float grados, bool debugMSG=false)
Mueve el motor hacia un ángulo relativo usando el camino más corto.
Definition motorStep.cpp:109
MotorPaso::fijarVelocidad
void fijarVelocidad(float rpm)
Establece la velocidad del motor en RPM.
Definition motorStep.cpp:33
PID
Controlador PID con anti-windup, derivative-on-measurement y limitación de cambio de salida (slew-rat...
Definition pid.h:15
PID::calculoPID
float calculoPID(float setpoint, float feedback, bool debugMSG=false)
Calcula la salida del controlador PID.
Definition pid.cpp:58
systemConfiguration
configuracionMain systemConfiguration
diagnoseAllUART
void diagnoseAllUART()
Runs a complete diagnostic on all available UART ports.
Definition diagnosticsUART.cpp:15
setup
void setup()
Arduino setup function (runs once at startup).
Definition main.cpp:13
loop
void loop()
Arduino main loop. Ejecuta continuamente la configuración de pines, lectura analógica,...
Definition main.cpp:60
main.h
Archivo principal de cabecera del firmware. Contiene metadatos del firmware, includes del sistema,...
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
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
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
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
configuracionMain
Main configuration structure for the project.
Definition config.h:13