sabe quando você quer usar a serial pra enviar um comando para o arduino executar alguma coisa, mas não quer ficar usando o enter ou clicar no botão enviar?
Neste vídeo mostro como contornar esse probleminha através do uso de comando do DOS.
Código-fonte:
/*
mais detalhes sobre essa função: http://fabianoallex.blogspot.com.br/2015/09/arduino-como-substituir-delay-pelo.html
*/
int time(long timeHigh, long timeLow, long atraso, long mref = 0) {
long ajuste = mref % (timeHigh + timeLow);
long resto = (millis() + timeHigh + timeLow - ajuste - atraso) % (timeHigh + timeLow);
return (resto < timeHigh ? HIGH : LOW);
}
void setup(){
Serial.begin(9600);
pinMode(6, OUTPUT);
}
boolean pisca = false;
void loop(){
int c = Serial.read();
if (c == 97) { digitalWrite(6, HIGH); pisca = false; } //a -> liga
if (c == 98) { digitalWrite(6, LOW); pisca = false; } //b -> desliga
if (c == 99) { pisca = true; } //c -> pisca
if (pisca) { digitalWrite(6, time(400, 400, 0)); }
}
arquivo .bat:
lembre-se de configurar a porta correta, nesse exemplo, utilizei a porta COM8.
MODE COM8 BAUD=9600 PARITY=n DATA=8
:LOOP
CHOICE /C:1234 /M "1: liga; 2: desliga; 3: pisca; 4: sair "
IF errorlevel 4 GOTO SAIR
IF errorlevel 3 GOTO PISCA
IF errorlevel 2 GOTO DESLIGA
IF errorlevel 1 GOTO LIGA
:DESLIGA
ECHO b > COM8
GOTO END
:LIGA
ECHO a > COM8
GOTO END
:PISCA
ECHO c > COM8
GOTO END
:END
CLS
GOTO LOOP
:SAIR
Nesse Artigo vou explicar um pouco dos detalhes de como implementei o código para poder controlar o Max7219 junto com o 74HC595, os quais mostrei dois vídeos na página do facebook.
Apesar de a ideia não ser entrar em detalhes do que são e como funcionam Registradores de Deslocamento, vou deixar aqui um trecho do que a wikipedia diz sobre eles:
Em eletrônica digital um registrador de deslocamento é um conjunto de registradores configurados em um arranjo linear de tal forma que a informação é deslocada pelo circuito conforme o mesmo é ativado. Os registradores de deslocamento podem possuir uma combinação de entradas e saídas seriais e paralelas, incluindo as configurações entrada serial, saída paralela (SIPO) e entrada paralela, saída serial (PISO). Existem outra configurações possuindo ambas as entradas serial e paralela e outra com saídas serial paralela. Existem também registradores de deslocamento bi-direcionais, os quais permitem que se varie a direção do deslocamento da informação. As entradas e saídas seriais de um registrador podem ser conectadas juntas, de modo a formar um registrador de deslocamento circular. Poderiam também ser desenvolvidos registradores de deslocamento multi-dimensionais, os quais podem realizar processamentos mais complexos. Mais informações, aqui.
Dois exemplos de Registradores de Deslocamento são o Max7219 e o 74HC595, cada um com uma finalidade diferente. Enquanto o 595 é usado apenas para expandir saídas, o Max7219 tem o objetivo de servir como driver para display de 7 segmentos e matriz de Leds 8x8. Apesar de terem suas diferenças, a comunicação entre os dois é basicamente a mesma, com a pequena diferença de que o 595 possui 8 bits de Saída, enquanto que o Max7219 possui 16.
Também não vou entrar em maiores detalhes de como cada um funciona, mas pra quem quiser mais informações, seguem os links para os datasheets:
A grande vantagem dos Registradores de Deslocamento é que eles podem ser ligados em cascata e sem um limite de quantidade. Ambos possuem 3 pinos de comunicação, clock e data, além do Load no max7219 e o seu equivalente Latch para o 74HC595.
Fisicamente não há grandes dificuldades na comunicação entre eles, uma estudada sobre como são as ligações de ambos dará pra entender (instintivamente) como liga-los juntos. Mas no caso específico que mostro aqui, há algumas regras. Foi necessário ligar primeiramente os Max7219, e por último os 595, nunca intercalando um com o outro.
Programação
A parte que deu mais trabalho foi a parte de programação, já que a ideia foi reutilizar as classes já existentes para controle de ambos, no caso do Max 7219 a biblioteca LedControl, e do 74HC595, utilizar uma classe que já disponibilizei aqui no blog ( veja ). Eu poderia criar uma classe do zero e recriar todas as funcionalidades nessa única classe, mas achei que seria retrabalho, então a ideia foi fazer algo que unisse a funcionalidade das duas.
Ambas as classes agora precisam funcionar de maneira unificada. Quando os dados de qualquer uma das duas for atualizado, será necessário envia-los para todos os CIs que estão ligados em cascata e não apenas a que foi alterada. Pra isso foi necessário criar uma terceira classe que controlasse o envio dos dados para os registradores, a qual chamei de ShiftRegisterController.
A finalidade dessa classe é gerenciar o envio dos dados para os CIs. Porém ainda há um outro detalhe, foi necessário criar uma outra classe que fosse a classe-base para LedControl e para a classe Expansor74HC595, de modo que as duas herdem as mesmas funcionalidades básicas.
Além da inclusão dessas novas classes, foram feitas alterações nas definições das classes já existentes, indicando que as mesmas, agora serão herdadas de ShiftRegister:
class Expansor74HC595 : public ShiftRegister {...};
class LedControl : public ShiftRegister {...};
Podemos ver que há um atributo chamado _pin_latch na classe ShiftRegisterController, que anteriormente ficava nas classes LedControl e Expansor74HC595, pois é através desse pino que todos os CIs são "notificados" que as alterações estão prontas e devem ser aplicadas as suas respectivas saídas, logo, as duas classes citadas não controlam mais quando os dados são finalizados, ficando essa função para a classe ShiftRegisterController.
Observação: Pra não ter que fazer essas alterações diretamente na biblioteca LedControl, eu copiei todo o conteúdo da classe dentro da própria sketch e fiz as alterações necessárias, como pode ser visto no código completo mais abaixo. Em outro artigo eu já mostrei como fazer isso, incluindo algumas melhorias na classe LedControl, a quais explico nesse artigo: http://fabianoallex.blogspot.com.br/2015/09/arduino-alteracoes-na-biblioteca.html
O código abaixo mostra como devem ser declarados os objetos, que são 3.
int const PIN_DATA = 10;
int const PIN_CLK = 9;
int const PIN_LATCH = 8;
int const QUANTIDADE_MAX7219 = 2;
int const QUANTIDADE_74HC595 = 1;
ShiftRegisterController exp_src = ShiftRegisterController(PIN_LATCH);
LedControl exp_lc = LedControl (PIN_DATA,PIN_CLK,QUANTIDADE_MAX7219, &exp_src);
Expansor74HC595 exp_595 = Expansor74HC595(PIN_DATA,PIN_CLK,QUANTIDADE_74HC595 , &exp_src);
Primeiramente foi necessário criar o objeto controlador e posteriormente criar os outros dois Objetos, um LedControl e outro Expansor74HC595. Veja que o primeiro objeto recebeu como parâmetro o PIN_LATCH, enquanto que as demais classes não recebem mais esse parâmetro, recebendo apenas o pino de clock e o pino de data, porém recebem como parâmetro o endereço do objeto controlador.
Código-Fonte - Arduino Uno:
/*
Criado em 04/10/2015
Por:
Fabiano A. Arndt
http://www.youtube.com/fabianoallex
http://fabianoallex.blogspot.com.br
fabianoallex@gmail.com
*/
/*
* LedControl.h / LedControl.cpp - A library for controling Leds with a MAX7219/MAX7221
* Copyright (c) 2007 Eberhard Fahle
*
* Permission is hereby granted, free of charge, to any person
* obtaining a copy of this software and associated documentation
* files (the "Software"), to deal in the Software without
* restriction, including without limitation the rights to use,
* copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following
* conditions:
*
* This permission notice shall be included in all copies or
* substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
* OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
* HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
*/
/*************************************************************************************************************
*******************************CLASSES ShiftRegister E ShiftRegisterController********************************
**************************************************************************************************************/
class ShiftRegisterController; //prototipo
class ShiftRegister{
protected:
ShiftRegisterController * _controller;
public:
virtual void shiftOutRegister() ;
};
class ShiftRegisterController {
private:
int _pin_latch;
ShiftRegister * _exp_595;
ShiftRegister * _exp_lc;
public:
ShiftRegisterController(int pin_latch) {
_pin_latch = pin_latch;
pinMode(_pin_latch,OUTPUT);
digitalWrite(_pin_latch, HIGH);
}
void setLedControl(ShiftRegister * lc) { _exp_lc = lc; }
void setExp74HC595(ShiftRegister * exp_595) { _exp_595 = exp_595; }
void shiftOutRegisters() {
if (_exp_595 && _exp_lc){
digitalWrite(_pin_latch, LOW);
_exp_595->shiftOutRegister();
_exp_lc ->shiftOutRegister();
digitalWrite(_pin_latch, HIGH);
}
}
};
/*************************************************************************************************************
***************************FIM CLASSES ShiftRegister E ShiftRegisterController********************************
**************************************************************************************************************/
/*************************************************************************************************************
*******************************EXPANSOR 74HC595***************************************************************
**************************************************************************************************************/
class Expansor74HC595 : public ShiftRegister {
private:
int _pin_clock;
int _pin_data;
int _num_cis;
byte* _pins;
int _auto_send;
public:
Expansor74HC595(int pin_data, int pin_clock, int num_cis, ShiftRegisterController * controller){
_pin_clock = pin_clock;
_pin_data = pin_data;
_num_cis = num_cis;
_auto_send = true;
_pins = new byte[_num_cis];
_controller = controller;
_controller->setExp74HC595(this);
pinMode(_pin_clock,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 shiftOutRegister(){ for(int i=_num_cis-1; i>=0; i--) { shiftOut(_pin_data, _pin_clock, MSBFIRST, readByte(i) ); } };
void send(){
_controller->shiftOutRegisters();
_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(); }
};
};
/*************************************************************************************************************
*******************************FIM 74HC595********************************************************************
**************************************************************************************************************/
/*************************************************************************************************************
*******************************LEDCONTROL ALTERADA************************************************************
**************************************************************************************************************/
//the opcodes for the MAX7221 and MAX7219
#define OP_DECODEMODE 9
#define OP_INTENSITY 10
#define OP_SCANLIMIT 11
#define OP_SHUTDOWN 12
#define OP_DISPLAYTEST 15
class LedControl : public ShiftRegister {
private :
byte spidata[16];
byte * status;
int SPI_MOSI;
int SPI_CLK;
int maxDevices;
int _auto_send;
void spiTransfer(int addr, volatile byte opcode, volatile byte data) {
int offset = addr*2;
int maxbytes = maxDevices*2;
for(int i=0;i<maxbytes;i++) { spidata[i]=(byte)0; }
spidata[offset+1] = opcode;
spidata[offset] = data;
_controller->shiftOutRegisters();
}
public:
void shiftOutRegister(){ for(int i=maxDevices*2;i>0;i--) { shiftOut(SPI_MOSI,SPI_CLK,MSBFIRST,spidata[i-1]); } };
LedControl(int dataPin, int clkPin, int numDevices, ShiftRegisterController * controller) {
_auto_send = true;
SPI_MOSI = dataPin;
SPI_CLK = clkPin;
maxDevices = numDevices;
_controller = controller;
_controller->setLedControl(this);
pinMode(SPI_MOSI, OUTPUT);
pinMode(SPI_CLK, OUTPUT);
status = new byte[maxDevices * 8]; //instancia o array de acordo com a quantia de displays usados
for(int i=0;i<maxDevices * 8 ;i++) { status[i]=0x00; }
}
void begin(){
for(int i=0;i<maxDevices;i++) {
spiTransfer(i, OP_DISPLAYTEST,0);
setScanLimit(i, 7); //scanlimit is set to max on startup
spiTransfer(i, OP_DECODEMODE,0); //decode is done in source
clearDisplay(i);
shutdown(i,true); //we go into shutdown-mode on startup
}
}
void startWrite() { _auto_send = false; };
void send() {
for (int j=0; j<maxDevices; j++) {
int offset = j*8;
for(int i=0;i<8;i++) { spiTransfer(j, i+1, status[offset+i]); }
}
_auto_send = true;
}
int getDeviceCount(){ return maxDevices; }
void shutdown(int addr, bool b){
if(addr<0 || addr>=maxDevices) return;
spiTransfer(addr, OP_SHUTDOWN, b ? 0 : 1);
}
void setScanLimit(int addr, int limit){
if(addr<0 || addr>=maxDevices) return;
if(limit>=0 && limit<8) spiTransfer(addr, OP_SCANLIMIT,limit);
}
void setIntensity(int addr, int intensity) {
if(addr<0 || addr>=maxDevices) { return; }
if(intensity>=0 && intensity<16) { spiTransfer(addr, OP_INTENSITY, intensity); }
}
void clearDisplay(int addr){
if(addr<0 || addr>=maxDevices) return;
int offset = addr*8;
for(int i=0;i<8;i++) {
status[offset+i] = 0;
if (_auto_send) { spiTransfer(addr, i+1, status[offset+i]); }
}
}
void setLed(int addr, int row, int column, boolean state) {
if(addr<0 || addr>=maxDevices) { return; }
if(row<0 || row>7 || column<0 || column>7) { return; }
int offset = addr*8;
byte val = B10000000 >> column;
if(state) { status[offset+row] = status[offset+row] | val; }
else {
val=~val;
status[offset+row] = status[offset+row]&val;
}
if (_auto_send) { spiTransfer(addr, row+1, status[offset+row]); }
}
void setRow(int addr, int row, byte value) {
if(addr<0 || addr>=maxDevices) return;
if(row<0 || row>7) return;
int offset = addr*8;
status[offset+row] = value;
if (_auto_send) {
spiTransfer(addr, row+1, status[offset+row]);
}
}
void setColumn(int addr, int col, byte value) {
if(addr<0 || addr>=maxDevices) return;
if(col<0 || col>7) return;
byte val;
for(int row=0; row<8; row++) {
val=value >> (7-row);
val=val & 0x01;
setLed(addr,row,col,val);
}
}
};
/*************************************************************************************************************
*******************************FIM LEDCONTROL ALTERADA********************************************************
**************************************************************************************************************/
/*
pin 10 is connected to the DataIn
pin 9 is connected to the CLK
pin 8 is connected to LOAD
*/
int const PIN_DATA = 10;
int const PIN_CLK = 9;
int const PIN_LATCH = 8;
int const QUANTIDADE_MAX7219 = 2;
int const QUANTIDADE_74HC595 = 1;
ShiftRegisterController exp_src = ShiftRegisterController(PIN_LATCH);
LedControl exp_lc = LedControl (PIN_DATA,PIN_CLK,QUANTIDADE_MAX7219, &exp_src);
Expansor74HC595 exp_595 = Expansor74HC595(PIN_DATA,PIN_CLK,QUANTIDADE_74HC595 , &exp_src);
const int LINHAS = 8;
const int COLUNAS = 16;
int cont=0;
void update_displays() {
exp_lc.startWrite();
for (int lin=0; lin<8; lin++) {
for (int col=0; col<16; col++) {
for (int i=0; i<2; i++) {
int l = lin;
int c = col - (i*8);
if (l>=0 && l<=7 && c>=0 && c<=7) {
exp_lc.setLed(i, l, c, (l+c+cont)%2 );
}
}
}
}
cont++;
exp_lc.send();
}
void setup() {
//Serial.begin(9600);
exp_lc.begin();
exp_lc.shutdown(0,false);
exp_lc.setIntensity(0,8);
exp_lc.clearDisplay(0);
exp_lc.shutdown(1,false);
exp_lc.setIntensity(1,8);
exp_lc.clearDisplay(1);
}
void loop() {
for (byte b=0; b<=255; b++) { //i=0-> B00000000 i=255-> B11111111
exp_595.startWrite();
exp_595.writeByte(0, b, LSBFIRST);
exp_595.send();
update_displays();
delay(500);
}
}
Código-fonte Attiny85:
/*
Criado em 04/10/2015
Por:
Fabiano A. Arndt
http://www.youtube.com/fabianoallex
http://fabianoallex.blogspot.com.br
fabianoallex@gmail.com
*/
/*
* LedControl.h / LedControl.cpp - A library for controling Leds with a MAX7219/MAX7221
* Copyright (c) 2007 Eberhard Fahle
*
* Permission is hereby granted, free of charge, to any person
* obtaining a copy of this software and associated documentation
* files (the "Software"), to deal in the Software without
* restriction, including without limitation the rights to use,
* copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following
* conditions:
*
* This permission notice shall be included in all copies or
* substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
* OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
* HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
*/
/*************************************************************************************************************
*******************************CLASSES ShiftRegister E ShiftRegisterController********************************
**************************************************************************************************************/
class ShiftRegisterController; //prototipo
class ShiftRegister{
protected:
ShiftRegisterController * _controller;
public:
virtual void shiftOutRegister() ;
};
class ShiftRegisterController {
private:
int _pin_latch;
ShiftRegister * _exp_595;
ShiftRegister * _exp_lc;
public:
ShiftRegisterController(int pin_latch) {
_pin_latch = pin_latch;
pinMode(_pin_latch,OUTPUT);
digitalWrite(_pin_latch, HIGH);
}
void setLedControl(ShiftRegister * lc) { _exp_lc = lc; }
void setExp74HC595(ShiftRegister * exp_595) { _exp_595 = exp_595; }
void shiftOutRegisters() {
if (_exp_595 && _exp_lc){
digitalWrite(_pin_latch, LOW);
_exp_595->shiftOutRegister();
_exp_lc ->shiftOutRegister();
digitalWrite(_pin_latch, HIGH);
}
}
};
/*************************************************************************************************************
***************************FIM CLASSES ShiftRegister E ShiftRegisterController********************************
**************************************************************************************************************/
/*************************************************************************************************************
*******************************EXPANSOR 74HC595***************************************************************
**************************************************************************************************************/
class Expansor74HC595 : public ShiftRegister {
private:
int _pin_clock;
int _pin_data;
int _num_cis;
byte* _pins;
int _auto_send;
public:
Expansor74HC595(int pin_data, int pin_clock, int num_cis, ShiftRegisterController * controller){
_pin_clock = pin_clock;
_pin_data = pin_data;
_num_cis = num_cis;
_auto_send = true;
_pins = new byte[_num_cis];
_controller = controller;
_controller->setExp74HC595(this);
pinMode(_pin_clock,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 shiftOutRegister(){ for(int i=_num_cis-1; i>=0; i--) { shiftOut(_pin_data, _pin_clock, MSBFIRST, readByte(i) ); } };
void send(){
_controller->shiftOutRegisters();
_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(); }
};
};
/*************************************************************************************************************
*******************************FIM 74HC595********************************************************************
**************************************************************************************************************/
/*************************************************************************************************************
*******************************LEDCONTROL ALTERADA************************************************************
**************************************************************************************************************/
//the opcodes for the MAX7221 and MAX7219
#define OP_DECODEMODE 9
#define OP_INTENSITY 10
#define OP_SCANLIMIT 11
#define OP_SHUTDOWN 12
#define OP_DISPLAYTEST 15
class LedControl : public ShiftRegister {
private :
byte spidata[16];
byte * status;
int SPI_MOSI;
int SPI_CLK;
int maxDevices;
int _auto_send;
void spiTransfer(int addr, volatile byte opcode, volatile byte data) {
int offset = addr*2;
int maxbytes = maxDevices*2;
for(int i=0;i<maxbytes;i++) { spidata[i]=(byte)0; }
spidata[offset+1] = opcode;
spidata[offset] = data;
_controller->shiftOutRegisters();
}
public:
void shiftOutRegister(){ for(int i=maxDevices*2;i>0;i--) { shiftOut(SPI_MOSI,SPI_CLK,MSBFIRST,spidata[i-1]); } };
LedControl(int dataPin, int clkPin, int numDevices, ShiftRegisterController * controller) {
_auto_send = true;
SPI_MOSI = dataPin;
SPI_CLK = clkPin;
maxDevices = numDevices;
_controller = controller;
_controller->setLedControl(this);
pinMode(SPI_MOSI, OUTPUT);
pinMode(SPI_CLK, OUTPUT);
status = new byte[maxDevices * 8]; //instancia o array de acordo com a quantia de displays usados
for(int i=0;i<maxDevices * 8 ;i++) { status[i]=0x00; }
}
void begin(){
for(int i=0;i<maxDevices;i++) {
spiTransfer(i, OP_DISPLAYTEST,0);
setScanLimit(i, 7); //scanlimit is set to max on startup
spiTransfer(i, OP_DECODEMODE,0); //decode is done in source
clearDisplay(i);
shutdown(i,true); //we go into shutdown-mode on startup
}
}
void startWrite() { _auto_send = false; };
void send() {
for (int j=0; j<maxDevices; j++) {
int offset = j*8;
for(int i=0;i<8;i++) { spiTransfer(j, i+1, status[offset+i]); }
}
_auto_send = true;
}
int getDeviceCount(){ return maxDevices; }
void shutdown(int addr, bool b){
if(addr<0 || addr>=maxDevices) return;
spiTransfer(addr, OP_SHUTDOWN, b ? 0 : 1);
}
void setScanLimit(int addr, int limit){
if(addr<0 || addr>=maxDevices) return;
if(limit>=0 && limit<8) spiTransfer(addr, OP_SCANLIMIT,limit);
}
void setIntensity(int addr, int intensity) {
if(addr<0 || addr>=maxDevices) { return; }
if(intensity>=0 && intensity<16) { spiTransfer(addr, OP_INTENSITY, intensity); }
}
void clearDisplay(int addr){
if(addr<0 || addr>=maxDevices) return;
int offset = addr*8;
for(int i=0;i<8;i++) {
status[offset+i] = 0;
if (_auto_send) { spiTransfer(addr, i+1, status[offset+i]); }
}
}
void setLed(int addr, int row, int column, boolean state) {
if(addr<0 || addr>=maxDevices) { return; }
if(row<0 || row>7 || column<0 || column>7) { return; }
int offset = addr*8;
byte val = B10000000 >> column;
if(state) { status[offset+row] = status[offset+row] | val; }
else {
val=~val;
status[offset+row] = status[offset+row]&val;
}
if (_auto_send) { spiTransfer(addr, row+1, status[offset+row]); }
}
void setRow(int addr, int row, byte value) {
if(addr<0 || addr>=maxDevices) return;
if(row<0 || row>7) return;
int offset = addr*8;
status[offset+row] = value;
if (_auto_send) {
spiTransfer(addr, row+1, status[offset+row]);
}
}
void setColumn(int addr, int col, byte value) {
if(addr<0 || addr>=maxDevices) return;
if(col<0 || col>7) return;
byte val;
for(int row=0; row<8; row++) {
val=value >> (7-row);
val=val & 0x01;
setLed(addr,row,col,val);
}
}
};
/*************************************************************************************************************
*******************************FIM LEDCONTROL ALTERADA********************************************************
**************************************************************************************************************/
/*
pin 2 is connected to the DataIn
pin 1 is connected to the CLK
pin 0 is connected to LOAD
*/
int const PIN_DATA = 2;
int const PIN_CLK = 1;
int const PIN_LATCH = 0;
int const QUANTIDADE_MAX7219 = 2;
int const QUANTIDADE_74HC595 = 1;
ShiftRegisterController exp_src = ShiftRegisterController(PIN_LATCH);
LedControl exp_lc = LedControl (PIN_DATA,PIN_CLK,QUANTIDADE_MAX7219, &exp_src);
Expansor74HC595 exp_595 = Expansor74HC595(PIN_DATA,PIN_CLK,QUANTIDADE_74HC595, &exp_src);
const int LINHAS = 8;
const int COLUNAS = 16;
int cont=0;
void update_displays() {
exp_lc.startWrite();
for (int lin=0; lin<8; lin++) {
for (int col=0; col<16; col++) {
for (int i=0; i<2; i++) {
int l = lin;
int c = col - (i*8);
if (l>=0 && l<=7 && c>=0 && c<=7) {
exp_lc.setLed(i, l, c, (l+c+cont)%2 );
}
}
}
}
cont++;
exp_lc.send();
}
void setup() {
//Serial.begin(9600);
exp_lc.begin();
exp_lc.shutdown(0,false);
exp_lc.setIntensity(0,8);
exp_lc.clearDisplay(0);
exp_lc.shutdown(1,false);
exp_lc.setIntensity(1,8);
exp_lc.clearDisplay(1);
}
void loop() {
for (byte b=0; b<=255; b++) { //i=0-> B00000000 i=255-> B11111111
exp_595.startWrite();
exp_595.writeByte(0, b, LSBFIRST);
exp_595.send();
update_displays();
delay(500);
}
}
Nesse fim de semana peguei uma impressora velha, uma HP Deskjet F4280 e tentei ver o que dava pra fazer com o display. Analisando os componentes que haviam na placa, identifiquei 3 registradores de deslocamento 595 - clique para ver o datasheet - (expansores de saídas) e 1 165 - clique para ver o datasheet - (expansor de entrada). Essa placa se comunicava com outra placa, através de um cabo flat através de 7 vias. Com ajuda de um multímetro identifiquei onde cada uma das vias estava chegando no circuito:
1 - pino 11 do 595 (SH_CP) e pino 2 do 165 (CLOCK)
2 - gnd
3 - pino 9 do 165 (QH)
4 - pino 14 do 595 (DS)
5 - vcc
6 - pino 12 do 595 (ST_CP) e pino 1 do 165 (LOAD)
7 - botão on/off - ligado diretamente
Com os pinos identificados, cortei com um tesoura um das extremidades do cabo flat e separei cada uma das trilhas. Com as pontas separadas, queimei o plástico que fica em volta do cabo flat para que apenas a trilha ficasse exposta, depois com um bombril removi os resíduos de plástico queimado dos terminais. Depois soldei essas trilhas em uma pequena placa, de modo que fosse possível conecta-las com o arduino através de jumpers.
--vou colocar uma foto de como foi feito
conforme as trilhas identificadas e numeradas acima, fiz a seguinte ligações no arduino:
1 --> arduino : pino 8
2 --> arduino : gnd
3 --> arduino : pino 2
4 --> arduino : pino 9
5 --> arduino : vcc
6 --> arduino : pino 10
7 --> arduino : não utilizado nesse exemplo. mas poderia ser ligado como qualquer pino e configura-lo como entrada
O próximo passo foi identificar como cada botão e cada led estavam sendo controlados. Os botões são controlados pelo único 165, e ao lado de cada botão (na cor preta) mostro qual o bit que é usado para representá-lo. Os outros 3 595 estão ligados em cascata, e têm suas saídas ligadas nos leds conforme numerados abaixo. O primeiro 595 está na cor Azul, o segundo na cor Vermelha e o terceira na Cor Verde.
Com tudo identificado, o próximo passo foi fazer a programação, pra isso aproveitei uma classe que eu já havia criado pra se comunicar com os registradores 595 e 165 juntos (veja o artigo aqui). Porém, o esquema desse display, não está exatamente da forma que mostrei no artigo citado, mas ainda assim deu pra aproveitar a classe, apenas fazendo algumas modificações. A principal delas, foi que quando é enviado HIGH para acionar um led, os leds são apagados.
Código-fonte:
/*
Criado em 27/09/2015
Por:
Fabiano A. Arndt
http://www.youtube.com/fabianoallex
http://fabianoallex.blogspot.com.br
fabianoallex@gmail.com
*/
/********************************************************************************************
*******************CLASSE Expansor74HC595_74HC165 INICIO*********************************
*********************************************************************************************/
class Expansor74HC595_74HC165 {
private:
int _pin_clock;
int _pin_latch;
int _pin_data;
byte* _pins_out;
byte* _pins_in;
int _num_cis_out;
int _num_cis_in;
public:
Expansor74HC595_74HC165(int pin_clock, int pin_latch, int pin_data, int num_cis_out, int num_cis_in){
_pin_clock = pin_clock;
_pin_latch = pin_latch;
_pin_data = pin_data;
_num_cis_out = num_cis_out;
_num_cis_in = num_cis_in;
_pins_out = new byte[num_cis_out];
_pins_in = new byte[num_cis_in];
pinMode(_pin_clock,OUTPUT);
pinMode(_pin_latch,OUTPUT);
clear();
}
void clear(){
for (int i=0; i<_num_cis_out; i++){ _pins_out[i] = B11111111; }
update();
}
void update(){
digitalWrite(_pin_clock, LOW);
digitalWrite(_pin_latch, LOW);
digitalWrite(_pin_latch, HIGH);
for(int i=max(_num_cis_in, _num_cis_out) * 8 - 1; i>=0; i-- ) { //max -->o for vai até o que tiver mais, ou entradas, ou saidas
int pos = i / 8;
int pin = 7-(i % 8);
if (i < _num_cis_in * 8){
pinMode(2, INPUT);
if ( digitalRead(2) ){
_pins_in[pos] |= (1 << pin); //set a bit HIGH
} else {
_pins_in[pos] &= ~(1 << pin); //set a bit LOW
}
}
if (i < _num_cis_out * 8){
pinMode(_pin_data, OUTPUT);
digitalWrite(_pin_data, (_pins_out[pos] & (1 << pin)) != 0 );
}
digitalWrite(_pin_clock, HIGH);
digitalWrite(_pin_clock, LOW);
}
digitalWrite(_pin_latch, LOW);
digitalWrite(_pin_latch, HIGH);
//pinMode(_pin_data, INPUT); //removido
}
int read(int pin){
int pos = pin / 8;
pin = 7-(pin % 8);
if (pos > _num_cis_out) {
pos = pos - _num_cis_out;
return ( (_pins_in[pos] & (1 << pin)) != 0 );
} else {
return ( (_pins_out[pos] & (1 << pin)) != 0 );
}
}
byte readByte(int num_ci) {
if (num_ci >= _num_cis_out) {
num_ci = num_ci - _num_cis_out;
return _pins_in[num_ci];
} else {
return _pins_out[num_ci];
}
}
void write(int pin, int value){
if (pin >= _num_cis_out*8) { return; }
int pos = pin / 8; //pos -> indica qual ci será atualizado.
pin = 7-(pin % 8);
if (pos > _num_cis_out) {
return; //se estiver tentando escrever um pino de entrada, apenas retorna, sem fazer nada.
} else {
if (value){
_pins_out[pos] |= (1 << pin); //set a bit HIGH
} else {
_pins_out[pos] &= ~(1 << pin); //set a bit LOW
}
}
}
void writeByte(int num_ci, byte b, int first = MSBFIRST) {
if (num_ci > _num_cis_out) {
return; //se estiver tentando escrever um pino de entrada, apenas retorna, sem fazer nada.
}
if (first == LSBFIRST) {
byte r=0;
for(int i=0;i<8;i++) {
r |= ((b>>i) & 0b1)<<(7-i);
}
b = r;
}
_pins_out[num_ci] = b;
} ;
};
/********************************************************************************************
*******************CLASSE Expansor74HC595_74HC165 FIM ***********************************
*********************************************************************************************/
const int PIN_CLOCK = 8;
const int PIN_LATCH = 10;
const int PIN_DATA_595 = 9;
const int PIN_DATA_165 = 2;
Expansor74HC595_74HC165 * exp1; //controla as saídas
Expansor74HC595_74HC165 * exp2; //controla as entradas
void setup() {
exp1 = new Expansor74HC595_74HC165(PIN_CLOCK, PIN_LATCH, PIN_DATA_595, 3, 0);
exp2 = new Expansor74HC595_74HC165(PIN_CLOCK, PIN_LATCH, PIN_DATA_165, 0, 3);
exp1->writeByte(0, B11111111);
exp1->writeByte(1, B11111111);
exp1->writeByte(2, B11111111);
Serial.begin(9600);
}
byte digitos[] = {
B01000000,
B01011110,
B00100100,
B00001100,
B00011010,
B10001000,
B10000000,
B01011100,
B00000000,
B00001000,
B00010000,
B10000010,
B11100000,
B00000110,
B10100000,
B10110000
};
byte leds[] = {20, 21, 22, 23, 4, 19, 18, 17, 16, 5};
unsigned int dig=0;
unsigned int opt=0;
unsigned int led=0;
void loop() {
exp2->update(); //primeiro verifica o estado dos botões
if (!exp2->read(5+16)) { exp1->write(15, !exp1->read(15)); }
if (!exp2->read(2+16)) { exp1->write(6, !exp1->read(6)); }
if (!exp2->read(0+16)) { dig++; }
if (!exp2->read(4+16)) { dig--; }
byte temp = exp1->read(15);
exp1->writeByte(1, digitos[dig%16]);
exp1->write(15, temp);
if (!exp2->read(6+16)) { opt++; }
exp1->write(1, opt%3+1==1);
exp1->write(2, opt%3+1==2);
exp1->write(3, opt%3+1==3);
if (!exp2->read(3+16)) {
for (int i=0; i<10; i++){
exp1->write(leds[i], led%10!=i);
}
led++;
}
exp1->update(); //agora envia o estado dos leds
Serial.println(exp1->readByte(0), BIN); //LE O PRIMEIRO CI (595)
Serial.println(exp1->readByte(1), BIN); //LE O SEGUNDO CI (595)
Serial.println(exp1->readByte(2), BIN); //LE O TERCEIRO CI (165)
Serial.println(exp2->readByte(2), BIN); //LE O QUARTO CI (165)
Serial.println("");
delay(100);
}
Como sabemos arrays são estruturas de dados utilizados para armazenar dados de um mesmo tipo em sequência. A sintaxe utilizada para a declaração de um array é a seguinte:
type nome_do_array [ tamanho ];
por exemplo,
int valores[10] = {1, 3, 2, 5, 6, 4, 8, 9, 7, 0};
É muito comum termos a necessidade de utilizarmos arrays para representar conjunto de dados como os listados acima.
Os tipos de dados a serem armazenados podem ser qualquer tipo de dado aceito em C.
boolean
char
unsigned char
byte
int
unsigned int
word
long
unsigned long
short
float
double
string - char array
String - object
Cada um dos tipos de dados tem um determinado tamanho que terá quer ser reservado na memória ao ser declarado um array. Um int, por exemplo, ocupa dois bytes de memória, um char ocupa um byte, um long ocupa 4 bytes.
Mas se tratando de programação para micro controladores, algo importante na hora de declarar um array, é escolhermos o tipo de dados mais adequado para armazenarmos os dados pretendidos. Por exemplo, se eu pretendo ter um array de números inteiros, mas os valores armazenados não ultrapassam o valor de 255, poderia utilizar um tipo de dados que não ocupasse mais de um byte, como word, ou byte. Caso contrário, teria que ser utilizado outro tipo, como int, ou ainda long. A escolha de cada um desses tipos de dados resulta em maiores ou menores quantidades de memória utilizadas. Em aplicações pequenas, talvez isso não faça diferença, mas algumas situações acaba fazendo.
Uma situação especial, e bastante comum, é necessitarmos armazenar arrays com informações binárias, ou seja, valor do tipo 1 ou 0. ou true ou false, ou HIGH ou LOW. enfim, apenas dois valores distintos podem ser armazenados em cada posição.
Um exemplo comum, seria por exemplo criar um array pra controlar o estado de um conjunto de lâmpadas, onde elas podem estar ou ligadas ou desligadas.
Vamos supor que fossem 20 lampadas.
Uma maneira fácil seria criar um array assim:
int lampadas[20] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
Mas será que essa é a melhor forma de declarar esse array?
Como sabemos, int ocupa dois bytes. Multiplicado por 20, totalizaria 40 bytes.
Mas e se quisermos diminuir ainda mais? Nesse caso teríamos que ter um tipo de dados que ocupasse menos de um byte, mas isso infelizmente a linguagem C não nos oferece, mas ainda assim há um jeito de diminuirmos.
Como sabemos, 1 byte é formado por 8 bits. E cada bit pode assumir apenas dois estados, ou seja, 1 ou 0. Uma saída então, seria utilizar 1 byte, pra controlar 8 lâmpadas. Com isso precisaríamos ter 20 / 8 (2.5 --> 3) bytes para representar os estados das 20 lâmpadas. ou seja, algo assim:
byte lampadas[3]; //24 bits disponíveis
O que totalizaria apenas 3 bytes de memória para gerenciar o estado de 20 lâmpadas.
Sem dúvida essa é uma estratégia bem útil quando temos limitações de memória importante, o que é bem comum quando se trata de micro controladores.
Mas como tudo tem seu preço, teremos agora que criarmos meios de alterarmos bit a bit de cada um dos bytes e para isso precisaremos utilizar operadores de bitwise.
Já fiz um vídeo explicando como funcionam operadores de bitwise, quem não conhece, vale muito a pena aprender.
Pra facilitar o uso desses recursos, criei uma classe que encapsula toda essa parte "complicada", a qual está abaixo:
class BitArray{
private:
int _num_bits; //quantidade de bits a serem gerenciados
int _num_bytes; //quantidade de bytes utilizados para armazenar os bits a serem gerenciados
byte * _bytes; //array de bytes onde estaram armazenados os bits
public:
BitArray(int num_bits){
_num_bits = num_bits;
_num_bytes = _num_bits/8 + (_num_bits%8 ? 1 : 0) + 1;
_bytes = (byte *)(malloc( _num_bytes * sizeof(byte) ) );
}
void write(int index, byte value) {
byte b = _bytes[ index/8 + (index%8 ? 1 : 0) ];
unsigned int bit = index%8;
if (value) { b |= (1 << bit); } else { b &= ~(1 << bit); }
_bytes[ index/8 + (index%8 ? 1 : 0) ] = b;
}
void write(byte value) {
for(int j=0; j<_num_bytes;j++) { _bytes[j] = value ? B11111111 : B00000000; }
}
int read(int index) {
byte b = _bytes[ index/8 + (index%8 ? 1 : 0) ];
unsigned int bit = index%8;
return (b & (1 << bit)) != 0;
}
~BitArray(){ free( _bytes ); }
};
Com isso, agora não iremos ter um array, mas sim um objeto, o qual poderá ser utilizado da seguinte maneira:
BitArray lampadas(20); //instancia do objeto com 20 bits
E para alterarmos uma das lâmpadas, fazemos da seguinte maneira:
lampadas.write(0, HIGH); //liga a primeira lampada
lampadas.write(1, HIGH); //liga a segunda lampada
if ( lampadas.read(0) ) { Serial.println("a primeira lampada está ligada."); } //verifica o estado da lampada.
Com isso conseguimos ter o menor consumo de memória, sem termos grandes dificuldades na parte de programação.
versão bidimensional :
class BitArray2D {
private:
unsigned int _rows;
unsigned int _columns;
unsigned int _cols_array; //pra cada 8 colunas, 1 byte é usado
byte** _bits;
public:
BitArray2D(unsigned int rows, unsigned int columns){
_rows = rows;
_columns = columns;
_cols_array = columns/8 + (_columns%8 ? 1 : 0) + 1; //divide por 8 o número de colunas
_bits = (byte **)malloc(_rows * sizeof(byte *));
for(int i=0;i<_rows;i++){ _bits[i] = (byte *)malloc( _cols_array * sizeof(byte)); } //cria varios arrays
clear();
}
unsigned int rows(){ return _rows; }
unsigned int columns(){ return _columns; }
void clear() {
for(int i=0;i<_rows;i++){
for(int j=0; j<_cols_array;j++) { _bits[i][j] = B00000000; }
}
}
void write(unsigned int row, unsigned int column, int value){
byte b = _bits[row][ column/8 + (column%8 ? 1 : 0) ];
unsigned int bit = column%8;
if (value) { b |= (1 << bit); } else { b &= ~(1 << bit); }
_bits[row][ column/8 + (column%8 ? 1 : 0) ] = b;
}
void write(byte value){
for(int i=0;i<_rows;i++){
for(int j=0; j<_cols_array;j++) {
_bits[i][j] = value ? B11111111 : B00000000;
}
}
}
int read(unsigned int row, unsigned int column){
byte b = _bits[row][ column/8 + (column%8 ? 1 : 0) ];
unsigned int bit = column%8;
return (b & (1 << bit)) != 0;
}
void toggle(unsigned int row, unsigned int column){ write(row, column, !read(row, column)); }
void toggle(){ for(int i=0;i<_rows;i++){ for(int j=0; j<_columns;j++) { toggle(i,j); } } }
};
