Este post é para mostrar um código que funciona para o envio de arquivos e parâmetros ao mesmo tempo em qualquer codificação.

In english:

One problem I ever face is when sending files and data (parameters, variables) using python via HTTP POST.

There are solutions to send only files or only parameters that are suitable for most use, but not mine. One example is sending a photo with title and description. One of the only good reference I found was this post on ActiveState made ​​in 2002, but the problem is that it does not work with UTF-8.

This post is to show a code that works for sending files and parameters simultaneously in any encoding.

Abaixo segue o código:

import httplib
import mimetypes
import base64

def post_multipart(host, selector, fields, files, encoding='utf-8'):
    """
    Post fields and files to an http host as multipart/form-data.
    fields is a sequence of (name, value) elements for regular form fields.
    files is a sequence of (name, filename, value) elements for data to be uploaded as files
    Return the server's response page.
    """
    content_type, body = encode_multipart_formdata(fields, files)
    body = body.encode(encoding)

    h = httplib.HTTP(host)
    h.putrequest(u'POST', selector)
    h.putheader(u'Content-Type', content_type)
    h.putheader(u'Charset', encoding)
    h.putheader(u'Content-Length', str(len(body)))
    h.endheaders()
    h.send(body)

    errcode, errmsg, headers = h.getreply()
    return h.file.read()

def encode_multipart_formdata(fields, files, encoding='utf-8'):
    """
    fields is a sequence of (name, value) elements for regular form fields.
    files is a sequence of (name, filename, value) elements for data to be uploaded as files
    Return (content_type, body) ready for httplib.HTTP instance
    """
    BOUNDARY = u'----------ThIs_Is_tHe_bouNdaRY_$'
    CRLF = u'rn'
    L = []

    for (key, value) in fields:
        L.append(u'--' + BOUNDARY)
        L.append(u'Content-Disposition: form-data; name="%s"' % key)
        L.append(u'Content-Type: text/plain;charset=%s' % encoding)
        L.append(u'Content-Transfer-Encoding: 8bit')
        L.append(u'')
        L.append(value)

    for (key, filename, value) in files:
        L.append(u'--' + BOUNDARY)
        L.append(u'Content-Disposition: form-data; name="%s"; filename="%s"' % (key, filename))
        L.append(u'Content-Type: %s;charset=%s' % (get_content_type(filename), encoding))
        L.append(u'Content-Transfer-Encoding: base64')
        L.append(u'')
        L.append(base64.b64encode(value).decode())

    L.append(u'--' + BOUNDARY + u'--')
    L.append(u'')
    body = CRLF.join(L)
    content_type = u'multipart/form-data; boundary=%s' % BOUNDARY

    return content_type, body

def get_content_type(filename):
    return mimetypes.guess_type(filename)[0] or 'application/octet-stream'

As diferenças entro o meu código e o código original são:

• Uso de strings unicode e a codificação é feita apenas no momento do envio da requisição.
• Uso da variável encoding para definir o encoding que será enviada a requisição.
• Codificando o arquivo em base64 para não ter problemas com acentuação interna.
• Indicando no cabeçalho do boundary que o arquivo está codificado em base64.
• Adicionando Charset no cabeçalho da requisição e nos cabeçalhos do boundary.

Depois de entender como reproduzir som com o Arduino, vou dar um exemplo de como usar um sensor ping (HC-SR05) para modificar o som que está sendo reproduzidor, este exemplo é muito parecido com o funcionamento de um Theremim simplificado.

Veja o vídeo no YouTube.

O que é um sensor ping  (HC-SR05)?

O sensor ping é constituido por duas partes: um gatilho (emissor) e o eco (receptor), funcionando basicamente como um sonar, emitimos um pulso ultrasônico e aguardamos o seu eco no receptor, quanto mais tempo demorar o eco, maior a distânica, e vice-versa. A partir deste dispositivo conseguimos medir a distância entre um objeto qualquer e o sensor, lembrando que sua medida nativa é o tempo decorrido entre a emissão e a recepção, é necessário transformar esta duração de tempo em distância.

Esquema

O esquema é simples, o sensor HC-SR05 necessita de +5V, GND (terra) e duas portas digitais, uma para o gatilho (saída) e outra para o eco (entrada), já o buzzer necessita de uma porta digital com PWM (Pulse with modulation) e um GND (terra). Segue o esquema que montei como exemplo:

Baixe o esquema do Theremim para Fritzing.

Alguns sensores ultrasônicos tem apenas três pinos, sendo os pinos das pontas +5V e GND e o pino central o gatilho e o eco ao mesmo tempo. Neste caso durante a programação você tem que especificar o que o pino será, saída (gatilho) ou entrada (eco) a cada vez que precisa usar o sensor. Veja a especificação do seu sensor antes de conectá-lo na breadboard.

Programação

Desta vez o programa é um pouco maior, mas é tão simples quanto os anteriores.

Este código está versionado no meu repostório do bitbucket.

/*
  Theremim

  Esta é uma implementação simplificada que tenta copiar o
  instrumento musical Theremim. Usa um sensor ping (HC-SR05)
  e um buzzer, dependendo da distância de um objeto qualquer
  sensor ping, será reproduzida uma nota, quanto mais longe,
  mais aguda é a nota.

  Esquema:
  - 5V de entrada em VCC.
  - Trigger (gatilho) no pino 2.
  - Echo (eco) o pino 3.
  - GND no terra.
  - Buzzer na porta 9.

  Algumas partes do código foram retiradas de:

http://www.arduino.cc/en/Tutorial/Ping

*/

#define NOTA_DO  262
#define NOTA_RE  294
#define NOTA_MI  330
#define NOTA_FA  349
#define NOTA_SOL 392
#define NOTA_LA  440
#define NOTA_SI  494

int pinoGatilho = 2;
int pinoEco = 3;
int pinoBuzzer = 9;
int valor = 0;
int nota = 0;
int intervalo_intervalo_distancia = 7;

void setup() {
  // O pino do gatilho enviará energia.
  pinMode(pinoGatilho, OUTPUT);
  // O pino do eco receberá o resultado.
  pinMode(pinoEco, INPUT);

  // O pino do buzzer enviará energia.
  pinMode(pinoBuzzer, OUTPUT);
}

void loop() {
  long duracao, cm;

  // Envia um ping, para tentar receber o eco.
  digitalWrite(pinoGatilho, LOW);
  delayMicroseconds(2);
  digitalWrite(pinoGatilho, HIGH);
  delayMicroseconds(5);
  digitalWrite(pinoGatilho, LOW);

  // Recebe o eco, já com o valor do intervalo de tempo tempo.
  duracao = pulseIn(pinoEco, HIGH);

  // Converte o tempo em distância.
  cm = microsecondsToCentimeters(duracao);

  // Verifica qual nota será tocada de acordo com a distância.
  if (cm > (intervalo_distancia * 0) && cm < (intervalo_distancia * 1)) {
    nota = NOTA_DO;
  } else if (cm >= (intervalo_distancia * 1) && cm < (intervalo_distancia * 2)) {
    nota = NOTA_RE;
  } else if (cm >= (intervalo_distancia * 2) && cm < (intervalo_distancia * 3)) {
    nota = NOTA_MI;
  } else if (cm >= (intervalo_distancia * 3) && cm < (intervalo_distancia * 4)) {
    nota = NOTA_FA;
  } else if (cm >= (intervalo_distancia * 4) && cm < (intervalo_distancia * 5)) {
    nota = NOTA_SOL;
  } else if (cm >= (intervalo_distancia * 5) && cm < (intervalo_distancia * 6)) {
    nota = NOTA_LA;
  } else if (cm >= (intervalo_distancia * 6) && cm < (intervalo_distancia * 7)) {
    nota = NOTA_SI;
  } else {
    nota = 0;
  } 

  // Toca a nota correspondente.
  if (nota) {
    tone(pinoBuzzer, nota);
  } else {
    noTone(pinoBuzzer);
  }

  // Aguarda 100ms para fazer novamente.
  delay(100);
}

long microsecondsToCentimeters(long microseconds)
{
  // A velocidade do som é de 340 m/s ou 29 microsegundo por centímetro.
  // O ping vai e volta, então para encontrar a distância do
  // objeto devemos dividir por dois a distância viajada.
  return microseconds / 29 / 2;
}

Links interessantes

• http://www.arduino.cc/cgi-bin/yabb2/YaBB.pl?num=1242689596 (português)
• http://www.arduino.cc/en/Tutorial/Ping (inglês)

A forma mais simples de reproduzir som no Arduino é usando um Buzzer ou um Piezo. O Buzzer é muito usado em computadores para emitir o sinal inicialização do sistema e para indicar possíveis erros. Quem nunca ouviu os 3 bips infernais de erro de memória e teve que ficar o final de semana inteiro sem computador? Pois é, é pelo Buzzer que esse sinal sonoro é emitido.

Como funciona o Buzzer?

Dentro do buzzer existem duas camadas de metal e uma camada interna de cristal piezoelétrico, quando é enviada corrente através do buzzer a camada interna vibra na mesma frequência reproduzindo assim um som, por exemplo, se enviarmos corrente em uma frequência de 440Hz, ouviremos o som da nota Lá. Quanto maior a corrente maior o “volume” do som.

Vamos ao esquema

O Buzzer tem apenas dois conectores, um positivo (vermelho) e um negativo (preto). O positivo conectaremos a uma saída digital que tenha PWM (Pulse With Modulation) escrito nela e o negativo conectaremos ao terra (GND) assim como segue o esquema:

Alguns buzzers são tão fracos que se você colocar um resistor não vai ouvir nada. Faça um teste no seu com resistor e sem resistor, ou se for possível teste vários resistores diferentes e veja qual é o melhor para o seu projeto.

Código

Para o nosso Buzzer reproduzir um som precisamos fazer com que um pino emita corrente e pare de emitir em uma determinada frequência, isso é um pouco complicado de ser fazer na mão (mas não é impossível). Por isso a linguagem de programação do Arduino vem com uma função chamada tone(). Esta função pede o número de um pino, a frequência e, opcionalmente, a duração.

Para usarmos a função tone(), o pino que estamos conectando o Buzzer deve ser um pino PWM.

Além da função tone() temos a função noTone(), que recebe o número de um pino e finaliza o som neste pino. Vamos ao código para tocarmos as notas musicais no Buzzer:

/*
  Caixinha de música.

  Reproduz as notas de Dó até o Sí.

  Esquema:
  - Ligar o positivo do áudio até o pino 3
    (ou qualquer outro com PWM).
  - Ligar o negativo do áudio no terra (GND).
*/

// Notas de acordo com a vibração em Hz.
// 440Hz é o Lá central.
#define NOTA_DO  262
#define NOTA_RE  294
#define NOTA_MI  330
#define NOTA_FA  349
#define NOTA_SOL 392
#define NOTA_LA  440
#define NOTA_SI  494

// Indicar o pino que está o áudio.
int pinoFalante = 3;

void setup() {
  // Definimos o pinoFalante como saída.
  pinMode(pinoFalante, OUTPUT);
}

void loop() {

  // A cada volta do loop  serão tocadas as notas.
  tone(pinoFalante, NOTA_DO);
  delay(500);
  tone(pinoFalante, NOTA_RE);
  delay(500);
  tone(pinoFalante, NOTA_MI);
  delay(500);
  tone(pinoFalante, NOTA_FA);
  delay(500);
  tone(pinoFalante, NOTA_SOL);
  delay(500);
  tone(pinoFalante, NOTA_LA);
  delay(500);
  tone(pinoFalante, NOTA_SI);
  delay(500);
  noTone(pinoFalante);
  delay(1000);

}

Seguem algumas explicações.

No trecho a seguir definimos uma constante, estamos dizemos que sempre que usarmos a constante NOTA_LA, termos um valor inteiro de 440. Nunca poderá ser alterado o valor de uma constante em tempo de execução (por isso o nome é constante, e não variável!).

#define NOTA_LA  440

Dentro do loop começamos a reproduzir som com a função tone(). No trecho a seguir temos a função tone sendo executada com o pinoFalante e NOTA_LA como parâmetros, isso quer dizer que o pinoFalante emitirá corrente na frequência NOTA_LA, que tem valor 440. O pinoFalante receberá corrente em uma frequência de 440Hz.

Após isso temos o delay de 500ms (meio segundo). Quando executamos a função tone() o pino equivalente ficará enviando corrente na frequência indicada até que sejá enviado um noTone no mesmo pino.

Na linha 3 mudamos de frequência, em nenhum momento o som irá parar, haverá apenas a mudança de nota a cada meio segundo.

tone(pinoFalante, NOTA_LA);
delay(500);
tone(pinoFalante, NOTA_SI);
delay(500);

E por último temos a chamada do noTone(), aí sim, fazendo com que o som pare. O delay de 1 segundo na linha abaixo faz com que o Buzzer não toque nada por 1 segundo.

noTone(pinoFalante);
delay(1000);

Com esta base você pode fazer músicas mais complexas, é só ficar atento às frequências e tempo, para saber mais siga os links:

• http://arduino.cc/en/Reference/Tone (inglês)
• http://arduino.cc/en/Reference/noTone (inglês)
• http://www.arduino.cc/cgi-bin/yabb2/YaBB.pl?num=1231194692 (inglês)

Usando quase o mesmo esquema do Led piscando, podemos inserir um botão no circuito e fazer com que o Led só acenda quando o botão é pressionado.

Para isso precisamos deixar o botão no circuito entre o pino de saída e o Led, desta forma como mostra o esquema:

Para entender um pouco mais sobre o botão

O botão é uma pequena chave que quando pressionada conecta os seus dois lados. A maioria dos botões tem quatro pernas de conexão, embaixo do botão podemos ver uma linha central aprofundada (ver imagem abaixo), esta linha divide os dois lado do botão, isso quer dizer que de um lado da linha os pinos são interconectados e do outro lado também, e quando o botão é pressionado um lado é conectado ao outro, fazendo a corrente passar de um lado pro outro.

E agora vamos fazer com que o pino do Led fique enviando corrente o tempo todo e quando o botão for pressionado, a corrente será enviada para o Led, fazendo com que ele acenda. Segue o código:

/*
  Led que liga quando o botão é apertado.

  Esquema:
  - Pino 2 como saída, conectado a um resistor
    de 1k-ohm, conectado a uma das pernas do botão.
  - Outra perna do botão conectada ao positivo do Led.
  - Negativo do Led conectado ao terra (GND).
*/

// Definindo qual será o pino do Led.
int pinoLed = 2;

void setup() {
  // Definindo o pino do Led como saída (OUTPUT).
  pinMode(pinoLed, OUTPUT);
  // Deixando o pino do Led enviando +5V.
  digitalWrite(pinoLed, HIGH);
}

void loop() {
}

Neste nosso código não temos nada no Loop, pois não mudamos em momento algum o comportamento dos pinos.

Bem simples, não é?

Fazer um led piscar com o Arduino é muito simples, vou mostrar aqui o esquema e a programação de como fazer isso com o seu arduino.

Primeiro você vai precisar de um LED e um resistor de 1kΩ, você deve montar o seguinte esquema:

Depois do esquema montado vamos ao programa:

/*
  Led piscando de 1 em 1 segundo.

  Esquema:
  - Led conectado a saída digital 2 através de
    um resistor de 1k-ohm.
  - Negativo do Led conectado ao terra (GND).
*/

// Definindo qual será o pino do Led.
int pinoLed = 2;

void setup() {
  // Definindo o pino do Led como saída (OUTPUT).
  pinMode(pinoLed, OUTPUT);
}

void loop() {
  // Ligando o Led.
  digitalWrite(pinoLed, HIGH);

  // Esperando 1 segundo com o Led ligado.
  // -> 1000 milisegundos = 1 segundo
  delay(1000);

  // Desligando o Led.
  digitalWrite(pinoLed, LOW);

  // Esperando 1 segundo com o Led desligado.
  delay(1000);
}

O programa é muito simples. Primeiro definimos qual será o pino que enviará energia para o Led acender:

// Definindo qual será o pino do Led.
int pinoLed = 2;

Depois é só dizer que o pino que o Led está servirá como pino de saída (os pinos digitais podem servir como saída e entrada):

void setup() {
  // Definindo o pino do Led como saída (OUTPUT).
  pinMode(pinoLed, OUTPUT);
}

E no loop fazemos com que o pino do Led fique enviando HIGH (+5V) para o Led, para que o mesmo fique ligado por 1 segundo (ou 1000 milisegundos) e depois fique enviando LOW (0V) para o Led para que o mesmo fique desligado por 1 segundo:

void loop() {
  // Ligando o Led.
  digitalWrite(pinoLed, HIGH);
  // Esperando 1 segundo com o Led ligado.
  // -> 1000 milisegundos = 1 segundo
  delay(1000);

  // Desligando o Led.
  digitalWrite(pinoLed, LOW);

  // Esperando 1 segundo com o Led desligado.
  delay(1000);
}

Acho que este é o esquema mais simples de se trabalhar com o Arduino. Em breve colocarei esquemas um pouco mais complicados.

Por que preciso usar um resistor entre o pino e o Led?

Um resistor é um componente feito para impedir ou reduzir a passagem de corrente elétrica. Se conectarmos o Led diretamente ao pino, será enviada muita corrente para o Led, mais corrente do que o necessário para que ele acenda. Isso pode fazer com que o Led “queime” ou até mesmo causar um curto circuito no seu Arduino.

Comprei recentemente um Arduino. Comecei a brincar primeiro com com leds e resistores e tudo é muito divertido, mesmo acender um led que é uma coisa muito simples traz uma enorme satisfação quando você faz tudo, desde o programa até o circuito.

Eu não sabia nada de eletrônica, e ainda não sei muito, mas é muito legal quando você tem que pensar sobre os componentes que farão parte do seu circuito e se você deve ou não colocar um resistor alí entre eles. Isso faz você aprender bastante na prática.

Neste blog vou tentar falar sobre Arduino e quando eu for desenvolvendo meus projetos colocarei em detalhes aqui.

Até mais.

PS: Tentarei colocar todas as imagens, diagramas e vídeos em alta definição para ficar mais simples de acompanhar o que e como estou fazendo.