Social Icons

Mostrando postagens com marcador C. Mostrar todas as postagens
Mostrando postagens com marcador C. Mostrar todas as postagens

LOIC - Instalação e Uso (Linux)


Desde que o grupo Anonymous usou o Low Orbit Ion Cannon (LOIC) para atacar uma serie de empresas que entraram no caminho do Wikileaks, este software tem sido colocado no centro das atenções.






LOIC é uma aplicação open source de ataque de rede, escrito em C. LOIC executa uma negação de serviço, ataque (DoS) (ou quando utilizados por várias pessoas, um ataque DDoS) em um local de destino, inundando o servidor com os pacotes TCP, UDP, HTTP ou pedidos com a intenção de interromper o serviço de um determinado host. As pessoas têm usado para se juntar LOIC alguns botnets.

O LOIC pode ser usando para testar reações em servidores contra tal ataque e também para testar os mecanismos de segurança dos envolvidos.

LOIC esta disponível no sistema operacional Windows XP ou superior, mas claro que é possível também usar no GNU/Linux com algumas manipulações.

Instalando o LOIC


Provavelmente e possível a instalação em todas as distribuições linux. Nessa tutorial estou usando o Ubuntu 11.04.

Começamos instalando os seguinte programas:

No Ubuntu/Debian entre no shell e execute:

sudo apt-get install git-core monodevelop

Encontrei um script que nos permite: Inicia, atualizar e executar o LOIC.

mkdir ~loic 

Baixe o script http://www.4shared.com/file/rly7YCfe/loic.html
e Depois:

mv loic.sh /home/bhior/~loic
cd ~loic
chmod a+x loic.sh


Instalando o LOIC.

Entre com o seguinte comando:

./loic.sh install

O script ira baixar a ultima versão dispobivel, e em seguinda, executar uma instalação no diretorio ~/loic/LOIC.

Atualizando o LOIC

Entre com o seguinte comando:

./loic.sh update

O script irá verificar a existência de uma nova versão disponível no GIT, e em seguida, executar uma instalação no diretório ~/loic/LOIC.

Iniciando o LOIC

Agora e a parte importante:

./loic.sh run

A seguinte janela deverá aparecer:



Não testem este software em um site que não pertence a você! Na verdade, o software não tem nenhum mecanismo para esconder o seu endereço IP, e você será mais facilmente detectado pelo site de destino. Mesmo sem prever o futuro sei que muitos não vão seguir o apelo. hahaha...

Por padrão, o tipo de ataques de inundação são lançados no TCP/80 porta (mas é possível fazer ataques UDP ou HTTP). 10 processos são executados em paralelo.


A interface gráfica e de fácil utilização, crio que e difícil alguém que terá dificuldades.
Segundo @LulzSecBrazil Sexta Feira às 20:20 terá um novo ataque...
Você pode também usar JS LOIC. Pesquisando no google acha os links é exatamente igual sem instalar nada...




Boa Sorte e façam bom Uso!

Programando para iOS no Ubuntu/Linux !



Eis aí a prova de que é possivel emular um ambiente para programar com SDK Oficial da Apple!
Estou tentando aqui em no meu Desk Também se obtiver algum sucesso farei um tutorial...

Um Dimmer Futurístico



Um dimmer digital que pode ser facilmente acoplado no Arduino ou qualquer outra placa controladora. O resultado é que você consegue controlar a intensidade de brilho de uma lâmpada incandescente.  Dependendo dos circutos que você colocar neste esquema, você pode controlar um ventilador, chuveiro, ou fazer um ferro de solda com controle de potência!

Os desafios propostos neste desenvolvimento foram bem interessantes e pessoalmente foram verdadeiras aulas práticas de eletrônica e microcontroladores. 

A primeira tentativa que fizemos utilizamos um isolador ótico simples e tentamos usar a PWM para controlar a potência, mas o resultado com a lâmpada não deu certo: ela ficava piscando. Então Paulo pesquisou e me passou uma solução mais trabalhosa mas que funcionaria.

Neste novo esquema elétrico usamos dois isoladores óticos: 4N35 um MOC3021. O primeiro é utilizado para detectar a passagem da corrente alternada por zero e interromper o ATMega cada vez que isso acontecere, no caso do Brasil com 60hz, 120 vezes por segunda a corrente passa por 0. Neste momento é onde temporizamos  a abertura do TRIAC e simulamos o controle de potência. Veja o esquema elétrico:




Segue o código-fonte para Arduino. Você pode mudar a intensidade alterando o valor da variável dim entre 1 e 120, sendo que 1 é o mais forte e 120 praticamente desligada. Este programa permite alteração desta variável por I2C ou por Serial:


/*

#include 
int AC_pin = 3;
volatile long dim = 60;

void setup(){
  pinMode(AC_pin, OUTPUT);
  Serial.begin(9600);
  attachInterrupt(0, light, CHANGE);
  Wire.begin(66);
  Wire.onReceive(receiveEvent);
}

void receiveEvent(int howMany){
   char comando[16];
   int counter=0;
   while(1 < Wire.available())  {
   char c = Wire.receive();
   comando[counter++]=c;
   Serial.print(c);
      }  

int x = Wire.receive();
Serial.println(x);
Serial.println("Evento");
Serial.println(howMany);
//value, fromLow, fromHigh, toLow, toHigh)  
dim = map(comando[1], 48,57,10,120);
  } 


void light(){
  if(dim<125) {
    long dimtime = (60*dim);  // eval the proper pause to fire the triac
    delayMicroseconds(dimtime);  // delay the dim time
    digitalWrite(AC_pin, HIGH);  // fire the Triac
    delayMicroseconds(1);  // pause briefly to ensure the triac turned on
    digitalWrite(AC_pin, LOW);   // turn off the Triac gate (triac will not turn off until next zero cross)
  }  else {
      digitalWrite(AC_pin, LOW);   // turn off the Triac gate (triac will not turn off until next zero cross)  
  }
}

void loop(){
if (Serial.available() > 0) {
    byte inByte = Serial.read();
    dim = inByte;  }
}



E na etapa seguinte integramos este circuito com o ping da Parallax para ter o controle de intensidade "on the air". Bem, isso deixamos para um próximo post, por enquanto vai se divertindo com este circuito!

A lista de materiais para você comprar e montar:

- 4 resistores de 47K (R1 a R4)
- 1 resistor de 10k (R5) (se não tiver 1k e 10k não é eletrônica!)
- 2 resistores 330 (R6 e R7)
- TRIAC BTA16
- 1 isolador 4N35
- 1 isolador MOC3021

Preço da lista: menos que R$ 10.

Criador do Projeto:  Vinicius Senger
http://twitter.com/vsenger
http://twitter.com/eletronlivre
http://loja.eletronlivre.com.br
http://www.globalcode.com.br/instrutores/ViniciusSenger

Projeto EscaPe! v1.1



Ontem a noite sem nada pra fazer comecei a trabalhar com novos caracteres para a LCD Shield e aprendi a criar caracteres especiais com este site você tem uma idéia de como eles vão ficar.
Criei alguns avatares,bonequinhos,símbolos e gostei, pensei então em fazer o bonequinho andar na tela com os comandos:

 lcd.setCursor(x,y);
X=Valor de 0 a 15(no caso de LCD 16x2); - COLUNA
Y=Valor 0 ou 1 (Linha de cima ou de baixo) - LINHA

Recomendo quem quer entender o código por completo que leia o outro tutorial que fiz para o reconhecimento das teclas da shield lcd, pois irei usar o mesmo código para fazer com que vá para cima/baixo...







------------------------------------------
Nome do Jogo: EscaPe! 
Versões:
- 1.0: (Bugs simples logo serão corrigidos);
   1.1 (Implementado e corrigido 3 Bugs, ainda tem bastante bugs mas como estou sem muito                                  tempo talvez demore a concertar todos - Qualque ajuda é bem vinda).


No Pack de Download estão todas as versões para você poder avaliar a evolução.
Totalmente OPEN SOURCE: Download do Código (coloquei assim porque é muito grande o código para largar aqui, +-350 linhas)
User como quiser.
Você pode acompanhar notícias do jogo pela label EscaPe! aguardem muitas novidades até o fim do mês.

Homens de Verdade Criam Seus Próprios Jogos!

Frase de efeito, mas muita gente (“geeks de verdade”) leva ao pé da letra. Claro que não dispensam um bom Wii ou XBox 360… mas brincar com a “Gamepack” aí embaixo é muito, muito mais legal.

diy_gameboy_arduino_2
O preço não é lá muito convidativo, especialmente em épocas de dólar caro: são US$ 250,00. O poder de processamento também não é “aquela coisa toda”.
Todos os esquemas estão disponíveis (o da CPU é este, por exemplo) e o display OLED é mesmo muito bonito. Mas, particularmente, ainda existe outro kit: o Hydra. (US$ 200,00), vem com teclado, tem saída para monitor/TV e gera imagens como essa aí de baixo:

hydra_ss_02_large

hydra_ss_03_large

gd-photo200
Para Nosso Arduino temos outra opção:

Em se tratando de acessibilidade e diversão com engenhocas DIY, nada pode bater o Arduino. Sim, projetos possibilitando a criação de jogos com uma proposta “do-it-yourself” já surgiram, mas pareciam caros e não muito atraentes. A ideia com o Gameduino é possibilitar que você crie o seu próprio “console” e saia jogando sem pagar caro para isso e com facilidade para dar vida às suas criações.

A solução se baseia em uma placa extra que se acopla ao Arduino adicionando o hardware necessário para transformá-lo numa plataforma de jogos de 8 bits. De acordo com seus criadores, adquirindo a placa por US$ 50,00 e sabendo como desenvolver projetos para o Arduino, qualquer um pode desenvolver seus próprios games sem muita complicação, contanto inclusive com a ajuda de elementos disponibilizados pela comunidade. Os jogos são declaradamente retrô, é óbvio, mas com criatividade é possível criar coisas bem interessantes.
Confira alguns detalhes técnicos sobre o projeto na página oficial do Gameduino.

Laços de Repetição

Hoje iremos tratar de um tema de suma importância na programação: Os Laços de Repetição. Em nossos programas já estamos lendo dados do usuário. Imagine o seguinte: vamos fazer uma soma de números. Lemos dois números e realizamos a soma. E se quiséssemos fazer uma soma de, por exemplo, 100 números, ou mesmo uma quantidade X definida pelo usuário? No caso da soma de 100 números, teríamos 100 vezes o comando Leia()? E como faríamos pra ler uma quantidade X de vezes? Sem as estruturas de repetição, sem dúvida, seria bem complicado. Além disso, teríamos um código extremamente grande e repetitivo, com comandos iguais pra fazer as mesmas coisas. Os Laços de Repetição foram criados para solucionar estes problemas, deixando os códigos mais compactos, mais legíveis e mais rápidos de serem desenvolvidos.
Os Laços de Repetição que iremos tratar aqui são o Enquanto, Faça e o Para. Descrevendo-os resumidamente, temos o seguinte:
  • Enquanto: testa a condição antes de executar o bloco de código
  • Faça: executa o bloco de código e depois verifica a condição
  • Para: executa um bloco de código um determinado número de vezes
Vamos começar, então, falando do Enquanto. O enquanto possui um funcionamento bem simples, porém é de grande utilidade. Ele compara uma sentença e executa o bloco de código se a condição for verdadeira. Da mesma forma que, por exemplo, no Se, você pode colocar diversas condições, com o uso dos operadores lógicos e e ou, além do não. A seguir temos o exemplo da sintaxe em algoritmo…
1enquanto (nota > 70) faça
2   comandos...
3fim-enquanto
… e em Pascal…
1while (Nota > 70) do
2begin
3   comandos...
4end;
Dessa forma, utilizamos o Enquanto quando vamos executar uma repetição sem sabermos necessariamente o número de vezes que ele será executado. O looping pode, ainda, não ser executado nenhuma vez, caso a condição não seja satisfeita, ou seja, no Enquanto, testa-se a condição antes de executar o bloco de código.
Outra estrutura de repetição importante é o Repita. Ela possui praticamente o mesmo funcionamento que o Enquanto, porém a condição é testada após a execução do bloco de código. Abaixo, temos a sua sintaxe algoritmica…
1repita
2   comandos...
3enquanto(nota <= 70) e (nota >= 30)
… e em Pascal…
1repeat
2   comandos...
3until(nota <= 70) and (nota >= 30);
Neste exemplo acima, utilizei o operador lógico e para condicionar a repetição. Dessa forma, o looping será executado somente enquanto a variável Nota estiver na faixa entre 30 e 70 (para mais detalhes sobre os operadores lógicos, dê uma olhada no post sobre eles).
Por último, mas não menos importante, temos o Para. Esta estrutura de repetição se diferencia das outras por executar a repetição um determinado número de vezes. Como assim? A execução do Para é executada através da verificação e incremento de uma variável inteira, ou seja, determinamos a quantidade de vezes que a repetição será executada através de um limite para o valor da variável. Meio confuso? Calma, nos exemplos abaixo vai ficar mais claro. Primeiro na forma algoritmica…
1para i = 1 até 50 faça
2   comandos...
3fim-para
… e em Pascal…
1for i := 1 to 50 do
2begin
3   comandos...
4end;
No exemplo acima, temos a variável I funcionando como o contador de execução do looping, sendo incrementado automaticamente a cada execução do bloco de código. Dessa forma, o nosso looping será executado 50 vezes, ou seja, enquanto a variável I for menor ou igual o valor 50. Podemos, em vez do valor 50 colocar outra variável ou uma constante pra controlar a quantidade de vezes que o Para será executado.
O Para também possui uma particularidade interessante, podendo realizar decrementos a cada execução do looping. Dessa forma, podemos, por exemplo, criar contadores decrescentes, ou ainda exibir vetores invertidos (para mais informações sobre vetores, consulte o próximo post). A seguir temos a sintaxe do Para com decremento tanto em algoritmo quanto em Pascal:
1para i = 50 até 1 passo -1
2   Comandos...
3fim-para
1for i := 50 downto 1 do
2begin
3   Comandos...
4end;
Bem, pessoal, acho que é isso. Com o tempo vocês verão que a utilização das estruturas de repetição está sempre presente no dia-a-dia de um programador e tem papel fundamental na construção de um código otimizado. Fiquem atentos, pois no próximo post iremos falar de vetores e matrizes. Até lá e bons estudos!

Estruturas de Repetição "SE" "IF"

Os programas geralmente, baseados em algum dado, selecionam porções do código a serem executadas, realizando operações diferenciadas a cada execução. Para representar essa seleção em nosso programa utilizamos as estruturas de seleção.
A primeira estrutura de seleção que iremos conhecer é o Se. O Se é utilizado quando esperamos por uma condição. O bloco de código referente só sera executado se a condição for verdadeira. A seguir temos um exemplo algoritmico da utilização dessa estrutura e sua implementação em Pascal.
1leia(numero)
2se (numero MOD 2 = 0) então
3   início
4      escreva("O número é par.")
5   fim
1readln(numero);
2if (numero MOD 2 = 0) then
3   begin
4      write('O número é par.');
5   end;
Neste exemplo, lemos do usuário a variável numero. Se o resto da divisão do conteúdo da variável for igual a zero, será mostrada na tela a frase O número é par. A partir disso, podemos criar condições para o nosso programa, executando determinadas tarefas somente se algumas condições forem satisfeitas. Mas e se, por exemplo o número não fosse par? Ele seria ímpar… mas como faríamos isso no programa? A estrutura do Se é composta do Senão, que é executado caso a condição do Se não seja satisfeita. A seguir temos o exemplo da utilização do Se com o Senão na forma algoritmica e na linguagem Pascal:
1leia(numero)
2se(numero MOD 2 = 0)
3   então
4      escreva("O número é par.")
5   senão
6      escreva("O número é impar.")
7fim-se
1readln(numero);
2if (numero MOD 2 = 0) then
3   begin
4      write('O número é par.');
5   end
6else
7   begin
8      write('O número é ímpar.');
9   end;
Dessa forma, se o número digitado fosse par, a mensagem O número é par. Caso contrário, a mensagem O número é ímpar. seria exibida. Além disso, podemos encadear vários ‘Ses’, criando uma série de condições. Podemos também, colocar mais de uma condição ou negar uma condição, com a utilização dos operadores lógicos e, ou e não.
1leia(idade)
2se (idade < 13)
3   então
4      Escreva("Criança")
5senão se (idade >= 13 e < 21)
6      escreva("Adolescente")
7   senão
8      escreva("Adulto")
9fim-Se
01readln(idade);
02if (idade < 13) then
03   begin
04      write('Criança');
05   end
06else if (idade >= 13 and idade < 21) then
07   begin
08      write('Adolescente');
09   end
10else
11   begin
12      write('Adulto');
13   end;
Ah, um detalhe. Percebam que em Pascal, somente o último End de uma sequência de Ifs tem ponto-e-vírgula! Observando o exemplo acima, podemos realizar diversas tarefas, encadeando diversos Ifs / Elses. Apesar de simples, esta estrutura é vastamente utilizada na programação. Porém, quando precisamos conferir o valor de uma variável frente a muitos valores, o uso de Ifs encadeados torna-se trabalhoso, principalmente ao programador, além de deixar o código repleto de Begins e Ends. Para resolver problemas do tipo, utilizamos uma estrutura chamada Escolha ou Case. Com ela, podemos comparar o conteúdo de uma variável frente a diversas constantes, de uma forma bem mais organizada que o simples encadeamento de Ifs. A seguir, temos um exemplo de um programa de apuração de votos, com a utilização do Escolha.
1...
2escolha (votos)
3   caso (votos = 1) : candidato1 ← candidato1 + 1
4   caso (votos = 2) : candidato2 ← candidato2 + 1
5senão
6   escreva("Voto inválido")
7fim-escolha
1case votos of
2   1 : candidato1 := candidato1 + 1;
3   2 : candidato2 := candidato2 + 2;
4else
5   write('Voto inválido');
6end;
Neste caso, a variável votos foi comparada com os valores 1 e 2. Dependendo do seu conteúdo,  incrementa-se a variável correspondente ao candidato. Caso o voto não confira com nenhuma das opções do case, ele irá executar o comando para escrever Voto inválido na tela. Nesta estrutura, assim como no se, o uso do senão é facultativo, ou seja, ele não precisa necessariamente estar presente, sendo utilizado de acordo com a necessidade. Outro ponto é que os valores constantes comparados não precisam ser necessariamente inteiros. Podem ser, por exemplo, um tipo caracter.
Bom, pessoal, é isso. No começo pode ser que vocês estranhem um pouco estas estruturas, mas com o tempo elas virão a estar presente em praticamente todas as aplicações que vocês fizerem. E lembrem-se que, em caso de dúvida, podem  simplesmente deixar um comentário aqui no blog.
Obrigado pela visita e até o próximo post com as Estruturas de Repetição. Abraço a todos! :)

Operadores Lógicos

Bom Agora que ja se sabe um pouquinho sobre a estrutura simples vamos começar a Relação de Dados, estrutura teórica e prática de Operadores Lógicos.


Operadores Relacionais Matemáticos Seria uma boa leitura antes desse texto abaixo...

Bom, os operadores lógicos são usados em todas as engenharias acredito eu, pois são a base do pensamento lógico racional, eu mesmo uso MUITO em Eletrônica, e MUITO em programação,....
Todo Operador Lógico tem uma condição de entrada e análise para condiçaõ de saida.


E : Operador Lógico Inclusivo.As 2 Condições declaradas tem de ser verdadeiras para poder sair um dado verdadeiro. Explicando melhor com exemplo.


A conjunção é verdadeira se e somente se os operandos são verdadeiros
A B   Resposta
V V   V
V F   F
F V   F
F F   F

Percebemos que somente quando A e B São Verdadeiras a Resposta é verdadeira.


OU: Só Resultara em FALSO quando todas forem falsas. Se uma ou outra for verdadeira ele resulta em verdadeiro. por isso OU, A ou B.

AB  Resposta
VV  V
VF  V
FV  V
FF  F

NÃO: A negação da proposição "A" é a proposição "~A", de maneira que se "A" é verdade então "~A" é falsa, e vice-versa.Ou Seja se a afimação for verdadeira ele retorna falsa se for falsa retorna verdadeira.

A ~A
V F
F V

Um monitor de batimentos cardíacos para o ARDUINO







monitorBatimentos_01



Parte 1: “Vendo” os pulsos

Introdução

A Eletrônica nos permite criar aparelhos que são de fato extensões de nossos sentidos, como aqueles que são capazes de captar certos sinais fisiológicos que normalmente somos incapazes de sentí-los. Uma vez captados por algum tipo de sensor esses sinais podem ser amplificados e digitalizados, depois podem ser alterados e até mesmo controlados com alguma forma de feedback. Um desses sinais fisiológicos é o número de batimentos do nosso coração. Emoções fortes como raiva e excitação causam um aumento da taxa de batimentos do coração humano. Outras emoções como tristeza e pesar fazem essa taxa diminuir. Meditação, contemplação e outros estados mentais tambem mexem com essa taxa. Com a ajuda do Arduino e um amplificador de alto ganho com sensor ótico podemos monitorar nossa taxa de batimentos cardíacos na tela do nosso PC. Fica fácil assim montar um instrumento que pode ser usado para experiências com controle de stress, respiração, relaxamento e biofeedback





Hardware





Nosso protótipo foi montado numa pequena placa perfurada de 3,5 x 5,5 cm para ser encaixada sobre o Arduino como um shield. Veja a figura 1. Os componentes são interligados com pequenos fios no lado da solda da placa.

Nesse projeto utilizamos o par de amplificadores operacionais dentro do LM-358N.  O circuito completo está na figura 3, e é um projeto por nós adaptado para o Arduino a partir de um circuito originalmente publicado pela revista inglesa Elektor em 2008, sob o título “Stress-O-Meter”. Esse tipo de monitor de batimentos cardíacos é uma variante de um aparelho médico-hospitalar chamado pletismógrafo, que serve para medir (e registrar) variações no volume de um orgão como resultado de flutuações rítmicas da circulação do sangue pelo corpo humano. Normalmente nesse tipo de aparelho essas flutuações são captadas por um sensor ótico posicionado em um lado do lóbulo de uma orelha, ou um lado da ponta de um dos dedos, e com a fonte de luz alinhada no lado oposto. Diferentemente, nosso aparelho mede as pulsações no fluxo de sangue na ponta do dedo de uma das mãos do experimentador com o sensor e a fonte de luz colocados num mesmo plano e montados numa caixa separada do amplificador. Veja a figura 2 abaixo. Em nosso protótipo usamos como sensor de pulsações um LDR comum com uma resistencia de 1 Mohm sem nenhuma luz incidente, e 400 ohms com incidencia de luz natural direta.





Como fonte de luz para o sensor usamos um LED vermelho comum de 3 mm. O experimentador deve posicionar o lado oposto à unha de seu dedo indicador sobre o LDR, e a dobra entre a ponta e o meio do dedo sobre o LED. A luz que é emitida pelo LED atravessa a pele da dobra e é refletida pelo osso sobre uma pequena concentração de artérias bem em cima do LDR. O volume de sangue nesse grupo de artérias pulsa em sintonia com as contrações do músculo cardíaco. Essa informação vai modular a resistência do LDR.





No circuito do monitor o resistor R1 limita a corrente direta atraves de LED1 em cerca de 20 mA. O LDR e o resistor R2 formam um circuito divisor de tensão cuja saída pulsante será função da resistência do LDR que é função da luz refletida pelo dedo do experimentador.  

Esses pulsos de muito baixa frequencia, entre 1 e 2 hertz, seguem para um filtro passa-altas formado por C1 e R3 e é amplificado pelo primeiro opAmp do LM-358N na configuração não-inversor com ganho de 120. C2 e R5 formam um filtro passa-baixas centrado em 1,5 Hz. Essa frequencia corresponde a 90 pulsos por minuto, que é a metade da frequencia maxima do coração humano. O potenciometro P1, que é a resistencia de carga do primeiro amplificador, controla a entrada do segundo opAmp tambem não-inversor com ganho de 560. Aqui o sinal modulado com os batimentos do coração do experimentador pode ser entregue para tratamento ao Arduino no pino digital 2. O LED2 será programado para piscar com os batimentos cardíacos.



Sugerimos ao leitor primeiro montar o conjunto fonte de luz/sensor. Para o nosso protótipo montamos esse conjunto em uma pequena caixa plástica de 3x4x1 cm, como na figura 2. Nessa caixa foi montada a pequena placa perfurada com o LED vermelho de 3 mm e seu resistor de 270 ohms e o LDR e seu resistor de 39 Kohms.



Lista de componentes
R1 e R10 Resistor 270 ohms x 1/8W
R2 Resistor 39K ohms x 1/8W
R3 e R6 Resistor 68K ohms x 1/8W
R4 Resistor 8K2 ohms x 1/8W
R5 Resistor 1M ohms x 1/8W
R7 Resistor 560K ohms x 1/8W
R8 Resistor 1K ohms x 1/8W
R9 Resistor 1K8 ohms x 1/8W
P1 Potenciometro 10K linear
LED1 e LED2 Led vermelho 3 mm
LDR LDR
S1 Chave miniatura 1/0
C1 e C3 Capacitor 1uF x 25V
C2 e C4 Capacitor 100nF
CI1 LM-358N dual opamp
Outros Placa CI perfuração padrão
Borne 3 pinos parafuso


A distancia entre os centros do LED e do LDR é cerca de 1,0 cm. Da caixa saem tres fios: o de +5 volts, o de saída do divisor de tensão e o comum a esses dois, o terra. O fio de saída do divisor de tensão vai para o capacitor C1 na entrada do primeiro amplificador pelo borne B1.

Software

Depois de conferir mais de uma vez toda a fiação, encaixe o shield no seu Arduino, conecte o sensor e depois o cabo USB no seu PC. Para ver os batimentos cardíacos de uma pessoa carregue no seu Arduino o sketch da listagem 1.

Listagem 1


int pinLed = 3;    

volatile int state = 0;    



void setup(){

pinMode(pinLed, OUTPUT);        

attachInterrupt(0, pulse, CHANGE); 

}

void loop(){

digitalWrite(pinLed, state);     

}

void pulse(){

state = !state;           

}
Esse sketch configura o pino digital 3 como saída para LED2 no circuito, e o pino digital 2 como entrada de interrupção para a função attachInterrupt( ) que chama a função pulse( ) toda vez que uma interrupção externa ocorrer nesse pino. A função attachInterrupt( ) requer tres parâmetros e sua sintaxe é a seguinte:



attachInterrupt(pino, função, modo);
O primeiro parametro é pino e deverá ser 0 para o pino digital 2, ou 1 para o pino digital 3 do Arduino; o segundo é função e se refere à função que será chamada quando a interrupção ocorrer; o último parâmetro modo define o momento em relação ao sinal no pino digital especificado em que a interrupção ocorrerá, que poderá ser de quatro modos: CHANGE, na mudança do nível no pino; LOW, quando o pino for baixo; RISING, quando o pino mudar de baixo para alto; ou FALLING, quando o pino mudar de alto para baixo.

Nesse sketch toda vez que o nível lógico no pino digital 2 mudar, a função  pulse( ) será chamada, e esta vai somente complementar (mudar o estado da) a variável state. A variável state vai mudar de acordo com os batimentos do coração do experimentador e fazer o LED2 acender ou apagar conforme seu estado na função digitalWrite( )

Para testar o circuito basta você repousar a ponta de seu dedo indicador sobre o sensor e girar o cursor do potenciometro P1 para o mínimo ganho até o LED no pino 3 apagar. Depois vá aumentando o ganho até que o LED comece a piscar com os batimentos do seu coração. Depois de algum treino pressionando mais ou menos o dedo sobre o sensor é possível achar o ponto ótimo para ver o LED piscar regularmente. O ajuste fino é feito com o potenciometro.

Podemos enviar nossos batimentos cardíacos pela porta serial para o PC e ver no terminal do Windows ou do Arduino sua forma digital como uma combinação de traços horizontais com caracteres ASCII 95 e 45. Para isso acrescente ao sketch acima uma linha para iniciar a porta serial em 9600 bps e os comandos if que testam a variável state; se esta for falsa o caracter 45 será enviado para o terminal serial com a função Serial.write( ); se state for verdadeira o caracter 95 será enviado. Veja a listagem 2 e a forma dos pulsos na figura 5 abaixo. As pausas de 10 ms entre as transmissões evitam a sobrecarga do buffer da porta serial.

Listagem 2


int pinLed = 3;      

volatile int state = 0;   



void setup(){

pinMode(pinLed, OUTPUT);      

attachInterrupt(0, pulse, CHANGE);

Serial.begin(9600);

}

void loop(){

digitalWrite(pinLed, state);      

if(!state) Serial.write(45);

delay(10);

if(state)Serial.write(95);

delay(10);

}

void pulse(){

state = !state;                   

}



pulsosCardiacosTerminal Arduino 


Figura 5: os pulsos do batimento cardíaco

Na segunda parte desse artigo vamos visualizar melhor esses pulsos cardíacos agora digitalizados numa interface gráfica na tela do seu PC usando alguns poucos comandos de uma linguagem open source e muito parecida com a do Arduino, a linguagem Processing.(Já Comentada em Posts Anteriores)...

Até Lá!

Monte seu próprio Arduino ( Muito Fácil)

 



monte seu Arduino

 


As opções de Arduino

O Arduino já montado e testado pode ser adquirido em sites de comercio eletronico tanto aqui no Brasil quanto lá fora. Existe muitas opções de modelos conforme o microcontrolador embarcado, desde o mais simples com o ATmega168 com comunicação RS-232 ou USB e até aqueles com o ATmega1280 com mais memória de programa e mais entradas e saídas digitais. Mas tambem o leitor poderá montar seu proprio Arduino a partir de componentes facilmente encontrados em lojas de componentes eletronicos. Nesse caso propomos um circuito básico com o microcontrolador ATmega8 ou com o ATmega168, alguns resistores e capacitores, um regulador de tensão comum e um conjunto de conectores do tipo mini-latch para placa de circuito impresso. A placa proposta é de face simples e poderá ser confeccionada por qualquer método caseiro, como o já consagrado método térmico a partir de uma impressão a laser. A fonte de alimentação é externa à placa e pode ser qualquer carregador de baterias de aparelhos portáteis, como o de telefones celulares, que forneça tensões entre 9 e 15 volts CC. Veja o circuito completo do nosso protótipo na figura 1 e como ficou a montagem final na figura 2 abaixo.

 

circuito do Arduino
figura 1: circuito proposto para montagem

Hardware

Tanto o ATmega8 quanto o ATmega168 pode ser utilizado na montagem do nosso Arduino. Observe que no circuito não aparece o conversor TTL-RS232. Preferimos separar esse circuito da placa principal por uma boa razão: dar a opção ao montador de escolher que tipo de comunicação serial o seu Arduino terá com um PC, se RS-232 ou USB. Para a comunicação RS-232 existe o conversor MAX-232 que é um circuito integrado muito fácil de encontrar em lojas de componentes eletronicos, e por ser do tipo DIL de 16 pinos é tambem muito fácil de montar em uma pequena placa de circuito impresso e ser conectado por um cabo diretamente entre uma porta RS-232 do PC e o conector “SERIAL” que aparece no diagrama.Num outro artigo mostraremos a montagem de um circuito conversor TTL-Serial para ser usado com o nosso Arduino.

Para a comunicação serial USB o conversor é o FT-232RL, um circuito integrado do tipo SMD de 28 pinos, um pouco mais difícil de encontrar no comercio, bem mais caro que o MAX-232 e de montagem mais complicada numa placa de circuito impresso caseira devido ao tamanho e espaçamento entre seus pinos. Mas tanto um tipo quanto o outro de conversor funciona normalmente com o Arduino. A grande vantagem da USB é que todo PC moderno tem várias dessas portas disponíveis, e só os de mesa, os desktop, ainda estão vindo com duas ou tres portas RS-232.

Descrição do Circuito

O microcontrolador é alimentado com +5 volts nos pinos 7 e 20 provenientes do regulador de tensão integrado LM7805, se o jumper JMP1 estiver na posição “EXT”. Os capacitores C1 a C4 formam os filtros CC de entrada e de saída do regulador. No conector J1 entramos com uma tensão de +9 volts a +15 volts de uma fonte externa ou de um carregador comum de baterias com o positivo no pino central.

O diodo D1 serve de proteção para o circuito no caso de o pino central ser negativo. O LED1, vermelho, acende se a tensão de alimentação do circuito estiver correta. Essa mesma tensão externa tambem é disponibilizada no primeiro pino do conector “POWER”. A tensão de +5 volts do regulador LM7805 alem de ser disponibilizada nos pinos dos conectores “POWER” e “SENSOR” segue tambem para o conector “SERIAL” para alimentar a placa externa com o conversor RS-232.

À direita do diagrama temos o microcontrolador e os conectores ICSP, os dois digitais e o analógico. São 14 pinos digitais (D0 a D13) e 6 analógicos (A0 a A5). O pino de entrada de referência (AREF) para o conversor A/D do Arduino fica no segundo conector digital. O LED de teste e o pino 3 do ICSP estão ligados no pino digital D13. Na área tracejada vemos um cristal de 16Mhz e dois capacitores de 22pF que formam o circuito de relógio para o microcontrolador. Esse conjunto cristal-capacitores pode ser substituido por um ressonador cerâmico de 16Mhz que já inclui os dois capacitores no mesmo encapsulamento.

O microcontrolador uma vez configurado pelo bootloader do Arduino é resetado pelo último pino do PORT C (pino 1do microcontrolador), onde tambem temos um botão de RESET. Esse mesmo sinal de RESET segue para o pino 5 do ICSP e, atraves de um capacitor de 100nF, para o circuito conversor serial externo, para onde vão tambem os pinos digitais D0 e D1 que normalmente são reservados para a comunicação serial do Arduino com um computador PC ou com outro Arduino. Nesse conector  “SERIAL” pode ser ligado um circuito conversor RS-232 ou um USB. Se for usado um conversor USB o jumper JMP1 deve ser mudado para a posição “USB” e com isso o Arduino passa a ser alimentado pela tensão +5 volts da porta USB  do computador PC. É interessante observar que se não dispusermos de um carregador de baterias para conectarmos em J1 nosso Arduino pode ser alimentado por uma fonte externa de +5 volts diretamente atraves do conector “POWER”. O microcontrolador aparece no meio da placa.

Todos os pinos digitais e analógicos obedecem as mesmas posições e distanciamentos do Arduino padrão. Na parte de cima ficam os conectores digitais e à direita destes o conector “SERIAL” que acrescentamos para ligarmos a placa do conversor serial que será montada à parte. Na parte de baixo da placa está o jumper para selecionarmos que interface serial estamos usando, se RS-232 ou USB, e o conector analógico e o de tensões disponíveis para outros circuitos. À esquerda deste acrescentamos tambem um conector de tres pinos, o “SENSOR”, que é uma extensão do pino analógico A0, a tensão de +5 volts e o terra num só conector. À direita da placa, temos o botão de RESET e acima dele o conector “ICSP”. Mais abaixo do RESET o conector de entrada de tensão para alimentar o Arduino. Os outros componentes são os capacitores e resistores, o regulador de tensão e os dois LEDs. O LED vermelho acende para indicar que o Arduino está corretamente alimentado e o LED verde é o que vai conectado ao pino digital D13 do Arduino e indica quando carregamos programas para o microcontrolador. Em nosso Arduino utilizamos um ressonador cerâmico de 16 Mhz  em vez do cristal e dois capacitores de 22pF que aparecem no diagrama da figura 1. Nossa placa tem somente quatro pequenos jumpers

 

figura 2




Lista de materiais para a montagem do Arduino proposto
Item Componente qtde Obs.
1 Soquete DIL 28 pinos 1 Ou 2x DIL de 14 pinos
2 ATmega8 1 ou ATmega168
3 Cristal 16 Mhz 1 Ou ressonador cerâmico 16 Mhz
4 Regulador LM-7805 1 Não precisa dissipador
5 Diodo 1N4148 1 qualquer um da série 1N414x
6 LED 5 mm vermelho 1  
7 LED 5 mm verde 1  
8 Capacitor 100uFx25V 1 Tipo axial
9 Capacitor 10uFx25V 1 Tipo axial
10 Capacitor 100nFx100V 3 Tipo poliester
11 Capacitor 22pFx100V 2 Dispensados se usar ressonador
12 Resistor 220 ohms x 1/8W 2 Tipo cerâmico
13 Resistor 10 Kohms x 1/8W 1  
14 Botão tipo campanhia   1 Micro-chave para circuito impresso
15 Jumper 3 pinos 1 Jumper com espaçamento 2,54 mm
16 Conector mini-latch 8 pinos fêmea 2 Para os pinos digitais
17 Conector  mini-latch 6 pinos fêmea 1 Para os pinos analógicos
18 Conector  mini-latch 6 pinos fêmea 1 Para os pinos de tensões externas
19 Barra de pinos 6 pinos 90 graus 1 Para a placa serial
20 Conector mini-latch 3 pinos fêmea 1 Para a entrada de sensor
21 Barra de pinos 2x3 fêmea 1 Para o ICSP
22 Conector alimentação femea 1 tipo jack para circuito impresso

 

A placa de Circuito Impresso

A placa de circuito impresso do nosso Arduino tem 7,5 cm por 5,5 cm e é de face simples. Veja na figura 3 o lado da solda e na figura 4 uma sugestão de serigrafia no lado dos componentes na placa.

 



figura 3
Placa PCI Arduino 02

figura 4


A placa de circuito impresso pode ser confeccionada por qualquer método caseiro, como o já consagrado método térmico com impressão ou fotocópia a laser numa folha de papel grassy. Nesse caso deve-se usar o desenho da figura 5, sem inversão do lado da solda. Note que em nossa placa utilizamos um ressonador cerâmico na posição indicada como “XTAL”, se for utilizado um cristal e os dois capacitores ceramicos de 22 pF o desenho da placa deverá ser modificado para acomodá-los. Os pinos 8 e 22 (GND) do microcontrolador já vêm conectados entre si dentro do encapsulamento e portanto no desenho da placa não aparecem conectados.

 

placa PCI Arduino 03
figura 5
Uma vez pronta a placa de circuito impresso, o nosso Arduino pode ser todo montado em umas poucas horas, dependendo da experiência em montagens eletronicas do leitor. As unicas recomendações são para conferir mais de uma vez a montagem dos componentes polarizados, como o diodo, os capacitores eletrolíticos e os LEDs, e para se certificar que o microcontrolador está corretamente alojado e orientado no seu soquete. Confira tambem se os quatro jumpers (são quatro pedaços de fios finos) foram corretamente soldados nos seus respectivos lugares. Por fim, coloque o strap de JMP1 na posição “EXT”.



Alimentando o Arduino

Com o hardware do Arduino montado já podemos alimentá-lo, embora ainda não possamos controlar nada  com ele pois não temos nenhum programa carregado.  Você pode alimentar o Arduino de duas maneiras diferentes: ou com uma fonte externa ou um carregador para aparelhos portáteis com tensões entre 9V e 15V, como o da figura 6 abaixo; ou diretamente com uma bateria comum de 9 volts com um cabo adaptado para o plug da bateria e para o plug do módulo, veja a figura 6. O positivo da fonte deverá ser o pino central do conector macho que vai ligado ao Arduino.







figura 6



Ao conectar qualquer dessas fontes de tensão ao Arduino somente o LED vermelho deverá acender de imediato indicando que o módulo está alimentado corretamente.  Num outro artigo vamos montar um programador para o bootloader e o cabo serial e fazer nossos primeiros experimentos com o nosso Arduino.



 É isso aí, agora se você ja fez seu arduino ou ja tem um siga a página principal de Arduino do Blog e vá seguindo os tutoriais! Bom Proveito!

Não Me Responsabilizo por Nada Aqui escrito, se pegar FOGO é por sua Conta!

Processing - Primeiros passos para interação com Arduino

Processing + Arduino | Interação Simples

Olá, gostaria de pedir desculpas pelo tempo sem atualização. Tanto o Processing como o Arduino já possuem bibliotecas prontas para uma comunicação eficaz entre eles, e neste post veremos como começar a utilizar tais recursos.

Para começar faça o download da biblioteca Arduino para o processing, já que ela não é nativa do programa.
processing-arduino-0017.zip
Extraia o arquivo zip dentro da pasta "libraries" no Processing, para que você possa utilizá-la.

A seguir, no Arduino, abra o exemplo "Standard Firmata" e faça o upload na sua placa, este exemplo contem o Firmware necessário para interagir diretamente PC-Arduino, este programa é uma ligação entre todos os recursos do arduino e a sua comunicação serial, assim você poderá acessar "diretamente" os valores nas suas entradas digitais e até mesmo escrever valores nas saidas do Arduino interagindo apenas com o seu PC, em outras palavras, você transforma o arduino em um "periférico" do seu pc e pode controlar ele diretamente.

Voltando.


Se você já fez o upload do Firmata para a sua placa, ela não precisa de mais nada para funcionar! Agora vamos a um exemplo básico.

Leitura digital utilizando o Firmata e o Processing

Neste exemplo vamos ver como acessar as portas do Arduino para utilizá-las como saídas para nosso programa Processing. Ligue alguns Leds nos pinos digitais do Arduino, nunca use os pinos 0 e 1 pois eles são ligações diretas com a comunicação serial, que neste caso será obrigatoriamente usada pela placa para conexão com o PC, independente do meio usado (usb, Bluetooth, XBee, rádio, etc). Continuando...

Exemplo de ligações.
Como já disse, você poderá ligar em qualquer pino exceto os pinos 0 e 1.

A seguir abra o Processing e abra o exemplo arduino_output que acompanha os arquivos da biblioteca, deverá ser como este:



import processing.serial.*; // Biblioteca serial nativa do processing

import cc.arduino.*; // Biblioteca de interação com o arduino

Arduino arduino; // Cria um novo objeto arduino para interação com a placa

color off = color(4, 79, 111); //Declara as cores usadas no exemplo
color on = color(84, 145, 158);

int[] values = { Arduino.LOW, Arduino.LOW, Arduino.LOW, Arduino.LOW,
 Arduino.LOW, Arduino.LOW, Arduino.LOW, Arduino.LOW, Arduino.LOW,
 Arduino.LOW, Arduino.LOW, Arduino.LOW, Arduino.LOW, Arduino.LOW };
//Cria um array para armazenar os valores a serem passados para a placa
//Arduino.LOW representa os valor LOW na placa arduino sendo acessada pela biblioteca
//Arduino

void setup() {
  size(470, 200);//Tamanho da tela
  
  println(Arduino.list());//Esse é um comando usado apenas para saber
  // qual a porta utilizada pela placa.
  
  arduino = new Arduino(this, Arduino.list()[0], 57600); //Construtor
  //do objeto arduino, onde Arduino.list()[0] é a porta usada e 57600 é a Baud
  //da porta serial
  
  //Este For é uma parte do código que devemos prestar atenção
  //pois nele estamos utilizando código do arduino.
  //tente substituir este bloco por:
  /*
  arduino.pinMode(2,Arduino.OUTPUT);
  arduino.pinMode(3,Arduino.OUTPUT);
  arduino.pinMode(4,Arduino.OUTPUT);
  etc
  */
  for (int i = 0; i <= 13; i++)
    arduino.pinMode(i, Arduino.OUTPUT);
}
//Percebeu a semelhança? com o código do arduino?
//Pois é...


//Este bloco desenha a interface, não vem ao caso agora
void draw() {
  background(off);
  stroke(on);
  
  for (int i = 0; i <= 13; i++) {
    if (values[i] == Arduino.HIGH)
      fill(on);
    else
      fill(off);
      
    rect(420 - i * 30, 30, 20, 20);
  }
}

//Esta função é um presset do Processing, pode ser chamada de Evento
// Ela é chamada SEMPRE que um botão do mouse é pressionado.
void mousePressed()
{
  int pin = (450 - mouseX) / 30;//Utiliza a posição X do mouse para
  //saber que botão foi clicado
  //Perceba que aqui ele não utiliza a posição Y 
  //mas vamos deixar assim pra simplificar.
  
  //Este bloco if simplesmente comuta os valores
  if (values[pin] == Arduino.LOW) {
    // A parte legal esta aqui!!
    // pra quem já conhece o arduino e POO não tem o que explicar
    // se não vamos lá:
    // aqui você manda a sua placa, representada aqui pelo objeto "arduino"
    // e manda ele escrever numa saída digital
    // perceba que a variável pin é uma variável do programa, e não da placa
    arduino.digitalWrite(pin, Arduino.HIGH);
    values[pin] = Arduino.HIGH;
  } else {
    arduino.digitalWrite(pin, Arduino.LOW);//idem
    values[pin] = Arduino.LOW;
  }
} 

Processing - Textos e Imagens

Vamos Tratar Aqui sobre Processing e Aplicações Visuais Simples.
Normalmente linguagens como o Delphi por exemplo, a IDE já faz praticamente todo o trabalho de codificação dos objetos apresentados na tela, o que não acontece no processing. Então para começar crie um novo projeto e salve no local desejado. Perceba que você não salva um arquivo apenas, o Processing cria uma pasta com o nome que você digitou, é dentro desta pasta que criaremos uma pasta com o nome "data" ela servirá para guardar os arquivos que você utilizará no programa.

Criando uma Fonte .vlw

No menu do Processing, vá em Tools>Create Font. Você deverá ver uma janela como esta:

Ai você deverá escolher exatamente como sua fonte deve parecer(exceto a cor) pois alterar o tamanho da fonte através do código resultará em perda de qualidade da imagem, você terá que criar um arquivo para cada tamanho que for usar, use nomes fáceis para facilitar o código.



Caso queira usar caracteres especiais clique no botão "Caracters" e selecione os tipos desejados, ou apenas selecione "All Caracters".

Para carregar uma fonte você deverá primeiro criar um objeto PFont, e carregá-lo com a fonte que você criou utilizando o Processing.

Vamos ao Código:
void setup() {
  background(255);//Cor de fundo 255,255,255
  size(200,100);  //tamanho da janela 200x100
  PFont font1; //Para começar crie um objeto PFont
  font1 = loadFont("fonte.vlw"); //Carrega o arquivo de fonte
  textFont(font1); //Seta a fonte a ser usada
  fill(0,0,255);   //Seta a cor a ser usada
  text("Hello Strings!",10,50);  //Escreve o texto
E o resultado é:
Caso tenha tido alguma dúvida durante o processo, sinta-se a vontade para perguntar.

Utilizando imagens
Nosso aplicativo com texto é extremamente simples ele nem ao menos precisou entrar no loop, a tela foi desenhada apenas uma vez e conseguimos o que queriamos. Para exemplificar o uso de imagens usarei algo pouco mais complexo.

Para começar, eu criei estas duas imagens que serão utilizadas no exemplo podem baixar e usá-las ou use qualquer outro ( .gif, .jpg, .tga, .png).
OBS.: As imagens devem está dentro da pasta "data" dentro do seu projeto.
Assim como o texto, as imagens também precisam ser previamente declaradas e carregadas e a forma de se fazer é praticamente a mesma. Mas para imagens, utilizaremos o objeto PImage e o metodo loadImage().
Organizando melhor o código ele ficou assim:

PFont font1; //Para começar crie um objeto PFont
PImage back; //Objeto PImage para nossa imagem de fundo

void setup() {
  font1 = loadFont("fonte.vlw"); //Carrega o arquivo de fonte
  back = loadImage("back.png"); //carrega a imagem
  size(240,320);  //tamanho da janela 240x320
  image(back,0,0); //Desenha a imagem na posição 0x0
  textFont(font1); //Seta a fonte a ser usada
  fill(0,0,0);   //Seta a cor a ser usada
  text("Hello Images!",60,20);  //Escreve o texto
}
Perceba que não usei background pois a imagem utilizada supostamente é o nosso background aqui. Agora para deixar as coisas mais interessantes vamos adicionar a outra imagem, e vamos fazer ela acompanhar a posição do mouse. Nosso código deveria ficar assim:

PFont font1; //Para começar crie um objeto PFont
PImage back; //Objeto PImage para nossa imagem de fundo
PImage pointer;

void setup() {
  font1 = loadFont("fonte.vlw"); //Carrega o arquivo de fonte
  back = loadImage("back.png"); //carrega a imagem
  pointer = loadImage("pointer.png");
  size(240,320);  //tamanho da janela 240x320
  smooth();
  image(back,0,0); //Desenha a imagem na posição 0x0
  textFont(font1); //Seta a fonte a ser usada
  fill(0,0,0);   //Seta a cor a ser usada
  text("Hello Images!",60,20);  //Escreve o texto
}

void draw(){
imageMode(CENTER);
image(pointer,mouseX,mouseY);
}

Compile e rode este código, confira cada letra, use nomes fáceis para os arquivos, é comum erros por tentar carregar um arquivo com nome errado, ou que está fora do lugar.
 Interessante!! Mas não é exatamente o que eu queria...
Para quem entendeu o que está acontecendo ótimo você pode pular alguns parágrafos, se não preste bastante atenção nesta parte que é importante.

Como ja foi dito anteriormente, o Processing gera sua aplicação através de desenhos na tela, ele foi feito para as mais diversas aplicações possiveis, desde programas mais comuns como oque utilizamos normalmente, a verdadeiras obras de arte em que sua janela é o quadro. Por este motivo, coisas básicas como limpar a tela a cada ciclo é algo que devemos fazer manualmente.

COMO?!?!?!?!?!?!

Bem simples, vamos ver o código mais de perto.

PFont font1; //Para começar crie um objeto PFont
PImage back; //Objeto PImage para nossa imagem de fundo
PImage pointer;

void setup() {
  font1 = loadFont("fonte.vlw"); //Carrega o arquivo de fonte
  back = loadImage("back.png"); //carrega a imagem
  pointer = loadImage("pointer.png");
  size(240,320);  //tamanho da janela 240x320
  smooth();
  image(back,0,0); //Desenha a imagem na posição 0x0
  textFont(font1); //Seta a fonte a ser usada
  fill(0,0,0);   //Seta a cor a ser usada
  text("Hello Images!",60,20);  //Escreve o texto
}

void draw(){
imageMode(CENTER);
image(pointer,mouseX,mouseY);
}
Os trechos destacados acima são as 3 funções que desenham nossa janela, primeiro é desenhado o fundo, depois o texto e por ultimo a espiral na posição do mouse, mas como vocês viram, ele desenha infinitas espirais a cada nova posição do mouse (afinal é pra isso que servem os loops não?), mas eu quero apenas UMA espiral movendo-se na tela, e não um rastro de infinitas...

Para isso basta transferir o código que desenha o fundo e o texto para o loop e fazer alguns ajustes como:
  1. Limpar a tela para que a imagem atual nao se misture com a anterior.
  2. Caso utilize mais de um modo de desenho, por exemplo imageMode(), não deixe de colocar, pois onde não houver explicitamente o modo, será usado o ultimo modo, que pode não ser interessante já que estamos dentro de um loop.
Resultado:
PFont font1; //Para começar crie um objeto PFont
PImage back; //Objeto PImage para nossa imagem de fundo
PImage pointer;

void setup() {
  font1 = loadFont("fonte.vlw"); //Carrega o arquivo de fonte
  back = loadImage("back.png"); //carrega a imagem
  pointer = loadImage("pointer.png");
  size(240,320);  //tamanho da janela 240x320
  smooth();
}

void draw() {
  background(255);//Pinta toda a tela de branco  
  imageMode(CORNER);
  image(back,0,0); //Desenha a imagem na posição 0x0
  textFont(font1); //Seta a fonte a ser usada
  fill(0,0,0);   //Seta a cor a ser usada
  text("Hello Images!",60,20);  //Escreve o texto
  imageMode(CENTER);
  image(pointer,mouseX,mouseY);
}