ArduinoMega2560_SPI 1.0
Cargando...
Buscando...
Nada coincide
Referencia del archivo pinout.h
#include <Arduino.h>
#include "system/msg/msg.h"
Gráfico de dependencias incluidas en pinout.h:
Gráfico de los archivos que directa o indirectamente incluyen a este archivo:

Ir al código fuente de este archivo.

Clases

struct  PinInfo
 Representa un pin del sistema con nombre simbólico, número físico y familia funcional. Más...

Espacios de nombres

namespace  Pins
 Contiene todos los arrays de pines organizados por familia funcional.

Funciones

uint8_t pinNumber (const PinInfo pin)
 Devuelve el número físico del pin.
const char * pinName (const PinInfo pin)
 Devuelve el nombre simbólico del pin.
const char * pinFamily (const PinInfo pin)
 Devuelve la familia funcional del pin.
bool isValidGPIO (const PinInfo &pin)
 Comprueba si un pin pertenece a la familia GPIO.
bool isValidPWM (const PinInfo &pin)
 Comprueba si un pin pertenece a la familia PWM.
bool isValidAnalog (const PinInfo &pin)
 Comprueba si un pin pertenece a la familia ANALOG.
void diagnoseAnalog ()
 Diagnóstico de pines analógicos.
void diagnoseGPIO ()
 Diagnóstico de pines GPIO.
void diagnosePWM ()
 Diagnóstico de pines PWM.
void fullDiagnosticsPins ()
 Ejecuta todos los diagnósticos de pines.

Variables

constexpr PinInfo Pins::UART_RX []
 Pines UART RX (recepción serie asíncrona).
constexpr PinInfo Pins::UART_TX []
 Pines UART TX (transmisión serie asíncrona).
constexpr PinInfo Pins::SPI []
 Pines SPI (comunicación síncrona maestro-esclavo).
constexpr PinInfo Pins::I2C []
 Pines I2C / TWI (comunicación de dos hilos).
constexpr PinInfo Pins::INTERRUPTS []
 Pines de interrupciones externas.
constexpr PinInfo Pins::ANALOG []
 Pines analógicos (ADC).
constexpr PinInfo Pins::PWM []
 Pines PWM (modulación por ancho de pulso).
constexpr PinInfo Pins::GPIO []
 Pines GPIO (entrada/salida digital general).
constexpr size_t Pins::NUM_ANALOG = sizeof(ANALOG) / sizeof(ANALOG[0])
 Número total de pines por familia.
constexpr size_t Pins::NUM_GPIO = sizeof(GPIO) / sizeof(GPIO[0])
constexpr size_t Pins::NUM_PWM = sizeof(PWM) / sizeof(PWM[0])
constexpr size_t Pins::NUM_UART_RX = sizeof(UART_RX) / sizeof(UART_RX[0])
constexpr size_t Pins::NUM_UART_TX = sizeof(UART_TX) / sizeof(UART_TX[0])
constexpr size_t Pins::NUM_SPI = sizeof(SPI) / sizeof(SPI[0])
constexpr size_t Pins::NUM_I2C = sizeof(I2C) / sizeof(I2C[0])
constexpr size_t Pins::NUM_INTERRUPTS = sizeof(INTERRUPTS) / sizeof(INTERRUPTS[0])

Documentación de funciones

◆ diagnoseAnalog()

void diagnoseAnalog ( )

Diagnóstico de pines analógicos.

Diagnóstico de pines analógicos.

Recorre todos los pines definidos en Pins::ANALOG, los configura como entrada, estabiliza la señal y realiza una lectura analógica. Convierte el valor leído a voltaje (asumiendo referencia de 5V) y lo muestra por Serial.

Nota
Incluye pequeñas demoras para estabilizar la señal.
Atención
Asegúrate de que el sistema use referencia de 5V para lecturas precisas.

Definición en la línea 37 del archivo pinout.cpp.

37 {
38 standardHeaderFull("⚡ Detecting external voltage on ANALOG pins:", __FILE__, __FUNCTION__, __DATE__, __TIME__);
39
40 for (size_t i = 0; i < Pins::NUM_ANALOG; ++i) {
41 const PinInfo& pin = Pins::ANALOG[i];
42
43 //Forze the pin to OUTPUT for redux noise and stabily electric system
44 pinMode(pin.number, OUTPUT);
45 digitalWrite(pin.number, LOW);
46 delay(20);
47
48 //Read the pin as INPUT to detect voltage
49 pinMode(pin.number, INPUT);
50 delay(20);
51
52 int value = analogRead(pin.number); // Read analog value
53 delay(20);
54 float voltage = value * (5.0 / 1023.0); // Convert to voltage (assuming 5V reference)
55
56 //Forze the pin to OUTPUT for redux noise and stabily electric system
57 pinMode(pin.number, OUTPUT);
58 digitalWrite(pin.number, LOW);
59 delay(20);
60
61 //State for default pin for init system
62 pinMode(pin.number, INPUT);
63 delay(20);
64
65 Serial.print("• ");
66 Serial.print(pin.name);
67 Serial.print(" [#");
68 Serial.print(pin.number);
69 Serial.print("] → Voltage: ");
70 Serial.print(voltage,2);
71 Serial.println(" V");
72
73 };
74};
standardHeaderFull
void standardHeaderFull(const char *message, const char *file, const char *function, const char *date, const char *time, uint16_t width=120, char deco='-')
Prints a decorated header with centered text and padding on both sides.
Definition msg.cpp:121
Pins::NUM_ANALOG
constexpr size_t NUM_ANALOG
Número total de pines por familia.
Definition pinout.h:177
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
PinInfo::name
const char * name
Definition pinout.h:19
Gráfico de llamadas de esta función:
Gráfico de llamadas a esta función:

◆ diagnoseGPIO()

void diagnoseGPIO ( )

Diagnóstico de pines GPIO.

Diagnóstico de pines GPIO.

Configura cada pin GPIO como INPUT, estabiliza la señal y lee su estado. Informa si el pin tiene voltaje externo (HIGH) o está en LOW/GND.

Nota
Útil para detectar si un pin está conectado a tierra o flotando.

Definición en la línea 85 del archivo pinout.cpp.

85 {
86 standardHeaderFull("⚡ Detecting external voltage on GPIO pins:", __FILE__, __FUNCTION__, __DATE__, __TIME__);
87
88 for (size_t i = 0; i < Pins::NUM_GPIO; ++i) {
89 const PinInfo& pin = Pins::GPIO[i];
90
91 //Forze the pin to OUTPUT for redux noise and stabily electric system
92 pinMode(pin.number, OUTPUT);
93 digitalWrite(pin.number, LOW);
94 delay(20);
95
96 pinMode(pin.number, INPUT); // Set pin as input without pull-up
97 delay(5); // Allow signal to stabilize
98
99 int state = digitalRead(pin.number); // Read pin state
100
101 Serial.print("• ");
102 Serial.print(pin.name);
103 Serial.print(" [#");
104 Serial.print(pin.number);
105 Serial.print("] → Voltage: ");
106
107 if (state == HIGH) {
108 Serial.println("⚡ External voltage detected (HIGH)");
109 } else {
110 Serial.println("🔻 No voltage (LOW or connected to GND)");
111 }
112 }
113
114}
Pins::GPIO
constexpr PinInfo GPIO[]
Pines GPIO (entrada/salida digital general).
Definition pinout.h:140
Pins::NUM_GPIO
constexpr size_t NUM_GPIO
Definition pinout.h:178
Gráfico de llamadas de esta función:
Gráfico de llamadas a esta función:

◆ diagnosePWM()

void diagnosePWM ( )

Diagnóstico de pines PWM.

Diagnóstico de pines PWM.

Configura cada pin PWM como entrada, estabiliza la señal y lee su estado digital. Informa si hay voltaje (HIGH) o no (LOW/GND).

Nota
No mide voltaje real, solo estado lógico.
Para medir voltaje real, usar pines analógicos.

Definición en la línea 126 del archivo pinout.cpp.

126 {
127 standardHeaderFull("⚡ Detecting voltage on PWM pins:", __FILE__, __FUNCTION__, __DATE__, __TIME__);
128
129 for (size_t i = 0; i < Pins::NUM_PWM; ++i) {
130 const PinInfo& pin = Pins::PWM[i];
131
132 //Forze the pin to OUTPUT for redux noise and stabily electric system
133 pinMode(pin.number, OUTPUT);
134 analogWrite(pin.number, 0);
135 delay(20);
136
137 pinMode(pin.number, INPUT); // Set pin as input (no pull-up)
138 delay(5); // Brief delay to stabilize reading
139
140 int state = digitalRead(pin.number); // Read the electrical state of the pin
141
142 Serial.print("• ");
143 Serial.print(pin.name);
144 Serial.print(" [Pin ");
145 Serial.print(pin.number);
146 Serial.print("] → Voltage: ");
147
148 if (state == HIGH) {
149 Serial.println("⚡ Voltage detected (HIGH)");
150 } else {
151 Serial.println("🔻 No voltage (LOW or connected to GND)");
152 };
153 };
154};
Pins::PWM
constexpr PinInfo PWM[]
Pines PWM (modulación por ancho de pulso).
Definition pinout.h:120
Pins::NUM_PWM
constexpr size_t NUM_PWM
Definition pinout.h:179
Gráfico de llamadas de esta función:
Gráfico de llamadas a esta función:

◆ fullDiagnosticsPins()

void fullDiagnosticsPins ( )

Ejecuta todos los diagnósticos de pines.

Ejecuta todos los diagnósticos de pines.

Esta función:

Útil como prueba inicial del hardware al arrancar el sistema.

Definición en la línea 16 del archivo pinout.cpp.

16 {
17 standardMessage("Starting PINOUT diagnostic", __FILE__, __FUNCTION__, __DATE__, __TIME__);
18
19 diagnoseAnalog(); // ANALOG pin diagnostic
20 diagnoseGPIO(); // GPIO pin diagnostic
21 diagnosePWM(); // PWM pin diagnosticº
22
23 standardHeaderFull("Full diagnostic complete.", __FILE__, __FUNCTION__, __DATE__, __TIME__);
24};
standardMessage
void standardMessage(const char *message, const char *file, const char *function, const char *date, const char *time)
Prints an enriched log message to the serial monitor.
Definition msg.cpp:15
diagnosePWM
void diagnosePWM()
Detecta la presencia de voltaje externo en pines PWM.
Definition pinout.cpp:126
diagnoseAnalog
void diagnoseAnalog()
Diagnostica el voltaje presente en los pines analógicos del sistema.
Definition pinout.cpp:37
diagnoseGPIO
void diagnoseGPIO()
Diagnóstico de pines GPIO configurados como entrada.
Definition pinout.cpp:85
Gráfico de llamadas de esta función:
Gráfico de llamadas a esta función:

◆ isValidAnalog()

bool isValidAnalog ( const PinInfo & pin)

Comprueba si un pin pertenece a la familia ANALOG.

Comprueba si un pin pertenece a la familia ANALOG.

Parámetros
pinPin a validar.
Devuelve
true si es ANALOG válido, false si no.

Definición en la línea 234 del archivo pinout.cpp.

234 {
235 for (size_t i = 0; i < Pins::NUM_ANALOG; ++i) {
236 if (Pins::ANALOG[i].number == pin.number &&
237 Pins::ANALOG[i].family == pin.family)
238 {
239 return true;
240 }
241 }
242
243 return false;
244};
PinInfo::family
const char * family
Definition pinout.h:21

◆ isValidGPIO()

bool isValidGPIO ( const PinInfo & pin)

Comprueba si un pin pertenece a la familia GPIO.

Comprueba si un pin pertenece a la familia GPIO.

Parámetros
pinPin a validar.
Devuelve
true si es GPIO válido, false si no.

Definición en la línea 196 del archivo pinout.cpp.

196 {
197 for (size_t i = 0; i < Pins::NUM_GPIO; ++i) {
198 if (Pins::GPIO[i].number == pin.number &&
199 Pins::GPIO[i].family == pin.family)
200 {
201 return true;
202 }
203 }
204
205 return false;
206};

◆ isValidPWM()

bool isValidPWM ( const PinInfo & pin)

Comprueba si un pin pertenece a la familia PWM.

Comprueba si un pin pertenece a la familia PWM.

Parámetros
pinPin a validar.
Devuelve
true si es PWM válido, false si no.

Definición en la línea 215 del archivo pinout.cpp.

215 {
216 for (size_t i = 0; i < Pins::NUM_PWM; ++i) {
217 if (Pins::PWM[i].number == pin.number &&
218 Pins::PWM[i].family == pin.family)
219 {
220 return true;
221 }
222 }
223
224 return false;
225};

◆ pinFamily()

const char * pinFamily ( const PinInfo pin)

Devuelve la familia funcional del pin.

Devuelve la familia funcional del pin.

Parámetros
pinEstructura PinInfo.
Devuelve
Familia del pin.

Definición en la línea 185 del archivo pinout.cpp.

185 {
186 return pin.family;
187}

◆ pinName()

const char * pinName ( const PinInfo pin)

Devuelve el nombre simbólico del pin.

Devuelve el nombre simbólico del pin.

Parámetros
pinEstructura PinInfo.
Devuelve
Nombre del pin.

Definición en la línea 174 del archivo pinout.cpp.

174 {
175 return pin.name;
176}

◆ pinNumber()

uint8_t pinNumber ( const PinInfo pin)

Devuelve el número físico del pin.

Parámetros
pinEstructura PinInfo.
Devuelve
Número del pin.

Definición en la línea 163 del archivo pinout.cpp.

163 {
164 return pin.number;
165}