IOT123 - SEGUIDOR SOLAR - CONTROLADOR: 8 Pasos

2024 Autor: John Day | [email protected]. Última modificación: 2024-01-30 08:43

Esta es una extensión de Instructable

IOT123 - SEGUIDOR SOLAR - INCLINACIÓN / PANEL, MARCO DEL PANEL, MONTAJE LDR RIG. Aquí nos concentramos en el controlador de los servos y sensores de la posición del sol. Es importante señalar que este diseño asume que se emplearán 2 MCU: uno (Arduino Pro Mini de 3.3V 8mHz) para el rastreador solar y un MCU independiente para sus sensores / actores.

Esta es la versión 0.3

En lugar de publicar todos los proyectos después de la completa satisfacción, practicaré la integración continua y entregaré algo más a menudo, modificando lo que he entregado según sea necesario. Escribiré otro instructivo para el cargador de batería, cuando se complete la optimización del software / hardware del controlador. Señalaré dónde se necesitan las optimizaciones a medida que avanzamos en esto.

Parte de la razón de este enfoque es la retroalimentación de los clientes. Si ven una necesidad o tienen un mejor enfoque, por favor comenten, pero tengan en cuenta que no puedo entregar todo y posiblemente no en un marco de tiempo que les convenga. Como estas explicaciones parecen menos relevantes, se eliminarán de este artículo.

Que incluye esto:

1. Utilice los LDR del Instructable original para detectar la ubicación aproximada del sol.
2. Mueva los servos para mirar hacia el sol.
3. Opciones para la sensibilidad de los movimientos.
4. Opciones para el tamaño del paso al moverse hacia el sol.
5. Opciones para las restricciones angulares utilizadas en los servos.
6. Opciones para los retrasos de los movimientos.
7. Interfaz I2C para configurar / obtener valores entre MCU.
8. Sueño profundo entre movimientos.

Lo que esto no incluye (y se abordará cuando el tiempo lo permita):

1. Solo usando energía durante las horas del día.
2. Recordando la posición del amanecer y yendo allí al atardecer.
3. Extracción del regulador de la MCU.
4. Desactivación de los LED en la MCU.
5. Redirigiendo la energía a través de VCC en lugar de RAW.
6. Proporciona soluciones para flashear sin alimentación regulada desde el convertidor USB a TTL serial.
7. Monitor de voltaje de batería.

HISTORIA

20 de diciembre de 2017 CÓDIGO V0.1

La versión inicial rastrea la fuente de luz, siempre encendida, sin carga

7 de enero de 2018 CÓDIGO V0.2

• CAMBIOS DE HARDWARE

  • Agregar pines I2C
  • Agregar interruptor a los servos GND
  • Etiqueta impresa en la fascia de la caja del controlador

• CAMBIOS DE SOFTWARE

  • Leer configuración de EEPROM
  • Soporte de bus I2C como esclavo de otra MCU (3.3V)
  • Establecer la configuración a través de I2C
  • Establecer habilitado a través de I2C
  • Obtener configuración a través de I2C
  • Obtenga propiedades de tiempo de ejecución a través de I2C (actualmente habilitado e intensidad de luz actual)
  • Eliminar el registro en serie (afectó los valores de I2C)

19 de enero de 2018 CÓDIGO V0.3

• HARDWARE

  Etiqueta actualizada. El interruptor ahora se usa para elegir el modo CONFIG o TRACK

• SOFTWARE

  • I2C solo se utiliza para la configuración
  • El controlador espera 5 segundos antes de inicializar el seguimiento, permite mover las manos
  • Para usar la configuración I2C, SPDT debe estar en CONFIG cuando la unidad se inicia
  • Entre el movimiento de seguimiento, la unidad está en modo de reposo profundo para el valor de configuración SLEEP MINUTES (predeterminado 20 minutos).

Paso 1: Materiales y herramientas

Ahora hay una lista completa de fuentes y materiales.

1. Piezas impresas en 3D.
2. Arduino Pro Mini 3.3V 8mHz
3. 1 placa de circuito impreso universal PCB prototipo de doble cara de 4x6 cm (para cortar por la mitad)
4. 1 cabezal macho 40P (para cortar a medida).
5. 1 cabezal hembra 40P (para cortar a medida).
6. 4 resistencias de 10K 1 / 4W.
7. Conectar cable.
8. Soldadura y Hierro.
9. 20 tornillos autorroscantes de cabeza plana de acero inoxidable de 4G x 6 mm.
10. 4 tornillos autorroscantes avellanados de acero inoxidable de 4G x 6 mm.
11. 1 batería LiPo de 3,7 V y soporte (termina en conectores dupont 2P).
12. 1 cabezal de ángulo recto macho 2P
13. 1 interruptor SPDT de 3 clavijas, paso de 2,54 mm
14. Pegamento de cianoacrilato fuerte
15. Conector hembra 1P de conectores Dupont (1 azul apagado, 1 verde apagado).

Paso 2: Montaje del circuito

El circuito actualmente no tiene el circuito divisor de voltaje (voltímetro).

1. Corte la placa de circuito impreso universal PCB prototipo de doble cara de 4x6 cm por la mitad a lo largo del eje largo.

2. Corte el cabezal macho 40P en pedazos:

   1. 2 de 12P
   2. 3 de descuento 3P
   3. 6 de 2P.

3. Corte el cabezal hembra 40P en pedazos:

   1. 2 de 12P
   2. 1 de 6P
4. Suelde 2 del cabezal hembra 12P como se muestra.
5. Pegue el espaciador que quitó de un cabezal macho 3P (adicional) en la parte inferior del interruptor SPDT con pegamento de cianoacrilato
6. En el otro lado, suelde 6 de 2P, 2 de 3P conector macho y el interruptor SPDT como se muestra.
7. Suelde 4 resistencias de 10K (A, B, C, D negro) a través del cable al conector de la clavija GND (# 2 negro) y a las clavijas del encabezado A0 - A3 (# 5, # 6, # 7, # 8) y luego a través del orificio (amarillo) como se muestra (3 fotos + 1 diagrama).
8. Trace 3.3V desde LDR PINS para soldar PINS # 4, # 6, # 8, # 10 y enrosque a través del orificio hasta el pin VCC del cabezal hembra (verde).
9. Trace 3.3V en el lado del cabezal hembra como se muestra (rojo) soldando a los PINS # 1, # 12, # 15.
10. 3.3V a través del orificio del PIN # 1 del cabezal RAW del lado soldado (rojo).
11. Trace la conexión naranja desde el PIN # 11 a través del orificio hasta el pin hembra de soldadura en el otro lado, como se muestra.
12. Trace y suelde el cable de conexión azul del n. ° 20 al n. ° 30 y del n. ° 31 al n. ° 13 y n. ° 16.
13. Suelde el PIN # 11 del conector hembra al PIN # 11 del conector macho a través del orificio.
14. Prepare 2 conectores dupont de 30 mm de largo con conector hembra 1P (1 azul, 1 verde). Pele y estañe el otro extremo.
15. Suelde el cable azul Dupont al # 28; suelde el cable Dupont verde al # 29.
16. En la parte superior del Arduino, fije el cabezal hembra 6P y luego suelde.
17. En la parte superior del Arduino, fije el encabezado hembra en ángulo recto 2P int # 29 y # 30 y luego suelde.
18. En la parte inferior del Arduino, fije los 2 pines macho 12P y 1 de 3P y luego suelde.
19. Inserte los pines macho 12P de Arduino en los encabezados hembra de PCB 12P.

Paso 3: flasheo de la MCU

El Arduino Pro Mini se actualiza convenientemente usando un convertidor FTDI232 USB a TTL usando el encabezado hembra 6P. Vea la foto de arriba para ver la alineación de las 2 tablas.

Asegúrese de que se elija la configuración de 3.3V en su FTDI232. Siga las instrucciones aquí usando el código a continuación (use el enlace a GIST).

Es necesario instalar la biblioteca de bajo consumo (adjunta y

Una vez que el Arduino Pro Mini + PCB está instalado en la carcasa, aún se puede flashear cuando se exponen los pines del cabezal. Simplemente desconecte la unidad controladora del marco del panel, dejando al descubierto el cabezal.

Seguidor solar basculante con configuración I2C / EEPROM y ciclo de sueño entre movimientos. La precisión de la duración del ciclo de sueño disminuye a medida que aumenta la duración, pero es suficiente para este propósito

/*

* modificado del código

* por Mathias Leroy

*

* MODIFICACIONES V0.2

** I2C SET OBTENER

** EEPROM SET OBTENER

** RETIRE LA SALIDA EN SERIE - I2C AFECTADO

** ACTIVAR / DESACTIVAR EL SEGUIMIENTO

** MOVER SERVOS A LÍMITES A TRAVÉS DE I2C

** LEER LA INTENSIDAD PROMEDIO ACTUAL A TRAVÉS DE I2C

* MODIFICACIONES V0.3

** INTERRUPTOR PARA 2 MODOS: PISTA (NO I2C) y CONFIGURAR (UTILIZA I2C)

** DORMIR EN MODO PISTA (MUY BAJA PRECISIÓN DEBIDO A 8 SEGUNDOS TROZOS)

** SEPARAR / ADJUNTAR SERVOS EN SUEÑO / DESPERTAR (TRANSISTOR USADO EVENTUALMENTE)

** ELIMINAR LA POSICIÓN INICIAL CONFIGURABLE (REDUNDANTE)

** ELIMINAR SEGUNDOS DE DESPERTAR CONFIGURABLES (REDUNDANTES)

** ELIMINAR CONFIGURABLE ACTIVAR / DESACTIVAR (REDUNDANTE)

** QUITAR EL SEGUIDOR CONFIGURABLE HABILITADO (UTILIZAR EL INTERRUPTOR DE HARDWARE)

** RETIRE EL OBTURADOR DE VOLTAJE - UTILIZARÁ UN COMPONENTE I2C SEPARADO

** AÑADIR REGISTRO EN SERIE CUANDO NO UTILICE I2C

*/

#incluir

#incluir

#incluir

#incluir

#incluir

# defineEEPROM_VERSION1

# defineI2C_MSG_IN_SIZE3

#definePIN_LDR_TL A0

#definePIN_LDR_TR A1

#definePIN_LDR_BR A3

#definePIN_LDR_BL A2

# definePIN_SERVO_V11

# definePIN_SERVO_H5

# defineIDX_I2C_ADDR0

# defineIDX_V_ANGLE_MIN1

# defineIDX_V_ANGLE_MAX2

# defineIDX_V_SENSITIVITY3

# defineIDX_V_STEP4

# defineIDX_H_ANGLE_MIN5

# defineIDX_H_ANGLE_MAX6

# defineIDX_H_SENSITIVITY7

# defineIDX_H_STEP8

# defineIDX_SLEEP_MINUTES9

# defineIDX_V_DAWN_ANGLE10

# defineIDX_H_DAWN_ANGLE11

# defineIDX_DAWN_INTENSITY12 // promedio de todos los LDRS

# defineIDX_DUSK_INTENSITY13 // promedio de todos los LDRS

# defineIDX_END_EEPROM_SET14

# defineIDX_CURRENT_INTENSITY15 // promedio de todos los LDRS - usado para calcular IDX_DAWN_INTENSITY luz ambiental no directa

# defineIDX_END_VALUES_GET16

# defineIDX_SIGN_117

# defineIDX_SIGN_218

# defineIDX_SIGN_319

Servo _servoH;

Servo _servoV;

byte _i2cVals [20] = {10, 10, 170, 20, 5, 10, 170, 20, 5, 20, 40, 10, 30, 40, 0, 0, 0, 0, 0, 0};

int _servoLoopDelay = 10;

int _slowingDelay = 0;

int _angleH = 90;

int _angleV = 90;

int _averageTop = 0;

int _averageRight = 0;

int _averageBottom = 0;

int _averageLeft = 0;

byte _i2cResponse = 0;

bool _inConfigMode = false;

voidsetup ()

{

Serial.begin (115200);

getFromEeprom ();

if (inConfigMode ()) {

Serial.println ("Modo de configuración");

Serial.print ("Dirección I2C:");

Serial.println (_i2cVals [IDX_I2C_ADDR]);

Wire.begin (_i2cVals [IDX_I2C_ADDR]);

Wire.onReceive (ReceiveEvent);

Wire.onRequest (requestEvent);

}demás{

Serial.println ("Modo de seguimiento");

delay (5000); // tiempo para apartar las manos si conecta la batería, etc.

}

}

voidloop ()

{

getLightValues ();

if (! _inConfigMode) {

// Tareas pendientes: ENCENDER EL INTERRUPTOR DEL TRANSISTOR

_servoH.attach (PIN_SERVO_H);

_servoV.attach (PIN_SERVO_V);

para (int i = 0; i <20; i ++) {

si (i! = 0) {

getLightValues ();

}

moveServos ();

}

retraso (500);

_servoH.detach ();

_servoV.detach ();

// Tareas pendientes: APAGAR EL INTERRUPTOR DEL TRANSISTOR

retraso (500);

dormidoPara ((_ i2cVals [IDX_SLEEP_MINUTES] * 60) / 8);

}

}

//---------------------------------MODO ACTUAL

boolinConfigMode () {

pinMode (PIN_SERVO_H, ENTRADA);

_inConfigMode = digitalRead (PIN_SERVO_H) == 1;

return _inConfigMode;

}

// --------------------------------- EEPROM

voidgetFromEeprom () {

si(

EEPROM.read (IDX_SIGN_1)! = 'S' ||

EEPROM.read (IDX_SIGN_2)! = 'T' ||

EEPROM.read (IDX_SIGN_3)! = EEPROM_VERSION

) EEPROM_write_default_configuration ();

EEPROM_read_configuration ();

}

voidEEPROM_write_default_configuration () {

Serial.println ("EEPROM_write_default_configuration");

para (int i = 0; i <IDX_END_EEPROM_SET; i ++) {

EEPROM.update (i, _i2cVals );

}

EEPROM.update (IDX_SIGN_1, 'S');

EEPROM.update (IDX_SIGN_2, 'T');

EEPROM.update (IDX_SIGN_3, EEPROM_VERSION);

}

voidEEPROM_read_configuration () {

Serial.println ("EEPROM_read_configuration");

para (int i = 0; i <IDX_END_EEPROM_SET; i ++) {

_i2cVals = EEPROM.read (i);

//Serial.println(String(i) + "=" + _i2cVals );

}

}

// --------------------------------- I2C

voidreceiveEvent (int count) {

si (cuenta == I2C_MSG_IN_SIZE)

{

char cmd = Wire.read ();

índice de bytes = Wire.read ();

valor de byte = Wire.read ();

cambiar (cmd) {

caso 'G':

si (índice <IDX_END_VALUES_GET) {

_i2cResponse = _i2cVals [índice];

}

rotura;

casos':

si (índice <IDX_END_EEPROM_SET) {

_i2cVals [índice] = valor;

EEPROM.update (índice, _i2cVals [índice]);

}

rotura;

defecto:

regreso;

}

}

}

voidrequestEvent ()

{

Wire.write (_i2cResponse);

}

// --------------------------------- LDR

voidgetLightValues () {

int valueTopLeft = analogRead (PIN_LDR_TL);

int valueTopRight = analogRead (PIN_LDR_TR);

int valueBottomRight = analogRead (PIN_LDR_BR);

int valueBottomLeft = analogRead (PIN_LDR_BL);

_averageTop = (valueTopLeft + valueTopRight) / 2;

_averageRight = (valueTopRight + valueBottomRight) / 2;

_averageBottom = (valueBottomRight + valueBottomLeft) / 2;

_averageLeft = (valueBottomLeft + valueTopLeft) / 2;

int avgIntensity = (valueTopLeft + valueTopRight + valueBottomRight + valueBottomLeft) / 4;

_i2cVals [IDX_CURRENT_INTENSITY] = mapa (avgIntensity, 0, 1024, 0, 255);

}

// --------------------------------- SERVOS

voidmoveServos () {

Serial.println ("moveServos");

if ((_averageLeft-_averageRight)> _ i2cVals [IDX_H_SENSITIVITY] && (_angleH-_i2cVals [IDX_H_STEP])> _ i2cVals [IDX_H_ANGLE_MIN]) {

// yendo a la izquierda

Serial.println ("moveServos yendo a la izquierda");

delay (_slowingDelay);

para (int i = 0; i <_i2cVals [IDX_H_STEP]; i ++) {

_servoH.write (_angleH--);

delay (_servoLoopDelay);

}

}

elseif ((_averageRight-_averageLeft)> _ i2cVals [IDX_H_SENSITIVITY] && (_angleH + _i2cVals [IDX_H_STEP]) <_ i2cVals [IDX_H_ANGLE_MAX]) {

// yendo a la derecha

Serial.println ("moveServos yendo a la izquierda");

delay (_slowingDelay);

para (int i = 0; i <_i2cVals [IDX_H_STEP]; i ++) {

_servoH.write (_angleH ++);

delay (_servoLoopDelay);

}

}

demás {

// haciendo nada

Serial.println ("moveServos sin hacer nada");

delay (_slowingDelay);

}

if ((_averageTop-_averageBottom)> _ i2cVals [IDX_V_SENSITIVITY] && (_angleV + _i2cVals [IDX_V_STEP]) <_ i2cVals [IDX_V_ANGLE_MAX]) {

// subiendo

Serial.println ("moveServos subiendo");

delay (_slowingDelay);

para (int i = 0; i <_i2cVals [IDX_V_STEP]; i ++) {

_servoV.write (_angleV ++);

delay (_servoLoopDelay);

}

}

elseif ((_averageBottom-_averageTop)> _ i2cVals [IDX_V_SENSITIVITY] && (_angleV-_i2cVals [IDX_V_STEP])> _ i2cVals [IDX_V_ANGLE_MIN]) {

// bajando

Serial.println ("moveServos bajando");

delay (_slowingDelay);

para (int i = 0; i <_i2cVals [IDX_V_STEP]; i ++) {

_servoV.write (_angleV--);

delay (_servoLoopDelay);

}

}

demás {

Serial.println ("moveServos sin hacer nada");

delay (_slowingDelay);

}

}

//---------------------------------DORMIR

voidasleepFor (unsignedint eightSecondSegments) {

Serial.println ("dormido para");

para (unsignedint sleepCounter = eightSecondSegments; sleepCounter> 0; sleepCounter--)

{

LowPower.powerDown (SLEEP_8S, ADC_OFF, BOD_OFF);

}

}

ver rawtilt_pan_tracker_0.3.ino alojado con ❤ por GitHub

Paso 4: Montaje de la carcasa del circuito

1. Asegúrese de que el Ardiuno Pro Mini esté insertado en los encabezados de la PCB.
2. Inserte la base de la caja del controlador SOLAR TRACKER en las paredes de la caja del controlador SOLAR TRACKER y fíjela con 2 tornillos autorroscantes avellanados de acero inoxidable de 4G x 6 mm.
3. Inserte Ardiuno Pro Mini + PCB con ranura de encabezado 6P en el vacío en la base de la caja del controlador SOLAR TRACKER.
4. Inserte la tapa de la caja del controlador SOLAR TRACKER en las paredes de la caja del controlador SOLAR TRACKER y fíjela con 2 tornillos autorroscantes avellanados de acero inoxidable de 4G x 6 mm.
5. Fije el conjunto de arriba a la base del marco del panel con 4 tornillos autorroscantes avellanados de acero inoxidable de 4G x 6 mm.

Paso 5: Conexión de los cables del equipo al controlador

Las conexiones pertinentes listas del Instructable anterior son 4 conexiones LDR 2P y 2 conexiones 3P de los servos. Lo que es temporal hasta que la recarga está lista es la batería. Utilice un LiPo de 3,7 V que termine en una conexión DuPont 2P por ahora.

1. Inserte las conexiones LDR (sin polaridad) desde arriba:

   1. Parte superior derecha
   2. Arriba a la izquierda
   3. Abajo a la derecha
   4. Abajo a la izquierda

2. Inserte las conexiones del servo (con el cable de señal a la izquierda) desde arriba:

   1. Horizontal
   2. Vertical
3. ESPERE HASTA QUE ESTÉ LISTO PARA LA PRUEBA ENTONCES: Inserte el cable de alimentación de CC de 3,7 V + ve hacia arriba, -ve hacia abajo.

Paso 6: prueba del controlador

Como se indicó anteriormente, el software no se ha optimizado para el flujo de trabajo de carga solar. Sin embargo, se puede probar y ajustar utilizando fuentes de luz naturales (sol) y no naturales.

Para probar el seguimiento en un entorno controlado, puede ser conveniente configurar los MINUTOS DE SUEÑO en un valor más bajo (ver el siguiente paso).

Paso 7: Configuración a través de I2C usando la entrada de consola

Esto explica la configuración del controlador a través de una segunda MCU, ingresando la configuración en una ventana de la consola.

1. Cargue el siguiente script en un D1M WIFI BLOCK (o Wemos D1 Mini).
2. Desconecte el USB de la PC

3. CONEXIONES PIN: -ve (Controlador) => GND (D1M) + ve (Controlador) => 3V3 (D1M) SCL (Controlador) => D1 (D1M)

   SDA (controlador) => D2 (D1M)

4. Gire el interruptor SPDT a CONFIG
5. Conectar USB a PC
6. Desde el IDE de Arduino, inicie una ventana de consola con el puerto COM correcto
7. Asegúrese de que estén seleccionados "Nueva línea" y "9600 baudios"
8. Los comandos se ingresan en el cuadro Enviar texto seguido de la tecla Intro.
9. Los comandos tienen el formato Carácter byte byte
10. Si el segundo byte (tercer segmento) no está incluido, el script envía 0 (cero)
11. Tenga cuidado al utilizar la entrada en serie; revise lo que ha ingresado antes de presionar la tecla "Enter". Si está bloqueado (por ejemplo, cambiando la dirección I2C a un valor que ha olvidado), deberá actualizar el firmware del controlador nuevamente.

Las variaciones admitidas en el primer carácter del comando son:

• E (Habilitar seguimiento de servo) útil para detener el movimiento durante la configuración. Esto se ingresa usando: E 0
• D (Desactivar seguimiento de servo) útil para iniciar el seguimiento automático si no se reinicia el dispositivo. Esto se ingresa usando: D 0
• G (Obtener valor de configuración) lee valores de EEPROM e IN-MEMORY: Esto se ingresa usando: G (el índice es valores de byte válidos 0-13 y 15)
• S (Establecer valor EEPROM) establece valores en EEPROM que están disponibles después de reiniciar. Esto se ingresa usando: S (el índice es valores de bytes válidos 0-13, el valor es valores de bytes válidos y varía según la propiedad)

El código es el punto de verdad para los índices, pero lo siguiente se usa como guía para valores / comentarios válidos:

• DIRECCIÓN I2C 0 - dirección esclava del controlador, el maestro la necesita para comunicarse con el controlador (por defecto 10)
• ÁNGULO VERTICAL MÍNIMO 1: límite inferior del servo vertical del ángulo (predeterminado 10, rango 0-180)
• ÁNGULO VERTICAL MÁXIMO 2: límite superior del servo vertical de ángulo (predeterminado 170, rango 0-180)
• SENSIBILIDAD VERTICAL LDR 3 - Margen de lectura de LDR vertical (predeterminado 20, rango 0 - 1024)
• PASO 4 DEL ÁNGULO VERTICAL: pasos del servo vertical del ángulo en cada ajuste (predeterminado 5, rango 1 - 20)
• ÁNGULO HORIZONTAL MÍNIMO 5 - límite inferior del servo horizontal del ángulo (predeterminado 10, rango 0 - 180)
• ÁNGULO HORIZONTAL MÁXIMO 6 - límite superior del servo horizontal del ángulo (predeterminado 170, rango 0 - 180)
• SENSIBILIDAD HORIZONTAL LDR 7 - Margen de lectura de LDR horizontal (predeterminado 20, rango 0 - 1024)
• PASO DE ÁNGULO HORIZONTAL 8: pasos de servo horizontal de ángulo en cada ajuste (predeterminado 5, rango 1 - 20)
• SLEEP MINUTES 9: el período de sueño aproximado entre el seguimiento (predeterminado 20, rango 1 - 255)
• ÁNGULO VERTICAL DEL AMANECER 10 - USO FUTURO - el ángulo vertical al que volver cuando se pone el sol
• ÁNGULO HORIZONTAL AMANECER 11 - USO FUTURO - el ángulo horizontal al que volver cuando se pone el sol
• DAWN INTENSITY 12 - FUTURE USE - el promedio mínimo de todos los LDR que desencadena el inicio del seguimiento solar diario.
• DUSK INTENSITY 13 - FUTURE USE - el promedio mínimo de todos los LDR que desencadena el fin del seguimiento solar diario.
• VALORES DE FIN DE EEPROM MARCADOR 14 - VALOR NO UTILIZADO
• INTENSIDAD ACTUAL 15 - el porcentaje medio actual de la intensidad de la luz
• FIN DE VALORES EN MEMORIA MARCADOR 16 - VALOR NO UTILIZADO.

Captura la entrada en serie (entrada del teclado en la ventana de la consola) y la reenvía a un esclavo I2C en el formato char, byte, byte

#incluir

# defineI2C_MSG_IN_SIZE2

# defineI2C_MSG_OUT_SIZE3

# defineI2C_SLAVE_ADDRESS10

boolean _newData = falso;

const byte _numChars = 32;

char _receivedChars [_numChars]; // una matriz para almacenar los datos recibidos

voidsetup () {

Serial.begin (9600);

Wire.begin (D2, D1);

retraso (5000);

}

voidloop () {

recvWithEndMarker ();

parseSendCommands ();

}

voidrecvWithEndMarker () {

byte estático ndx = 0;

char endMarker = '\ n';

char rc;

while (Serial.available ()> 0 && _newData == false) {

rc = Serial.read ();

if (rc! = endMarker) {

_receivedChars [ndx] = rc;

ndx ++;

if (ndx> = _numChars) {

ndx = _numChars - 1;

}

} demás {

_receivedChars [ndx] = '\ 0'; // termina la cadena

ndx = 0;

_newData = verdadero;

}

}

}

voidparseSendCommands () {

if (_newData == true) {

constchar delim [2] = "";

char * token;

token = strtok (_receivedChars, delim);

char cmd = _receivedChars [0];

índice de bytes = 0;

valor de byte = 0;

int i = 0;

while (token! = NULL) {

//Serial.println(token);

i ++;

cambiar (i) {

caso 1:

token = strtok (NULL, delim);

índice = atoi (ficha);

rotura;

caso2:

token = strtok (NULL, delim);

if (token! = NULL) {

valor = atoi (ficha);

}

rotura;

defecto:

token = NULL;

}

}

sendCmd (cmd, índice, valor);

_newData = falso;

}

}

voidsendCmd (char cmd, índice de bytes, valor de bytes) {

Serial.println ("-----");

Serial.println ("Enviando comando:");

Serial.println ("\ t" + Cadena (cmd) + "" + Cadena (índice) + "" + Cadena (valor));

Serial.println ("-----");

Wire.beginTransmission (I2C_SLAVE_ADDRESS); // transmitir al dispositivo

Wire.write (cmd); // envía un char

Wire.write (índice); // envía un byte

Wire.write (valor); // envía un byte

Wire.endTransmission ();

respuesta de byte = 0;

bool hadResponse = false;

si (cmd == 'G') {

Wire.requestFrom (I2C_SLAVE_ADDRESS, 1);

while (Wire.available ()) // el esclavo puede enviar menos de lo solicitado

{

hadResponse = true;

respuesta = Wire.read ();

}

if (hadResponse == true) {

Serial.println ("Obteniendo respuesta:");

Serial.println (respuesta);

}demás{

Serial.println ("No hay respuesta, verifique la dirección / conexión");

}

}

}

ver rawd1m_serial_input_i2c_char_byte_byte_v0.1.ino alojado con ❤ por GitHub

Paso 8: Pasos siguientes

Vuelva a consultar periódicamente para comprobar si hay cambios en el software / hardware.

Modifique el software / hardware según sus requisitos.

Comente sobre las solicitudes / optimizaciones.