IoT Python embarcados

IoT – Primeiros passos utilizando
Python com embarcados
Vinicius J. Leódido Correia | Engº Voluntário
Engenheiros Sem Fronteiras – Núcleo Rio de Janeiro

Agenda
 Dia 1:
 Introdução, usos mais comuns, estrutura de dados em Python, leitura e
escrita de arquivos
 Dia 2:
 Iniciando os passos básicos nas placas, GPIOs, as bibliotecas MRAA /
UPM, ligações seriais USB/TTL.
 Dia 3:
 Lendo os dados dos sensores, encaminhando os dados para a nuvem,
entendendo e adaptando os dados no script Python para gravação via
REST, realizando comunicações via MQTT.
www.sieng.ctc.puc-rio.brwww.sieng.ctc.puc-rio.br

Dia 1 – Introdução e Características
 A linguagem foi criada em 1990 por Guido van Rossum, no
Instituto Nacional de Pesquisa para Matemática e Ciência da
Computação da Holanda (CWI) e tinha originalmente foco em
usuários como físicos e engenheiros. O Python foi concebido
a partir de outra linguagem existente na época, chamada
ABC.

 O nome Python foi tirado por Guido van Rossum do programa
da TV britânica Monty Python Flying Circus, e existem várias
referências ao programa na própria documentação da
linguagem, como, por exemplo, o repositório oficial de
pacotes do Python se chamava Cheese Shop, que era o
nome de um dos quadros do programa.
Atualmente, o nome do repositório é Python Package Index11
(PyPI - pypi.python.org).

 Linguagem de Alto Nível
 Sintaxe Clara e Concisa
 Favorece Legibilidade do Cógido Fonte
 Favorece o uso de estruturas de alto nível
 Diversas bibliotecas prontas para uso
 Portabilidade
 Multiparadigma, funcional, orientada a objetos
 Software Open Source (GPL)
 Utilizada também para Scripts e execução de tarefas, como
Perl e Ruby
 Frameworks Python para Web (Django é o mais conhecido)

 Integração com outras Linguagens
 Implementação official pela PSF é escrita em C – Conhecido
como CPython
 Curiosidades:
 Utilizado para renderização de Vídeos e uso em VFX
 LucasFilm’s, Pixar e outras Grandes companhias utilizam motor de
renderização em Python

 IDE’s: PyCharm (JetBrains)

 Execução de comandos no Python:
 Obs.: Python opera somente com o código identado!
Lembre-se de manter sempre a identação em seu código
(padronizado com 4 espaços “ “).

 Execução em blocos de códigos

 Tipagem Dinâmica – Duck Typing
 No momento em que uma variável é criada através de atribuição, o
interpretador define um tipo para a variável, com as operações que
podem ser aplicadas.
 Tipagem Forte
 o interpretador verifica se as operações são válidas e não faz coerções
automáticas entre tipos incompatíveis. Para realizar a operação entre
tipos não compatíveis, é necessário converter explicitamente o tipo da
variável ou variáveis antes da operação.
>>> s = 5
>>> t = “3”
>>> print 'A soma de %d + %s e %d' %(s, t, (s+int(t)))
A soma de 5 + 3 e 8

 Controle de Fluxo
 A partir da Versão 2.5, deu suporte ao Operador ternário:
print 'a é menor' if a < b else 'a não é menor‘ #Uso de Operador Ternário
>>> if a < b: #Uso padrão do controle de fluxo
... print 'a é menor‘
... else:
... print 'a não é menor'

 Laços
 Estruturas de repetição para controle e processamento de coleções de
dados.

 Laços
 Uso de Laços com FOR
#Soma de 0 a 99
s = 0
for x in range(1, 100):
s = s + x
print s
4950

 Laços
 Uso de Laços com WHILE
#Soma de 0 a 99
s = 0
x = 1
while x < 100:
s = s + x
x = x + 1
print s
4950

 Tipos de Dados
 Tipos de Dados pré definidos no Python:
 Números (inteiros, reais, complexos, etc…)
 Texto
 Tipos de Dados que atuam como Coleções:
 Lista
 Tupla
 Dicionário
 Tipos de Dados no Python podem ser:
 Mutáveis – Seu conteúdo pode ser alterado
 Imutáveis – Quando seu conteúdo não se altera
Obs.: No Python, nomes de variáveis são referências, que podem ser
alteradas em tempo de execução!

 Tipos de Dados
 Números – Funções Padrões de builtins:
 Inteiro (int): i=1
 Real de Ponto Flutuante (float): f=3.14
 Complexo (complex): c = 3 + 4j
 Inteiro longo (long) – Python faz gerenciamento automático entre int
e long
 Com essas funções, podemos realizer conversões para outros
tipos:

 Conversões Numéricas

 Operações Aritméticas
 Soma (+).
 Diferença (-).
 Multiplicação (*).
 Divisão (/): entre dois inteiros funciona igual à divisão inteira. Em outros
casos, o resultado é real.
 Divisão inteira (//): o resultado é truncado para o inteiro imediatamente
inferior, mesmo quando aplicado em números reais, porém neste caso
o resultado será real também.
 Módulo (%): retorna o resto da divisão.
 Potência (**): pode ser usada para calcular a raiz, através de expoentes
 fracionários (exemplo: 100 ** 0.5).
 Positivo (+).
 Negativo (-)

 Operações Lógicas
 Menor (<).
 Maior (>).
 Menor ou igual (<=).
 Maior ou igual (>=).
 Igual (==).
 Diferente (!=).

 Tipos de Dados
 Texto:
 As strings por si só, já são uma própria função builtin
 Strings são imutáveis. Para alterar seu conteúdo, somente criando
uma nova String ou adicionando um novo conteúdo
 Tipos de Strings
 String padrão: s = ‘palavras ao vento’
 String Unicode: s = u‘São apenas Palavras’
 Também podem ser convertidas com a função unicode()
 A inicialização de Strings podem ser com aspas simples ou duplas
 Em várias linhas, desde que sejam com 3 aspas simples ou duplas

 Operações com Strings
# -*- coding: latin1 -*-
s = 'Camel‘
# Concatenação
print 'The ' + s + ' run away!‘
# Interpolação
print 'tamanho de %s => %d' % (s, len(s))
# String tratada como sequência
for ch in s:
print ch
# Strings são objetos
if s.startswith('C'):
print s.upper()
# o que acontecerá?
print 3 * s
# 3 * s é consistente com s + s + s

 Interpolação de Strings
 Operador “%” é usado para fazer interpolação de strings. A interpolação
é mais eficiente no uso de memória do que a concatenação
convencional.
 Símbolos usados na interpolação:
 %s: string.
 %d: inteiro.
 %o: octal.
 %x: hexacimal.
 %f: real.
 %e: real exponencial.
 %%: sinal de percentagem.

 “Fatiando” Strings – Trabalhando com Slices
 Fatias de Strings podem ser obtidas, simplesmente colocando índices
entre colchetes após a string.
 Índices podem ser definidos como: [inicio:fim + 1:intervalo]

 Listas
 Listas são coleções heterogêneas de objetos, que podem ser de
qualquer tipo, inclusive outras listas.
 As listas são mutáveis e podem ser “fatiadas” como as Strings
# Uma nova lista: Brit Progs dos anos 70
progs = ['Yes', 'Genesis', 'Pink Floyd', 'ELP']
# Varrendo a lista inteira
for prog in progs:
print prog
# Trocando o último elemento
progs[-1] = 'King Crimson‘
# Incluindo
progs.append('Camel')
# Removendo
progs.remove('Pink Floyd')

 Listas
# Ordena a lista
progs.sort()
# Inverte a lista
progs.reverse()
# Imprime numerado
for i, prog in enumerate(progs):
print i + 1, '=>', prog
# Imprime do segundo item em diante
print progs[1:]

 Listas
 Lista possui método pop(), como opção para uso de filas e pilhas:
lista = ['A', 'B', 'C']
print 'lista:', lista
# A lista vazia é avaliada como falsa
while lista:
# Em filas, o primeiro item é o primeiro a sair
# pop(0) remove e retorna o primeiro item
print 'Saiu', lista.pop(0), ', faltam', len(lista)

 Listas
# Mais itens na lista
lista += ['D', 'E', 'F']
print 'lista:', lista
while lista:
# Em pilhas, o primeiro item é o último a sair
# pop() remove e retorna o último item
print 'Saiu', lista.pop(), ', faltam', len(lista)
 Possuem operações de ordenação (sort) e inversão (reverse)
que são realizadas na própria lista, mas seu conteúdo não é
alterado nessas operações.

 Tuplas
 São bastante similar as listas, porém, são imutáveis. Não se pode
acrescentar, apagar ou fazer atribuições aos itens
 Tupla: t = (a, b, c, d, …, n-1)
 Tupla com 1 elemento: t = (1,)
 Tupla vazia: t = ()
 Elementos podem ser referenciados como na lista:
elemento1 = t[0]
 Listas podem ser convertidas em Tuplas e vice-versa:
tupla = tuple(lista) #Conversão para Tupla
lista = list(tupla) #Conversão para Lista

 Tuplas
 Embora a tupla possa conter elementos mutáveis, esses elementos não
podem sofrer atribuição, pois modificaria a referência ao objeto.
>>> t = ([1,2],4)
>>> t[0].append(3)
>>> t
([1,2,3],4)
>>>> t[0] = [1,2,3]
Traceback (most recent call last):
File "<input>", line 1, in ?
TypeError: object does not support item assignment
>>>

 Tuplas
 As tuplas são mais eficientes do que as listas convencionais, pois
consomem menos recursos de memória do que as listas, por serem
mais simples.

 Outras Funções Seqüenciais de Builtins:
 Set – Seqüência mutável sem repetições
 Frozenset – Seqüência imutável sem repetições
 Implementam operações de conjuntos, como União, Intersecção, e
diferença.
# Conjuntos de dados
s1 = set(range(3))
s2 = set(range(10, 7, -1))
s3 = set(range(2, 10, 2))
# Exibe os dados
print 's1:', s1, 'ns2:', s2, 'ns3:', s3
#Saída
s1: set([0, 1, 2])
s2: set([8, 9, 10])
s3: set([8, 2, 4, 6])

# União
s1s2 = s1.union(s2)
print 'União de s1 e s2:n', s1s2
# Diferença
print 'Diferença com s3:n', s1s2.difference(s3)
# Interseção
print 'Interseção com s3:n', s1s2.intersection(s3)
# Testa se um set inclui outro
if s1.issuperset([1, 2]):
print 's1 inclui 1 e 2'
# Testa se não existe elementos em comum
if s1.isdisjoint(s2):
print 's1 e s2 não tem elementos em comum'
#Saída
União de s1 e s2:
set([0, 1, 2, 8, 9, 10])
Diferença com s3:
set([0, 1, 10, 9])
Interseção com s3:
set([8, 2])
s1 inclui 1 e 2
s1 e s2 não tem elementos em
comum

 Obs.: Quando uma lista é convertida para set, as repetições são
descartadas.

 Dicionários
 Um dicionário é uma lista de associações compostas por uma chave
única e estruturas correspondentes. Dicionários são mutáveis, tais
como as listas.
 A chave precisa ser de um tipo imutável, geralmente são usadas
strings, mas também podem ser tuplas ou tipos numéricos. Já os itens
dos dicionários podem ser tanto mutáveis quanto imutáveis. O
dicionário do Python não fornece garantia de que as chaves estarão
ordenadas.
dicionario = {'a': a, 'b': b, ..., 'z': z}

 Dicionários

 Dicionários
dic = {'nome': 'Shirley Manson', 'banda': 'Garbage'}
#Acessando Elementos
print dic['nome']
#Adicionando Elementos
dic['album'] = 'Version 2.0'
#Apagando um elemento
del dic['album']
#Obtendo itens, chaves e valores
itens = dic.items()
chaves = dic.keys()
valores = dic.values()
#Saída
Shirley Manson

 Dicionários
 Alguns exemplos de operações com Dicionários:
# Progs e seus albuns
progs = {'Yes': ['Close To The Edge', 'Fragile'],
'Genesis': ['Foxtrot', 'The Nursery Crime'],
'ELP': ['Brain Salad Surgery']}
# Mais progs
progs['King Crimson'] = ['Red', 'Discipline']
# items() retorna uma lista de
# tuplas com a chave e o valor
for prog, albuns in progs.items():
print prog, '=>', albuns
# Se tiver 'ELP', deleta
if progs.has_key('ELP'):
del progs['ELP']
#Saída
Yes => ['Close To The Edge', 'Fragile']
ELP => ['Brain Salad Surgery']
Genesis => ['Foxtrot', 'The Nursery
Crime']
King Crimson => ['Red', 'Discipline']

 Verdadeiro, Falso e Nulo
 Em Python, o tipo booleano (bool) é uma especialização do tipo inteiro
(int). O verdadeiro é chamado True e é equivalente a 1, enquanto o
falso é chamado False e é equivalente a 0.
 Os seguintes valores são considerados como falso (False):
• False
• None
• 0 (zero)
• ‘’ ou “” – String vazia
• [ ] lista vazia
• ( ) tupla vazia
• { } dicionário vazio
• Outras estruturas com tamanho igual a zero

 Operadores Booleanos
 Possibilidade de construir condições mais complexas para controlar
desvios condicionais e laços
 São os operadores: And, or, not, is, in
• and: retorna verdadeiro se e somente se receber duas expressões
verdadeiras.
• or: retorna false se e somente se receber duas expressões falsas.
• not: retorna falso se receber uma expressão verdadeira e vice-versa
• is: retorna verdadeiro quando duas referências forem idênticas ao mesmo
objeto e falso em caso contrário
• in: retorna verdadeiro se receber um item e uma lista e o item ocorrer uma
ou mais vezes na lista e falso em caso contrário

 Funções
 São blocos de código identificados por um nome, que podem receber
parâmetros pré-determinados
 Podem retornar ou não objetos
 Aceitam Doc Strings
 Parâmetros opcionais. Caso não receba parâmetros em sua chamada, será igual ao
default definido em na função
 Aceitam parâmetros passados com nome, e para este caso, a ordem em que os
parâmetros foram passados não é relevante.
Obs.: Doc Strings são strings que estão associadas a uma estrutura do Python.
Nas funções, as Doc Strings são colocadas dentro do corpo da função, geralmente
no começo. O objetivo das Doc Strings é servir de documentação para aquela
estrutura.
def dobro(x):
""“Doc String: Esta função retorna o dobro do número x"""
return x*2

 Funções
 São blocos de código identificados por um nome, que podem receber
parâmetros pré-determinados
def func(parametro1, parametro2=padrao):
"""Doc String"""
<bloco de código>
return valor
def fatorial(num):
"""Fatorial implementado de forma
recursiva""“
if num <= 1:
return 1
else:
return(num * fatorial(num – 1))
# Testando fatorial()
print fatorial(5)
# Saída
120

 Funções
 Exemplo Fatorial sem recursão
def fatorial(n):
n = n if n > 1 else 1
j = 1
for i in range(1, n):
j = j * i
return j
# Testando
for i in range(1,6):
print i, ‘->’, fatorial(i)
# Saída
1 -> 1
2 -> 2
3 -> 6
4 -> 24
5 -> 120

 Funções
 Método Principal: podemos referenciar o nome de uma função ou
chamá-la como método principal
def func1(param1, param2):
return value_func1
def func2(param):
return value_func2
if __name__== “__main__” :
func1(p1, p2)
func2(p)
# Saída
value_func1
value_func2

 Funções
def rgb_html(r=0, g=0, b=0):
""“Converte RGB em #RRGGBB"""
return “#%02x%02x%02x“, %(r, g, b)
def html_rgb(color=“#000000"):
""“Converte #RRGGBB em RGB"""
if color.startswitch(‘#’): color = color [1:]
r = int(color[:2], 16)
g = int(color[2:4], 16)
b = int(color[4:], 16)
return r, g, b
if __name__== “__main__” :
print rgb_html(200, 200, 255)
print rgb_html(b=200, g=200, r=255)
print html_rgb('#c8c8ff')
# Saída
#c8c8ff
#ffc8c8
(200, 200, 255)

 Estrutura de Dados
 Abordaremos aqui alguns dos pontos falados anteriormente, citados em
usos com Listas, porém, descreveremos alguns métodos adicionais.
 list.append(x): Adiciona um elemento ao fim da lista.
 list.extend(L): Prolonga a lista, adicionando ao fim da lista atual os
demais elementos da lista L.
 list.insert(i, x): Insere um item em uma posição especificada, onde i =
índice do elemento antes da inserção e x = o valor a ser inserido.
 list.remove(x):Remove o primeiro item encontrado na lista cujo valor é
igual a X
 list.pop([i]): Remove o item na posição dada e o devolve. Se nenhum
índice for especificado, list.pop() remove e devolve o último item na
lista.
 list.index(x): Devolve o índice do primeiro item cujo valor é igual a x,
gerando ValueError se este valor não existe

 list.count(x): Devolve o número de vezes que o valor x aparece na lista.
 list.sort(): Ordena os itens na própria lista.
 list.reverse(): Inverte a ordem dos elementos na lista (sem gerar uma
nova lista).
>>> a = [66.25, 333, 333, 1, 1234.5]
>>> print a.count(333), a.count(66.25), a.count('x')
2 1 0
>>> a.insert(2, -1)
>>> a.append(333)
>>> a [66.25, 333, -1, 333, 1, 1234.5, 333]
>>> a.index(333)
1
>>> a.remove(333)
>>> a
[66.25, -1, 333, 1, 1234.5, 333]
>>> a.reverse()
>>> a
[333, 1234.5, 1, 333, -1, 66.25]
>>> a.sort()
>>> a
[-1, 1, 66.25, 333, 333, 1234.5]

 Usando Lista como Pilha (LIFO – Last In, First Out).
>>> pilha = [3, 4, 5]
>>> pilha.append(6)
>>> pilha.append(7)
>>> pilha
[3, 4, 5, 6, 7]
>>> pilha.pop()
7
>>> pilha
[3, 4, 5, 6]
>>> pilha.pop()
6
>>> pilha.pop()
5
>>> pilha
[3, 4]

 Usando Lista como Fila (FIFO – First In, First Out).
 Devemos fazer o uso da Classe collections.deque
>>> from collections import deque
>>> fila = deque(["Eric", "John", "Michael"])
>>> fila.append("Terry") # Terry chega
>>> fila.append("Graham") # Graham chega
>>> fila.popleft() # O primeiro a chegar parte
'Eric'
>>> fila.popleft() # O segundo a chegar parte
'John'
>>> fila # O resto da fila, em ordem de chegada
deque(['Michael', 'Terry', 'Graham'])

 Arquivos e I/O
 Os arquivos no Python são representados por objetos do tipo file Arquivos
podem ser abertos para leitura ('r'), gravação ('w') ou adição ('a'), em modo texto
ou binário('b').
import sys
# Criando um objeto do tipo file
temp = open('temp.txt', 'w')
# Escrevendo no arquivo
for i in range(100):
temp.write('%03dn' % i)
# Fechando
temp.close()
temp = open('temp.txt')
# Escrevendo no terminal
for x in temp:
# Escrever em sys.stdout envia
# o texto para a saída padrão
sys.stdout.write(x)
temp.close()
Exemplo de Escrita:

 Arquivos e I/O
 Os arquivos no Python são representados por objetos do tipo file Arquivos
podem ser abertos para leitura ('r'), gravação ('w') ou adição ('a'), em modo texto
ou binário('b').
import sys
import os.path
# raw_input() retorna a string digitada
fn = raw_input('Nome do arquivo: ').strip()
if not os.path.exists(fn):
print 'Tente outra vez...'
sys.exit()
# Numerando as linhas
for i, s in enumerate(open(fn)):
print i + 1, s,
# Imprime uma lista contendo linhas do arquivo
print open('temp.txt').readlines()
Exemplo de leitura:

 Sistemas de Arquivos
 Algumas funções para manipular Diretórios de Arquivos (fyle systems):
 Muitas destas funcionalidades estão implementadas no módulo os.path:
 os.path.basename(): retorna o componente final de um caminho
 os.path.dirname(): retorna um caminho sem o componente final
 os.path.exists(): verifica se um caminho existe (True), caso contrário
acusa como inexistente (False).
 os.path.getsize(): retorna o tamanho do arquivo em bytes

Exercícios!

OBRIGADO
Vinícius J. L. Correia
E-mail: vini.leodido@gmail.com
br.linkedin.com/in/vinileodido

Realização
Organização
Apoio

IoT Python embarcados

Recomendados

Recomendados

Mais conteúdo relacionado

Mais procurados

Mais procurados (6)

Semelhante a IoT Python embarcados

Semelhante a IoT Python embarcados (20)

IoT Python embarcados