Publicidade:

quarta-feira, 4 de maio de 2016

Arduino - Luminária com efeito fade-in

Projeto de uma luminária com efeito fade-in para 3 lâmpadas.

vídeo:

código-fonte:


/**********************************************************************************
************************************CLASSE UNIQUE RANDOM***************************
**********************************************************************************/
class UniqueRandom{
  private:
    int _index;
    int _min;
    int _max;
    int _size;
    int* _list;
    void _init(int min, int max) {
      _list = 0; 
      if (min < max) { _min = min; _max = max; } else { _min = max; _max = min; }
      _size = _max - _min; 
      _index = 0;
    }    
  public:
    UniqueRandom(int max)           { _init(0,   max); randomize(); } //construtor com 1 parametro
    UniqueRandom(int min, int max)  { _init(min, max); randomize(); } //construtor com 2 parametros
     
    void randomize() {
      if (_list == 0) { _list = (int*) malloc(size() * sizeof(int)); }  
      for (int i=0; i<size(); i++) {   _list[i] = _min+i;  }   //preenche a lista do menor ao maior valor
       
      //embaralha a lista
      for (int i=0; i<size(); i++) {  
        int r = random(0, size());     //sorteia uma posição qualquer
        int aux = _list[i];               
        _list[i] = _list[r];
        _list[r] = aux;
      }
    }
     
    int next() {                                  //retorna o proximo numero da lista
      int n = _list[_index++];
      if (_index >= size() ) { _index = 0;} //após recuper o ultimo numero, recomeça na posicao 0
      return n;
    }
     
    int size() { return _size; }
     
    ~UniqueRandom(){ free ( _list ); }  //destrutor
};
/**********************************************************************************
************************************FIM CLASSE UNIQUE RANDOM***********************
**********************************************************************************/

const int pins_pwm[] = {9, 10, 11};
const int num_pins = 3;

UniqueRandom ur(0, 3); //declaracao do objeto unique random

void setup() {
  for (int i=0;i<num_pins;i++){ pinMode(pins_pwm[i], OUTPUT); }
  
  randomSeed(analogRead(0));
  ur.randomize();
  
  efeito_02(random(14+3));
}


void efeito_02(int d){
  for (int i=0;i<num_pins;i++){
    efeito_02_on(pins_pwm[ur.next()], d);
  }
}

void efeito_02_on(int pin, int d){
  for (int i=0; i<256;i++ ){
    analogWrite(pin, i);
    delay(d);
    
    if (i<=50) { i++; }
    if (i>50) { i +=4; }
    if (i>185) { i +=8; }
  }
  analogWrite(pin, 255);
}

void loop() {}

Fade-Off

Nesse segundo vídeo, mostro uma ideia de como fazer o contrário, efeito de fade-off, ou seja, desligar as lâmpadas gradualmente.


terça-feira, 12 de abril de 2016

Arduino - Memória EEPROM - AT24C256

Essa semana postei um artigo no site sistemas embarcados. O Assunto foi memória EEPROM, interna e externa. No caso da memória externa foi abordado o CI AT24C256. Segue o link para o artigo completo: http://www.sistemasembarcados.org/2016/04/arduino-memoria-eeprom.html

Veja também o vídeo sobre o AT24C256.



Veja também o vídeo que mostra a classe feita para facilitar a gravação e leitura da memória:



Código-fonte:

/*
Baseado nos exemplos abaixo:
http://hobbytronics.co.uk/eeprom-page-write
http://playground.arduino.cc/Code/EEPROMWriteAnything

Fabiano A. Arndt
www.youtube.com/fabianoallex
www.facebook.com/dicasarduino
*/

#include <Wire.h>

/*************************************************************************************************************
*******************************CLASSE EE24CXXX - CI I2C EEPROM AT24C128/256***********************************
**************************************************************************************************************/
class EE24CXXX {
  private:
    byte _device_address;
  public:
    EE24CXXX(byte device_address){ _device_address = device_address; }
    void write(unsigned int eeaddress, unsigned char * data, unsigned int data_len);
    void read (unsigned int eeaddress, unsigned char * data, unsigned int data_len);
    
    template <class T> int write(unsigned int eeaddress, const T& value);
    template <class T> int read(unsigned int eeaddress, T& value);
};

void EE24CXXX::write(unsigned int eeaddress, unsigned char * data, unsigned int data_len) {
  unsigned int  address;
  unsigned int  page_space;
  unsigned int  page=0;
  unsigned int  num_writes;
  unsigned char first_write_size;
  unsigned char last_write_size;  
  unsigned char write_size;  
  
  page_space = int(((eeaddress/64) + 1)*64)-eeaddress;      // Calculate space available in first page

  if (page_space>16) {                                      // Calculate first write size
     first_write_size = page_space-((page_space/16)*16);
     if (first_write_size==0) { first_write_size=16; }
  } else {
    first_write_size = page_space; 
  }
  if (data_len>first_write_size)  { last_write_size = (data_len-first_write_size)%16;   }      // calculate size of last write  
  num_writes = (data_len>first_write_size) ? ((data_len-first_write_size)/16)+2 : 1;           // Calculate how many writes we need
     
  unsigned char i=0, counter=0;
  address = eeaddress;
  for (page=0; page<num_writes; page++)  {
    if (page == 0) { 
      write_size = first_write_size; 
    } else if(page == (num_writes-1)) { 
      write_size = last_write_size;
    } else { 
      write_size = 16;
    }
 
    Wire.beginTransmission(_device_address);
    Wire.write((int)((address) >> 8));   // MSB
    Wire.write((int)((address) & 0xFF)); // LSB
    counter = 0;
    do { 
      Wire.write((byte) data[i++]);
      counter++;
    } while(counter<write_size);
    Wire.endTransmission();
    address += write_size;   // Increment address for next write
     
    delay(5);  // needs 5ms for page write
  }
}

void EE24CXXX::read(unsigned int eeaddress, unsigned char * data, unsigned int data_len){
  unsigned char i = 0;
  unsigned int size = data_len;
  unsigned int j=0;
  while (size > 0){
    Wire.beginTransmission(_device_address);
    eeaddress += j*28;
    
    Wire.write((int)(eeaddress >> 8));   // MSB
    Wire.write((int)(eeaddress & 0xFF)); // LSB
    Wire.endTransmission();
    
    if (size >= 28) { 
      Wire.requestFrom(_device_address, (unsigned int) 28);
      size -= 28;
    } else {
      Wire.requestFrom(_device_address, (unsigned int) size);
      size = 0;
    }
    while(Wire.available()) { data[i++] = Wire.read(); }
    j++;
  }
}

template <class T> int EE24CXXX::write(unsigned int eeaddress, const T& value) {
  const byte* p = (const byte*)(const void*)&value;
  unsigned char data[sizeof(value)+1];
  for (int i=0; i<sizeof(value); i++) { data[i] = *p++; }
  data[sizeof(value)] = '\n';
  write(eeaddress, data, sizeof(value));
  return sizeof(value);
}

template <class T> int EE24CXXX::read(unsigned int eeaddress, T& value) {
  byte * p = (byte*)(void*)&value;
  unsigned char c[sizeof(value)];
  read(eeaddress, c, sizeof(value));
  for (int i=0; i<sizeof(value); i++) { *p++ = c[i]; }
  return sizeof(value);
}
/*************************************************************************************************************
*******************************FIM - CLASSE EE24CXXX - CI I2C EEPROM AT24C128/256*****************************
**************************************************************************************************************/

EE24CXXX m(0x50);

struct teste{
  int a;
  int b;
  int c;
};

void setup() {
  Serial.begin(9600);
  Wire.begin();  
  
  char i[] = {"1234567890"};
  char j[10];

  m.write(18522, i);              //grava na memória a quantidade de bytes ocupada pelo tipo de dados passado
  
  int count = m.read(18522, j);   //carrega da memória a quantidade de bytes 
  
  Serial.print("Quant: ");
  Serial.println(count);
  Serial.print("Valor: ");
  Serial.println(j);
}

void loop() { }


sexta-feira, 8 de abril de 2016

Arduino - Série de vídeos sobre montagens de CIs

Comecei há alguns dias uma série de vídeos rápidos sobre montagens de CIs. Conforme foram sendo feitos, essa lista aqui vai sendo atualizada. Inscreva-se no Canal para acompanhar todos os vídeos.


















Arduino - Instalação de driver para Nano V3 (CH340G) no win7

Faz um tempo já que comprei alguns Arduinos Nano, mas acabaram ficando um bom tempo guardado. Hoje resolvi utilizá-los (tentar) e tive algumas dificuldades para tentar instalar os drivers corretos no windows 7. Vários artigos explicam como fazer, mas não obtive sucesso com nenhum.

Depois de muito tentar, resolvi procurar os drivers do próprio CI (CH340G, da foto abaixo) que veio com o Arduino Nano que comprei, e encontrei um vídeo, que através do qual consegui resolver o problema. E como dor de barriga não dá uma vez só, resolve criar esse pequeno artigo, pra caso eu venha precisar novamente, eu ter os passos necessários, e claro, para também compartilhar com quem encontrou o mesmo problema.


Vídeo que explica o procedimento:


o arquivo citado no vídeo, encontra-se nesse link: http://www.mediafire.com/download/c9pyi2u7g93iqt6/CH341SER.ZIP

ou se preferirem, aqui no blog mesmo:

https://drive.google.com/file/d/0B9ZzXhiNwNSrMW1KNEUxajZYUjg/view?usp=sharing

de resto, só seguir os passos mostrado no vídeo, apesar de não ser português nem inglês, tem como acompanhar.