Arduino - Classe para 74HC595 Corrigida

Nesse post (clique aqui) foi mostrado como criar uma classe pra facilitar o uso do registrador de deslocamento 74HC595 com o Arduino.

Apesar de funcionar perfeitamente, a classe ocupava muita memória para armazenar o estados de todas as saídas.

o código abaixo, foi reescrito de forma a ocupar menos memória e ser mais simples. Alguns métodos foram renomeados.

segue código-fonte:

class Expansor74HC595 {
  private:
    int  _pin_clock;
    int  _pin_latch;
    int  _pin_data;
    int  _num_cis;
    byte* _pins;
    int  _auto_send;
  public:
    Expansor74HC595(int pin_clock, int pin_latch, int pin_data, int num_cis){
      _pin_clock        = pin_clock;
      _pin_latch        = pin_latch;
      _pin_data         = pin_data;
      _num_cis          = num_cis;
      _auto_send        = true;
      _pins             = new byte[_num_cis];

      pinMode(_pin_clock,OUTPUT);
      pinMode(_pin_latch,OUTPUT);
      pinMode(_pin_data, OUTPUT);
      clear();
    };
  
    void startWrite() { 
      _auto_send = false; 
    };
    
    void clear() { 
      for (int i=0; i<_num_cis; i++){ 
        _pins[i] = 0b00000000; 
      }
      
      send();  
    };
  
    int read(int pin)  { 
      if (pin >= _num_cis * 8) {return LOW;} 
      
      int pos = pin / 8;
      pin = pin % 8;

            
      return (_pins[pos] & (1 << pin)) != 0;
    };
  
    byte readByte(int num_ci) { 
      return _pins[num_ci];
    };
   
    void send(){
      
      digitalWrite(_pin_latch, LOW); 
      for(int i=_num_cis-1; i>=0; i--) {  shiftOut(_pin_data, _pin_clock, MSBFIRST, readByte(i) );  }
      digitalWrite(_pin_latch, HIGH);
      _auto_send = true;
      
    };
    
    void writeByte(int num_ci, byte b, int first = MSBFIRST) {  
      
      if (first == MSBFIRST){
        byte reversed;
        for(int i=0;i<8;i++){
          reversed |= ((b>>i) & 0b1)<<(7-i);
        }
        b = reversed;
      }
      
      _pins[num_ci] = b; 
      if (_auto_send) { send(); } 
    } ;
    
    void write(int pin, int value) {
      if (pin >= _num_cis * 8) { return; }
      
      int pos = pin / 8;
      pin     = pin % 8;

      if (value){
        _pins[pos] |= (1 << pin);  //set a bit HIGH
      } else {
        _pins[pos] &= ~(1 << pin); //set a bit LOW
      }

      if (_auto_send) { send(); }
    };
};
 

const int PIN_CLOCK = 2; 
const int PIN_LATCH = 3; 
const int PIN_DATA  = 4; 

Expansor74HC595 *exp1;
 
void setup() {
  exp1   = new Expansor74HC595(PIN_CLOCK, PIN_LATCH, PIN_DATA, 3);
  
  Serial.begin(9600);
}
 
void loop() {
  for (byte b=0; b<=255; b++) {                    //i=0-> B00000000   i=255-> B11111111
    exp1->startWrite();
    exp1->writeByte(0, b);
    exp1->writeByte(1, b, LSBFIRST);
    exp1->write(23, HIGH);
    exp1->send();
  
    delay(500);
  }
  
  exp1->clear();
  delay(500); 
}

Arduino - Expansão dinâmica de portas

Vaja como fazer para o Arduino identificar a quantidade de expansores (74hc595, max7219, etc) conectados em série. veja o vídeo.

vídeo anterior sobre o 74HC595:
http://youtu.be/SwQECcYdEkI

Link para o artigo:
http://www.arduinoecia.com.br/2014/04/Painel-de-led-max7219.html


código:

int conta_modulos(int pino, float Rb, float Rp){
  float La = analogRead(pino);
  double N = ( 1 / (  ((1023*Rb)/La) - Rb ) )  / ( 1 / Rp );
  int n = round(N);
    
  Serial.print(N);
  Serial.print(" arredondado: ");
  Serial.println(n);
  
  return n;
}

void setup() { Serial.begin(9600); }

void loop() {
  int q1 = conta_modulos(A0, 1000, 10000);  //resistor gnd->1K, resistor paralelo 10k
  delay(1000);
}

Arduino - Classe para 74HC595

No vídeo abaixo mostro como criar uma classe para facilitar o uso do Registrador 74HC595 com o Arduino.

Código:

ATENÇÃO:

o código abaixo foi melhorado, e publicado em um novo post. Clique aqui para o código atualizado.

class Expansor74HC595 {
  private:
    int  _pin_clock;
    int  _pin_latch;
    int  _pin_data;
    int  _num_cis;
    int* _pins;
    int  _envio_automatico;
  public:
    Expansor74HC595(int pin_clock, int pin_latch, int pin_data, int num_cis=1);
    void startWrite()         { _envio_automatico = false; };
    int  get_num_portas() { return _num_cis * 8; };
    void limpar() { for (int i=0;i < _num_cis * 8;i++){ _pins[i] = LOW; } enviar();  };
    int  read(int pin)  { if (pin >= get_num_portas()) {return LOW;} return _pins[pin]; };
  
    void enviar();
    void writeByte(int num_ci, byte values, bool q0=true);
    void write(int pin, int value);
};

Expansor74HC595::Expansor74HC595(int pin_clock, int pin_latch, int pin_data, int num_cis){
  _pin_clock        = pin_clock;
  _pin_latch        = pin_latch;
  _pin_data         = pin_data;
  _num_cis          = num_cis;
  _envio_automatico = true;
  _pins             = new int[_num_cis*8];
  
  pinMode(_pin_clock,OUTPUT);
  pinMode(_pin_latch,OUTPUT);
  pinMode(_pin_data, OUTPUT);
  limpar();
}

void Expansor74HC595::writeByte(int num_ci, byte b, bool q0) { 
  for(int i=(num_ci*8-1),j=q0?7:0;  i>=(num_ci-1)*8;  i--, q0?j--:j++) {
    _pins[i]  = (b & (1 << j)) ?  HIGH  :  LOW;
  }     
  
  if (_envio_automatico) { enviar(); }
}

void Expansor74HC595::write(int pin, int value) {
  if (pin >= get_num_portas()) {return;}
  _pins[pin] = value ? HIGH : LOW;
  if (_envio_automatico) { enviar(); }
}

void Expansor74HC595::enviar(){
  digitalWrite(_pin_latch, LOW); 
  
  for (int i=(_num_cis*8-1); i>=0; i-- ) {  
    digitalWrite(_pin_clock, LOW); 
    digitalWrite(_pin_data,  _pins[i]);
    digitalWrite(_pin_clock, HIGH); 
    digitalWrite(_pin_data,  LOW);
  }
  
  digitalWrite(_pin_latch,HIGH);
  
  _envio_automatico = true;
}


/*----------------------*/



const int PIN_CLOCK = 2; 
const int PIN_LATCH = 3; 
const int PIN_DATA  = 4; 

Expansor74HC595 *exp1;
 
void setup() {
  exp1 = new Expansor74HC595(PIN_CLOCK, PIN_LATCH, PIN_DATA, 16);
  
  Serial.begin(9600);
}


void conta_tempo(void(*p)(), String descricao){
  long m1, m2;
  m1 = millis();
  (*p)(); //executa a função
  m2 = millis();
 
  Serial.print(descricao + ": m1= ");
  Serial.print(m1);
  Serial.print(" - m2 = ");
  Serial.print(m2);
  Serial.print(" - dif = ");
  Serial.print(m2 - m1);
  Serial.println(" milissegundos");
}

void enviar(){
  exp1->enviar();
}
 
void loop() {
  
  for (int i=0; i<=255; i++) {                    //i=0-> B00000000   i=255-> B11111111
    exp1->startWrite();
    
    exp1->writeByte(1, i);         //q0 será o menos significativo   
    exp1->writeByte(3, i, false);  //q7 será o menos significativo
    
    exp1->write(8, 1); 
    exp1->write(9, 0);
    exp1->write(10, 1);
    exp1->write(11, 0);

    conta_tempo(enviar, "teste");

    //exp1->enviar();
  
    delay(500);
  
    exp1->startWrite();

    exp1->write(8, 0);
    exp1->write(9, 1);
    exp1->write(10, 0);
    exp1->write(11, 1);

    exp1->enviar();
    
    delay(500);  
    
    exp1->limpar();
    delay(300);    
  }
}