IOT123 - SOLAR TRACKER - CONTROLADOR: 8 etapas

2024 Autor: John Day | [email protected]. Última modificação: 2024-01-30 11:39

Esta é uma extensão do Instructable

IOT123 - SOLAR TRACKER - TILT / PAN, PAINEL FRAME, LDR MOUNTS RIG. Aqui nos concentramos no controlador dos servos e nos sensores da posição do sol. É importante ressaltar que este projeto presume que 2 MCUs serão empregados: um (3,3V 8mHz Arduino Pro Mini) para o rastreador solar e um MCU independente para seus sensores / atores.

Esta é a versão 0.3

Em vez de publicar todos os projetos após a satisfação total, praticarei a integração contínua e entregarei algo com mais frequência, modificando o que entreguei conforme preciso. Escreverei outra instrução para o carregador de bateria, _quando_ a otimização do software / hardware do controlador for concluída. Vou apontar onde as otimizações são necessárias à medida que avançamos nesse processo.

Parte do motivo dessa abordagem é o feedback do cliente. Se vocês virem uma necessidade ou tiverem uma abordagem melhor, por favor, comente, mas lembre-se de que não posso entregar tudo e possivelmente não dentro de um prazo adequado para vocês. Como essas explicações parecem menos relevantes, elas serão excluídas deste artigo.

O que isso inclui:

1. Use os LDRs do Instructable original para detectar a localização aproximada do sol.
2. Mova os servos para enfrentar o sol.
3. Opções para a sensibilidade dos movimentos.
4. Opções para o tamanho do passo ao mover para o sol.
5. Opções para as restrições angulares usadas nos servos.
6. Opções para os atrasos dos movimentos.
7. Interface I2C para definir / obter valores entre MCUs.
8. Sono profundo entre os movimentos.

O que isso não inclui (e será tratado conforme o tempo permitir):

1. Usando energia apenas durante o dia.
2. Lembrando da posição do amanhecer e indo para lá ao anoitecer.
3. Removendo o regulador do MCU.
4. Desativando o (s) LED (s) no MCU.
5. Redirecionando a energia por meio de VCC em vez de RAW.
6. Fornecendo soluções alternativas para piscar sem alimentação regulada do conversor USB para TTL Serial.
7. Monitor de tensão da bateria.

HISTÓRIA

20 de dezembro de 2017 CÓDIGO V0.1

A versão inicial rastreia a fonte de luz, sempre ligada, sem carregamento

7 de janeiro de 2018 V0.2 CODE

• ALTERAÇÕES DE HARDWARE

  • Adicionar pinos I2C
  • Adicionar interruptor para GNDs servo
  • Etiqueta impressa no painel frontal da caixa do controlador

• ALTERAÇÕES DE SOFTWARE

  • Leia a configuração da EEPROM
  • Suporte de barramento I2C como escravo de outro MCU (3,3V)
  • Definir configuração via I2C
  • Definir habilitado via I2C
  • Obter configuração via I2C
  • Obtenha propriedades de tempo de execução via I2C (atualmente ativado e intensidade de luz atual)
  • Remova o registro serial (afetou os valores I2C)

19 de janeiro de 2018 V0.3 CODE

• HARDWARE

  Etiqueta atualizada. A chave agora é usada para escolher o modo CONFIG ou TRACK

• PROGRAMAS

  • I2C usado apenas para configuração
  • O controlador espera 5 segundos antes de inicializar o rastreamento, permite mover as mãos
  • Para usar a configuração I2C, o SPDT deve estar em CONFIG enquanto a unidade é inicializada
  • Entre o movimento de rastreamento, a unidade está no modo de hibernação para o valor de configuração SLEEP MINUTES (padrão 20 minutos).

Etapa 1: Materiais e Ferramentas

Agora existe uma lista completa de Bill of Materials and Sources.

1. Peças impressas em 3D.
2. Arduino Pro Mini 3.3V 8mHz
3. Placa de circuito impresso universal 1 de 4x6cm protótipo de duplo lado PCB (para ser cortado ao meio)
4. 1 cabeçote macho 40P (para ser cortado no tamanho certo).
5. 1 cabeçote fêmea 40P (para ser cortado no tamanho).
6. 4 restistores de 10K 1 / 4W.
7. Fio de conexão.
8. Solda e Ferro.
9. Parafusos auto-roscantes de cabeça panela de aço inoxidável 20 off 4G x 6mm.
10. 4 parafusos auto-roscantes escareados de inox 4G x 6mm.
11. 1 bateria LiPo de 3,7 V desligada e suporte (terminando em conectores dupont 2P).
12. 1 cabeçote macho em ângulo reto 2P
13. 1 interruptor SPDT desligado 3 pinos 2,54 mm pitch
14. Cola forte de cianoacrilato
15. Conectores Dupont conector fêmea 1P (1 azul, 1 verde).

Etapa 2: montagem do circuito

O circuito atualmente não possui o Circuito Divisor de Tensão (voltímetro).

1. Corte a placa de circuito impresso universal de PCB protótipo de lado duplo de 4x6 cm pela metade no eixo longo.

2. Corte o cabeçalho 40P macho em pedaços:

   1. 2 off 12P
   2. 3 off 3P
   3. 6 desligado 2P.

3. Corte o cabeçalho 40P fêmea em pedaços:

   1. 2 off 12P
   2. 1 off 6P
4. Solda 2 fora do cabeçalho 12Pfemale conforme mostrado.
5. Cole o espaçador removido de um cabeçalho macho 3P (adicional) na parte inferior do interruptor SPDT com cola de cianoacrilato
6. Do outro lado, solde 6 off 2P, 2 off 3Pmale header e a chave SPDT como mostrado.
7. Solde 4 resistores de 10K (A, B, C, D preto) via cabo para o conector do pino GND (# 2 preto) e para A0 - pinos do cabeçalho A3 (# 5, # 6, # 7, # 8) e então através do orifício (amarelo) conforme mostrado (3 fotos + 1 diagrama).
8. Rastreie 3,3 V dos PINOS de solda dos PINS LDR # 4, # 6, # 8, # 10 e rosqueie através do orifício até o pino VCC do cabeçalho feminino (verde).
9. Rastreie 3,3 V no lado do coletor fêmea conforme mostrado (vermelho) soldando aos PINOS # 1, # 12, # 15.
10. 3,3 V através do orifício do pino # 1 do cabeçote RAW soldado sobre o lado (vermelho).
11. Trace a conexão laranja do PIN # 11 através do orifício para soldar o pino fêmea do outro lado, conforme mostrado.
12. Trace e solde o fio de conexão azul de # 20 a # 30 e de # 31 a # 13 e # 16.
13. Solde o pino da plataforma fêmea nº 11 ao pino da plataforma macho nº 11 através do orifício.
14. Prepare 2 conectores duplos de 30 mm de comprimento com cabeçote 1P fêmea (1 azul, 1 verde). Retire e estanhe a outra extremidade.
15. Solde o fio Dupont azul em # 28; soldar o fio Dupont verde a # 29.
16. Na parte superior do Arduino, fixe o conector fêmea 6P e depois solde.
17. Na parte superior do Arduino, fixe o cabeçote fêmea de ângulo reto 2P int # 29 e # 30 e depois solde.
18. No lado inferior do Arduino, fixe os 2 pinos 12P e 1 dos 3P machos e, em seguida, solde.
19. Insira os pinos 12P machos do Arduino nos conectores fêmeas do PCB 12P.

Etapa 3: Atualizando o MCU

O Arduino Pro Mini é convenientemente flasheado usando um conversor FTDI232 USB para TTL usando o conector fêmea 6P. Veja a foto acima para o alinhamento das 2 placas.

Certifique-se de que a configuração de 3,3 V seja escolhida em seu FTDI232. Siga as instruções aqui usando o código abaixo (use o link para GIST).

A biblioteca de baixa potência (anexada e https://github.com/rocketscream/Low-Power) precisa ser instalada.

Uma vez que o Arduino Pro Mini + PCB é instalado na caixa, ele ainda pode ser piscado quando os pinos do cabeçalho são expostos. Basta desconectar a unidade do controlador do quadro do painel, expondo o cabeçalho.

Rastreador solar de inclinação panorâmica com configuração I2C / EEPROM e ciclo de sono entre movimentos. A precisão da duração do ciclo do sono diminui à medida que a duração aumenta, mas é suficiente para esse propósito

/*

* modificado a partir do código

* por Mathias Leroy

*

* MODIFICAÇÕES V0.2

** I2C SET GET

** EEPROM SET GET

** REMOVER A SAÍDA SERIAL - I2C AFETADA

** ATIVAR / DESATIVAR RASTREAMENTO

** MOVER SERVOS PARA LIMITES VIA I2C

** LEIA A INTENSIDADE MÉDIA ATUAL VIA I2C

* MODIFICAÇÕES V0.3

** TROCAR PARA 2 MODOS - TRACK (NO I2C) e CONFIGURAR (USOS I2C)

** DORMIR NO MODO DE PISTA (PRECISÃO MUITO BAIXA DEVIDO A 8 SEGUNDOS CHUNKS)

** RETIRAR / ANEXAR SERVOS AO DORMIR / ACORDAR (TRANSISTOR USADO EVENTUALMENTE)

** REMOVER A POSIÇÃO INICIAL CONFIGURÁVEL (REDUNDANTE)

** REMOVER CONFIGURABLE WAKE SECONDS (REDUNDANT)

** REMOVER ATIVAR / DESATIVAR CONFIGURÁVEL (REDUNDANTE)

** REMOVER O TRACKER CONFIGURÁVEL ATIVADO (USE O INTERRUPTOR DE HARDWARE)

** REMOVER GETTER DE TENSÃO - USARÁ COMPONENTE I2C SEPARADO

** ADICIONE REGISTRO SERIAL QUANDO NÃO USAR 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 // média de todos os LDRS

# defineIDX_DUSK_INTENSITY13 // média de todos os LDRS

# defineIDX_END_EEPROM_SET14

# defineIDX_CURRENT_INTENSITY15 // média de todos os LDRS - usado para calcular a luz não direta ambiante IDX_DAWN_INTENSITY

# 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 configuração");

Serial.print ("Endereço I2C:");

Serial.println (_i2cVals [IDX_I2C_ADDR]);

Wire.begin (_i2cVals [IDX_I2C_ADDR]);

Wire.onReceive (receiveEvent);

Wire.onRequest (requestEvent);

}outro{

Serial.println ("Modo de rastreamento");

delay (5000); // tempo para tirar as mãos do caminho ao conectar a bateria etc.

}

}

voidloop ()

{

getLightValues ();

if (! _inConfigMode) {

// ToDo: LIGUE O INTERRUPTOR DO TRANSISTOR

_servoH.attach (PIN_SERVO_H);

_servoV.attach (PIN_SERVO_V);

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

if (i! = 0) {

getLightValues ();

}

moveServos ();

}

atraso (500);

_servoH.detach ();

_servoV.detach ();

// ToDo: DESLIGUE O INTERRUPTOR DO TRANSISTOR

atraso (500);

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

}

}

//---------------------------------MODO ATUAL

boolinConfigMode () {

pinMode (PIN_SERVO_H, INPUT);

_inConfigMode = digitalRead (PIN_SERVO_H) == 1;

return _inConfigMode;

}

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

voidgetFromEeprom () {

E se(

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 (contagem interna) {

if (contagem == I2C_MSG_IN_SIZE)

{

char cmd = Wire.read ();

índice de bytes = Wire.read ();

valor do byte = Wire.read ();

switch (cmd) {

case'G ':

if (índice <IDX_END_VALUES_GET) {

_i2cResponse = _i2cVals [índice];

}

pausa;

case'S ':

if (índice <IDX_END_EEPROM_SET) {

_i2cVals [índice] = valor;

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

}

pausa;

predefinição:

Retorna;

}

}

}

voidrequestEvent ()

{

Wire.write (_i2cResponse);

}

// --------------------------------- LDRs

voidgetLightValues () {

int valueTopLeft = analogRead (PIN_LDR_TL);

int valueTopRight = analogRead (PIN_LDR_TR);

valor internoBottomRight = analogRead (PIN_LDR_BR);

valor intBottomLeft = 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]) {

// indo para a esquerda

Serial.println ("moveServos indo para a esquerda");

atraso (_slowingDelay);

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

_servoH.write (_angleH--);

atraso (_servoLoopDelay);

}

}

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

// indo para a direita

Serial.println ("moveServos indo para a esquerda");

atraso (_slowingDelay);

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

_servoH.write (_angleH ++);

atraso (_servoLoopDelay);

}

}

outro {

// fazendo nada

Serial.println ("moveServos sem fazer nada");

atraso (_slowingDelay);

}

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

// subindo

Serial.println ("moveServos subindo");

atraso (_slowingDelay);

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

_servoV.write (_angleV ++);

atraso (_servoLoopDelay);

}

}

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

// indo para baixo

Serial.println ("moveServos indo para baixo");

atraso (_slowingDelay);

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

_servoV.write (_angleV--);

atraso (_servoLoopDelay);

}

}

outro {

Serial.println ("moveServos sem fazer nada");

atraso (_slowingDelay);

}

}

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

voidasleepFor (unsignedint eightSecondSegments) {

Serial.println ("asleepFor");

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

{

LowPower.powerDown (SLEEP_8S, ADC_OFF, BOD_OFF);

}

}

visualizar rawtilt_pan_tracker_0.3.ino hospedado com ❤ por GitHub

Etapa 4: Montagem do revestimento do circuito

1. Certifique-se de que o Ardiuno Pro Mini seja inserido nos cabeçalhos do PCB.
2. Insira a base da caixa do controlador SOLAR TRACKER nas paredes da caixa do controlador SOLAR TRACKER e fixe com 2 parafusos auto-roscantes escareados de inox 4G x 6mm.
3. Insira Ardiuno Pro Mini + PCB com 6P Header encaixando no vazio na base da caixa do controlador SOLAR TRACKER.
4. Insira a tampa da caixa do controlador SOLAR TRACKER nas paredes da caixa do controlador SOLAR TRACKER e fixe com 2 parafusos auto-roscantes escareados de inox 4G x 6mm.
5. Fixe o conjunto acima à base da estrutura do painel com 4 parafusos auto-roscantes escareados de inox 4G x 6mm.

Etapa 5: Conectando os condutores da plataforma ao controlador

As conexões pertinentes prontas do Instructable anterior são 4 conexões LDR 2P desligadas e 2 conexões 3P desligadas dos servos. O que é temporário até que a recarga esteja pronta é a bateria. Use um LiPo de 3,7 V que termina em uma conexão DuPont 2P por enquanto.

1. Insira as conexões LDR (sem polaridade) de cima:

   1. Canto superior direito
   2. Cima Esquerda
   3. Canto inferior direito
   4. Inferior esquerdo

2. Insira as conexões Servo (com o fio de sinal à esquerda) de cima:

   1. Horizontal
   2. Vertical
3. ESPERE ATÉ PRONTO PARA O TESTE, ENTÃO: Insira o cabo de alimentação de 3,7 Vcc + ve para cima e -ve para baixo.

Etapa 6: Testando o controlador

Conforme declarado antes, o software não foi otimizado para o fluxo de trabalho de carregamento solar. Ele pode ser testado e ajustado usando fontes de luz naturais (sol) e não naturais.

Para testar o rastreamento em um ambiente controlado, pode ser conveniente definir SLEEP MINUTES para um valor inferior (consulte a próxima etapa).

Etapa 7: configuração via I2C usando entrada do console

Isso explica a configuração do controlador por meio de um segundo MCU, inserindo as configurações em uma janela do console.

1. Carregue o seguinte script em um D1M WIFI BLOCK (ou Wemos D1 Mini).
2. Desconecte o USB do PC

3. CONEXÕES DE PINOS: -ve (Controlador) => GND (D1M) + ve (Controlador) => 3V3 (D1M) SCL (Controlador) => D1 (D1M)

   SDA (controlador) => D2 (D1M)

4. Gire a chave SPDT para CONFIG
5. Conecte o USB ao PC
6. No IDE do Arduino, inicie uma janela de console com a porta COM correta
7. Certifique-se de que "Nova linha" e "9600 baud" estão selecionados
8. Os comandos são inseridos na caixa de texto de envio seguidos da tecla Enter
9. Os comandos estão no formato Character byte byte
10. Se o segundo byte (terceiro segmento) não for incluído 0 (zero) é enviado pelo script
11. Tenha cuidado ao usar a entrada serial; reveja o que você digitou antes de apertar a tecla "Enter". Se você estiver bloqueado (por exemplo, alterando o endereço I2C para um valor que você esqueceu), você precisará atualizar o firmware do controlador novamente.

As variações suportadas no primeiro caractere do comando são:

• E (Ativar rastreamento de servo) útil para parar o movimento durante a configuração. Esta é a entrada usando: E 0
• D (Desativar rastreamento de servo) útil para iniciar o rastreamento automático se não for reinicializar o dispositivo. Esta é a entrada usando: D 0
• G (obter valor de configuração) lê valores de EEPROM e IN-MEMORY: Esta é a entrada usando: G (o índice é valores de byte válidos 0 - 13 e 15)
• S (Definir valor EEPROM) define valores para EEPROM que estão disponíveis após as reinicializações. Esta é a entrada usando: S (índice é valores de bytes válidos de 0 a 13, valor é valores de bytes válidos e variam por propriedade)

O código é a verdade para os índices, mas o seguinte é usado como um guia para valores / comentários válidos:

• I2C ADDRESS 0 - endereço escravo do controlador, o mestre precisa disso para se comunicar com o controlador (padrão 10)
• ÂNGULO VERTICAL MÍNIMO 1 - limite inferior do servo vertical de ângulo (padrão 10, faixa 0 - 180)
• ÂNGULO VERTICAL MÁXIMO 2 - limite superior do servo vertical de ângulo (padrão 170, faixa 0 - 180)
• SENSIBILIDADE LDR VERTICAL 3 - Margem de leitura LDR vertical (padrão 20, intervalo 0 - 1024)
• PASSO 4 DO ÂNGULO VERTICAL - passos do servo vertical do ângulo em cada ajuste (padrão 5, intervalo 1 - 20)
• ÂNGULO HORIZONTAL MÍNIMO - limite inferior do servo horizontal de 5 ângulos (padrão 10, intervalo 0 - 180)
• ÂNGULO MÁXIMO HORIZONTAL 6 - limite superior do servo horizontal de ângulo (padrão 170, intervalo 0 - 180)
• SENSIBILIDADE HORIZONTAL LDR 7 - Margem de leitura horizontal do LDR (padrão 20, intervalo 0 - 1024)
• ANGULO HORIZONTAL PASSO 8 - passos servo horizontais em cada ajuste (padrão 5, intervalo 1 - 20)
• SLEEP MINUTES 9 - o período de sono aproximado entre o rastreamento (padrão 20, intervalo 1 - 255)
• ÂNGULO VERTICAL DE AMANHECER 10 - USO FUTURO - o ângulo vertical para retornar quando o sol se põe
• ÂNGULO DE AMANHECER HORIZONTAL 11 - USO FUTURO - o ângulo horizontal para retornar quando o sol se põe
• INTENSIDADE DAWN 12 - USO FUTURO - a média mínima de todos os LDRs que aciona o início do rastreamento diário do sol
• DUSK INTENSITY 13 - FUTURE USE - a média mínima de todos os LDRs que aciona o fim do rastreio solar diário
• MARCADOR DE VALORES DE FIM DE EEPROM 14 - VALOR NÃO UTILIZADO
• INTENSIDADE DE CORRENTE 15 - a porcentagem média atual da intensidade de luz
• MARCADOR DE FIM DE VALORES IN-MEMORY 16 - VALOR NÃO UTILIZADO.

Captura a entrada serial (entrada do teclado na janela do console) e a encaminha para um escravo I2C no formato char, byte, byte

#incluir

# defineI2C_MSG_IN_SIZE2

# defineI2C_MSG_OUT_SIZE3

# defineI2C_SLAVE_ADDRESS10

boolean _newData = false;

const byte _numChars = 32;

char _receivedChars [_numChars]; // um array para armazenar os dados recebidos

voidsetup () {

Serial.begin (9600);

Wire.begin (D2, D1);

atraso (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;

}

} outro {

_receivedChars [ndx] = '\ 0'; // termina a string

ndx = 0;

_newData = true;

}

}

}

voidparseSendCommands () {

if (_newData == true) {

constchar delim [2] = "";

char * token;

token = strtok (_receivedChars, delim);

char cmd = _receivedChars [0];

índice de bytes = 0;

valor do byte = 0;

int i = 0;

while (token! = NULL) {

//Serial.println(token);

i ++;

switch (i) {

caso 1:

token = strtok (NULL, delim);

índice = atoi (token);

pausa;

case2:

token = strtok (NULL, delim);

if (token! = NULL) {

valor = atoi (token);

}

pausa;

predefinição:

token = NULL;

}

}

sendCmd (cmd, índice, valor);

_newData = false;

}

}

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

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

Serial.println ("Enviando comando:");

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

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

Wire.beginTransmission (I2C_SLAVE_ADDRESS); // transmitir para o dispositivo

Wire.write (cmd); // envia um char

Wire.write (índice); // envia um byte

Wire.write (valor); // envia um byte

Wire.endTransmission ();

resposta de byte = 0;

bool hadResponse = false;

if (cmd == 'G') {

Wire.requestFrom (I2C_SLAVE_ADDRESS, 1);

while (Wire.available ()) // escravo pode enviar menos do que o solicitado

{

hadResponse = true;

resposta = Wire.read ();

}

if (hadResponse == true) {

Serial.println ("Obtendo resposta:");

Serial.println (resposta);

}outro{

Serial.println ("Sem resposta, verifique o endereço / conexão");

}

}

}

ver rawd1m_serial_input_i2c_char_byte_byte_v0.1.ino hospedado com ❤ por GitHub

Etapa 8: Próximas etapas

Verifique periodicamente para verificar se há alterações no software / hardware.

Modifique o software / hardware de acordo com seus requisitos.

Comente sobre quaisquer solicitações / otimizações.