Eletronica - Divisor de Tensão

Divisor de tensão

Basicamente um divisor de tensão é algo parecido com o circuito abaixo:


          R1           R2
Vin-----/\/\/\---+---/\/\/\-----GND
                 |
                 |
               Vout


A tensão obtida em Vout será dada pela seguinte fórmula:

Vout = R2 / (R1+R2) * Vin

É comum precisarmos utilizar divisões de tensão pra reduzir a tensão de 5V para 3.3V. Isso significa que precisamos ter um Vout de 2/3 de Vin. Há várias combinações de resistores comerciais que se aproximam desses valores, como por exemplo, um resitor de 10 Kohms para R1 e um de 20 Kohms para R2, ou um resistor de 330 ohms para R1 e 680 ohms para R2. Ou ainda diversos outros resistores que tem uma mesma relação aproximada de 2/3 entre eles.

Mas caso você não tenha em mãos os resistores com os valores corretos para ter essa redução, uma solução bem simples, é utilizar 3 resistores de mesmo valor (o valor não importa, o importante é que os 3 sejam exatamente o mesmo valor).

Tendo os 3 resistores iguais, basta combiná-los na forma de um dos dois circuitos abaixo, que a tensão de saída obtida será sempre dada pela fórmula abaixo:

Vout = 2/3 Vin.

como exemplo, imaginemos uma entrada de 5V

 2/3 * 5V ==> 3.33V


(1)
          R            R         R
Vin-----/\/\/\---+---/\/\/\----/\/\/\-----GND
                 |
                 |
               Vout

OU

(2)

          R

     +--/\/\/\--+   

     |    R     |         R
Vin--+--/\/\/\--+---+---/\/\/\-----GND
                    |
                    |
                  Vout

Pra ficar um pouco mais claro, matematicamente falando, vamos analisar a fórmula inicial do cálculo do divisor de tensão, que é:


Vout = R2 / (R1+R2) * Vin

Considerando, 3 Resistores de valores R, teríamos o seguinte para o circuito (1):

Como temos dois resistores em Série no lugar de R2, devemos somar os dois resistores, que será 2R.


Vout = R2 / (R1+R2) * Vin
Vout = 2R / (2R + R) * Vin
Vout = 2R / 3R * Vin

como R/R é igual a 1, podemos cortar os dois R
e como resultados teremos:

Vout = 2/3 * Vin
ou
Vout = 0.66666 * Vin

Ou seja, nossa fórmula não irá depender do valor de R, bastando apenas que ele seja diferente de zero.


no circuito (2) temos no lugar de R1, dois resistores de valor R em paralelo. Como sabemos, quando dois resistores de mesmo valor estão em séries, sua resistencia equivalente, é o valor de R divido por 2. ou seja, a metade do valor. nesse caso, a fórmula ficara da seguinte maneira:

Vout = R2 / (R1+R2) * Vin
Vout = R  / (R + R/2)  * Vin
Vout = R / (R + 0.5 R) * Vin
Vout = R / 1.5 R * Vin

como R/R é igual a 1, podemos cortar os dois R
e como resultados teremos:

Vout = 1/1.5 * Vin
Vout = 0.6666 * Vin

Como vemos, temos o mesmo resultado que o circuito (1)

Oracle SQL - Comandos SQL para Oracle

Os vídeos mostrados aqui são parte de uma série de vídeos voltadas a apresentar os comandos SQL do oracle para iniciantes ou pessoas com pouca experiência com banco de dados.

A intenção não é entrar em muitos detalhes, apenas dar uma ideia geral de forma rápida sobre os comandos apresentados. Alguns dos comandos apresentados aqui, podem exigir consulta extra a outras documentações.

Os testes foram feitos na versão 11g.

Comandos Básicos

Funções Simples

Comandos Básicos DDL

Campo auto-incremento

Sub-consultas

Consultas hierárquicas e tabelas autoreferenciadas

Group by estendido - Rollup e Cube

Junções internas e externas

Inscreva-se no canal do Youtube para próximos vídeos

Arduino - Dicas de Programação

Link com todos os artigos e vídeos da série Dicas de Programação para Arduino:

http://fabianoallex.blogspot.com.br/2014/07/arduino-dicas-de-programacao-01-video.html
http://fabianoallex.blogspot.com.br/2014/07/arduino-dicas-de-programacao-02-segundo.html
http://fabianoallex.blogspot.com.br/2014/08/arduino-dicas-de-programacao-03.html
http://fabianoallex.blogspot.com.br/2014/09/arduino-dicas-de-programacao-04.html
https://www.youtube.com/watch?v=V96LLuPKFCw - 05 - Cadê o main?
http://fabianoallex.blogspot.com.br/2014/12/arduino-dicas-de-programacao-06-tempo.html
https://www.youtube.com/watch?v=XuLR1Sh3HhQ - 07 - Bitwise
http://fabianoallex.blogspot.com.br/2015/09/arduino-dicas-de-programacao-08-int-x.html
http://fabianoallex.blogspot.com.br/2016/01/arduino-dicas-de-programacao-bit-fields.html

Arduino - Dicas de Programação - Bit Fields

Quando se trata de programação de microcontroladores, precisamos estar sempre atento ao tamanho do data type a ser usado ao declarar uma variável, pois em geral contamos com poucos bytes a disposição para nossos programas.

Eu já fiz um vídeo (veja aqui) explicando como utilizar operações de bitwise, que se bem utilizadas nos garante uma boa economia de bytes. Mas nesse artigo quero falar sobre outro recurso que a liguagem C nos oferece: Os Bit Fields.

Bit fields são utilizados em conjunto com structs, que pra quem não sabe, são estruturas de dados que podem ser definidas pelo programador, para representar dados compostos, como por exemplo, dados sobre uma pessoa, que pode ter o nome, idade, etc.

Exemplo de struct:

struct Pessoa {
   char nome[10];
   int idade;
};

Além disso bit fields também podem ser utilizados em unions e classes.

Vamos a um exmeplo: É comum precisarmos utilizar flags em nossos programas, que são variáveis que irão receber possivelmente apenas dois valores, como 0 e 1, ou true e false, etc. Nesses casos é comum utilizarmos variáveis do tipo boolean, byte ou pior ainda int. As variáveis do tipo boolean e do tipo byte, possuem tamanho de 1 byte, já um int precisa de 2 bytes. Se a nossa intenção é armazenar valores que podem assumir no máximo dois valores, em teoria não precisaríamos de 1 byte completo (lembrando que um byte tem 8 bits), já que um único bit nesse caso seria suficiente para representar o nosso flag.

Infelizmente não temos como declarar variáveis do tipo bit, mas temos o recurso de Bit Fields que são muito fáceis de serem usados. Vamos a um exemplo:

struct Flags {
   byte flag_1 : 1;
};

Veja que adicionamos um sinal de ":" e após isso o número 1. Isso significa que estamos limitando o tamanho da variável flag_1 para que tenha apenas um bit, logo ela somente irá representar valores que podem ser 1 ou 0. Porém na prática, ainda não temos nenhuma economia de memória, pois apesar da variável flag_1 ter sido limitada no que pode representar, a memória alocada fisicamente ainda será de um byte por variável do tipo Flags.

Mas isso acontece, pois tivemos a necessidade de apenas um flag, se nós tivéssemos que utilizar dois, três ou mais, aí sim começaríamos a nos beneficiar dos bit fields. Então vamos incluir mais alguns flags nessa estrutura:

struct Flags {
   byte flag_1 : 1;
   byte flag_2 : 1;
   byte flag_3 : 1;
   byte flag_4 : 1;
   byte flag_5 : 1;
   byte flag_6 : 1;
   byte flag_7 : 1;
   byte flag_8 : 1;
};

Agora temos 8 flags e ainda assim o tamanho que uma variável do tipo Flags ocupará é de apenas 1 byte. Isso por que cada um dos bits fará parte de um único byte. Caso adicionássemos um "flag_9 : 1" aí um novo byte teria que ser alocado.

Apesar desse exemplo utilizar apenas 1 bit pra cada variável da struct, poderíamos ter outras quantidades de bits. Por exemplo, uma variável que tenha valores possíveis entre 0 e 7, poderia ser declarada da seguinte maneira:

struct MeuBitField {
   byte valor_1 : 3;  /*0..7 ou 000 ... 111*/
   byte valor_2 : 3;
   byte flag_1 : 1;
   byte flag_2 : 1;
};

Para provar que esse recurso realmente funciona, veja as imagens abaixo, onde na primeira compilação, sem o uso de bit fields tivemos o uso de 17 bytes. Enquanto que na segunda vez, já com o uso dos bit fields, tivemos o uso de apenas 10 bytes. E para provarmos que uma variável do tipo Flags irá consumir apenas 1 byte, compilamos também o código vazio, apenas com o loop e setup sem nenhum código. O que consumiu 9 bytes.

Orientação a Objetos

Uma desculpa que sempre vejo que alguns programadores dão para não usarem orientação a objetos em programas para microcontroladores é que objetos ocupam muita memória. Mas geralmente essas afirmações ficam apenas nisso, ninguém se dá ao trabalho de realmente tirar a prova ou demonstrar que objetos consomem mais memória que programação estrutural.

Um bom exemplo de que dá pra programar Orientado a objetos com código enxuto, é que classes também podem ter bit fields.

Veja:

class Teste {
  private:
    byte _x : 1;
    byte _y : 1;
  public:
    void setX(boolean x){ _x = x; }
    void setY(boolean y){ _y = y; }
    
    boolean getX(){ return _x; }
    boolean getY(){ return _y; }
};

Teste t;

void setup() {
  t.setX(true);
  t.setX(false);
}

void loop() { }