quarta-feira, 20 de julho de 2016

HX711 – Vários módulos HX711 em paralelo!

Utilizando vários módulos HX711 com a captura em paralelo!


Este código esta em construção, por enquanto somente a captura do canal A esta disponível em cada modulo HX711.

Resolvi atualizar no BLOG, pois acredito que a base para a captura em paralelo já foi construída, e para que não fosse dado um passo muito longo entre as postagens.

A ideia é para X amostras:

1 – Disparar a conversão dos N módulos  HX711

2 – Verificar qual já módulo HX711 terminou a conversão

3- Captura o que já terminou a conversão

3.1 – voltar a disparar a captura para este modulo

 4 – Voltar a (2) verificar qual módulo HX711 já terminou até atingir X amostras por módulo HX711.

O código abaixo  parece estar funcionando a contento para  2 módulos HX 711, ainda não testei com mais módulos.

#define numcelulas 2 // define o mumero de modulos hx711 a serem utilizadas
unsigned long tempo = 0;
float saida = 0;
int DOUT[numcelulas] = A5,A3;  // Pinos DT placa HX711
int hxSCK[numcelulas] = A4,A2;   // Pino SCK placa HX711

 // ALTERAR PARA SUAs CELULAs DE CARGA!!!!!
float kconst[numcelulas] = 21097.164, 21097.164; // Fator para Kilograma pequenos pesos

//Cria variaveis paras as celulas

unsigned long CAPTURAcell[numcelulas];
float pesos[numcelulas];
unsigned long TARA[numcelulas];
unsigned long MEDIAcell[ numcelulas ];


//______________________________________________________________________
//                      SUBROTINAS
//______________________________________________________________________
// Inicia o(s) HX711
void IniciaCAPT( int cell )

   digitalWrite(hxSCK[cell], LOW); 

//______________________________________________________________________
// pega valor HX711
unsigned long Pega( int cell )

   CAPTURAcell[cell] = 0;
   for (int i=0; i<24; i++)             // loop 24 pulsos
        digitalWrite(hxSCK[cell], HIGH); 
        CAPTURAcell[cell] = CAPTURAcell[cell]<<1;
        digitalWrite(hxSCK[cell], LOW);
        if(digitalRead(DOUT[cell]) == 1) CAPTURAcell[cell]++;
         
   // pulso extra 25 pulsos proxima leitura canal A ganho 128     
   digitalWrite(hxSCK[cell], HIGH); 
   delayMicroseconds(10); 
   digitalWrite(hxSCK[cell], LOW);
   //********************************************************
  return CAPTURAcell[cell] ^= 0x00800000;  

//______________________________________________________________________
void CAPTURA(int media)
int Pointermedia [numcelulas]; 
int Pointerblock [numcelulas]; 
// zera e estarta todas as capturas
for (int i = 0; i < numcelulas; i++)
   CAPTURAcell[i] = 0;
   MEDIAcell[i] = 0;  
   Pointermedia[i] = 0; 
   Pointerblock [i] = 0; 
   digitalWrite(hxSCK[i], LOW); 
   
//******************************
  int Aguarda = 0;                                      // Variavel para testar se já capturou todos os canais
  while (Aguarda < numcelulas ) 
    for (int i = 0; i < (numcelulas); i++)
       if (digitalRead(DOUT[i])==0 && Pointerblock [i] == 0) 
          MEDIAcell[i] += Pega(i);                        // Soma o valor capturado ao balde da media
          //leituras [i][Pointermedia [i]] = MEDIAcell[i];
          Pointermedia [i] = Pointermedia [i] + 1;        // incrementa a cada vez que acrescenta um valor a media
         
              if (Pointermedia [i] == media )           // ja capturou todos os valores do canal i
                  MEDIAcell[i] =  (long) MEDIAcell[i]/media;    // divide o valor do balde pelo numero de amostras
                  Pointerblock [i] = 1;                   // Bloqueia canal i pois ja encheu o balde
                  Aguarda++;                              // incrementa quando terminou a captura no canal i
                   else 
                    IniciaCAPT(i);                        // inicia a proxima captura
            
        
   

//______________________________________________________________________
void setTARA()
  // reseta o conversores HX711
  for (int i = 0; i < numcelulas; i++)  digitalWrite(hxSCK[i], HIGH); 
  delay (200);
  for (int i = 0; i < numcelulas; i++)  digitalWrite(hxSCK[i], LOW); 
  delay (1);
  // -------------------------
  CAPTURA(50);
  for (int i = 0; i < numcelulas; i++) 
      TARA[i] = MEDIAcell[i];
  

//______________________________________________________________________
void Peso()

    CAPTURA(20);
    for (int i = 0; i < numcelulas; i++)   
      pesos[i] = (long)(MEDIAcell[i] - TARA[i]);
      pesos[i] = (float) pesos[i] / kconst[i];
          
    

//______________________________________________________________________
// FIM SUBROTINAS
//______________________________________________________________________
void setup() 
  Serial.begin(115200);
  pinMode(hxSCK[0], OUTPUT);
  pinMode(hxSCK[1], OUTPUT);
  pinMode(DOUT[0], INPUT);
  pinMode(DOUT[1], INPUT);
  Serial.println("Aguarde estou zerando!");
  setTARA() ;
  Serial.println("Estou pronto!");

//______________________________________________________________________
void loop() 
     tempo = millis();
     Peso();
     tempo = millis()-tempo;  
     for (int i = 0; i < numcelulas ; i++)
         Serial.print("Celula");
         Serial.print(i);
         Serial.print(" = ");
         Serial.print(pesos[i],3);
         Serial.print(" Kg, ");
        
     
  
  Serial.print("Tempo= ");
  Serial.print(tempo);
  Serial.print(" ms");
  Serial.print(", SPS= ");
  Serial.print(float(20000/tempo)); // 125 Amostras  
  Serial.println(" Amostras/segundo p/ todos canais");


Módulo HX711

O primeiro teste foi feito com um módulo modificado capturando em ~90SPS e um módulo mini HX711 sem alterações com ~11SPS:
Resultado da primeira captura usando o Cod. Paralelo

O resultado foi conforme o esperado, o módulo HX711 mais lento determinou o valor de amostras por segundos para todo o grupo.

Modifiquei o módulo MiniHx711 (muito fácil de alterar) para que ele passa-se a capturar mais vezes por segundo.

O segundo teste foi feito com um módulo modificado capturando em ~90SPS e um módulo mini HX711 modificado com ~90SPS:


Captura paralela com dois módulos HX711 modificados.

No momento estou usando uma célula de carga de  20Kg e uma célula de carga de 2Kg sem seus fatores K ajustados.  Para estes testes iniciais os valores em quilogramas não estarem  ajustados não era importante.

Para os próximos passos, vou montar as células de carga em uma bancada mais adequada para realizar a calibração, (ajuste do fator K individual) e depois vou realizar outros testes comum maior rigor.




HX711 – Vários módulos HX711 em paralelo!

segunda-feira, 18 de julho de 2016

HX711 - Usando dois módulos HX711. Testes iniciais com captura sequencial!

Teste para captura com dois ou mais módulos HX711.


Primeiro código teste para captura com dois ou mais módulos HX711. Foram utilizados no teste dois módulos modificados para se ter um maior Sample Rate!

Este primeiro código trabalha selecionando qual a célula de carga que se deseja o ler valor. No próximo código vou tentar fazer de forma paralela a captura dos valores:

unsigned long tempo = 0;
float saida = 0;
int DOUT[2] = A5,A3;  // Pinos DT placa HX711
int hxSCK[2] = A4,A2;   // Pino SCK placa HX711
unsigned long TARA[2] = 0,0;
 // ALTERAR PARA SUAs CELULAs DE CARGA!!!!!
float kconst[2] = 21097.164, 21097.164; // Fator para Kilograma pequenos pesos

//Cria variaveis para duas
unsigned long CAPTURAcell[2] = 0,0;
unsigned long MEDIAcell[2] = 0,0;


void setup() 
  Serial.begin(9600);
  pinMode(hxSCK[0], OUTPUT);
  pinMode(hxSCK[1], OUTPUT);
  pinMode(DOUT[0], INPUT);
  pinMode(DOUT[1], INPUT);
  Serial.println("Aguarde estou zerando!");
  TARA[0] = setTARA(0);
  TARA[1] = setTARA(1);
  Serial.println("Estou pronto!");


void loop() 
     tempo = millis();
     saida = Peso(0);
     tempo = millis()-tempo;    
     Serial.print("Celula 1= ");
     Serial.print(saida);
     Serial.print(" Kg");
     Serial.print(",   Tempo= ");
     Serial.print(tempo);
     Serial.print(" ms");
     Serial.print(",   SPS= ");
     Serial.print(float(125000/tempo)); // 125 Amostras  
     Serial.println(" Amostras por segundo");

     tempo = millis();
     saida = Peso(1);
     tempo = millis()-tempo;    
     Serial.print("Celula 2= ");
     Serial.print(saida);
     Serial.print(" Kg");
     Serial.print(",   Tempo= ");
     Serial.print(tempo);
     Serial.print(" ms");
     Serial.print(",   SPS= ");
     Serial.print(float(125000/tempo)); // 125 Amostras  
     Serial.println(" Amostras por segundo");
     
     
    // delay (10); //Aguarda 10ms




unsigned long CAPTURA(int cell)
  CAPTURAcell[cell] = 0;
  MEDIAcell[cell] = 0;  
  for (int j=0; j<5; j++)             // loop 5 para media
  CAPTURAcell[cell] = 0;
  digitalWrite(hxSCK[cell], LOW); 
  while (digitalRead(DOUT[cell])==1) ; //Bloqueio!!! Aguarda o coneversor estar pronto para nova aquisição
  for (int i=0; i<24; i++)             // loop 24 pulsos
        digitalWrite(hxSCK[cell], HIGH); 
        CAPTURAcell[cell] = CAPTURAcell[cell]<<1;
        digitalWrite(hxSCK[cell], LOW);
        if(digitalRead(DOUT[cell]) == 1) CAPTURAcell[cell]++;
         
   // pulso extra 25 pulsos proxima leitura canal A ganho 128     
   digitalWrite(hxSCK[cell], HIGH); 
   delayMicroseconds(10); 
   digitalWrite(hxSCK[cell], LOW);
   //-------------------------------------------------------
  CAPTURAcell[cell] ^= 0x00800000; 
  MEDIAcell[cell] += CAPTURAcell[cell];
  
   CAPTURAcell[cell] = MEDIAcell[cell]/5;
 return CAPTURAcell[cell];




unsigned long setTARA(int cell)
  // reseta o conversor HX711
  digitalWrite(hxSCK[cell], 1);  
  delay (200);
  digitalWrite(hxSCK[cell], LOW); 
  delay (1);
  // -------------------------
 return Media(70,cell);
    

float Peso(int cell)

    long peso = (Media(25,cell) - TARA[cell]);
    return (float) peso / kconst[cell];


long Media(byte vezes, int cell)

    long soma = 0;
    for (byte i = 0; i < vezes; i++)
    
        soma += CAPTURA(cell);
    

    return soma / vezes;


Resultado observado pela serial !




Resultado do teste inicial usando dois módulos HX711 modificados!


HX711 - Usando dois módulos HX711. Testes iniciais com captura sequencial!

domingo, 17 de julho de 2016

HX711- Alterando o tempo de captura ( SAMPLE RATE ) do módulo HX711!

Como foi falado os módulos do HX711 vem com o sample rate em aproximadamente 10 amostras por segundo (10 SPS), pois o pino 15 (RATE) esta ligado ao terra (GND). Para alterar o sample rate do módulo é necessário fazer alterações na placa. Será necessário retirar o CI HX711 da placa, depois cortar a trilha que liga o pino 15 (RATE)  ao terra (GND), e  por fim ligar o pino 15 (RATE) ao 5V (VCC).

      As alterações necessárias para alteração do Sample rate do módulo HX711.


Cortar a trilha do pino 15 (RATE) ao GND e ligar o pino 15 (RATE) ao VCC

A placa do modulo tem uma trilha por baixo do CI HX711 ligando o pino 14 ao pino 15 (RATE).



Módulo HX711 sem alterações
Detalhe visual pinos 14 e 15

Para cortar a trilha  é necessário retirar o CI HX711, como podemos observar nas fotos a seguir.



Modulo sem o CI HX711

        Detalhe da trilha cortada com um estilete!



Detalhe do corte da trilha pino 15 ao GND.


Para finalizar as alterações no modulo HX711 e necessário re-soldar o CI HX711 a placa e liga o pino 15 ao VCC!


Detalhe módulo HX711 do pino 15 ligado ao VCC, através de uma solda entre os terminais do CI. As soldas nos pinos serão refeitas apos os testes!

Finalizado a parte física vamos alterar o software para que possamos observar a diferença de um modulo alterado para um original!!

O software para testes:


O software esta com um filtro de 5 amostras na função CAPTURA e de 25 Amostras na função Media, dando um total de 125 amostras por leitura!

unsigned long tempo = 0;
float saida = 0;
const int DOUT = A5; // Pino DT placa HX711
const int hxSCK = A4; // Pino SCK placa HX711
unsigned long TARA = 0;
// ALTERAR PARA SUA CELULA DE CARGA!!!!!
float kconst = 21097.164; // Fator para Kilograma pequenos pesos


void setup() 
  Serial.begin(9600);
  pinMode(hxSCK, OUTPUT);
  pinMode(DOUT, INPUT);
  Serial.println("Aguarde estou zerando!");
  TARA = setTARA();
  Serial.println("Estou pronto!");


void loop() 
     tempo = millis();
     saida = Peso();
     tempo = millis()-tempo; 
     Serial.print(saida);
     Serial.print(" Kg");
     Serial.print(", Tempo= ");
     Serial.print(tempo);
     Serial.print(" ms");
     Serial.print(", SPS= ");
     Serial.print(float(125000/tempo)); // 125 Amostras 
     Serial.println(" Amostras por segundo");
     
    // delay (10); //Aguarda 10ms




unsigned long CAPTURA()
  unsigned long CAPTURA = 0;
  unsigned long MEDIA = 0; 
  for (int j=0; j<5; j++) // loop 5 para media
  CAPTURA = 0;
  digitalWrite(hxSCK, LOW); 
  while (digitalRead(DOUT)==1) ;
  for (int i=0; i<24; i++) // loop 24 pulsos
        digitalWrite(hxSCK, HIGH); 
        CAPTURA = CAPTURA<<1;
        digitalWrite(hxSCK, LOW);
        if(digitalRead(DOUT) == 1) CAPTURA++;
         
   // pulso extra 25 pulsos proxima leitura canal A ganho 128 
   digitalWrite(hxSCK, HIGH); 
   delayMicroseconds(10); 
   digitalWrite(hxSCK, LOW);
   //-------------------------------------------------------
  CAPTURA ^= 0x00800000; 
  MEDIA += CAPTURA;
  
   CAPTURA = MEDIA/5;
 return CAPTURA;




unsigned long setTARA()
  // reseta o conversor HX711
  digitalWrite(hxSCK, 1); 
  delay (200);
  digitalWrite(hxSCK, LOW); 
  delay (1);
  // -------------------------
 return Media(70);
    

float Peso()

    long peso = (Media(25) - TARA);
    return (float) peso / kconst;


long Media(byte vezes)

    long soma = 0;
    for (byte i = 0; i < vezes; i++)
    
        soma += CAPTURA();
    

    return soma / vezes;


      O resultado dos testes no módulo HX711 original.


O modulo sem modificação no hardware foi testado com as células de carga de uma balança de banheiro sem carga e o sample rate foi de 11  amostras por segundo (11 SPS).


 O HX711 original da por volta de 11 amostras por segundo (11 SPS)



       O resultado do módulo HX711 com as alterações de Hardware.


O modulo com a modificação no hardware foi testado com uma célula de carga de 20Kg como pode ser  visto nas fotos a seguir e o sample rate foi de aproximadamente 92 amostras por segundo ( 92 SPS ).


O módulo HX711 modificado da por volta de 92 amostras por segundo ( 92 SPS )


Módulo Hx711 ligado a uma célula de carga 20Kg
 Detalhe do módulo Hx711 ligado a uma célula de carga 20Kg



OBS: Recomendo aterrar o canal B caso não seja utilizado em seu projeto!


HX711- Alterando o tempo de captura ( SAMPLE RATE ) do módulo HX711!