Ebook Python com Arduino - Assistente Virtual

Prévia do material em texto

INDICE
Apresentação ........................................................................................................... 03
1. O que é o Python ................................................................................................. 03
2. Introdução ao Python .......................................................................................... 05
a. Variáveis ......................................................................................................... 05
b. Entrada e Saída ............................................................................................... 07
c. Condicional ..................................................................................................... 08
d. Bibliotecas ...................................................................................................... 14
3. Projeto Assistente Virtual ................................................................................... 15
a. O que é um Assistente Virtual ........................................................................ 15
b. Fazendo o Python Falar .................................................................................. 16
c. Fazendo o Python Ouvir ................................................................................. 18
d. Chatbot com Python ...................................................................................... 21
4. Aduino ouvindo Python ....................................................................................... 26
5. Projeto Completo ................................................................................................. 34
6. Conclusão ............................................................................................................ 38
Bibliografia ............................................................................................................... 39
3
Apresentação
 
A Pixels Escola é uma escola de tecnologia especialista em cursos de Design, 
Software e Robótica, onde no período da pandemia de 2020 se reinventou e 
desenvolveu diversos cursos on-line, um deles é este, Assistente Virtual com 
Python e Arduino, disposto em 10h/a ministradas ao vivo e 6h/aula de vídeo 
gravado postado no Youtube, não listado, onde somente você terá o acesso a este 
conteúdo produzido especialmente para nossos alunos do curso de robótica com 
Arduino.
Para complementar a Escola Pixels produziu este ebook como um guia escrito 
para o melhor aproveitamento do curso e possibilidade de referência em pesquisa 
futura.
Aproveite este ebook e avance no conhecimento: 
“Não se deve ir atrás de objetivos fáceis, é preciso buscar o que só pode ser 
alcançado por meio dos maiores esforços.”
Albert Einstein
1. O que é o Python
Segundo o Livro Python para desenvolvedores de Luiz Eduardo Borges: “Python é 
uma linguagem de altíssimo nível (em inglês, Very High Level Language) orientada 
a objeto, de tipagem dinâmica e forte, interpretada e interativa.”
Abaixo apresento algumas características:
 Sintaxe clara e concisa
 Possui estrutura de Alto nível
 Possibilidade de adição de frameworks de terceiros
 Suporta programação modular, funcional e orientada a objetos
 Código portável
 Software de Código Aberto
A linguagem surgiu em 1990 pelo professor Guido Van Rossum do Instituto 
Nacional de Pesquisa para Matemática e Ciência da Computação da Holanda 
(CWI).
4
Python é uma linguagem interpretada ou também conhecida como uma 
linguagem de script e também é uma linguagem interpretada quanto uma 
linguagem compilada. E o que é um compilador?
É o compilador que traduz linguagem Python em linguagem de máquina - 
código Python é traduzido em um código intermediário que deve ser executado 
por uma máquina virtual conhecida como PVM (Python Virtual Machine), ops, 
máquina virtual? Isso mesmo que você se lembrou, o bom e velho Java, sim o 
Virtual Machine do Python é muito similar ao Java que tem o objetivo de traduzir 
programas Python em bytecode Java para JVM (Java Virtual Machine).
O interpretador faz esta ‘tradução’ em tempo real para código de máquina, e 
o compilador traduz o programa inteiro em código de máquina de uma só vez e 
então o executa, criando um arquivo que pode ser executado.
Alguns links são importantes para caminhada na programação Python, abaixo 
listei os principais, porém a comunidade é muito grande e com isso podemos 
encontrar informações e soluções em vários sites e livros:
● 
https://www.python.org/
https://python.org.br/
https://pypi.org/
https://anaconda.org/anaconda/python
E para finalizar esse primeiro capítulo, apresento algumas empresas que usam 
python em seu projetos ou produtos.
5
2. Introdução ao Python
 
Um programa Python, executa instrução após instrução sendo a execução linear, 
gerando ao final um arquivo .py. Nos blocos de código, como nas condicionais que 
iremos estudar mais a frente, a indentação tem a função de delimitar esses blocos 
e organizá-los.
Imagem: Livro Python para desenvolvedores de Luiz Eduardo Borges, pag 24
Neste capítulo iremos iniciar nossa programação em Python conhecendo os 
Tipos de variáveis, como que se escreve na Tela do Computador, como recebe um 
dado do mundo externo, as formas de condicionais do programa e por fim uma 
introdução a bibliotecas.
a. Variáveis
O Python possui tipagem dinâmica, ou seja, você não precisa declarar o tipo 
de variável que está usando, basta escrever o valor que o Python identifica e irá 
atribuir corretamente. Os principais tipos internos de variáveis são números, 
sequências, mapas, classes, objetos e exceções, mas iremos focar primeiramente 
nos números (int e float), lógicos (bool) e sequências de texto (strings).
int: guarda números inteiros entre -2147483648 e 2147483647, utiliza 4 bytes
6
float: guarda números com ponto flutuante, frações ou seja números reais 
entre (aproximadamente) 10-38 e 1038, utiliza 6 bytes, precisão de 8 dígitos. 
Ao contrário dos números reais, os números representáveis pelo hardware são 
finitos. A maneira como os tipos de ponto flutuante são armazenados é abstrata 
para o programador, entretanto, o hardware segue o padrão IEEE 754 (Standard for 
Floating-Point Arithmetic).
boolean: variáveis que podem assumir apenas 2 estados, true (verdadeiro) ou 
false (falso);
String: Uma variável do tipo String pode ser iniciada ou inicializada de forma 
semelhante a uma variável de tipo primitivo além de poder ser iniciada através 
de construtores como será visto mais à frente. A iniciação é feita com literais do 
tipo String . Um literal do tipo String é uma seqüência de caracteres iniciada e 
terminada com aspas. 
O operador + também funciona com strings de uma maneira diferente dos 
números. Ele funciona concatenando strings, ou seja, juntando duas strings:
Imagem: site Caelum
O operador * também funciona com strings, multiplicando seu conteúdo por um 
inteiro. Vamos checar esse resultado:
Imagem: site Caelum
Segue na imagem abaixo um exemplo das variáveis estudadas:
O resultado será conforme imagem abaixo:
7
b. Entrada e Saída
Os comandos de entrada e saída no Python ou em qualquer outra linguagem 
de programação possuem o objetivo de comunicar o seu código com o mundo 
exterior, ou seja, o comando de entrada permite que o usuário envie dados do mundo 
exterior, como do teclado, sensores ou mouse, para uma variável do programa, 
aquela variável que definimos o tipo associada ao comando, e o comando de saída 
permite exibir, mostrar, imprimir, por exemplo na tela do computador, mensagens, 
expressões, gráficos, imagens e/ou valores armazenados em variáveis do 
programa.
O comando de Entrada permite receber o valor digitado no teclado, por exemplo, 
pelo usuário e atribuir esse valor a variável que foi associada ao comando. Comando 
(função) de entrada do python: input. Saiba que ele irá interromper a execução do 
programa para esperar que o usuário digite o valor solicitado no teclado, então 
cuidado no uso deste comando, pois elepode ser criado e nada informado ao 
usuário e com isso ele ficar sem saber o que fazer, logo é boa prática junto com o 
comando de input tenha um texto orientando o que o usuário deve fazer e ao final 
da digitação basta ser pressionada a tecla “Enter”. Após isso, o valor digitado será 
movido para variável associada ao input.
Forma Geral:
variável = input(‘Mensagem para o usuário’)
Exemplo:
nome = input(‘Digite o seu Nome Completo’)
Por padrão, o comando input move valores do tipo String para as variáveis 
associadas ao comando. Porém caso o usuário deseje digitar um número, deve 
ser usado o tipo de variável correspondente a variável para o python entender que 
não se trata de um texto e sim de um valor numérico.
Para receber um número inteiro escreva no seu código o nome da variável 
= int(input(‘Texto a ser mostrado ‘)), é essa composição da função input com 
8
a função int que garante que o resultado final armazenado na variável será um 
número inteiro.
Para receber um número real escreva no seu código o nome da variável = 
float(input(‘Texto a ser mostrado ‘)), neste caso o uso da função float garantirá 
que o resultado final que será armazenado na variável seja um número real.
O comando de saída nós já usamos aqui em nosso e-book para imprimir os 
tipos de variáveis, porém vamos oficializar a estrutura e teoria desta função no 
Python.
O comando print (função) permite exibir na tela do usuário mensagens, 
expressões e/ou valores armazenados em variáveis do programa, sua sintaxe é:
print(‘Mensagem para o usuário’, variável)
No exemplo abaixo o algoritmo recebe o ano de nascimento do usuário, o ano 
atual e imprime a idade, quer tentar fazer? Pois faça uma pausa nesta leitura, abra 
seu Pycharm (QUE JÁ ERA PRA ESTAR ABERTO!) e tente resolver essa atividade.
c. Condicional
Como seria bom se todo caminho em nossa vida fosse uma linha reta, não 
houvesse imprevistos, desvios ou tomadas de decisões, caminho único, objetivo 
único, vida perfeita não é? É, mas essa vida só existe em conto de fadas, e na 
programação é do mesmo jeito, a todo momento são impostas condições que 
devem ser analisadas, tratadas ou questionadas para o código tomar o caminho 
correto, essa situação é devido às estruturas condicionais, onde se divide em if/
else, while, for e switch/case, e vamos estudar cada uma delas.
9
IF/ELSE
 A condicional IF/ELSE é um teste onde SE a condição for verdadeira execute 
uma tarefa SENÃO executa outra tarefa:
Você observou que usamos o “==”? Esse simbolo ai é chamado de operador 
condicional, os Operadores Condicionais são utilizados para fazer as comparações 
dos valores que são passados e retornam o valor Verdadeiro ou Falso.
Imagem: Site Devmedia
Vamos fazer um exemplo para fixar: 
Ex. 01: “Faça um algoritmo que receba um número real e informe se ele é positivo, 
negativo ou nulo.”
10
Ex. 02: “Faça um algoritmo que obtém do usuário do usuário a sua idade e 
informa a qual faixa etária esse usuário pertence:
Criança menor igual a 12 anos
Adolescente maior de 12 e menor que 18 anos
Adulto entre 18 e 64 anos
Idoso maior de 64 anos
WHILE
A condicional do tipo laço de repetição é um recurso das linguagens de 
programação que é responsável por “rodar” um bloco de código repetidas vezes 
enquanto determinada condição passada for verdadeira, onde neste caso deste 
capítulo iremos estudar a condicional while.
O comando while repete um trecho do código enquanto uma condição é 
atendida. Quando o resultado dessa condição passa a ser falso, a execução do 
loop é interrompida. O uso do while poupa linhas de códigos, torna o programa 
mais legível e robusto podendo ser chamado de laço, loop ou loping, observe o 
exemplo abaixo:
11
Observe que o programa fica dentro do while enquanto a condição contador 
for menor que 10, e toda vez que passar pelo while ele vai imprimir um contador 
incrementado mais 1 unidade conforme mostra a figura abaixo.
FOR
A instrução for é um pouco diferente da while, também se trata de um laço 
em que o programa fica rodando até a condição de teste for falsa, porém ela se 
caracteriza pela obrigatoriedade em definir a quantidade de vezes [ciclos] que 
será executado, diferente do while que esse ciclo é definido dentro do laço, quando 
fizemos a instrução contador = contador +1. O Laço de Repetição for do Python se 
assemelha ao for each encontrado linguagens como o Java, PHP, C# e etc. 
12
Observe a seguir o esquema para o uso da instrução for:
A variável a ser declarada na primeira parte da estrutura, receberá, a cada ciclo, 
um elemento contido na lista que está sendo iterada. Ao término, todos elementos 
terão sido percorridos e, a cada ciclo, o elemento seguinte contido no objeto 
iterável terá sido passado pela variável definida inicialmente.
Observe o resultado impresso:
Exemplo 02, você pode percorrer uma string, pois uma string nada mais é do que 
uma lista de caracteres:
13
Exemplo 03, posso percorrer com o for uma lista de Strings:
Exemplo 04, podemos usar o método range:
Observe nos exemplo usando o range que o último elemento do incremento não 
é inclusivo.
14
SWITCH/CASE
 Cada linguagem usa uma sintaxe e abordagem própria para atacar problemas 
similares, no caso do Switch/Case, presente no PHP, Arduino, etc, usamos uma 
estrutura if/elif no Python.
O primeiro elif eu posso passar como parâmetro valores específicos, nesse caso 
o programa entraria nesta condição quando a variável num receber 1 ou 4.
d. Bibliotecas
import speech_recognition 
import pyttsx3
import serial
import threading
import time
Essas serão as bibliotecas que usaremos em nosso projeto que inicia no próximo 
capítulo, mas afinal, o que é uma biblioteca? O que é esse import?
15
É um conjunto de funções usado em uma linguagem de programação que foram 
pré-escritas por outro programador, para ser usado por outros desenvolvedores 
importando essas funções que irão resolver certos problemas sem que você 
precise reinventar um código. É basicamente funções que já existem no programa 
e que você pode usar.
A vantagem de criar bibliotecas para desenvolver programas é que seu programa 
será resolvido de uma forma mais simples. Mas como insiro esse outro programa 
em meu código? No python usamos o comando import.
import package
Para importar um módulo utilizamos o import.
import math
print(math.sqrt(25))
O código acima importará todos os módulos de math, para importar apenas o 
necessário utilizamos from.
from package import item
O código abaixo importará o módulo sqrt do pacote math.
from math import sqrt
print(sqrt(25))
Observe que ao utilizar from package import item, o item pode ser um subpacote, 
submódulo, classe, função ou variável.
Cada uma das cinco bibliotecas serão comentadas dentro de cada tópico 
quando fizer referência no nosso programa do Assistente Virtual, então, vamos 
fazer nosso amigo nascer, vamos iniciar a programar nosso assistente virtual.
3. Projeto Assistente Virtual
 
Chegamos ao objetivo principal deste ebook, aprender a criar um Assistente 
Virtual em Python, que além de um chatbot também tenha a função de ligar e 
desligar componentes conectados no meu Arduino no próximo capítulo.
Iremos, neste capítulo fazer o python falar, ouvir e por ultimo responder, mas 
antes, vamos alinhar aqui sobre o que é um assistente virtual.
a. O que é um Assistente Virtual
Um assistente virtual é um robô que pode estar instalado em seu computador, 
16
em uma caixa de som, no seu carro ou embarcado em uma placa como o Raspberry, 
ele tem a função de auxiliar em atividades como ligar eletrodomésticos, lembretes, 
leitura de livros e pesquisas na internet por exemplo. Alguns modelos comerciais 
temos a Siri, Cortana e o Jarvis, neste e-book iremos fazer um conceito e programar 
um assistente com comandos simples e sem inteligência Artificial.
A Cortana, por exemplo, é a assistente virtual da Microsoft. Ou seja, suas 
funções são parecidas com as da Siri, da Apple, ou do Google Assistente, do 
Google, ela possuiuma inteligência artificial aprendendo com os hábitos de 
utilização do usuário. Dessa forma, quanto mais você usa a assistente virtual, 
mais personalizadas ficam as respostas. Sem esquecer, claro, da possibilidade de 
usar comandos de voz em algumas ações.
Uma das vantagens da Cortana é que a assistente virtual pode ser usada em 
computadores e notebooks com Windows 10 e em smartphones Android e iOS, por 
meio do aplicativo. Dessa forma, todas as suas informações podem ser acessadas 
em diferentes dispositivos.
b. Fazendo o Python Falar
Nesta primeira programação de nosso Estudo de um Assistente Virtual com 
Python, gostaria de mostrar o pacote e a programação responsável por fazer o 
Python falar.
Um assistente virtual é um software que auxilia o humano em atividades 
rotineiras como alarme, buscar informações na rede de internet, controlar casas 
ou carros e até mesmo um bom bate papo.
E todo bom assistente tem que falar, por isso iremos ensinar como programar o 
Python para falar, bora lá?
17
Para quem está iniciando na linguagem de programação terá que ter um pouco 
mais de dedicação pois nesse projeto do assistente iremos considerar que você 
tem o mínimo de conhecimento, mas vamos sempre, na medida do possível 
explanar cada linha do código.
Da linha 1 até a 4, as aspas dupla (“) repetida por 3x (“””) garante que o que 
tiver escrito após as primeiras aspas, linha 1, e a última aspas, linha 4, será um 
comentario, ou seja, não faz parte do meu código, é apenas um texto ao qual deve 
me lembrar de algo importante referente a esse código.
Na linha 6 do meu programa eu importo o pacote pyttsx3, responsável por 
executar o áudio usando o próprio sistema operacional do Windows.
import pyttsx3
O pacote PYTTSX3 é uma biblioteca OFFLINE de texto em fala Python (TTS) que 
funciona tanto para python3 quanto para python2. Esta biblioteca é muito útil, 
especialmente se você não deseja nenhum atraso no discurso produzido e não 
deseja depender apenas da Internet para a conversão de TTS. Ele também suporta 
vários mecanismos TTS como Sapi5, nsss, espeak. 
Podemos baixá-la e instalar usando o comando: pip install pyttsx3 no CMD de 
seu computador, o link ao lado explica um pouco mais sobre o pacote e como 
baixá-lo.
E o que é esse TTS? TTS, que significa Text to Speech, nada mais é do que uma 
técnica de sintetização da fala humana, que converte texto em linguagem normal. 
Ou seja uma pesquisa sobre um conceito de tecnologia num evento de tecnologia. 
Muitos usam esse pacote mas poucos entendem o que realmente significa TTS, 
agora nós sabemos.
Para instalar em outro sistema operacional eu recomendo a leitura no site 
https://pyttsx.readthedocs.io/en/latest/install.html
Continuando o desmembramento de nosso código, na linha 7, o meu programa 
chama a função .init( ) do meu pacote pyttsx, pyttsx.init( ), para inicializar e obter 
uma referência para o meu pacote de texto que suporta até 2 vozes, uma do sexo 
feminino e outra do sexo masculino fornecido pelo SAPI5 no caso do Windows, 
no MAC OSx o mecanismo TTS é o nsss - NSSpeechSynthesizer e para qualquer 
outro sistema operacional o mecanismo usado será o speak - Speak . Ainda na 
mesma linha eu crio um novo objeto chamado engine. 
18
engine = pyttsx3.init()
A linha 9, ordena que o Python diga (say em inglês) o que está escrito em 
parênteses através do objeto engine que foi criado anteriormente e carrega toda 
a configuração para executar essa tarefa. Logo, tudo que você escrever entre 
parênteses usando o método .say irá ser dito em voz pelo seu computador, basta 
escrever a linha baixo no seu código.
engine.say(“Python com Arduíno!”)
A linha 10, através da função .runAndWait( ) , o seu Python irá pronunciar o texto 
que foi carregado no objeto engine na linha anterior, esse método é importante 
pois sua função consiste em duas ações básicas, a ordem de executar a pronúncia 
do texto e aguardar um tempo para garantir a execução completa.
engine.runAndWait()
Na última linha, a linha 11, é executado o comando de parar o processo de 
reprodução da fala, deixando assim o programa livre para as próximas ações 
necessárias.
engine.stop()
c. Fazendo o Python Ouvir
Na tópico passado, Fazendo o Python falar, aprendemos um programa que faz o 
nosso assistente virtual falar, agora vamos dar mais um passo em nosso projeto, 
vamos fazer o Python ouvir nossa voz e confirmar o que ouviu nos devolvendo 
um texto, usando a rede neural do Google você verá a precisão que ficará esse 
programa, e ai vamos lá?
Observe o código abaixo, é nele que iremos trabalhar neste tópico.
Abaixo temos mais uma vez nosso super Python, como pode perceber um código 
simples e intuitivo onde o resultado alcançado é surpreendente, com esse simples 
código seu Assistente Virtual começará a lhe ouvir, basta falar que ele identifica a 
fala, reduz o ruído do ambiente, envia o que ouviu para o Google (isso mesmo, para 
esse assistente funcionar você precisa de uma conexão com o Google, logo você 
precisa estar conectado na internet) e devolve para o meu programa um arquivo 
de texto que será usado para confirmarmos se realmente nosso programa ouviu o 
que falamos. Então vamos explorar o código linha a linha.
19
O reconhecimento de fala é o processo de conversão de palavras faladas em 
texto. O Python suporta muitos mecanismos de reconhecimento de voz e APIs, 
incluindo Google Speech Engine, Google Cloud Speech API, Microsoft Bing Voice 
Recognition e IBM Speech to Text. Neste programa, usaremos o Google pacote 
speech_recognition e este módulo depende do pyaudio para funcionar, logo vamos 
instalar esses dois pacotes através dos comandos conda install -c anaconda 
pyaudio e pip install SpeechRecognition no seu CMD, basta copiar e colar, porém 
caso queira pesquisar esse comando de instalação na internet, basta acessar os 
links ao lado para ter acesso a esses pacotes e outros mais.
Na linha 01, importamos o pacote de reconhecimento de fala e como ele é um 
nome grande, quando formos usá-lo como objeto ficaria um pouco trabalhoso 
ficar reescrevendo o nome “speech_recognition”, logo abreviamos esse nome para 
“sr”, assim fica mais fácil e prático a escrita do código.
import speech_recognition as sr
Na linha 03, o método “Recognizer” ativa a função de reconhecimento de fala e 
áudio e pega as configurações de seu computador para usá-la no reconhecimento. 
Observe que usamos o objeto “sr” para chamar o método e as informações 
adquiridas já atribuímos a um novo objeto que chamamos de “r”.
r = sr.Recognizer()
20
Na linha 05, o método “Microphone” também chamado pelo objeto “sr” tem a 
função de habilitar o microfone para ouvir o usuário do Assistente Virtual e já 
atribuímos a um novo objeto que chamamos de “mic”.
mic = sr.Microphone()
Na linha 07, já com o “mic em mãos”, dizemos para o Python praticamente assim 
com essa linha de comando: “Python use a sua configuração do microfone com a 
fonte, que seria sua voz captada”.
with mic as fonte:
Já na linha 08, eu chamo a função de redução de ruído através do objeto “r”, 
que trata do reconhecimento de fala disponível no pacote “speech_recognition” e 
aplico essa redução de ruído passando como parâmetro a minha “fonte”.
 r.adjust_for_ambient_noise(fonte)
Na linha 09 usamos a função print, ela permite que apareça na tela do usuário a 
informação que eu escrever ou chamar dentro dos parênteses, nesse caso, como já 
foi filtrado o ruído na linha de comando anterior, nós usamos o print para informar 
ao usuário que o programa está pronto para ouvi-lo.
print(“Fale alguma coisa”)
Na linha 10, a função “listen” coloca o reconhecimento em modo passivo e 
armazena a informação que ouviu na variável áudio.
 audio = r.listen(fonte)
Como o envio para o Google pode demorar alguns segundos, dependerá se 
sua internet e processamento de seu computador, na linha 11 eu notifico mais 
uma vez o usuário com a função print informando que o está sendo enviado para 
reconhecimento de áudio o que meu Assistenteouviu.
print(“Enviando para reconhecimento”)
A linha 13, é a chave de entrada para passar o áudio para o Google ou informar 
para o usuário que meu assistente não entendeu o que foi dito, logo o “try” é um 
teste onde se o programa estiver reconhecido um padrão de fala permitirá entrar 
nessa condicional e dar continuidade a conversa, caso contrário o programa pula 
para a linha 17 que habilita a entrada na linha 18 que estudaremos logo em seguida.
21
try:
Na linha 14, o áudio é enviado para o reconhecimento do Google através da 
função “recognize_google” sempre sendo chamado pelo objeto “r”, passando 
nessa função dois parâmetros: (o áudio salvo na linha 10, idioma), quando retornar 
do reconhecimento do Google a informação é salva na variável “text”.
text = r.recognize_google(audio, language = “pt-BR”)
Agora na linha 15 chegou a hora de confirmar o que meu Assistente virtual ouviu, 
pois a informação salva na variável “text” da linha anterior será impressa nessa 
linha usando o método “.format()”.
O método format() serve para criar uma string que contém campos entre 
chaves a serem substituídos pelos argumentos de format. Repare os campos de 
substituição na string (que é tudo que está entre aspas) estão associadas aos 
parâmetros de format onde se eu tivesse dentro da string 3 chaves o meu format 
passaria 3 parâmetros que respectivamente cada parâmetro corresponderia a 
uma chave.
print(“Você disse: { }”.format(text))
E o nosso programa encerra nas linhas 17 e 18 que ocorre quando o padrão de 
fala não é reconhecido.
Gostou desse código? Se interessou em aprender mais? Pois aguarde que a 
próxima postagem, no dia 28/11 iremos ensinar ao seu Python a repetir o que você 
fala.
except:
print(“Não entendi o que você disse”)
d. Chatbot com Python
Agora iremos dar um pouco de empatia para nosso sistema, que tal montar uma 
programação que ele me responda? Lógico que não será uma inteligência Artificial 
onde ele aprenda, mas poderemos montar uns if’s e marcar umas perguntas chave, 
ou palavras chaves onde quando o python detectar ele monte a resposta mais 
coerente, legal né?
Pois isso fica como atividade, aqui iremos mostrar como ele testa uma frase 
22
para neste caso enviar uma resposta, onde no próximo capítulo além da resposta 
ele irá atuar o nosso Arduino.
Observe o código abaixo, iremos detalhar o que ainda não conhecemos e explicar 
a lógica dos blocos escrito.
23
As importações dos pacotes e inicialização já é de nosso conhecimento dos 
tópicos passados, apenas estamos juntando 2 códigos em 1.
import speech_recognition as sr
import pyttsx3
engine = pyttsx3.init()
r = sr.Recognizer()
mic = sr.Microphone()
Para começar, definimos um ponto inicial para o Assistente começar a conversar 
conosco, que seria eu chamá-lo pelo nome Python, então, quando inicia o sistema 
aparece na tela do usuário a mensagem e o python também fala avisando que 
caso queira conversar basta chamá-lo pelo nome.
with mic as fonte:
 print(“Se quiser conversar me chame pelo meu nome: Python!”)
 engine.say(“If you want to talk, call me by my name: Python!”)
 engine.runAndWait()
 engine.stop()
 audio = r.listen(fonte)
 r.adjust_for_ambient_noise(fonte)
 print(“Enviando para reconhecimento”)
24
Após o usuário falar, o Python vai enviar o reconhecimento para o Google que irá 
devolver em forma de texto, se a comunicação for bem sucedida o programa entra 
no try e confere se o texto recebido do google é o nome “Python”, sendo verdadeiro 
o programa ficará neste loop enquanto esta variável “text” for verdadeira, porém 
o programa pergunta o nome de quem está falando para a partir deste ponto o 
nosso assistente saber quem é o usuário e tratá-lo pelo nome.
 try:
 text = r.recognize_google(audio, language = “pt-BR”)
 while text == “Python”:
 print(“Olá, qual o seu nome?”)
 engine.say(“Hello. Whats your name?”)
 engine.runAndWait()
 engine.stop()
 r.adjust_for_ambient_noise(fonte)
 audio = r.listen(fonte)
 print(“Enviando para reconhecimento”)
 try:
 text2 = r.recognize_google(audio, language = ”pt-BR”)
 engine.say(“Nice too meet you Teacher: { }”.format(text2))
 engine.runAndWait()
 engine.stop()
 print(“É um prazer conhecê-lo Professor: { }”.format(text2))
A partir daqui, o Assistente já sabe com quem está falando e está habilitado no 
modo conversa, logo usamos a mesma variável para ele permanecer neste while 
mais interno, pois caso contrário o programa voltaria a perguntar o nome. Neste 
bloco o sistema simplesmente aguarda uma frase, onde ele ouvindo poderá tomar 
várias possibilidades como respostas, é a partir daqui que um assistente será 
diferente do outro.
while text == “Python”:
 print(“Fale algo!”)
 text3 = r.recognize_google(audio, language = ”pt-BR”)
 r.adjust_for_ambient_noise(fonte)
 audio = r.listen(fonte)
 print(“Enviando para reconhecimento”)
 try:
 text3 = r.recognize_google(audio, language = ”pt-BR”)
Nesta próxima linha abaixo nós temos um comando novo, que é transformar 
qualquer texto recebido para letras minúsculas, isso é necessário pois o Python 
25
diferencia letras maiúsculas de minúsculas logo a palavra “Python” é diferente de 
“python”, sendo assim para evitar erros, todo o texto que for devolvido pelo google 
para o meu sistema será transformado para caixa baixa.
text3 = text3.lower()
Neste bloco IF tentamos fazer a primeira conversação, se a pessoa tiver falado 
a frase “como vai você” o python irá retornar uma resposta “Eu vou bem e você”, 
lembrando que em um programa mais avançado, não é legal “engessar” uma frase, 
o interessante é que o python tenha palavras chaves e tente adivinhar uma frase, 
pois se no lugar da pergunta “como vai você” fosse “como você está”? Tem o 
mesmo sentido porém com palavras diferentes, neste caso, poderíamos alimentar 
o python como palavras chaves “como”, “está”, “vai” e etc...assim ele buscaria 
essas palavras e faria uma associação delas e montaria um sentido.
if text3 == “como vai você”:
 engine.say(“I am fine, and you? { }”.format(text2))
 engine.runAndWait()
 engine.stop()
 print(“Eu vou bem, e você? { }”.format(text2))
 Porém, se a variável “text3”, que é a devolutiva do google, não coincidir com 
“como vai você”, o else será acessado e o python irá repetir o que foi falado e 
complementar com o nome do usuário que já foi armazenado em text2 na primeira 
pergunta no inicío do programa, esse bloco é bom para saudações como “bom 
dia”, “boa tarde”, “boa noite”, onde o Assistente irá responder, “bom dia, Sandro” 
por exemplo.
else:
 engine.say(text3 + “ “ + text2)
 engine.runAndWait()
 engine.stop()
 print(text3 + “ “ + text2)
O except é uma estrutura específica para tratamento de exceções que Python 
usa para lhe indicar que algo anormal aconteceu durante a execução do seu código. 
Ou seja, se algo de errado acontecer na execução do try, o seu código chama o 
except para tratar essa exceção, que no nosso caso é informar para o usuário que 
o pacote de reconhecimento de voz não entendeu o que foi dito.
 except:
 engine.say(“Sorry, I didn’t understand what you said.”)
26
 engine.runAndWait()
 engine.stop()
 print(“Desculpe, não entendi o que você disse.”)
 except:
 engine.say(“Sorry, I didn’t understand what you said.”)
 engine.runAndWait()
 engine.stop()
 print(“Desculpe, não entendi o que você disse.”)
except:
 engine.say(“My name is not { }, sorry but we can’t talk”.format(text))
 engine.runAndWait()
 engine.stop()
print(“Meu nome não é { }, desculpe mas não podemos conversar”.format(text))
Pronto, se até aqui rodou tudo bem, você está preparado para avançar e agora o 
Python falar com o Arduino, lembra do nosso primeiro ebook? Radar Ultrassônicocom Processing. Pois sim, será semelhante a relação do computador, nesse caso 
o Python e o nosso Arduino, pois vamos lá, vencer mais esse capítulo.
4. Arduino ouvindo o Python
 
O programa apresentado na figura 31 é o código que será carregado no Arduino 
para receber os comando do Python, observe ele que iremos tratá-lo e explicá-lo 
nas próximas linhas deste ebook.
27
Para ficar mais fácil você entender vamos detalhar esse código, lembrando que 
iremos tratá-lo considerando que você já programa em Arduino e domina Lógica 
de programação.
Cria uma variável inputString e declara como tipo String para armazenar dados 
recebidos pelo Python.
String inputString = “”; 
 
Cria uma variável stringComplete e declara como tipo bool para verificar se 
o estado da palavra recebida esta completa, ou seja, se já recebeu toda a frase 
enviada pelo Python.
bool stringComplete = false; 
Setup do Código
void setup() {
 
Inicializa a comunicação serial com uma taxa de transmissão de 115.200 
baunds.
 Serial.begin(115200);
 
Função que reserva 200 bytes para a variável que o Arduino vai receber
 inputString.reserve(200);
 
Define o pino 13 do Arduino como Saída
 pinMode(LED_BUILTIN, OUTPUT);
 }
Bloco loop de programação do código
 void loop() {
Verifica se chegou uma nova linha de texto
 if (stringComplete) {
Imprime a mensagem que o Assistente Virtual está falando
 Serial.print(“Assistente Virtual Arduino Falando: “);
Imprime o texto recebido
 Serial.print(inputString);
Se o texto recebido iniciar com a palavra “ligar”
28
 if(inputString.startsWith(“ligar”)){
Liga o LED
 digitalWrite(LED_BUILTIN, HIGH);
 }
Se o texto recebido iniciar com a palavra “desligar”
if(inputString.startsWith(“desligar”)){
Desliga o LED
 digitalWrite(LED_BUILTIN, LOW);// toggle
 }
Limpa a String
 inputString = “”;
 stringComplete = false;
 }
}
SerialEvent ocorre sempre que novos dados chegam no RX serial do hardware.
A rotina é executada entre cada vez que o loop () é executado, portanto, o atraso 
no loop pode gerar um atraso na resposta. Vários bytes de dados podem estar 
disponíveis.
void serialEvent() {
Verifica se teve uma interação com a comunicação serial e obtem o número 
de bytes (caracteres) disponíveis para leitura na porta serial. São dados que já 
chegaram e são armazenados no buffer de recebimento serial (que contém 64 
bytes).
 while (Serial.available()) {
Obtém o novo byte (que no caso é uma letra) e salva na variável inChar
 char inChar = (char)Serial.read();
 
Soma mais um na posição da String que está sendo formada
 inputString += inChar;
Se o caractere recebido for uma nova linha, define um sinalizador para que o 
loop principal possa continuar na próxima atividade
29
 if (inChar == ‘\n’) {
 stringComplete = true;
 }
 }
}
Pronto, agora que nosso Arduino está preparado para ouvir o Python, vamos 
escrever um código exemplo no Python para enviar mensagens para o Arduino e 
fazê-lo piscar o LED.
30
Importa o pacote serial para estabelecer a comunicação entre a porta USB do 
computador e a comunicação serial do Arduino
import serial
O pacote threading é importado pois precisamos trabalhar com os threads em 
Python que são fluxos de programas que executam em paralelo dentro de uma 
aplicação, isto é, uma ramificação de uma parte da aplicação que é executada de 
forma independente e escalonada independentemente do fluxo inicial da aplicação.
import threading
O time é necessário para trabalharmos com a gestão de tempo dentro do 
programa.
import time
conectado = False
Nesta linha de programação escrevemos entre aspas simples a porta COM que 
seu computador reconheceu o Arduino, então volte na IDE do Arduino e identifique 
qual a porta que está selecionada.
porta = ‘COM7’ # linux ou mac em geral -> ‘/dev/ttyS0’
Para comunicação com um computador use uma destas taxas: 300, 1200, 2400, 
4800, 9600, 14400, 19200, 28800, 57600, 115200. Logo optamos por usar a maior 
taxa de transmissão ofertada, assim a comunicação ficaria mais eficiente e rápida, 
31
lembrando que o valor que for setado aqui no Python deverá ser igual no Arduino.
velocidadeBaud = 115200
mensagensRecebidas = 1;
desligarArduinoThread = False
try:
A função “serial.Serial” exige 3 parâmetros que são: A porta COMO que será 
realizada a comunicação serial, a taxa de transmissão e o tempo de espera para 
tentar nova conexão, o timeout=1, ele serve para no caso de tentarmos conectar 
e o dispositivo não responder, o programa vai ficar ocioso aguardando, de forma 
blocante, como usamos timeout=0.2 tem-se um tempo de 0.2s para a conexão 
responder.
 SerialArduino = serial.Serial(porta, velocidadeBaud, timeout=0.2)
except:
 print(“Verificar porta serial ou religar arduino”)
O “def” é a chamada para uma nova função criada no programa Python, uma 
função é uma sequência de comandos que executa alguma tarefa e que tem um 
nome. A sua principal finalidade é nos ajudar a organizar programas em pedaços 
que correspondam a como imaginamos uma solução do problema.
Neste caso essa função tem como objetivo manipular os dados que estão sendo 
recebidas do Arduino
def handle_data(data):
Em Python, as variáveis definidas ficam acessíveis às funções declaradas dentro 
de um mesmo escopo, ou seja, a variável que você declara só é reconhecida dentro 
do bloco declarado, mas há a possibilidade de declararmos globalmente, ou seja, 
onde irá valer para todo o programa, global e “meio global” — no caso algo mais 
específico da versão 3.x do Python.
 global mensagensRecebidas
 print(“Recebi “ + str(mensagensRecebidas) + “: “ + data)
 mensagensRecebidas += 1
Esta função tem o objetivo de ler os dados recebidos na porta serial.
32
def read_from_port(ser):
 global conectado, desligarArduinoThread
Quando usamos a sintaxe “while conectado:” eu estaria criando um laço de 
repetição onde enquanto a variável conectado for “true”, ou seja, verdadeira o 
programa iria continuar nesse bloco, porém se você voltar um pouco neste e-book 
irá observar que iniciamos o conectado com “false”, logo este é o motivo de incluir 
o “not” neste teste, assim a lógica ficou enquanto não conectado entre neste bloco, 
logo entraria na primeira passagem por ele.
 while not conectado:
Porém ao entrar no bloco, o primeiro comando é alterar a variável conectado 
para “True”, assim quando retornasse para o teste while acima o programa não 
entraria mais.
 conectado = True
Neste bloco criou-se um loop infinito, até que o break seja executado
 while True:
Este comando ler a linha recebida na comunicação serial, decodifica e carrega 
em uma variável reading.
 reading = ser.readline().decode()
Se a variável não estiver carregada com o uma string vazia ele entra neste bloco 
e chama a função “handle_data” já estudada acima e executa os comandos lá.
 if reading != “”:
 handle_data(reading)
Se a variável “desligarArduinoThread” for verdadeira, mais na frente iremos 
ver quando esta variável vira verdadeira, este bloco é executa e o break realizado 
fazendo com que saia do while e pare o programa.
 if desligarArduinoThread:
 print(“Desligando Arduino”)
 break
Parece estranho, mas essa linha é executada antes dos blocos anteriores, essa 
33
é uma das características em trabalhar com funções, o seu código não é linear, ele 
executa os blocos de acordo com as solicitações.
Basicamente essa linha é a que manda o Python ler a porta serial em paralelo 
pelo pacote threading, funciona assim: é invocado o método Thread da biblioteca 
threading onde esse método leva dois parâmetros, que são necessários para a 
execução de sua atividade, esse parâmetros estão dentro dos parênteses e são 
o target que traduzindo é alvo, e o args que é o argumento. Ou seja, ele executa 
a leitura da porta serial e escrita dentro da função read_from_port levando para 
lá as configurações da comunicaçãoserial com a variável SerialArduino que foi 
configurada no início do programa.
lerSerialThread = threading.Thread(target=read_from_port, 
args=(SerialArduino,))
Inicia o objeto lerSerialThread criado na linha anterior
lerSerialThread.start()
print(“Preparando Arduino”)
time.sleep(2)
print(“Arduino Pronto”)
Cria-se aqui um laço infinito, onde enquanto for verdadeiro o programa irá ficar 
executando este bloco ligando e desligando o led, onde somente quando houver 
algum erro, o programa será direcionado para o except e irá sair do loop com o 
break.
while (True):
 try:
 print(“Enviando”)
 SerialArduino.write(‘ligar luzes\n’.encode())
 time.sleep(2)
 print(“Enviando”)
 SerialArduino.write(‘desligar luzes\n’.encode())
 time.sleep(2)
 except KeyboardInterrupt:
 print(“Apertou Ctrl+C”)
 desligarArduinoThread = True
 SerialArduino.close()
 lerSerialThread.join()
 break
34
5. Projeto Completo
Agora que você já conhece todos os recursos necessários para criar um 
assistente virtual básico usando o python para controlar um LED conectado no 
Arduino, vamos juntar os conhecimentos e construir um código só, porém usando 
uma lógica que o assistente só inicia quando chamado pelo nome e fica sempre 
a disposição para um novo comando até que ele escute a palavra “dispensado” 
onde será automaticamente desconectado e encerrado a programação.
import speech_recognition as sr
import pyttsx3
import serial
import threading
import time
conectado = False
porta = ‘COM7’ # linux ou mac em geral -> ‘/dev/ttyS0’
velocidadeBaud = 115200
mensagensRecebidas = 1;
desligarArduinoThread = False
try:
 SerialArduino = serial.Serial(porta, velocidadeBaud, timeout=0.2)
except:
 print(“Verificar porta serial ou religar arduino”)
def handle_data(data):
 global mensagensRecebidas
 print(“Recebi “ + str(mensagensRecebidas) + “: “ + data)
 mensagensRecebidas += 1
def read_from_port(ser):
 global conectado, desligarArduinoThread
 while not conectado:
 conectado = True
 while True:
 reading = ser.readline().decode()
35
 if reading != “ ”:
 handle_data(reading)
 if desligarArduinoThread:
 print(“Desligando Arduino”)
 break
lerSerialThread = threading.Thread(target=read_from_port, 
args=(SerialArduino,))
lerSerialThread.start()
print(“Preparando Arduino”)
time.sleep(2)
print(“Arduino Pronto”)
engine = pyttsx3.init()
r = sr.Recognizer()
mic = sr.Microphone()
with mic as fonte:
 r.adjust_for_ambient_noise(fonte)
 print(“Para me ativar, me chame pelo meu nome.”)
 engine.say(“To activate me, call me by my name.”)
 engine.runAndWait()
 engine.stop()
 audio = r.listen(fonte)
 print(“Enviando para reconhecimento”)
 try:
 text = r.recognize_google(audio, language= “pt-BR”)
 while (text == ‘Arduino’):
 r.adjust_for_ambient_noise(fonte)
 engine.say(“Hello teacher, what do you want?”)
 engine.runAndWait()
 engine.stop()
 print(“Olá professor, o que posso ajudar?”)
 audio = r.listen(fonte)
 print(“Enviando para reconhecimento”)
 try:
 text2 = r.recognize_google(audio, language=”pt-BR”)
36
 engine.say(“You said:: { }”.format(text2))
 engine.runAndWait()
 engine.stop()
 print(“You said:: { }”.format(text2))
 if (text2 == “Ligar LED”):
 print(“Enviando”)
 SerialArduino.write(‘ligar led\n’.encode())
 time.sleep(2)
 elif (text2 == “desligar led”):
 print(“Enviando”)
 SerialArduino.write(‘desligar led\n’.encode())
 time.sleep(2)
 elif (text2 == “dispensado”):
 text = text2
 engine.say(“Okay, I’m leaving.. Good Bye.”)
 engine.runAndWait()
 engine.stop()
 print(“Ok, irei embora. Adeus.”)
 print(“”)
 except:
 engine.say(“Did not understand, what you said.”)
 engine.runAndWait()
 engine.stop()
 print(“Não entendi o que você disse.”)
 print(“ ”)
 except:
 engine.say(“Okay, so you don’t want to talk to me. Good Bye.”)
 engine.runAndWait()
 engine.stop()
 print(“Ok, então você não quer falar comigo. Adeus.”)
Tudo que foi ensinado está neste código acima, logo te convido a comentar aqui 
abaixo a lógica de programação deste assistente e a descrição de cada função 
apresentada.
________________________________________________________________________________
_______________________________________________________________________________
________________________________________________________________________________
________________________________________________________________________________
________________________________________________________________________________
________________________________________________________________________________
37
________________________________________________________________________________
________________________________________________________________________________
________________________________________________________________________________
________________________________________________________________________________
________________________________________________________________________________
________________________________________________________________________________
________________________________________________________________________________
________________________________________________________________________________
_______________________________________________________________________________
________________________________________________________________________________
________________________________________________________________________________
________________________________________________________________________________
________________________________________________________________________________
________________________________________________________________________________
________________________________________________________________________________
________________________________________________________________________________
________________________________________________________________________________
________________________________________________________________________________
________________________________________________________________________________
________________________________________________________________________________
________________________________________________________________________________
________________________________________________________________________________
________________________________________________________________________________
________________________________________________________________________________
________________________________________________________________________________
________________________________________________________________________________
________________________________________________________________________________
________________________________________________________________________________
________________________________________________________________________________
________________________________________________________________________________
________________________________________________________________________________
________________________________________________________________________________
________________________________________________________________________________
________________________________________________________________________________
________________________________________________________________________________________________________________________________________________________________
________________________________________________________________________________
________________________________________________________________________________
________________________________________________________________________________
________________________________________________________________________________
________________________________________________________________________________
________________________________________________________________________________
38
 6. Conclusão
 
Concluímos mais um projeto na Pixels |Escola e integramos o Arduino 
com mais um software diferente, todo o código apresentado neste ebook está 
disponível no github Sandro Mesquita ( https://github.com/Sandromesquita/
pythoncomarduino ), as vídeos aulas estão disponíveis no Youtube Sandro 
Mesquita no modo privado, logo o acesso é exclusivo pelo link: https://www.
youtube.com/playlist?list=PLAlxexaObetk7RF0RYWSlBQ6417zJGQks e dúvidas, 
correções ou criticas recebemos pelo email contato@profsandromesquita.com.
Espero ter alcançado vossas expectativas e nos encontramos no próximo ebook, 
envie sugestão a escola, o que você quer aprender?
39
Bibliografia
PYTHON PACKAGE INDEX. PyPi: suporte python, c2020. Página inicial. Disponível 
em: <https://pypi.org/>. Acesso em: 15 de jul. de 2020.
CONDA PACKAGE. Conda: suporte python, c2020. Página inicial. Disponível em: 
<https://docs.conda.io/en/latest/>. Acesso em: 16 de jul. de 2020.
PYTHON BRASIL. Comunidade Python Brasil, c2020. Página inicial. Disponível 
em: <https://python.org.br/>. Acesso em: 17 de jul. de 2020.
W3SCHOOLS. w3schools.com, c2020. Página inicial. Disponível em: <https://
www.w3schools.com/python/python_strings.asp>. Acesso em: 18 de jul. de 2020.