Virtualização (VMware Player 3.1.4 for 32-bit and 64-bit Windows)

Boa noite meus caros!
Para falar um pouco de Virtualização irei explicar um pouco como configurar e utilizar o software Vmware.
Vamos ao Bla Bla Bla!
Virtualização nada mais é que substituir um desktop/servidor físico devidamente montado e com sistema operacional e o transportar para uma VM (maquina virtual), preservando todas as suas características. Ou seja, você somente terá uma única máquina para substituir seu ambiente de produção ou no caso dos usuários domésticos, para criar um ambiente de testes, e poder utilizar vários sistemas operacionais em uma única máquina, não consumindo um alto nível de CPU e memória.

Exemplo:

 

Porque virtualizar?

Um exemplo de por que virtualizar seria de um amigo que possue o sistema operacional windows7(seven), e pretende instalar um programa de PLC, que por incompatibilidade não roda neste novo sistema.

A solução mais adequada e barata seria virtualizar(rsrsrsrsr) esta é pra vc meu amigo Ademilson...

Hoje para montarmos um ambiente virtualizado de teste, não precisaremos mais do que a seguinte configuração.
Processador P4 ou AMD (mínimo 1.2GHZ)
Memória 512MB
HD de 40GB
Leitor de CD (Preferencialmente Combo-Drive)
Como puderam notar não é uma máquina, muito potente e nem de custo elevado, mas que suportará tranquilamente de duas a três máquinas virtuais rodando juntas. Hoje se adquirirmos esta configuração no mercado não gastaremos mais que R$1000,00 (Mil Reais).

Utilizarei o sistema operacional Windows XP Professional como base para iniciar a configuração do VMWare. Mais você pode virtualizar com qualquer sistema operacional.
Utilizarei o VMware Player 3.1.4, por ser grátis e de fácil aprendizado e instalação.

Vou explicar algumas nomenclaturas que utilizarei.
VM’s – É a abreviação para Virtual Machine (Máquina Virtual)
VMX – É o arquivo onde contem as informações de configurações da sua VM
VMDK – É o disco (HD) de sua VM

Click e Baixe Aqui o SoftwareVmware

Após Concluir o Donwload e descompactar Vamos executar o software:

 Nesta tela basta avançar:

 Aqui Você pode escolher o local da instalação (basta avançar):

Nesta tela você marca para o vmware atualizar sempre uma versão mais nova:

Nesta eu prefiro não marcar nada (Avançar).

Aqui os atalhos são criados Marco todas (Avançar).

Aqui começa realmente a bendita instalação( Rs rs rs).

Bla bla bla...

...Instalação concluida, basta clicar Restart Now para sua maquina reiniciar e seu software estar pronto para funcionar...

Fim

 Na Proxima Postagem irei ensinar como configurar uma estação virtual utilizando o Vmware.
Click e continue lendo...

Administrador Bacana.:

Um pouco de programação PLC.

Irei representar uma aplicação de como fazer em plc e supervisório (logix500/rsview32).
um controle de sinal transito, este exemplo é apenas para simplificar uma aplicação básica que pode ser feita de várias maneiras, dependendo do grau de conhecimento do programador.




Fig1.

 Na fig1 vemos a aplicação feita no RSview, um semáforo com as cores vermelho (B3/0), amarelo (B3/1) e verde (B3/2). e no logix500 as linhas de teste representando essas memórias, veja que ativando-as as cores correspondentes ficam acesas, rsrsrssr




Fig2.



Na fig2, podemos perceber que foi criado um contador com uma memória do sistema onde este mesmo contador se reseta ao chegar em 200 incrementos, num ciclo constante 0 a 200...0 a 200...



Fig3.

 Agora começamos ao raciocínio, vamos fazer nosso controle com a instrução LIM, vocês logo vão perceber como esta instrução funciona em nosso exemplo. ela compara se o valor do contador (C5:0.ACC) e verifica se está dentro do limite estipulado, se for verdadeiro, ativa sua saída.
uma dica:
 vermelho 120 a 200
amarelo 81 a 119
verde 0 a 80
Agora basta repetir para as outras saídas e o exemplo do sinal estará funcionando...
Agora mãos à obra, façam o teste simulem e vejam como é facil interagir com logix e rsview32.
comentem. rsrsrs

Este vídeo é de como fazer um cabo para o logix5:

PROCESSADOR INTEL CORE I3 530 “CLARKDALE”

Se computadores fossem carros, o Intel Core i5 “Clarkdale” seria algo como um motor 1.8 com turbo para veículos de linha. Mas como nem todos estão dispostos e/ou tem condições de pagar a mais ter um carro com turbo, os fabricantes costumam oferecer opções mais simples (e sem turbo) como os motores 1.6 que podem até não inflar o ego do consumidor, mas também não fazem feio na hora de ultrapassar um caminhão na estrada ou subir um morro mais inclinado. Baseado nessa analogia, eu diria que o novo processador Intel Core i3 seria o novo motor 1.6 da empresa, posicionando-se como uma opção mais em conta para aqueles que procuram num PC bom e honesto e que querem fugir de modelos mais “populares” com chips Celeron ou mesmo Pentium.

Ao contrário dos rumores que insinuavam que o Core i3 poderia ser um Core 2 Duo renomeado, o Core i3 tem praticamente as mesmas características do Core i5 série 6xx, abrindo mão de um pouco da velocidade e obviamente do Turbo Boost — uma tecnologia que acelera um ou mais núcleos do processador de maneira dinâmica e de acordo com o contexto — e, por causa disso, ele chega a ser de 43 a 63 dólares mais em conta que o Core i5 mais barato (preço de lançamento nos EUA para lote de mil peças).

Como o processo/custo de fabricação do Core i5 é praticamente o mesmo que o Core i3, não me surpreenderia em saber que este último não passe de um i5 com turbo desabilitado por software e que algum dia algum entusiasta/hacker/maluco não descubra um meio de reativá-lo, como já fizeram para destravar o quato núcleo do Phenom x3.

O chip analisado por este Zumo é o Core i3 530 de 2,93 GHz o modelo mais em conta da linha e que — por causa disso — talvez seja o que mais apareça nas lojas.

E atendendo a pedidos, a tradicionalíssima foto do processador que todo mundo põe quando faz um review:

Para testá-lo chip utilizamos a mesma plataforma que usamos para testar o Core i5 661, ou seja, uma placa-mãe ATX-mini modelo DH55TC “Tom Cove” com chipset H55, 4 GB de SDRAM DDR 1333 MHz em dual channel e um disco rígido Hitachi Deskstar HDT721032SLA360 SATA 300 de 320 GB e 7.200 rpm. O sistema operacional utilizado foi o Windows 7 Ultimate.

Dando uma olhada no CPU-Z 1.52.2 podemos ver que o Core i3 é de fato muito parecido com o Core i5 661, ficando a diferença na velocidade do núcleo do QPI Link:

O GPU-Z 0.3.8 diz a mesma coisa: praticamente a mesma GPU do Core i5 o Havendale de 45 nm.

Apesar disso, é curioso notar que o desempenho gráfico — em especial para jogos — foi o item que definiu o Índice de Experiência do Windows 7 em 4,3 pontos, contra 5,2 pontos do Core i5. Vale a pena lembrar que o Core i3 530 é um chip de 2,96 GHz contra 3,33 GHz (~ 3,6 GHz no modo turbo) do Core i5 661.

A diferença no processamento fica mais evidente nos testes de aplicações. No caso do HDxPRT o Create HD Score que foca seus testes em programas de processamento de mídia apresentou um desempenho 13,2 % menor que o Core i5 661. Apesar disso,o Play HD experience apresentou a pontuação máxima o que fica dentro da proposta dos novos chips Clarkdale de oferecer um bom suporte para vídeo em alta definição:

Nos outros testes, o Clarkdale bateu 176 pontos no Sysmark 2007 Preview 1.05, 5.629 pontos no PCMark Vantage e 4.643 pontos no 3DMark Vantage (modo Entry) e 390 pontos no modo Performance. No AutoGK 2.45, o sistema levou apenas 59m38s para transformar um filme em DVD para um arquivo AVI de 700 MB. O processo oposto (criar uma imagem de DVD a partir de um arquivo de vídeo) feito com o DVDFlick 1.3.0.6 foi de 2h51m10s utilizando um thread e 2h31m39 com quatro Threads. No geral o Core i3 530 foi de 11~23% mais lento que o Core i5 661.

No CINEBENCH R10 e os resultados foram os seguintes:

Rendering (Single CPU): 3.200 CB-CPU
Rendering (Multiple CPU): 7.591 CB-CPU
Multiprocessor Speedup: 2,37
Shading (OpenGL Standard): 2.175 CB-GFX

O Super-Pi do David Lopes:

E segundo o EEcoMark 1.0.0 384 (sem considerar o uso do monitor) o sistema consumiu em média 34,47 watts em idle, 2,37 watts no modo sleep e 1,54 watts em off segundo o Energy Star V4. No V5 o sistema mediu 34,25 watts em idle, 2,39 watts em sleep e 1,56 watts em off. Seu consumo fou um pouquinho menor devido ao uso de um processador mais lento mas de qualquer modo continua sendo um valor impressionante para um desktop.

Para se ter um cenário de uso mais real, eu peguei meu medidor de energia e monitorei o sistema rodando o PCMark 2005. Na média ela consumiu em média de 49,1 watts com picos de 76,6 watts.

Assim como o Core i5 661, minha impressão do core i3 540 é bastante positiva já que — no geral — ele oferece praticamente todos os recursos do Core i5 abrindo mão de um pouco de seu desempenho. Acredito que seu público alvo — consumidores que vão comprar (ou trocar) seu primeiro PC — ficarão satisfeitos com o Core i3 já que ele atende bem as necessidades do dia a dia como editar documentos e acessar a Internet e até mesmo assistir vídeos em HD, uma aplicação cuja demanda cresce à medida que os consumidores migram para as TVs de tela plana com tecnologia de Plasma/LCD. Os entusiastas e gamers podem até torcer o nariz para o Intel GMA HD, mas eles sempre terão a opção de usar sua placa de vídeo favorita, desde que a placa-mãe venha equipada com um slot PCI-E x16. E tudo isso consumindo bem menos energia que um PC de uma ou mais gerações anteriores.

Se você procura um PC bom e honesto, acredito que o Core i3 seja uma opção a ser considerada. Só espero que os integradores locais também colaborem, oferecendo o Core i3 por um preço camarada e que, como nos carros não infle seu preço maquiando o mesmo com um adesivo transado, calota com cara de roda de liga ou mesmo colocando uma bolinha de câmbio com siri dentro.

Estressados Pela Tecnogia....

Alguns videos de estressados que tem na internet.

Criando jogo Genius...Arduino

Neste post, irei falar sobre como iniciar o desenvolvimento de objetos interativos com Arduino. Agora, vamos ver como adicionar dispositivos de entrada e saída, sejam eles analógicos ou digitais. A plataforma Arduino possui 14 entradas e saídas digitais, das quais 6 podem ser usadas para saída analógica emulada via PWM, e 6 entradas (entradas apenas) analógicas. As funções para entrada digital e para entrada e saída analógica são:

• digitalRead(num_da_porta) — função que lê e retorna o valor digital (0 ou 1) da porta
• analogWrite(num_da_porta, valor) — função que escreve um valor analógico na porta. Este valor pode variar de 0 a 255 e representa uma tensão média de saída entre 0V (0) e 5V (255). Para maiores informações, ver a explicação da modulação PWM no site do Arduino.
• analogRead(num_da_porta) — função que lê e retorna um valor de tensão analógico presente na porta especificada, convertido para um número entre 0 e 1023, sendo o valor 0 correspondendo a 0V e 1023 correspondendo a 5V.

Agora iremos usar as entradas e saídas do arduino para fazer um jogo no estilo do Genius (Simon). O jogo consiste em quatro botões grandes que acendem em sequência e o jogador precisa memorizar esta sequência e repetí-la. A cada rodada a sequência aumenta em 1 elemento. O jogo termina quando o jogador erra a sequência apresentada ou, no nosso caso, quando a sequência chega a 100 elementos.

Montando os circuitos

Para implementar este jogo, utilizaremos 4 sensores de pressão para representar os botões, quatro LEDs coloridos para indicar qual botão da sequência deve-se pressionar, um LED para indicar que o jogador deve começar a pressionar os botões, e um auto-falante para emitir o som de cada botão.
Primeiro vamos conectar os LEDs às saídas digitais do Arduino. Escolhemos conectá-los às saídas digitais PWM, pois desta forma poderemos incrementar o nosso jogo posteriormente, adicionando efeitos nos LEDs, com escrita analógica nestas portas. Assim, os LEDs vermelho, verde, azul e amarelo serão conectados às portas 5, 6, 9 e 10, respectivamente. O LED que indica a vez do jogador repetir a sequência será conectado à porta 2. Adicionamos as seguintes diretivas de pré-processamento para facilitar a leitura do código:
// LEDs em portas de saída PWM digital
#define LED_RED      5
#define LED_GREEN    6
#define LED_BLUE     9
#define LED_YELLOW   10O circuito para ligar os LEDs às portas é composto do LED propriamente dito e um resistor de 220Ω em série para limitar a corrente no LED, como pode ser visto na figura abaixo:

Os sensores de pressão que utilizamos são resistores que variam sua resistência  de acordo com a força aplicada sobre ele. Sem nenhuma força exercida sobre ele, sua resistência é acima de 1MΩ, e com 10Kg sua resistência é próxima de 0Ω. Assim, ligaremos o sensor de pressão com um resistor de 10kΩ para formar um divisor de tensão, que vai variar a tensão de entrada na porta analógica de acordo com a força aplicada ao sensor de pressão. Ligaremos cada sensor de pressão (que chamaremos de PAD no código) a uma das portas analógicas de acordo com a definição abaixo:

// PADs nas portas de entrada analógica
#define PAD_RED      0
#define PAD_GREEN    1
#define PAD_BLUE     2
#define PAD_YELLOW   3
#define MAX_PADS     4

O circuito para os sensores de pressão está mostrado na figura abaixo:

Para emitir os sons do jogo, utilizaremos um pequeno auto-falante, destes encontrados em headphones. Este auto-falante será conectado à porta 12 do Arduino. Abaixo segue a diretiva de pré-processamento com a definição desta porta:

// Speaker on digital out port 12
#define SPEAKER        12

Caso seja necessário, podemos adicionar um resistor de baixo valor (100Ω ou menos) para reduzir o volume do auto-falante. O Genius utiliza notas musicais para indicar o acionamento de cada botão. Sabemos que o som de uma nota musical é a variação do deslocamento do ar em uma única frequência. Assim, se ligarmos e desligarmos a porta em que o auto-falante está conectado, na frequência desejada, o auto-falante emitira o som da nota correspondente. As notas que utilizaremos para cada um dos botões são: Lá para o vermelho, Lá, uma oitava acima (o dobro da frequência) para o verde, Ré para o azul e Sol para o amarelo. Para ligar e desligar o auto-falante na frequência desejada, precisamos calcular o período, que é o inverso da frequência. O auto-falante deverá permanecer meio período ligado e meio período desligado, tantas vezes quanto for a duração da nota. Assim, temos as seguintes definições para o meio período de cada nota a ser tocada:
// Notas desempenhado por cada PAD
// O valor de cada constante representa o período de cada
// Note que será tocado quando um bloco é pressionado.
// A relação de cada almofada com uma nota é o seguinte:
#define NOTE_HPERIOD_RED      1136    // Uma nota  - 440Hz
#define NOTE_HPERIOD_GREEN    568     // Uma nota e uma oitava acima do RED - 880Hz
#define NOTE_HPERIOD_BLUE     1700    // D-note - 294Hz
#define NOTE_HPERIOD_YELLOW   1275    // G-note - 392Hz
#define NOTE_HPERIOD_ERROR    5000    // 100Hz
Abaixo segue a função para tocar uma nota, bem como o circuito para ligar o auto-falante à porta.

// Plays a note according to its half periodvoid playNote(long hperiod, long duration)
{
    long elapsed_time = 0;

    //  Jogou menos tempo do que 'duração' 
    while (elapsed_time < duration) 
    {
        // turno para a metade do período 
        digitalWrite(SPEAKER, HIGH);
        delayMicroseconds(hperiod);

        // turno fora por metade do período 
        digitalWrite(SPEAKER, LOW);
        delayMicroseconds(hperiod);

        // Adiciona um período de tempo decorrido
        elapsed_time += (hperiod*2);
    }
}

Ao juntar todos estes circuitos e conectá-los ao Arduino, temos a nossa configuração de hardware pronta. A figura abaixo mostra como ficou este circuito montado em uma protoboard.

Funções do Jogo

A logica do jogo é bastante simples. Primeiro temos que sortear um elemento (pad) e adicioná-lo à sequência de pads. Depois executamos toda a sequência para que o jogador a memorize, e depois esperamos pelo pressionamento dos pads e comparamos os pads pressionado com a sequência salva. Caso o jogador acerte a sequência, começamos este ciclo novamente. Se não, sinalizamos o erro e o jogo recomeça.
Para o nosso jogo, definimos um conjunto de constantes, que representam o tempo que cada LED permanece aceso, o intervalo entre o acendimento dos LEDs, a sensibilidade dos PADs, etc. Além disto, definimos duas tabelas para converter um valor de PAD para a porta do respectivo LED e o valor do PAD em um periodo da nota a ser tocada. Também temos variáveis para representar o fim do jogo e para armazenar a sequência de pads a serem pressionados. Abaixo seguem estas definições e as funções setup() e loop() do nosso jogo:

////////////////////////////////////////////////////////////
// Definição de constantes
////////////////////////////////////////////////////////////
// Notas desempenhado por cada PAD 
// O valor de cada constante representa o período de cada 
// Note que será tocado quando um bloco é pressionado. 
// A relação de cada almofada com uma nota é o seguinte: 
#define NOTE_HPERIOD_RED      1136    // Uma nota  - 440Hz
#define NOTE_HPERIOD_GREEN    568     // Uma nota e uma oitava acima do RED - 880Hz
#define NOTE_HPERIOD_BLUE     1700    // D-note - 294Hz
#define NOTE_HPERIOD_YELLOW   1275    // G-note - 392Hz

#define NOTE_HPERIOD_ERROR    5000    // 100Hz


// Número máximo de toques na PAD, para terminar o jogo 
#define MAX_NUM_TOUCHES      100
// Duração máxima de cada toque em milisegundos 
#define MAX_TOUCH_DURATION   500
// Intervalo máximo de cada toque em milisegundos 
#define MAX_TOUCH_INTERVAL   250
// Sensibilidade do sensor de toque
#define TOUCH_SENSIBILITY    1000
// Porta analógica para a leitura do inicializador randomSeed 
#define RANDOM_SEED_PORT     5


////////////////////////////////////////////////////////////
// Definição de variáveis globais 
////////////////////////////////////////////////////////////

// Tabela de pesquisa para converter PAD para um LED
unsigned char PAD_TO_LED[MAX_PADS];
// Tabela de pesquisa para converter PAD para um período NOTA 
unsigned long PAD_TO_NOTE_HPERIOD[MAX_PADS];
// Jogo mais variável 
boolean gameOver;
// Seqüência de pastilhas de ser tocado 
unsigned char padSequence[MAX_NUM_TOUCHES];

// O número atual de usuários toca deve executar 
int currentNumTouches;
// Duração de cada toque (irá diminuir ao longo do tempo) 
long currentTouchDuration;
// Intervalo de tempo entre os toques (vai diminuir ao longo do tempo) 
int currentTouchInterval;

////////////////////////////////////////////////////////////
// Declarações de função 
////////////////////////////////////////////////////////////
// Função para repor o estado do jogo 
void restartGame();
// Função para preencher nex aleatório para ser pressionado e inseri-lo em seqüência pad 
void nextRound();
// Função que reproduz a seqüência de teclado atual 
void playSequence();
// Função que verifica a entrada do jogador contra a seqüência salvo 
void verifySequence();

// Função para aguardar uma entrada de teclado 
int readPads();
// Função para transformar o bloco em correspondig levou, 
// E jogar bloco de notas correspondentes 
void turnPadOn(int pad);
// Função que reproduz o som da vitória 
void playVictorySound();
// Função que reproduz o som de erro 
void playErrorSound();
// Função para tocar uma nota com base no seu período de meia 
void playNote(long period, long duration);
// Coloque todos os leds no teclado 
void turnAllLedsOn();
// Coloque todos os leds apagados pad 
void turnAllLedsOff();

////////////////////////////////////////////////////////////
// Configuração do Arduino () função 
////////////////////////////////////////////////////////////
void setup()
{
    // Definindo portas LED como SAÍDAS 
    pinMode(LED_PLAYING, OUTPUT);
    
    pinMode(LED_BLUE, OUTPUT);
    pinMode(LED_GREEN, OUTPUT);
    pinMode(LED_YELLOW, OUTPUT);
    pinMode(LED_RED, OUTPUT);
    
    // Definindo como porta SPEAKER OUTPUT
    pinMode(SPEAKER, OUTPUT);
    
    // Não há necessidade de usar pinMode para definir as entradas PADs 
    // Porque eles estão ligados as entradas analógicas 
    // (Na verdade você não pode fazer isso porque pinMode 
    // Afecta apenas as portas digitais) RS Rs se liga mané!

    // Inicializando a PAD para LED tabela de pesquisa 
    PAD_TO_LED[PAD_RED] = LED_RED;
    PAD_TO_LED[PAD_GREEN] = LED_GREEN;
    PAD_TO_LED[PAD_BLUE] = LED_BLUE;
    PAD_TO_LED[PAD_YELLOW] = LED_YELLOW;

    // Inicializando a almofada NOTA tabela de pesquisa 
    PAD_TO_NOTE_HPERIOD[PAD_RED] = NOTE_HPERIOD_RED;
    PAD_TO_NOTE_HPERIOD[PAD_GREEN] = NOTE_HPERIOD_GREEN;
    PAD_TO_NOTE_HPERIOD[PAD_BLUE] = NOTE_HPERIOD_BLUE;
    PAD_TO_NOTE_HPERIOD[PAD_YELLOW] = NOTE_HPERIOD_YELLOW;
    
    restartGame(); 
}

////////////////////////////////////////////////////////////
// Loop Arduino () função 
////////////////////////////////////////////////////////////
void loop()
{
    // Gera almofada próxima aleatória e acrescenta que a seqüência pad 
    nextRound();
    // Executar a seqüência de teclado atual 
    playSequence();
    delay(currentTouchInterval);
    // Aguarda pela entrada do jogador e verificar se a entrada do jogador
    // Corresponde a seqüência de teclado 
    verifySequence();
    
    // Se o jogo tiver terminado, reiniciar o jogo 
    if(gameOver)
    {
        restartGame();     
    }    
}

Para a geração de números aleatórios, utilizamos as seguintes funções do Arduino: randomSeed(), que inicializa o gerador de números aleatórios; e random() que retorna um numero aleatório dentro de um intervalo. Para inicializar a função randomSeed() usamos o valor lido de uma porta analógica não utilizada (conectada), que vai flutuar (variar) de acordo com as ondas eletromagnéticas do ambiente. Esta inicialização e a inicialização as variáveis do jogo é feita na função restartGame(), apresentada abaixo:

void restartGame()
{
    // Reset global variables
    gameOver             = false;
    currentNumTouches    = 0;
    currentTouchDuration = MAX_TOUCH_DURATION;
    currentTouchInterval = MAX_TOUCH_INTERVAL;

    // turn off all leds
    turnAllLedsOff();

    // Restart random number generation
    randomSeed(analogRead(RANDOM_SEED_PORT));
}

Abaixo seguem as funções para calcular o próximo pad a ser pressionado, executar a sequência de pads para que o usuário memorize e verificar se os pads pressionados pelo usuário estão na sequência correta.

////////////////////////////////////////////////////////////
// Game functions
////////////////////////////////////////////////////////////
void nextRound()
{
    // Increments the number of pad touches for this round
    currentNumTouches++;
    // If pad touches reaches the maximum, the player has finished the game
    // So, play the victory sounds
    if (currentNumTouches >= MAX_NUM_TOUCHES)
    {
        playVictorySound();
    }
    // Else, adds a new random pad to the sequence
    else
    {
        padSequence[currentNumTouches - 1] = random(0, MAX_PADS);
    }
}

void playSequence()
{
    // go through the stored PAD sequence turn on corresponding LED and
    // playing corresponding note
    for (int i=0; i < currentNumTouches; i++)
    {
        turnPadOn(padSequence[i]);
    }
}

void verifySequence()
{
    int pad = 0;

    // Turn the playing LED on
    // This notifies the player that it is time to press the pads
    digitalWrite(LED_PLAYING, HIGH);

    // Run though pad sequence waiting for player input and
    // verifying the input against the sequence
    for(int i=0; i< currentNumTouches; i++)
    {
        // Waits for pad input
        pad = readPads();
        // Verify if the correct pad was pressed
        if (pad == padSequence[i])
        {
            // If the pad is correct, turn the corresponding LED
            // on and play its note
            turnPadOn(pad);
        }
        else
        {
             // if pressed pad is a wrong pad, the player looses the game
             // so, play the Error sound
             playErrorSound();
             gameOver = true;
             break;
        }

    }
    // Turn the playing LED off
    digitalWrite(LED_PLAYING, LOW);
}

Quando o jogador pressiona um pad, sua resistência diminui, levando o valor de tensão na porta correspondente do arduino para baixo também. Assim, para verificar os pads pressionados, devemos ler cada uma das portas dos pads em sequência. Caso o valor lido seja menor que o nosso valor de sensibilidade (no nosso caso 1000, para uma sensibilidade bem alta), consideramos este pad pressionado. A função que faz esta leitura está descrita abaixo:

int readPads()
{
    boolean padPressed = false;
    int pad = 0;
    
    do{
        // Verifica a porta de cada bloco, verificando se 
        // Foi pressionado 
        for(int i=0; i
        {
            // Lê a porta de almofada 
            int pressure = analogRead(i);
            // Se a pressão atravessa o threashold, bloco atual é pressionado 
            if(pressure < TOUCH_SENSIBILITY)
            {
                padPressed = true;
                pad = i;
                break;
            }
        }
    }while (!padPressed);

    return pad;
}

As outras funções do código são funções auxiliares bastante simples, por isso não serão discutidas aqui. Você pode fazer o download do código completo para execução no seu arduino neste link: CESAR_simon_game.zip.
Abaixo segue um vídeo do protótipo do jogo funcionando. Nos próximos posts da serie abordaremos outras funcionalidades do arduino mais avançadas, fiquem ligados!

Mais algumas fotos... Africa

Tem gente pensando que na áfrica é lugar de sofrimento. Vamos mudar este paradígma:

Bico pra beber de 0800.

Viajando.

100km.

Coconuts.

Thamires.

Waldir e Ricardo.

Mesa e Mar.

 Ilha do cabo, um lugar especial e agradavel onde o stress fica calminho. rsrsrsrsrsrs
De tarde nada melhor que pegar uns cocos, e ficar na beira da piscina. rsrsrsrsrs

Macaco bruno.

Ricardo gordo.

O Proximo sou eu rsrsrs.

Carioca da gema.

vida de Bacana.

Farofeiro.

Lapa.

De noite temos que ir na Lapa Jogar uma sinuca ou um Tenis de mesa. ouvindo uma musica e bebendo socialmente. rsrsrsrsrs.

lapa.

Som 3D... Veja como produzir.

Hoje em dia todo mundo quer ter um home-theater com caixas de som 5.1 (ou mais) para curtir toda aquela imersão sonora que o som espacial permite. Porém, existe uma técnica muito ignorada que dá um efeito muito superior, e usando fones de ouvido comuns: o esquema Binaural Recording, ou “gravação bináurea”.

Não, não estamos falando daqueles fones multimídia que possuem 3 conectores estéreo, que são ligados às saídas de uma placa de som 5.1 e que reproduzem todas elas dentro do fone. Nada disso. Estamos falando de você usar fones de ouvido comuns e sentir uma imersão que não deixa nada à desejar ao melhor home-theater em termos de imersão, uma sensação que é simplesmente indescritível.

Isto é possível usando um esquema de gravação com dois microfones, cada um dedicado a captar o que seria um dos ouvidos, que ficam afastados a cerca de 18 centímetros um do outro. Em tese, isto simula a zona neutra que existe entre nosso ouvidos e permite a captação do som de maneira mais real. Mas não é só isso: o processo mais profissional inclui ainda microfones de alta sensibilidade, que são colocados dentro de um molde de uma cabeça humana, de forma a simular todo caminho percorrido pelas ondas sonoras através de nossas orelhas.

Este é o segredo do tal “efeito”. Porque, como diz o próprio personagem Luigi, da demonstração acima, não há efeito algum, e sim o processamento natural do cérebro, que distingue variações de força, tom e equalização e calcula, automaticamente, a distância e a posição do que é escutado. Ao tocar o arquivo em fones de ouvido, nosso cérebro é automaticamente enganado e nos leva a acreditar que o que estamos ouvindo está se posicionando de maneiras diferentes.

Então, nada melhor do que ouvir uma demo do efeito chamada “Luigi’s Virtual Haircut”, que simula uma ida a um engraçado barbeiro italiano e seu assistente Manuel — o áudio está em inglês, mas mesmo assim a demonstração não deixa de impressionar. Confira — sem esquecer dos fones de ouvido

Voltando as origens... Arduino.

Queridos. Peço desculpas aos emais que recebi pedindo projetos com Arduino. Devido ao numero excessivo de trabalho não tive tempo de pulblicar nada. apenas desebafos. Mais obrigado pelo Feed Back.

Para começar terei que falar um pouco sobre um componente eletrônico que terá um papel fundamental neste projeto:

LDR - Light Dependent Resistor

 

 

O LDR possui a interessante característica de ser um componente eletrônico cuja resistência elétrica diminui quando sobre ele incide energia luminosa. Isto possibilita a utilização deste componente para desenvolver um sensor que é ativado (ou desativado) quando sobre ele incidir energia luminosa.

A resistência do LDR varia de forma inversamente proporcional à quantidade de luz incidente sobre
ele, isto é, enquanto o feixe de luz estiver  incidindo, o LDR oferece umaresistência muito baixa.
Quando este feixe é cortado, sua resistência aumenta.

Construção do LDR e suas Aplicações

É composto de um material semicondutor, o sulfeto de cádmio, CdS, ou o sulfeto de chumbo. O processo de construção de um LDR consiste na conexão do material fotossensível com os terminais, sendo que uma fina camada é simplesmente exposta à incidência luminosa externa.

Com o LDR pode-se fazer o controle automático de porta, alarme contra ladrão, controle de iluminação em um recinto, contagem industrial, todos estes fotocontrolados para a operação de um relé.   

Características do LDR

Também chamado de célula fotocondutiva, ou ainda de fotoresistência, o LDR é um dispositivo semicondutor de dois terminais, cuja resistência varia linearmente com a intensidade de luz incidente, obedecendo à equação R = C.L.a , onde L é a luminosidade em Lux, C e a são constantes dependentes do processo de fabricação e material utilizado.

Como foi dito anteriormente o LDR tem sua resistência diminuída ao ser iluminado. A energia luminosa desloca elétrons da camada de valência para a de condução (mais longe do núcleo), aumentando o número destes, diminuindo a resistência. 

Conforme aumenta a intensidade de luz incidente no LDR, um número maior de elétrons na estrutura tem também seu nível de energia aumentado, devido à aquisição da energia entregue pelos fótons. O resultado é o aumento de elétrons livres e elétrons fracamente presos ao núcleo.   

Agora depois desta explicação vamos ao projeto.

Trabalho com uma caldeira onde existe um módulo que faz o controle do queimador, módulo que trabalha da seguinte forma:

Entradas:

1= Habilita o 1º estágio

2= Habilita o 2º estágio

3= Habilita o 3º estágio

4= Thermistor Motor ventilador

5= Entrada analogica, LDR Fogo do Queimador

Saídas:

1= Motor Ventilador

2= Valv. Segurança

3= Valv. 1º estágio

4= Valv. 2º estágio

5= Valv. 3º estágio

6= Sinaleiro Start.

7= Sinaleiro Falhas.

8= Sentelha Queimador.

Agora vamos ao funcionamento:

É simples o sistema verifica a entrada 4, depois quando recebe o sinal da entrada 1, verifica a entrada 5, se não tem chama e após 3segundos liga a saida 1, 1s liga a saída 2 e 3, 1s depois liga aciona a saida 8 até a entrada 5 detectar a ignição. (Pronto o primeiro estágio está concluído) 

Caso a entrada 5 não detectar o fogo em 10 segundos o sistema para e apresenta a saída 7 de alarme.

pronto agora vamos por mãos ha obra. comemtem caso consigam concluir o projeto. aguardo postagens no comentario.

Decidi fazer este muito pequeno projecto apenas para ensinar os que estão agora a adquirir o Arduino a ligar uma LDR ao nosso projeto, isto porque os LDR’s dao bastante jeito em algumas situações.

 Então cá vai… Espero que gostem…

Material Necessario (Hardware):
- Arduino
- LDR
- Fios De ligação
- Rectangulo de Pele (ou outro material nao condutor) para proteger o arduino
- Cabo USB
- Computador
- BreadBoard

- Resistor de 1k ou 10k
- LED

Material Necessário (Software):
- Arduino 0017 (Disponivel em arduino.cc)

1º Passo

Arranjar um local limpo e arrumado onde possamos trabalhar á vontade e onde tenhamos todo o material junto de nós.

2º Passo

Neste passo vamos proceder á montagem do circuito…

Em baixo está  o circuito que têm que construir:

3º Passo

Neste passo vamos começar a parte da programação. Neste exemplo é bem simples de perceber a programação. E qualquer coisa que não perceberem e so perguntarem que eu responderei com todo o gosto.

/*# PROGRAMA ELABORADO POR MARCELOBCN. #*/
int valor = 0; // Variavel onde e guardado o valor lido do LDR
int led_pin = 8; // Pino onde vamos ligar o LED
int analogin = 5; // Pino onde vamos ligar a LDR
void setup(){
Serial.begin(9600); // Inicia A comunicação da porta Serial para que possamos ver o valor do LDR
}
void loop(){
valor = analogRead(analogin); // O valor que irá ser lido na porta analogica numero 6 irá ser guardado na variavel “valor”
Serial.print(“O valor Da LDR e igual a: “); // Mostrar na consola a frase “O valor Da LDR e igual a: “
Serial.println(valor); // Mostras no Serial Monitor o valor da variavel “valor”
delay(25); // Faz uma pequena pausa de 25 Mili Segundos
if (valor < 300) { // Se a variavel valor for menor que 300
digitalWrite(led_pin, HIGH); // acende o led da porta 8
} else { digitalWrite(led_pin, LOW); } // se for maior mantem o led da porta 8 apagado
}

4º Passo

Vamos agora proceder ao Upload do codigo para o arduino.

- Primeiro ligamos o USB ao Arduino

- Depois ao PC

- Depois é so carregar no botao de Upload

- E por fim esperar que no canto inferior esquerdo apareça a mensagem “Done Uploading”

NOTA: Se neste passo acontecer algo e nao aparecer essa mensagem, recomendo a verificarem o codigo e/ou se o cabo está correctamente ligado ao PC e ao Arduino.

5º Passo

Por fim vamos testar o que acabamos de fazer… Para isso ligamos o nosso arduino ao pc apenas para este ficar alimentado, e passamos a mão (ou algum objecto) por cima da LDR fazendo com que o LED acenda, se retiramos a mão e o LED apagar é porque está tudo a funcionar correctamente.

Espero que tenham Gostado…

Marcelo Bacana.

 

 

 

 

Vinhos o inicio de tudo...

Bom dia meus caros!
O meu contato inicial com vinhos foi bem na adolescência, eu adorava ver aqueles babacas que se dizem entendidos de vinhos com aquelas frescuradas todas com um certo sarcasmo e desconfiança.
Na verdade eu não acreditava que alguem poderia sentir algo diferente do de eu sentia, ao engolir um pouco de vinho. Mais o tempo foi passando e minha opinião e gosto foi mudando. RS RS RS...
Acho que virei mais um Babaca...
Então vamos entender essa Babaquice!

Como degustar um Vinho?
Os cínicos dizem:
«Olha só eu ja sei como degustar. Faço todos os dias e acho que essa bobagem de degustação só serve para complicar o vinho.»

Eu concordo com os cínicos, e também acho que uma pessoa que sabe saborear um bom café ou um bife com fritas tabém é capaz de degustar um Vinho. Na verdade só precisamos de um Cérebro, Papilas gustativas e um nariz. A não ser que você seja como meu grande amigo «Domingos Velho» que perdeu o olfato por causa de produtos químicos que utilizava todos os dias em seu local de trabalho, Você também tem tudo que é necessário para degustar um vinho de maneira certa.

Todos nós temos tudo que é necessário para falar Crioulo Haitiano (é esta língua existe! rsrsrs). No entanto, ter a capacidade de fazer algo é bem diferente de saber como fazê-lo e aplicar este conhecimento na sua vida.

Agora chega de enrolação e vamos ao degustar:
você toma bebidas todos os dias, degustando-as ou simplesmente as engole como um funil velho e enferrujado. Para a maioria das pessoas a segunda opção é a mais indicada.
Entretanto, no caso do vinho, beber e degustar não são sinônimos. O vinho tem muito mais complexbilidade do que as outras bebidas:
muito mais coisas acontecem em uma boca cheia de vinho. por exemplo:
A maioria dos vinhos tem vários sabores (castas diferentes e sutis), todos ao mesmo tempo, e eles te fazem sentir diversas sensações agradaveis quando estão em sua boca, como suavidade ou tanino.

Se você engolir o vinho como faz com um refrigerante, estará perdendo uma grande parte do preço que pagou por esta bebida. porém se você ao invéz disto, degustá-lo, poderá descobrir suas nuances. E quanto mais lenta e atenciosamente você o fizer, mais interessante e rico de detalhes fica o seu vinho.

Agora meus caros, já temos duas regras importantes para a degustação de um vinho:

1. Vá devagar...
2. Preste atenção...

Ainda tem mais... (ver para crer...)
Quando estamos com um copo de agua, olhamos e apartir daí tentamos definir a sua pureza ou qualidade pelo quão transparente o liquido se encontra (apesar de uma coisa não estar relativamente ligada a outra).
No processo de degustação de um vinho o primeiro passo é: (observar, cheirar)

Saborear a boa aparência do vinho.
olhar para o vinho em uma taça, notar como é brilhante e como reflete a luz, identificando seu tom de vermelho. Observe se o vinho é claro ou escuro, se a cor muda do centro da taça para as bordas. Note também, se o vinho é turvo, claro ou brilhante. (com o tempo e a experiência você vai perceber que a maioria dos vinhos é clara, alguns podem não ser brilhantes, nais não devem ser turvos.) tente identificar padrôes como uma coloração mais profunda em vinhos de safra mais recente.

Cheirar o vinho.
Esta é a parte que mais me alegra, afinal girar e cheirar. este é o momento que muitos viajam na imaginação, Enfim quando você diz que um vinho tem aroma de framboesas silvestres, como poderão provar o contrário?
Para obter o máximo de seu olfato, gire o vinho na taça primeiro. (mais nem pense em fazer isso se seu vinho estiver em mais da metade da taça - o mico vai ser entornar tudo)
com a taça sobre a mesa gire-a para que o vinho se misture com o ar. Em seguida, traga a taça rapidamente até o nariz, e cheire. faça suas associações de aroma.
frutado, amadeirado, fresco, quente, tostado, intenso, leve, perolado, só não seja genérico. pratique seja ousado. Coloque o seu nariz dentro da taça, onde os aromas poderão ser capturados.
Não use perfumes muito fortes, para não confundir com o aroma do vinho.
O cheiro de tomates, pode ser na verdade do molho de macarrão, cuidado com os aromas ao seu redor.
Pratique a arte de cheirar. cheire cada ingrediente ao cozinhar, cheire tudo o que comer, as frutas vegetais e ate mesmo os cheiros ao seu redor, como couro, terra, asfalto, flores.
Abasteça sua base de dados mental, para que você tenha memórias aromáticas ao seu dispor quando você precisar delas.
Quando se trata de cheirar vinhos, muitas pessoas ficam preocupadas se conseguirão realmente detectar o máximo de aromasque acreditam que são capazes de perceber. Cheirar vinhos é realmente uma questão de pratica e atenção. se você passar a prestar mais atenção aos aromas em suas atividades cotidianas, vai se aperfeiçoar na arte de cheirar vinhos. Boa sorte!

Metendo a boca...
Parece frescura mais agora entendo o porque desse ritual, outro dia coloquei um vinho no copo e com pressa sorvei um gole de algo que parecia mais com vinagre, foi horrivel! mais fez me entender que poderia ter evitado se tivesse cheirado meu vinho.
Depois observar e cheirar o vinho, você tem finalmente permissão de saboreá-lo. (cair de boca. rs rs rs)
Calma a palhaçada ainda não acabou. este é o momento das caras esquisitas, de jogar o vinho de um lado para o outro da boca, bochechando e com uma concentração intensa. Se você distrair um degustador neste momento, pode ganhar um grande inimigo.

Vamos ao procedimento:
Dê um gole médio no vinho. Segure o em sua boca, franza os lábios e deixe entrar um pouco de ar em sua língua, sobre o vinho.(se você engasgar vai ser o maior mico de sua vida) Em seguida, movimente o vingo dentro de sua boca, como se o tivesse mastigando. Em seguida engula suavemente. Isso tudo deve demorar um pouco dependendo de sua concentração. (Ja estou abrindo meu Fronteira)

O que é um vinho Ruim?... (Alerta esnobe...)
Parece estranho, mais o direito de declarar que um vinho é «bom» por que você gosta dele não carrega consigo o direito de dizer que um vinho seja «Ruim» só porque você não gosta dele. Neste jogo você pode fazer as suas próprias regras, mais não pode forçar as outras pessoas a viver de acordo com elas.

Atualmente, há poucos vinhos  ruins no mundo, visto se compararmos há 20 anos atráz. E muitos dos vinhos que poderíamos chamar de ruins são, na verdade, apenas garrafas ruins. Garrafas que foram mau manipuladas e fizeram com que o vinho estragasse.
Aqui algumas características onde ha maioria concorda em indicar em um vinho ruim.
Espero que você nunca encontre um.

Fruta Mofada:
você já deve ter comido uma framboesa do fundo da caixa, com um gosto empoeirado, de papelão? este mesmo gosto de estragado pode estar em um vinho se ele estiver sido fabricado com uvas não totalmente frescas e saudáveis na colheita. vinho ruim.

Vinagre:
Na ordem natural das coisas, o vinho é apenas um estágio entre o suco de uva e o vinagre. Hoje em dia a maioria dos vinhos passam muito tempo no estágio de vinho por causa da tecnologia  ou da fabricação cuidadosa. Mais se você encontrar um vinho que tenha ultrapassado o limite em direção ao vinagre, é um Vinho ruim. (eu já bebi um desses, a rolha estava ressecada)

Cheiros químicos ou bactérias:
Os mais comuns são acetona (removedor) e enxofre (ovos podres, borracha queimada, alho estragado). Vinho ruim.

Vinho oxidado:
Este vinho tem cheiro fraco ou até cozido, e tem o mesmo gosto. Pode até ter sido um bom vinho, mais o ar entrou de alguma maneira, (oxigênio) e matou o vinho. Garrafa ruim.

Aromas e gostos cozidos:
Um vinho armazenado ou transportado no calor, pode ficar com gosto de cozido ou assado. geralmente há vazamento pela rolha, ou a rolha foi deslocada para cima. Garrafa ruim.

Vinho com gosto de rolha:
A falha mais comum, o gosto de rolha surge mom um cheiro de papelãomolhado, que piora com o ar e uma intensidade comprometida do sabor. causado por uma rolha ruim. pode acontecer com qualquer vinho. garrafa ruim.

Queridos espero que estejam gostando, afinal uma boa informação nunca é D+.
Em breve escreverei mais.
Comentem...

Vinho para Leigos...

Bom dia meus caros!

Em outra postagem escrevi sobre os vinhos Borgonha, hoje vou relatar sobre um vinho bem mais barato mais que não perde muito, ideal para os iniciados ao prazer de um bom vinho.

 Afinal, convenhamos que nem todo ser vivo tem R$ 2900 pra beber um Borgonha. Para um iniciante as coisas devem fluir aos poucos, é bom começar com um bom vinho barato, e depois vai refinando o seu gosto. 

Afinal quando se trata de vinhos, o céu é o limite...

CHILE:

O Chile produz vinho desde a chegada dos espanhóis, no século XVI. Apesar da boa qualidade, sua produção esteve por muito tempo longe da galeria dos melhores vinhos do mundo. Faltavam-lhe nobreza de sabor e reputação, que diferenciam o excelente do comum. Há dez anos, quando os chilenos viviam a euforia da redemocratização e da prosperidade econômica, o país adotou como meta produzir um vinho premiado, capaz de dar maior notabilidade a suas vinícolas e aumentar o volume de exportações – o resultado foi espantoso. Já há vinhos chilenos em condições de agradar ao paladar francês. O segredo? Bem, o salto de qualidade só foi possível porque encontraram produtores franceses dispostos a dar uma mãozinha. A primeira grande tacada de franceses e chilenos foi uma joint venture da Concha y Toro, a maior vinícola do país, com o selo de qualidade do barão Philippe de Rothschild, que produz o Château Mouton Rothschild, pérola dos tintos franceses. Em 1997, os chilenos cederam 40 hectares de sua melhor vinícola para que os franceses criassem o Almaviva, que se transformou no melhor tinto do Chile.

A minha sugestão (na verdade uma indicação de Waldir noronha um amigo e  apreciador de bons vinhos) para os iniciantes é o Frontera da Concha yToro, Basicamente é um Cabernet Sauvignon, suave, frutado com sabor médio e agradável, nada aveludado (nenhum tanino), bom pra ser acompanhado de carnes, queijo, massas com molhos picantes e condimentados. e tem mais o preço também é agradável não passa de U$ 12 (R$ 24,00).

 Segue então esta dica, para os que me acompanham até breve, e comentem sobre este vinho.

Vamos aprender a  identificar Alguns vinhos: