A linguagem de programação para a

Internet das Coisas

Magnus Åsrud
Mestre Tese de Primavera 2017
A linguagem de programação para a Internet de
Coisas

Magnus Åsrud

02 de maio de 2017
2
Abstrato

A Internet das Coisas (Internet das coisas) está se tornando mais integrada com as nossas vidas diárias
para cada dia que passa. Algumas famílias já estão equipados com dispositivos inteligentes que executam
tarefas como monitorar o clima interior tomowing o gramado. Existe frameworks de código aberto
projetado para a Internet das coisas que podem ser usadas por amadores e profissionais para seus
próprios projetos. No entanto, muitas dessas ferramentas exigem que o usuário sabe linguagens como C,
Python e JavaScript programação. Os usuários que não sabem muito de programação e que gostaria de
mexer com a Internet das coisas pode achar que é um desafio para trabalhar com essas ferramentas.

Nesta tese veremos como criar um fi específico linguagem de programação orientada camente no IOT.
A linguagem é dirigido a programadores amadores, com o objetivo de torná-lo fácil de programar qualquer
dispositivo Internet das coisas. Vamos discutir as limitações atuais do hardware da Internet das coisas e
como a linguagem deve trabalhar em torno deles. Finalmente, vamos ver como implementar um intérprete
para este idioma em um 3 Modelo Raspberry Pi B.

3
4
Conteúdo

I Background 13

1. Introdução 15
1.1 impulso SmartCity. . . . . . . . . . . . . . . . . . . . . . . . 15
1.2 O projecto actual. . . . . . . . . . . . . . . . . . . . . . . . 16
1,3 Agradecimentos. . . . . . . . . . . . . . . . . . . . . . . . 16

2 A Internet das Coisas 17

2.1 Internet das Coisas. . . . . . . . . . . . . . . . . . . . . . . . . 17
2.1.1 O que é a Internet das coisas? . . . . . . . . . . . . . 17
2.2 sensores. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
2.2.1 Energia eficiência. . . . . . . . . . . . . . . . . . . . . 20
2.3 Comunicação. . . . . . . . . . . . . . . . . . . . . . . . . . 20
2.3.1 Bluetooth. . . . . . . . . . . . . . . . . . . . . . . . . 20
2.3.2 WiFi . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
2.3.3 WiFi HaLow. . . . . . . . . . . . . . . . . . . . . . . . 23

3 projectos relacionados 25
3.1 alternativas. . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
3.1.1 Scriptr. . . . . . . . . . . . . . . . . . . . . . . . . . . 25
3.1.2 LibeliumWaspmote Plug & Sense. . . . . . . . . . . 25
3.1.3 Johnny-Five. . . . . . . . . . . . . . . . . . . . . . . . 26
3.1.4 Tessel 2. . . . . . . . . . . . . . . . . . . . . . . . . . . 26
3.2 Avaliação. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26

II projeto 27

4 Requisitos para uma linguagem de programação Internet das coisas 29

4.1 A plataforma de destino. . . . . . . . . . . . . . . . . . . . . . . . 29
4.2 O público-alvo. . . . . . . . . . . . . . . . . . . . . . . 29
4.3 Os requisitos fundamentais. . . . . . . . . . . . . . . . . . . . . . 30
4.4 Scripts Hot Swap. . . . . . . . . . . . . . . . . . . . . . . . . 30
4.5 Interpretação vs Compilando. . . . . . . . . . . . . . . . . . . . 30
4.5.1 Compilando. . . . . . . . . . . . . . . . . . . . . . . . . 30
4.5.2 Interpretação. . . . . . . . . . . . . . . . . . . . . . . 32
4.5.3 Avaliação. . . . . . . . . . . . . . . . . . . . . . . . . 32
4.6 O Sistema Type. . . . . . . . . . . . . . . . . . . . . . . . . 32
4.6.1 tipagem estática. . . . . . . . . . . . . . . . . . . . . . . 32

5
 4.6.2 tipagem dinâmica. . . . . . . . . . . . . . . . . . . . . 33
4.6.3 Inferido Digitação. . . . . . . . . . . . . . . . . . . . . . 33
4.6.4 Avaliação. . . . . . . . . . . . . . . . . . . . . . . . . 33
4.7 Evento Programação Orientada. . . . . . . . . . . . . . . . . . 34
4.7.1 Manipulando eventos. . . . . . . . . . . . . . . . . . . . . 34
4.8 Segurança. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
4.9 erros e excepções. . . . . . . . . . . . . . . . . . . . . . 35
4.10 Manuseio de uma Bater Software. . . . . . . . . . . . . . . . . . . 35
4.10.1 Alternativa 1: Repor. . . . . . . . . . . . . . . . . . . . 35
4.10.2 Alternativa 2: Remover o script. . . . . . . . . . . . 36
4.10.3 Alternativa 3: Ignore-o. . . . . . . . . . . . . . . . . . 36
4.10.4 Alternativa 4: Terminar. . . . . . . . . . . . . . . . . 36
4.10.5 Alternativa 5: Informar o usuário. . . . . . . . . . . . . . 37
4.10.6 Watchdog Daemon. . . . . . . . . . . . . . . . . . . . 37
4.11 sensores e actuadores. . . . . . . . . . . . . . . . . . . . . . 37
4.12 A biblioteca padrão. . . . . . . . . . . . . . . . . . . . . . . 38

5 Designing Daspel 39
5.1 O que é Daspel? . . . . . . . . . . . . . . . . . . . . . . . . . . 39
5.2 A sintaxe. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
5.3 Os tipos de dados. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
5,4 Integer. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
5.4.1 Integer Sintaxe. . . . . . . . . . . . . . . . . . . . . . . 40
5.5 Real. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
5.5.1 Sintaxe Real. . . . . . . . . . . . . . . . . . . . . . . . 41
5.6 booleana. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
5.6.1 Por que incluir boolean? . . . . . . . . . . . . . . . . . . 41
5,7 cadeia. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42
5.7.1 Unicode. . . . . . . . . . . . . . . . . . . . . . . . . . 42
5.7.2 Dinâmica Size. . . . . . . . . . . . . . . . . . . . . . . 42
5.7.3 Caráter Individual. . . . . . . . . . . . . . . . . . . . . 42
5.7.4 Sintaxe de String. . . . . . . . . . . . . . . . . . . . . . . 42
5,8 List. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
5.8.1 Lista de sintaxe. . . . . . . . . . . . . . . . . . . . . . . . . 43
5.9 Nil o tipo de erro. . . . . . . . . . . . . . . . . . . . . . . . . 43
5.10 Variáveis ​e declaração de variável. . . . . . . . . . . . . . . 43
5.10.1 Declaração Ambiguidade variável. . . . . . . . . . . . 44
5.10.2 Declaração Parte Variável . . . . . . . . . . . . . . . . 44
5.10.3 Variáveis ​e escopos. . . . . . . . . . . . . . . . . . . 45
5.11 Escopo. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45
5.11.1 Âmbito variável. . . . . . . . . . . . . . . . . . . . . . . 46
5.11.2 Âmbito Library. . . . . . . . . . . . . . . . . . . . . . . 47
5.11.3 escopo global. . . . . . . . . . . . . . . . . . . . . . . 47
5.11.4 Função Scope. . . . . . . . . . . . . . . . . . . . . . 47
5.12 Operadores. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47
Demonstrações 5.13. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48
5.13.1 For Loop. . . . . . . . . . . . . . . . . . . . . . . . . . 49
5.13.2 While Loop. . . . . . . . . . . . . . . . . . . . . . . . 49

6
 5.13.3 Conditionals aka. If-Else. . . . . . . . . . . . . . . . . 49
5.13.4 Funções. . . . . . . . . . . . . . . . . . . . . . . . . 49
5.14 Things That Did Not torná-lo para o idioma. . . . . . . . 50
5.14.1 Função variádicos. . . . . . . . . . . . . . . . . . . . . 50
5.14.2 Tuple. . . . . . . . . . . . . . . . . . . . . . . . . . . . 50
5.14.3 Tipo de anotação para os parâmetros de função. . . . . . 50
5.14.4 Métodos tipo de dados. . . . . . . . . . . . . . . . . . . . 51
5,15 Unicode Syntax. . . . . . . . . . . . . . . . . . . . . . . . . . 51

III Implementação 59

6 Prova de Conceito 61
6.1 O Objectivo da implementação. . . . . . . . . . . . . . . . . 61
6.2 O hardware. . . . . . . . . . . . . . . . . . . . . . . . . . . 61
6.3 O intérprete . . . . . . . . . . . . . . . . . . . . . . . . . . 61
6.4 Código Fonte. . . . . . . . . . . . . . . . . . . . . . . . . . . . 62
6.5 Isenção de responsabilidade. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62

7 O Pi framboesa e o HAT Sense 63

7,1 framboesa Pi 3 Modelo B. . . . . . . . . . . . . . . . . . . . . 63
7.1.1 Software. . . . . . . . . . . . . . . . . . . . . . . . . . 64
7,2 Sentido HAT. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64
7.2.1 Comunicação Sensor. . . . . . . . . . . . . . . . . 65
7.2.2 Byte Encoding. . . . . . . . . . . . . . . . . . . . . . . 65
7.2.3 Os sensores. . . . . . . . . . . . . . . . . . . . . . . . 65
7.2.4 O LEDMatrix. . . . . . . . . . . . . . . . . . . . . . 66
7.2.5 RTIMULib. . . . . . . . . . . . . . . . . . . . . . . . . 67
7.2.6 Erros em temperaturas de leitura. . . . . . . . . . . . 67

8 Implementação 69
8,1 Critérios. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69
8.2 implementação da linguagem. . . . . . . . . . . . . . . . . . . . 69
8.2.1 Python. . . . . . . . . . . . . . . . . . . . . . . . . . . 70
8.2.2 C. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 70
8.2.3 C ++. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71
8.2.4 Rust . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72
8.2.5 Conclusão. . . . . . . . . . . . . . . . . . . . . . . . 73
8.3 configuração Trabalho. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73
8.3.1 Software Obrigatório. . . . . . . . . . . . . . . . . . . . 73
8.4 Portando a biblioteca Sense HAT para Rust. . . . . . . . . . . . . 74
8.4.1 Escrevendo o invólucro C. . . . . . . . . . . . . . . . . . 74
8.4.2 O Framebuffer. . . . . . . . . . . . . . . . . . . . . 75
8.4.3 reimplementar o Sense HATmodule fromC à ferrugem 76
8.5 A análise léxica e análise sintática. . . . . . . . . . . 76
8.5.1 O scanner. . . . . . . . . . . . . . . . . . . . . . . . 76
8.5.2 O analisador. . . . . . . . . . . . . . . . . . . . . . . . . 77
8.6 Representando o tipo de dados Real em Rust. . . . . . . . . . . . 78

7
 8.6.1 Operações aritméticas. . . . . . . . . . . . . . . . . . 78

IV Resumo 81

9 Conclusão 83
9.1 Análise. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 83
9.2 trabalho futuro. . . . . . . . . . . . . . . . . . . . . . . . . . . . 83

8
Lista de Figuras

1.1 Um programa para controlar um fã usando a notação gráfica. . 16

representação 2.1 Campo das bandas WiFi. . . . . . . . . . . . 23

4.1 Fluxograma para a execução do programa. . . . . . . . . . . . . . 31

5.1 O padrão de bits de um número de ponto fixo. . . . . . . . . . . . 41

5.2 Um exemplo de como as variáveis ​podem ser declaradas em uma linguagem com um
sistema de tipo estático. . . . . . . . . . . . . . . . . . . . . 46

7.1 O Raspberry Pi 3 Modelo B. Fonte [39]. . . . . . . . . . . . 63

7.2 O CHAPÉU sentido. Fonte [41]. . . . . . . . . . . . . . . . . . . 65
7.3 A orientação. Fonte [43]. . . . . . . . . . . . . . . . . . . 66
7.4 A RGB 565 bits campo após um valor RGB 888 foi codificado pela biblioteca Python. .
...................... 66

8.1 Uma união marcado em C. . . . . . . . . . . . . . . . . . . . . . . 71

9
10
Lista de mesas

5.1 Os operadores aritméticos. . . . . . . . . . . . . . . . . . . . . . . 48

5.2 Os operadores lógicos. . . . . . . . . . . . . . . . . . . . . . . . . 48
5.3 Emojis para zero. . . . . . . . . . . . . . . . . . . . . . . . . . . . 52
5.4 Emojis para enviar. . . . . . . . . . . . . . . . . . . . . . . . . . 52
5,5 Emojis pelo poder. . . . . . . . . . . . . . . . . . . . . . . . . 53
5.6 Emojis para temporizador. . . . . . . . . . . . . . . . . . . . . . . . . . 53
5.7 Emojis para microfone. . . . . . . . . . . . . . . . . . . . . . 53
5.8 Emojis para alto-falante. . . . . . . . . . . . . . . . . . . . . . . . . 54
5,9 Emojis para GPS. . . . . . . . . . . . . . . . . . . . . . . . . . . 54
5.10 Emojis de temperatura. . . . . . . . . . . . . . . . . . . . . . 54
5.11 Emojis de humidade. . . . . . . . . . . . . . . . . . . . . . . . 55
5.12 Emojis para a pressão. . . . . . . . . . . . . . . . . . . . . . . . 55
5.13 Emojis para LED. . . . . . . . . . . . . . . . . . . . . . . . . . 55
5.14 Emojis para luz. . . . . . . . . . . . . . . . . . . . . . . . . . 56
5.15 Emojis para monitores. . . . . . . . . . . . . . . . . . . . . . . . 56
5.16 Emojis para a ação ON / OFF. . . . . . . . . . . . . . . . . . . . . 56
5,17 Emojis para loop. . . . . . . . . . . . . . . . . . . . . . . . . . 57
5.18 Emojis para If-Else. . . . . . . . . . . . . . . . . . . . . . . . . 57
5,19 Emojis para função. . . . . . . . . . . . . . . . . . . . . . . . 57

7.1 O Pi framboesa 3 Modelo B especi fi cação [36]. . . . . . . . . 64

7.2 Os módulos de sensores Sentido HAT [42]. . . . . . . . . . . . . . 66
7.3 O sentido HAT especi fi cação [40, 48]. . . . . . . . . . . . . . 67

11
12
 parte I

fundo

13
Capítulo 1

Introdução

1.1 impulso SmartCity

Este projecto foi inicialmente vai ser uma contribuição para um outro projeto chamado pulso
SmartCity. Pulso SmartCity é, como o nome indica, uma inteligente líder do projeto da cidade por Jon
Bohmer. A ideia era usar centenas de dispositivos da Internet das coisas espalhadas atribui uma
cidade para coletar informações sobre clima, temperatura, movimento de veículos e para monitorar o
consumo de energia elétrica. O sistema consistiria em um gateway, nós e tags. Os nós iria comunicar
com um gateway para transmitir dados. As tags seria usado como ers fi identi e nós seria capaz de
reconhecê-los.

A contribuição para Pulso SmartCity era criar uma linguagem de script para este sistema. Parte
do projeto nós era que o usuário deve ser capaz de programá-los através de uma interface Web. Para
tornar a programação mais fácil, a interface do usuário usaria elementos gráficos para construir um
script. Conceitos semelhantes podem ser encontrados em linguagens de programação como zero [1].
A notação gráfica seria convertido a uma forma textual nos bastidores. A linguagem tinha que ser
simples para que qualquer pessoa pode usá-lo.

A segunda parte da contribuição seria para projetar um intérprete para o idioma. Os scripts seria
interpretada nos dispositivos da Internet das coisas. Os dispositivos também tinha que ser capaz de mudar a
scripts rodando com os novos a qualquer momento. O objetivo era fazer com que os nós tão independente
quanto possível, mesmo se eles foram colocados em áreas de difícil acesso. Isso significa que o usuário
pode simplesmente enviar um novo roteiro para um nó através de ondas de rádio.

Havia algumas restrições que tinham de ser abordadas ao projetar tanto a linguagem de
programação e o intérprete. Os nós têm espaço de armazenamento, memória RAM e poder de
processamento limitado. Eles também têm uma pequena bateria, de modo que o objetivo era minimizar
o consumo de energia, tanto quanto possível. Os scripts tinha que ser tão pequeno e compacto quanto
possível em termos de tamanho fi le. Esta é reduzir a quantidade de dados que tem de ser transmitida
a um nó como envio e recebimento de sinais de rádio consome muita energia.

Os dados coletados pelos nós seria enviado para um serviço na nuvem, como o Amazon AWS,
onde seria processado. Os nós de si seria capaz de fazer algum dos próprios processamento. Como
resultado, menos dados serão transmitidos através da rede que irá liberar algum

15
largura de banda. Os nós seria capaz de conservar mais energia por não ter que usar gerar ondas de
rádio com tanta freqüência.

Figura 1.1: Se a temperatura estiver acima de 30 unidades, ligar o ventilador na potência de 65%. A
unidade não foi especi fi ed pelo criador. Crédito: Jon Bohmer.

1.2 O projecto actual

Conforme o tempo passava, o objetivo desta tese alterado. O foco se afastou da ideia de criar uma linguagem
de programação para uma plataforma fi c específica. Em vez disso, a linguagem de programação que se
destina a funcionar para todos os dispositivos da Internet das coisas, independentemente da arquitetura.

A maioria das metas originais permanecem os mesmos. O objetivo principal é criar uma
pequena linguagem de script que é fácil de usar. A linguagem é projetado para se parecer com uma
linguagem de programação imperativo tradicional. O público-alvo são pessoas que possuem
conhecimentos básicos sobre programação. A funcionalidade do intérprete permanece o mesmo.

1,3 Agradecimentos

Eu gostaria de expressar minha gratidão ao meu supervisor, Dag Langmyhr, pelo seu excelente
ajuda e orientação. Seu bom humor e otimismo me manteve durante todo o período de duração do
projeto.
Eu também gostaria de agradecer a dois estudantes, Vetle Volden-Freberg e Olav Wegner Eide,
que me fizeram companhia ao longo do último par de meses.

16
Capítulo 2

A Internet das Coisas

2.1 Internet das Coisas

Tecnologia já percorreu um longo caminho desde os primórdios da computação. A primeira computadores

digitais eram grandes, caros e consumiu uma grande quantidade de energia. Escrever um programa para
resolver uma determinada tarefa pode demorar mais tempo algumas décadas atrás do que seria hoje.
Com o passar do tempo, os computadores tornaram-se menores, mais rápidos, mais ef energia fi ciente e
mais importante: mais barato. O poder de um supercomputador de volta, então agora pode ser
encontrado em smartphones modernos. Este avanço tecnológico veio com muitos benefícios.
Comunicação e troca de informações sobre todo o mundo e até mesmo para o espaço foi possível por
algumas décadas e é parte de nossa vida diária. Todos os tipos de informações a partir de vários meios
de comunicação já está disponível na ponta dos nossos dedos.

A tecnologia tem nos últimos anos vindo a tomar um passo em uma direção nova e inexplorada e
uma nova frase para este fenômeno surgiu: A Internet das Coisas (Internet das coisas).

2.1.1 O que é a Internet das coisas?

A Internet das Coisas (Internet das coisas) é um conceito de conexão de dispositivos através da
Internet com a capacidade de recolher e trocar dados. Esses dispositivos ou aparelhos são
geralmente incorporado com micro-controladores, software, sensores, atuadores e conectividade
com a Internet [2]. Tais dispositivos podem incluir itens domésticos regulares, como máquinas de
lavar, geladeiras, sistemas de som, máquinas de café, despertadores e muito mais. Há também
aplicações IdC utilizados em cidades como sensores que monitorizam TRAF fi c, poluição do ar e da
água e do consumo de energia eléctrica. No recurso, carros auto condução será transportar pessoas
para os seus destinos e estes carros vai usar sensores e tecnologia sem fio para se comunicar uns
com os outros no tráfego fi c. Estima-se que haverá 6,4 bilhões (6,4 · 10 9) dispositivos ligados e em
uso no final de 2016 e que esse número aumente para 20,8 mil milhões em 2020 [3].

17
2.2 Sensores

"Um sensor é um dispositivo que detecta e responde a algum tipo de entrada a partir
do ambiente físico. A entrada fi c específica poderia ser luz, calor, movimento,
humidade, pressão, ou qualquer um de um grande número de outros fenómenos
ambientais. A saída é geralmente um sinal que é convertido para exibição legível na
localização do sensor ou transmitido electronicamente sobre uma rede para a leitura
ou o processamento ". [4]

dispositivos da Internet das coisas são geralmente equipados com um ou mais sensores que eles usam para
coletar informações. Essas informações são então processadas internamente no dispositivo ou enviados de volta
para um servidor (ex. Amazon Cloud Services ou um computador local).

Posição, posicionamento e deslocamento

Este sensor é capaz de detectar a forma como o raio de um outro objeto. Dentro

outras palavras, a distância. Um tipo diferente de este tipo de sensor de for capaz de determinar em
que medida que percorre desde um ponto de fi xa ser medição movimento angular, ou por rotação. Por
exemplo, um robô pode saber o quão longe ele viajou com base em howmany vezes suas rodas ter
rodado.

Presença e movimento

Sensores que detectam a presença tem a capacidade de detectar se um objeto está localizado nas proximidades. Por

exemplo, uma lâmpada pode ser equipado com um sensor de presença. Ele pode ser ligada se o seu sensor detecta

que um ser humano entrou no quarto. O sensor pode detectar movimento, o calor do corpo, ou ambos. Uma outra

maneira de detectar uma presença c fi cações seria a utilização de um dispositivo de localização. Este dispositivo pode

por exemplo ser colocados sobre um animal de estimação. Em seguida, o sensor pode detectar quando o animal com o

dispositivo move-se para ou para fora da sua gama.

Rapidez

Estes senors pode medir o quão rápido um objeto está se movendo com a ajuda de ímãs ou luz.
Exemplo de uso podem ser encontrados em Sistemas de break-rotação Anti (ABS) em carros que
medem o quão rápido as rodas estão girando.

Temperatura

Um tipo de sensor comumente encontrados em residências. Um exemplo bem conhecido é um

termómetro digital para medir a temperatura dentro e fora de uma casa. Um sistema mais adiantado
envolveria poderia ser capaz de medir a temperatura em todos os quartos dentro de uma casa e de
controle de dispositivos de regulação da temperatura. O sistema poderia detectar sempre que tem para
ligar o painel de aquecimento, a bomba de calor ou o ar condicionado, se for muito quente ou a frio com
base em leituras de temperatura.

18
Humidade e humidade

A capacidade de medir a quantidade de água no ar. Este é também um sensor muito comum que pode
ser encontrado em dispositivos que também medem a temperatura. Equipamento instalado com sensores
de humidade pode ser encontrado em casas, agrupa em conjunto com um termómetro. Eles também
podem ser encontrados em estufas, sistemas de ar condicionado, de escritórios e carros [5].

Som, acústica e vibração

Este sensor de detecção de som é mais vulgarmente conhecido como um microfone. O microfone pode
ser concebido de várias maneiras. Ela pode ser concebida para escolher apenas até tipos específicos de
ruídos como um fecho de fecho da porta ou um par de palmas.

Luz

Estes são sensores que podem detectar a luz visível humano. Muito parecido com sensores de
proximidade, esses sensores usar luz visível para detectar mudanças e movimento em um ambiente.
Por exemplo, uma lâmpada pode transformar-se automaticamente se detectar que há muito pouca
luz presente em uma sala e pode desligar-se se houver muita luz.

Movimento e rotação

Estes são mais comumente conhecido são giroscópios e detectar o movimento de rotação e as
alterações de orientação. As câmeras podem usar giroscópios para detectar agitação e irregular
movimento que ajuda-los a permanecer na posição. Isso resulta em menos fotos instáveis ​e captura de
vídeo.

GPS

Sistema de Posicionamento Global (GPS) é um sistema que permite que um dispositivo para medir a
sua posição e velocidade em qualquer lugar do mundo [6]. receptores GPS utilizam satélites em órbita
da Terra para determinar a sua posição. Pelo menos quatro satélites são necessários para obter uma
posição precisa. A margem de erro é geralmente dentro de alguns metros com um bom sinal. Os
satélites transmitem as suas posições e tempo através de ondas de rádio e estes sinais são captados
por um receptor. O receptor sabe quanto tempo se passou após o sinal foi enviado e é capaz de
determinar a sua localização na Terra.

Alguns gadgets da Internet das coisas tem um sensor de GPS instalado para que eles possam registrar ou sinalizar a sua

posição atual e velocidade. O sensor GPS pode ser usado para manter o controle da localização das pessoas, animais e itens.

Um animal de estimação animal do agregado familiar, como um gato, pode transportar colarinho instalado com um rastreador

GPS para que o proprietário pode knowwhere seu animal de estimação está localizado.

19
2.2.1 Energia eficiência

Baixo consumo de energia é um elemento chave importante para a Internet das coisas. Porque os dispositivos
podem ser colocados em para obter locais remotos ou duros, que normalmente será necessário para equipar
themwith uma fonte de alimentação interna. A nova tecnologia com baixo consumo de energia em mente está
sendo criado para o uso da Internet das coisas. Por exemplo, uma nova versão do Bluetooth, chamado
Bluetooth Low Energy [7] ea HaLow Wi-Fi [8].

Os dispositivos passam a maior parte de seu tempo em um estado de baixa energia onde eles
estão adormecidos e só liga se os sensores de pegar um sinal ou o dispositivo tem de enviar / receber
informações. Isso requer hardware inteligente e baixa compatibilidade sleepmode consumo de energia
[9].
processadores 3DRAM e 2.5D e 3D são tecnologias que são design para um desempenho mais
elevado com menor consumo de energia, bem como menores custos de fabrico [10] [11]. O
desenvolvimento dessas tecnologias é parcialmente impulsionado pela Internet das coisas como
smartphones.

2.3 Comunicação

A Internet das coisas geralmente usam tecnologia de comunicação sem fio para transmitir informações.
Esta informação pode ser enviada a outros IdC dispositivos, terminais ou servidores na Internet. Em
alguns casos, pode não ser necessário enviar dados através da Internet. Por exemplo, um smartphone
que recebeu uma mensagem através de um aplicativo de mídia social pode enviar um fi cação noti
através de Bluetooth para smartwatch do proprietário. O relógio pode, em seguida, exibir a mensagem
em sua tela. Em outras situações, uma mensagem é enviada através da Internet para notificar uma
parte remota em distâncias variadas, desde a poucos metros de continentes inteiros.

Como o fenômeno da Internet das coisas tem crescido, a necessidade de tecnologias ef energia fi cientes
melhor andmore têm surgido. A comunicação sem fio é uma das tecnologias que têm sido modi fi cado e
desenvolvidos para encaixa a necessidade da Internet das coisas. Os dispositivos da Internet das coisas tem
capacidade muito baixa bateria, mas eles geralmente não enviar um monte de informações a qualquer momento.
Isso significa que os desenvolvedores podem criar novos ou modificar os protocolos de comunicação existentes
para usar menos energia à custa de menos rendimento. As próximas seções irá cobrir dois próximos e populares
protocolos sem fio que visam melhorar a vida da bateria e alcance da Internet das coisas modernas.

2.3.1 Bluetooth

Bluetooth é uma tecnologia sem fio projetado para troca de dados em curtas distâncias. A tecnologia
permite o fluxo contínuo de dados entre dois dispositivos a uma alta taxa de transferência (25 Mbit /
largura de banda s teórico). Bluetooth utiliza sinais de rádio e opera entre 2,4 GHz e 2.485 GHz, o
que significa que funciona dentro do espectro de frequência de outras tecnologias sem fio como
Wi-Fi [12]. dispositivos Bluetooth podem se conectar uns com os outros por sorteio. Bluetooth não
enviar sinais em uma direção geral. Em vez disso, ele transmite um sinal para outros dispositivos
próximos podem vê-lo e emparelhar-se.

20
No entanto, eles precisam estar em uma estreita faixa, geralmente até 10m. Bluetooth também vem com o
benefício de compatibilidade com versões anteriores, ou seja, dispositivos com versões mais recentes do
Bluetooth ainda pode comunicar com dispositivos com versões mais antigas do Bluetooth.

Uso comum

Esta tecnologia é muito popular e fácil de usar que é por isso que ele é usado em muitos dispositivos
eletrônicos comuns, como smartphones. Por exemplo, um usuário pode emparelhar-se um telefone a
um fone de ouvido sem fio e transmitir música para ele. Bluetooth também pode ser usado para trocar
dados de um dispositivo para outro, tornando mais fácil para transferir imagens de um telefone para um
computador para backup, ou para sincronizar dados em dois dispositivos. Nos últimos anos tem havido
um desenvolvimento no uso de beacons Bluetooth em lojas de varejo. As balizas podem informar uma
pessoa através de seu telefone sobre a localização e informações sobre a loja. Apple e Google, as
duas principais desenvolvedores do sistema operacional para smartphones, fornecer suporte para
beacons Bluetooth no iOS e Android [13] [14]. Esta tecnologia funciona por ter o telefone
constantemente a ouvir as informações enviadas a partir de tais balizas ao consumir o mínimo de
energia da bateria possível. Quando se recebe um sinal a partir de uma baliza, que pode, em seguida,
notificar o utilizador por exibir uma mensagem ou a abertura de uma aplicação designada.

Bluetooth Low Energy (Bluetooth inteligente)

Padrão Bluetooth é excelente para a transferência de dados de forma contínua, mas esse recurso pode não ser
uma necessidade para dispositivos de Internet das coisas, que não transmitir dados, mas sim transmiti-lo através
de rajadas curtas e de outra forma ficar em um modo de baixa energia (sleep). Portanto, um NewVersion de
Bluetoothwas criado: Bluetooth
4.0, também conhecido como Bluetooth Low Energy (BLE) [15]. Esta versão foi projetada com a Internet das
coisas em mente, o que significa que oferece baixo consumo de energia por ficar é um estado de baixa energia
quando não se comunicar com outros dispositivos e enviando pequenas quantidades de dados em uma alta taxa
de transferência (1 Mbit / s). BLE também gasta pouco tempo emparelhamento com dispositivos que consome
menos energia. Enquanto clássico Bluetooth pode gastar em torno de 100ms para se conectar, BLE precisa
apenas cerca de 6 ms. Bateria-sábio, esta tecnologia pode fazer um pequeno dispositivo durar um par de anos
com apenas uma pequena bateria tamanho de uma moeda como fonte de energia. Em termos de gama, BLE tem
em torno da mesma gama como Bluetooth padrão em torno de 10m dentro de casa e até 100m ao ar livre sem
obstáculos.

Bluetooth versão 4.1 e 4.2

Bluetooth 4.0 foi anteriormente sabe asWibree andwas desenvolvido pela Nokia 2001-2006 antes de
mudar de nome [16]. A tecnologia foi primeiramente implementado no iPhone 4S na tarde de 2011 e
desde então tem sido adicionado em outros dispositivos de outros fabricantes. No momento da
escrita, dois nova versão do 4.x Bluetooth especi fi cação foram lançados: Versão 4.1 e 4.2. Versão
4.1 foi uma atualização de software para o fi cação especí existente

21
que adicionou novas funcionalidades que melhoram o usuário eo desenvolvedor usabilidade. Uma
característica fixada uma questão comumente sabe onde sinais Bluetooth 4.0 e 4G (LTE) iria
interferir uns com os outros, resultando em pior desempenho e mais consumo de energia. (Versão
4.2)

Bluetooth 5

A próxima versão do Bluetoothwas anunciado em junho 2016 pelo Bluetooth Special Interest Group
(SIG), que é o zelador e inovadora de tecnologia Bluetooth [17]. As novas promessas versão maior
alcance, velocidade de transferência e capacidade de mensagens de transmissão.
A gama é
quadruplicou, passando de um máximo teórico de 100m a 400m ao ar livre e 10m a 40m dentro de casa. A
velocidade de transferência é dobrado a partir de 1 Mb / s a ​2 Mb / s. Bluetooth 4.2 permite que os dispositivos
para enviar pacotes de 31 bytes em tamanho, mas Bluetooth 5 aumenta esta quantidade para 255 bytes, o que
resulta em um aumento de 800% da capacidade. Estes grandes melhorias permitem dispositivos para ficar
conectado mesmo a longas distâncias e, possivelmente, reduzir a quantidade de repetidores necessários em
uma rede de dispositivos Bluetooth. A transferência de dados é maior, ou seja, mais informações podem ser
transferidos em menos tempo. Como resultado, menos energia é consumida devido ao menor tempo que está
sendo usado para enviar dados. desde a versão

4.2, os dispositivos podem conectar-se uns aos outros sem emparelhar-se como um normalmente faz quando
o emparelhamento um telefone a um fone de ouvido sem fio. beacons Bluetooth usam este tipo de conexão
par-menos para enviar informações e dados de localização para smartphones. Bluetooth 5 permite que tais
balizas para enviar muito mais informações por mensagem que as versões anteriores.

2.3.2 WiFi

Wi-Fi é uma tecnologia que permite que os dispositivos para se conectar a uma rede sem fio LAN (WLAN).
Isso permite que os dispositivos para conexão sem fio com
outros dispositivos ou à Internet. WiFi opera no espectro de frequência de 2,4 GHz e 5 GHz. O
Instituto de Eletrônica e Electronics Engineers (IEEE) é uma associação que de fi normas e
protocolos para tecnologias de comunicação em setores como telecomunicações nes. Os usos IEEE
usa números exclusivos para cada padrão. O 802 é o pré fi x utilizado por qualquer protocolo ou
alteração que envolve a área de rede. Por exemplo, redes de área pessoal Bluetooth são designados
por 802.15, enquanto WLAN é designado por 802.11 [18]. Hoje, a maioria dos dispositivos e
aparelhos utilização

802.11n ou 802.11ac, também conhecido como WiFi N e Wi-Fi AC respectivamente. Wi-fi

N, que foi lançado em 2007, tem uma taxa de transferência em torno de 300-450 Mb / s dependendo
do número de antenas utilizadas e o intervalo quando WiFi AC a partir de 2013 pode chegar a uma
velocidade de 1 Gb / s. No entanto, WiFi AC utiliza apenas a banda de frequência de 5 GHz. Enquanto
a alta frequência telas o sinal da popular 2,4 GHz (resultando em menos interferência) ela perde um
monte de gama. Wi-Fi N pode funcionar em ambas as bandas. Ambas estas normas são compatíveis
com os padrões mais velhos A, B e G.

22
 Figura 2.1: A imagem não está à escala com alcance real. Fonte [19]

2.3.3 WiFi HaLow

Enquanto standardWiFi permite altas taxas de transferência, ele usa muita energia para enviar dados. Por
exemplo, o botão Amazon Internet das coisas é um dispositivo que registra pressionado o botão e envia
uma mensagem através da Internet para o serviço Amazon AWS. Enquanto o próprio dispositivo
permanece no modo de espera na maioria das vezes, quando pressionado ele acorda e se conecta ao
WiFi. Ligar a uma rede Wi-Fi consome muita energia. O dispositivo acaba durando apenas cerca de um
1000 prensas antes de sua bateria se esgote [20]. Isto é altamente ineficiente.

Uma nova geração de Wi-Fi está actualmente a ser desenvolvido pela aliança Wi-Fi [8]. O
seguinte protocolo generationWiFi passa sob o nome de Wi-Fi HaLow e seus especi fi cações são
descritos pela 802.11ah norma IEEE. O protocolo WiFi HaLow é, como o LE Bluetooth, projetado
com Internet das coisas em mente. É um concorrente para o padrão BLE, mas os dois protocolos
diferem em que WiFi HaLow permite que os dispositivos para se conectar diretamente à Internet.

Especi fi cação

Wi-Fi a / b / g / n / AC funciona na banda de 2,4 GHz, quando WiFi HaLow opera na banda de 900 MHz. A
banda de 900 MHz é uma frequência mais baixa significa que é preciso menos energia para enviar dados.
sinais WiFi HaLow pode viajar mais longe do que sinais de WiFi normais. WiFi HaLow deverá ter um intervalo
de 1 km [21]. A menor largura de banda também significa que os sinais são melhores em penetrar paredes, o
que significa um edifício pode fazer com menos repetidores WiFi para seus dispositivos da Internet das coisas.
Isso fortalece a capacidade de colocar dispositivos da Internet das coisas em áreas remotas como eles podem
operar em distâncias mais longas. WiFI Halow tem

23
um débito mínimo de 100 Kbps, que pode não parecer muito, mas deve su fi ce para as curtas
rajadas de transferência de dados da Internet das coisas dispositivos empregam. Dispositivos que
suporte a WiFi HaLow devem usar a 2,4 GHZ, 5 GHz e 900 MHz, o que significa que eles podem se
comunicar tanto com tecnologia nova e velha, fazendo WiFI HaLow mais acessível e mais fácil de
integrar.

24
Capítulo 3

Projetos relacionados

Neste capítulo vamos olhar para projetos que incorporam linguagens de script para a plataforma Internet das
coisas.

3.1 Alternativas

3.1.1 Scriptr

Scriptr.io, ou apenas roteiro, é uma plataforma baseada em nuvem para aplicativos de Internet das coisas,
móveis e da web. Ele oferece aos desenvolvedores a escrever e implantar scripts do lado do servidor que
servem como APIs costume de back-end para suas soluções da Internet das coisas [22]. Os scripts podem
ser escritos em JavaScript ou em blocos. Blocos é uma linguagem de programação visual onde o usuário
pode arrastar e soltar de código “blocos” para criar programas e é semelhante ao risco linguagem de
programação. Scriptr oferece uma interface web hospedado e fornece conexões seguras para dispositivos
se conectam ao serviço por meio de tokens de autenticação. Além da funcionalidade existente em
JavaScript, Scriptr também oferece uma variedade de módulos, tais como gerenciamento de dispositivos e
conexão com plataformas de mídia social.

3.1.2 LibeliumWaspmote Plug & Sense

Libelium é um provedor de plataforma de rede de sensores sem fio para soluções de Smart City e é o
desenvolvedor do Waspmote Plug & Sense (WPS) [23]. O DM é um dispositivo de sensores sem fio
encapsulado que permite que os integradores de sistema para implementar as redes de sensores sem
fio escaláveis ​e modulares [24]. Ele pode ser alimentado através de energia solar através de um painel
solar, que tem opções para vários tipos de tecnologias de comunicação de rádio, tais como Wi-Fi,
ZigBee, 3G, e seus oito módulos podem ser integrados com mais de 60 sensores [24]. Mais importante
ainda, o seu programa pode ser trocado sem fio, o que significa que pode ser colocado em fora das
áreas de alcance, permitindo o mantenedor para mudar facilmente o programa actualmente em
execução. Os programas executados pelos dispositivos WPS são escritos em C / C ++.

similarmente

de código Arduino, o código WPS C / C ++ também requerem configuração e laço

25
funções. TheWPS também pode ser acessado através de uma interface de programação gráfica.

3.1.3 Johnny-Five

Johhny-Five é uma plataforma Open Source JavaScript para robótica e Internet das coisas. A
estrutura suporta uma ampla gama de microcontroladores e computadores de placa única, como
Arduino e Raspberry Pi e muitos outros. A estrutura conta com node.js para interpretar os programas
JavaScript. JohnnyFive tem suporte para uma grande variedade de sensores e actuadores utilizados
por equipamentos IdC, tal como LEDs, servos, GPS, motores e sensores ambientais.

3.1.4 2 Tessel

Tessel 2 é uma plataforma de desenvolvimento robusto Internet das coisas e robótica [25]. Mais
especificamente, o Tessel 2 é uma placa de desenvolvimento de código aberto com capacidades WiFi
on-board que lhe permite criar scripts em Node.js [25, 26]. Ele também é capaz de executar programas de
ferrugem. As ofertas de plataforma de fi cial e módulos criados pela comunidade para vários sensores e
atuadores [25].

3.2 Avaliação

JavaScript é uma linguagem de programação popular. Ele é usado na web e em aplicativos de desktop
[27] e Internet das coisas [28]. JavaScript é capaz de rodar em
dispositivos da Internet das coisas, graças a Node.js. Node.js é um open-source, multiplataforma JavaScript
ambiente tempo de execução [29]. Ele usa o mecanismo de execução Google V8 para compilar o código
JavaScript para código de máquina nativo para maior velocidade e desempenho [29, 30]. V8 pode ser
executado em em vários sistemas, incluindo os processadores ARM. Com Node.js e JavaScript torna-se
fácil para escrever aplicações que podem se conectar à Internet e usar serviços da web diretamente no
dispositivo Internet das coisas.

JavaScipt também pode ser usado no lado do servidor em vez disso. Os dispositivos físicos podem
usar linguagens que operam em um nível inferior, como C. programação Esta abordagem aumenta o
conhecimento necessário do usuário como baixo nível C é mais difícil de obter direito de trabalhar com
uma linguagem com abstrações de alto nível.

A razão pela qual Node.js e JavaScript não é usado para este projeto é porque JavaScript é
grande e complexa. Um dos objectivos deste projecto é criar um pequeno e simples linguagem de
programação.

26
 parte II

desenhar

27
Capítulo 4

Requisitos para uma linguagem de

programação Internet das coisas

Neste capítulo vamos discutir os requisitos para a implementação de uma linguagem de script para a Internet
das coisas. Vamos também olhar para a plataforma Internet das coisas, o intérprete e seus requisitos.

4.1 A plataforma de destino

A linguagem é destinado a dispositivos da Internet das coisas. Estes dispositivos não são apenas muito poder eficientes e,

geralmente, pequeno em tamanho, mas eles também são limitados em termos de poder de processamento, espaço e

capacidade de memória RAM. dispositivos da Internet das coisas não executar um monte de processamento de dados e na

maioria dos casos, apenas recolher dados dos seus arredores e transferi-lo para um dispositivo externo, como um servidor

remoto.

dispositivos da Internet das coisas não são necessariamente feito para ser usado como um computador de
uso geral ou micro-controlador, como o Raspberry Pi ou o Arduino, mas em vez disso são realizar tarefas
pequenas e particulares. O Raspberry Pi é mais adequado para aplicações de uso geral. Isso não quer dizer que
dispositivo, como um Raspberry Pi não pode ser usado na Internet das coisas, mas eles podem não ser tão
eficientes em fazer uma determinada tarefa como um dispositivo personalizado seria.

Em alguns casos, os programas para dispositivos embarcados são escritos em C como o idioma
permite ao programador escrever programas rápidos com uma pegada pequena da memória e fi
le-size. C dá ao programador um monte de controle sobre o comportamento do programa, mas requer
uma boa compreensão do hardware que está sendo executado. Por outro lado, já existe soluções de
script para a Internet das coisas que utilizam JavaScript para a parte scripting. Estas aplicações podem
negociar afastado algum a velocidade trazida por um costume, solução de baixo nível para um o
benefício de fácil configuração e implantação.

4.2 O público-alvo

O público-alvo são estudantes ou pessoas que sabem um pouco sobre aspectos de programação e
construções. Além disso, os usuários são pessoas que estão interessadas em programação e
Internet das coisas. A linguagem deve fornecer

29
os meios para escrever simples projeto Internet das coisas em um curto espaço de tempo. Como tal, a linguagem deve oferecer

a funcionalidade básica necessária para implantar rapidamente soluções simples da Internet das coisas.

4.3 Os requisitos básicos

A linguagem deve ser simples e fácil de usar. O público-alvo são programadores amadores, assim
que a linguagem deve ser restrito em termos de complexidade. Isso deverá facilitar a curva de
aprendizagem e tornar os usuários mais produtivos.

4.4 Scripts Hot Swap

Os programas são scripts. Os dispositivos da Internet das coisas vai ter software que pode executar
esses scripts. Parte do projeto é a capacidade de trocar de scripts com os novos. Isto significa que
um dispositivo que está executando um script pode receber um novo script. Quando isso acontece, o
software terá que verificar se o novo roteiro é utilizável (ie. Que não contém erros de sintaxe). Se o
novo roteiro é OK, o script em execução é interrompida e eliminada juntamente com os seus dados
(variáveis ​etc.). Em seguida, o intérprete começa a funcionar o novo script. Por outro lado, o novo
roteiro é eliminada se o intérprete detecta que ele contém um erro. A execução do antigo roteiro é
retomada.

O usuário deve ser capaz de carregar um novo script para o dispositivo desejado,
independentemente de onde ele está localizado. Isto significa que os scripts podem ser enviados
através de conexões sem fio, como Wi-Fi e Bluetooth. Estes mecânica torna o platformmore flexível e
fácil de usar.
O fl owchart na figura 4.1 na página 31 mostra os vários estados o intérprete pode estar.

Interpretação 4,5 vs Compilação

Neste sectionwe'll olhar para bene fi ts e desvantagens de compilação do programa e interpretação

programa com relação a este projeto.

4.5.1 Compilando

Um compilador é capaz de verificar a semântica de um programa antes de compilá-lo para um formato

executável. O compilador pode também criar executável que são adaptados para uma arquitetura fi c
específica para melhorar a velocidade e consumo de memória. Como resultado, programas que são
compila tendem a ser rápido. Dependendo do idioma, a análise do programa pode ser usado para
detectar erros que ocorrem durante o tempo de execução. Assim, compiladores pode adicionar garantias
de segurança adicionais. Por exemplo, o compilador pode detectar incompatibilidades tipo em uma
linguagem de tipagem estática.

30
Figura 4.1: Fluxograma para a execução do programa

31
 A desvantagem é que o executável gerado pode (geralmente) só pode ser usado em uma
arquitectura alvo. O tempo de compilação também pode ser lenta, ao benefício de executável rápido.

4.5.2 Interpretação

Uma linguagem que é interpretada é executado por um intérprete. Isto significa que o código não é
compilado para um hardware específico linguagem fi c. Em vez disso,

é interpretado quer directamente quer através de um intérprete ou compilado para bytecode primeiro. Por exemplo,
Java compila a um especi fi c código de bytes de Java que podem ser interpretados pela máquina virtual Java
(JVM). Um benefício de programas interpretados é que eles podem ser implementados rapidamente. linguagens
interpretadas também são portáteis e podem ser executados em qualquer máquina, enquanto que as máquinas
arquitectura é suportado.

programas interpretados são geralmente mais lento do que os programas compilados. Um

compilador pode gerar pode gerar binários otimizados para uma plataforma de hardware, enquanto
um intérprete tem que manter interpretar o programa. Dito isto, é possível otimizar programas
interpretados através da geração de bytecode otimizado. O intérprete pode detectar segmentos de
código que são usados ​frequentemente e passar algum tempo para otimizar os. Eventualmente, a
interpretação pode se tornar mais rápido para cada otimização.

4.5.3 Avaliação

A linguagem é mais adequado para ser uma linguagem interpretada como ele vai ser usado como
uma linguagem de script. O problema com programas compilados é que seria difícil para verificar-los
no dispositivo Internet das coisas. Há sempre uma possibilidade de que algo correr mal com o
programa como ele é enviado para o dispositivo. Por exemplo, não é impossível que os bits se fl ipped
ou que alguns pacotes com os dados são perdidos. O compilador teria que suportar uma ampla gama
de arquiteturas diferentes. Dito isto, este argumento pode ser mudo como intérprete deve ser capaz
de rodar em diferentes arquiteturas.

Parte do projeto original era usar um intérprete para uma linguagem de script. A razão era, e é
ainda, o benefício de código veri fi cação em várias fases de implantação. Isso permite que o usuário
e do dispositivo de recepção para verificar os scripts. Isso deve fazer o platformmore robusto.

4.6 O Sistema Tipo

Nesta seção vamos discutir tipagem estática e tipagem dinâmica. Também discutiremos que tipo de
sistema é adequado com base nos requisitos exigidos.

4.6.1 estática Typing

Com tipagem estática, o usuário deve especificar o tipo de uma variável quando uma variável é
declarada. O tipo de uma variável não pode ser alterado uma vez atribuído. Isto significa que todas as
variáveis ​têm os seus tipos conhecidos durante o tempo de compilação. O compilador pode apenas
verificar o tipo de cada variável e

32
 informar ao usuário se houver um tipo de miss-jogo. Ele também pode evitar os erros que ocorrem durante o tempo de

execução. tipagem estática pode levar a menos bugs como os erros são detectada precocemente durante o

desenvolvimento.

Como exemplo, vamos olhar para declarações de variáveis ​em C. Uma variável inteira pode ser
declaredwithout uma atribuição ( int x;) ou com uma ( int y = 42;), mas deve sempre ter um tipo especi fi
cado.

4.6.2 Tipagem Dinâmica

tipagem dinâmica permite que as variáveis ​para ser declarado sem ter que declarar explicitamente seu tipo.
Uma variável não está limitado a qualquer tipo. Por isso, pode ser transferido para outro valor de um tipo
diferente. línguas geralmente interpretados usar tipagem dinâmica como não há compilador para executar
uma verificação de tipo. Quaisquer erros de tipo são capturados durante a execução. Abaixo está um
exemplo trivial de como tipagem dinâmica pode levar a erros sutis. Em uma base de código maior,
encontrando este tipo de erro pode levar até um monte de tempo. 1 def adicionar (a, b):

2 Retorna a + b
34 adicionar( 1 , 2 ) # ESTÁ BEM

5 adicionar( 3 , "Olá" ) # Erro tempo de execução

6 adicionar( "abc" , "Def" ) # ESTÁ BEM

4.6.3 Inferido Typing

digitação inferida permite que o compilador para inferir o tipo de uma variável com base em como ele é usado.
Isso permite aos usuários pular escrever o tipo de uma variável, mas eles mantêm o benefício de verificação de
tipo durante o tempo de compilação. Sempre que o compilador não pode inferir o tipo de uma variável, ela será
cancelada com um erro do compilador. Isso força o usuário a especificar o tipo de dados para que o programa
pode compilar. digitação inferida se enquadra na categoria de tipagem estática como todos os tipos são
conhecidos durante o tempo de compilação.

Como um exemplo: Na oxidação nós podemos escrever o seguinte código. 1 seja x = 128 ;

2 deixe y: u 16 = 20 + X;

Aqui, X inicialmente não tem nenhum tipo, mas o compilador sabe que deve ser um inteiro. o y é
declarada com o tipo U16, Portanto, a expressão no lado direito da declaração de atribuição deve
retornar um valor com o tipo U16. O compilador pode então inferir que X deve ter o tipo U16.

digitação inferido é mais complexo do que tipagem estática normal e é mais difícil de implementar. Ele
também não oferece nenhuma prática benefício, mas pode tornar o código olhar um pouco menos detalhado.

4.6.4 Avaliação

tipagem dinâmica significa que o usuário não precisa se preocupar com os tipos de declarações.
tipagem dinâmica também deve ajudar a baixar a curva de aprendizagem.

33
 O script fi le tamanhos deve ser tão pequena quanto possível. Podemos potencialmente economizar alguns
bytes por não ter que escrever o tipo de cada variável. Quanto menos dados dos dispositivos da Internet das
coisas têm de enviar, menos poder que têm para consumir em comunicação sem fio. Isso também significa que
podemos potencialmente libertar algum espaço em disco e RAM.

Um contra-argumento para tipos dinâmicos é que elas aumentam a chance de erros de tempo de execução
devido ao tipo de incompatibilidades. Um dos objetivos da língua é que ele nunca deve causar um acidente, de
modo a escolher tipagem dinâmica sobre tipagem estática é contra-intuitivo que estes últimos possam evitar
erros de tipo.

4.7 Evento Programação Orientada

A maioria das linguagens de programação que são usadas para a Internet das coisas são linguagens imperativas [28].

É provavelmente o paradigma mais utilizado e é fácil

para entender como é fácil seguir o fluxo da execução do programa durante a leitura de código
imperativo. No entanto, há um outro paradigmwhich programação é mais adequado para a Internet
das coisas e para a linguagem deste projeto: Evento de programação orientada.

dispositivos da Internet das coisas são unidades que esperam por seus sensores e atuadores para reagir às
mudanças. Quando um evento que desencadeou, o software no dispositivo deve manipular o evento. programação
orientada evento permite ao usuário escrever programas que modelo se assemelham ao comportamento do
dispositivo. Isto deve fazer programação Internet das coisas se sentir mais natural para o usuário.

É possível escrever programas orientados de eventos em linguagens imperativas, mas podem ser
desajeitado, detalhado e não muito intuitivo. Em vez de fazer manipulação de um complemento à
linguagem evento, o idioma será construído em torno de eventos de manipulação direta.

4.7.1 Manipulando eventos

Todos os eventos serão inseridos em uma piscina evento. Os eventos serão classificados com base em sua
prioridade andwhen eles estão programados para ser executado. O intérprete irá pesquisar um evento de cada
vez e manipular o evento. Quando um manipulador de eventos está em execução, não será esgotado e será
permitida a execução até que esteja completo.

O intérprete será único segmento. Isto significa que não mais do que um evento pode ser manipulado
a qualquer momento. Este fi simpli es a implementação e elimina a possibilidade de condições de corrida
para os dados compartilhados entre manipuladores de eventos.

O tipo de manipuladores de eventos variar fromuser definido para entrada e saída de sensores,
actuadores e IO.

4.8 Segurança

A segurança é um fator importante quando se trata de Internet das coisas. Os dispositivos são bastante vulneráveis
​como eles estão conectados à Internet. Assim sendo. eles podem ser

34
acessada por terceiros mal-intencionados. Estes dispositivos tendem a ter pouca ou nenhuma proteção contra
ataques externos.
Lamentavelmente, os mecanismos de segurança da língua e o intérprete não eram uma
preocupação primordial para esta tese.

4.9 Erros e Excepções

O intérprete deve ser sempre a correr e nunca deve terminar a menos que o dispositivo está
desligado. Idealmente, o intérprete deve ser capaz de lidar com erros causados ​por scripts de usuário,
no sentido de que ele nunca deve falhar quando encontra um. Um dos manuais outros, compiladores
e intérpretes pode imprimir um aviso se detectar uma coisa doentia dentro do código que eles estão
analisando. Um programa que faz com que um erro devido a uma exceção ou um erro lógico pode
terminar com segurança graças à construído em manipulação de erro. Claro, alguns erros estão além
do nosso controle, enquanto outras são devido a descuidos de implementação ou bugs. Por exemplo,
o programa pode ficar sem memória, ele tenta acessar dados que está fora dos limites, ele corre para
a exceção de ponteiro nulo infame ou simplesmente faz com que uma falha de segmentação. O que
sempre a causa pode ser, muitos destes erros não podem ser manipulados pelo próprio intérprete e
do sistema operacional subjacente provavelmente irá terminar o intérprete. Mais tarde veremos como
podemos tentar manter um perto de 100% acima do tempo usando um processo em segundo plano
para monitorar o status do intérprete.

4.10 Manuseio de uma Bater Software

Quando o intérprete detecta um erro no script de usuário deve agora escolher um curso de ação
apropriado. Um erro pode ser causada por vários meios, dependendo da implementação e design da
língua. Vamos agora olhar para as várias maneiras diferentes de lidar com um acidente.

4.10.1 Alternativa 1: Repor

O intérprete reinicia a interpretação do script. Isso significa que ele começa a interpretar o script
desde o começo. Há desvantagens, no entanto.

• Todos os dados temporária é perdida.

• O programa pode encontrar o erro novamente, fazendo um ciclo interminável de reinicializações.

• O usuário será spam de relatórios de erro se estiver ativado.

Não parece ser muitas vantagens para esta solução. No entanto, o usuário não precisa
performany manutenção adicional que os scripts apenas reinicia. Pode ser que o erro foi causado por
um erro uma vez que significa que poderia ter sido o esperado para acontecer.

35
 4.10.2 Alternativa 2: Remover o script

O intérprete remove o script completo do meio de armazenamento, ou seja, o intérprete já não tem
um script de interpretar. Esta cenários podem também resulta em perda de dados intermediários. O
intérprete entra em seu estado padrão, o estado de espera. Neste estado, o intérprete deve agora
esperar para que o usuário fornecer um script que pode ser executado.

A vantagem dessa abordagem é que o usuário saiba o intérprete vai parar com segurança
interpretar um script como um programa normal, que encontrou um erro faria em um computador
desktop. Algumas exceções podem ser causados ​por erros graves e pode ser mais seguro para parar,
simplesmente, em vez de executar novamente o mesmo script novamente.

4.10.3 Alternativa 3: Ignore-o

O intérprete pode optar por ignorar o erro e continuar a interpretar o programa. Em JavaScript, existe
um valor nulo, o que representa a ausência intencional de um valor de objeto. O utilizador pode usar
null em operações aritméticas com outros tipos de dados que podem produzir resultados confusos. 1> 1
+ nulo

21
3> 1 * nulo
40
5> {} + nulo
60
7> {} * nulo
8 Erro de sintaxe
9> nulo * {}
10 NaN

No entanto, ele está lá por design e pode causar um acidente programa em determinadas
situações, o que pode forçar o programador para verificar se há valores nulos.

Voltando ao intérprete, poderíamos implementar um mecânico semelhante se o idioma

implementa um tipo nulo para representar um erro ou falta de dados. Agora, se o intérprete fosse
para detectar o uso de um valor nulo, ele pode optar por ignorá-lo e permitir que a corrupção dos
dados. No entanto, algumas exceções são causados ​por problemas mais graves que não podem ser
ignorados. Esta solução teria que ser implementado em conjunto com uma ou ambas as soluções
discutidas nas seções acima.

4.10.4 Alternativa 4: Terminar

O intérprete pode encerrar completamente e nunca reiniciar automaticamente. O que isto significa é que
o usuário tem que reiniciar o programa manualmente. Isso pode ser feito de várias maneiras,
dependendo do hardware e software de hospedagem. Por exemplo, se os dispositivos é uma Pi
Raspberry executando uma distribuição Linux, o usuário pode reiniciar o programa, ou remotamente
(através ex. Ssh) ou localmente. Para outros dispositivos com sistemas operacionais mais simples, o
usuário pode ter que se aproximar fisicamente o dispositivo e reiniciá-lo manualmente,

36
por desconectar e conectar novamente a fonte de alimentação ou pressionando o interruptor de alimentação.

Desde que gostaríamos nossos dispositivos da Internet das coisas para estar sempre pronto e funcionando.
Que encerra o processo em execução eo script provavelmente faria mais mal do que bem.

4.10.5 Alternativa 5: Informe o usuário

Seria benéfico para informar o usuário que ocorreu um erro. No caso em que as falhas intérprete ou
termina, não será possível para que possa enviar uma mensagem de diagnóstico para um usuário, a
menos que haja um programa de observador (daemon) bruxa detecta o acidente e é capaz de erros
de reporte. Por outro lado, se apenas o script falhar ou provoca um erro, o próprio intérprete pode
notificar o usuário sobre quando eo que deu errado. O intérprete deve, portanto, saber como e para
quem ele deve enviar a mensagem. O diagnóstico deve conter informações como quando ocorreu o
erro, o que causou isso e a posição no script onde aconteceu.

4.10.6 Watchdog Daemon

Um daemon é um programa que é executado em segundo plano e não está sob o controle direto do
usuário. Em sistemas Unix-like, há um daemon chamado Watchdog que verifica se o sistema operacional
está sendo executado corretamente e pode fazer com que o kernel para executar uma reinicialização se
ocorreu um erro.
No caso em que o intérprete termina, por qualquer motivo, um processo daemon poderia ser
responsável por iniciar uma nova instância do programa intérprete. O daemon deve ser capaz de
determinar se o intérprete está sendo executado ou não, ou se seu simplesmente dormindo.

O daemon em si deve ser simples, pequeno em tamanho e executar o menor número de operações quanto
possível enquanto ainda está sendo capaz de avaliar corretamente o estado do interpretador de sua observação.
Esta é reduzir o consumo de energia e para conservar o máximo de recursos do sistema quanto possível, eles já
podem ser limitados devido à natureza atual de dispositivos da Internet das coisas.

A adição de um processo de daemon pode exigir que o dispositivo IdC para ser capaz de
executar um sistema operativo que é capaz de executar vários processos, quer em paralelo ou
simultaneamente. No caso em que o
intérprete está sendo executado como uma parte integrada do sistema, também conhecido como não há
nenhum sistema operacional subjacente com um gerente de programador e de recursos, pode tornar-se
impossível de implementar o daemon desejado. Embora, talvez seja possível imitar um comportamento
daemons através de outros meios.

4.11 Sensores e Actuadores

A linguagem irá fornecer uma interface para os sensores, atuadores e IO. Isso significa que o usuário
nunca terá que se preocupar sobre como implementar a funcionalidade de baixo nível. Isso coloca
muita responsabilidade por um responsável pela implementação do intérprete como ele ou ela deve
implementar a interface

37
para os sensores e actuadores. No entanto, a interface torna-se mais ef fi ciente como ele é implementado
em uma linguagem de nível mais baixo e pode ser acessado diretamente pelo intérprete.

Um dos objetivos deste projeto é fazer com que uma língua que você pode usar para implantar rapidamente

aplicações da Internet das coisas. Ao oferecer um construído em interface com sensores e atuadores somos capazes de

ful fi l este objetivo.

4.12 A Biblioteca Padrão

A biblioteca normal (STD) irá conter funções que permitem ao utilizador acesso sensores, actuadores
e IO. Além disso, o STDwill contêm funções que permite ao utilizador manipular e interagir com o
construído em tipos de dados.

38
capítulo 5

Designing Daspel

5.1 O que é Daspel?

Daspel é uma linguagem de script orientada a evento que é voltado para Internet de dispositivos as
coisas. Daspel fornece captações alto nível sobre o dispositivo, incluindo sensores, actuadores, IO e
comunicação de rede.

Designando a linguagem

'Há apenas duas coisas difíceis em Ciência da Computação:. Invalidação de cache e

nomear as coisas' - Phil Karlton [31]

Com a ajuda de Vetle Volden-Freberg, I em um nome para a linguagem de script: Daspel. O

nome é derivado do Event-Driven atuador & Sensor Programming Language, ou EDASPL para
breve. No entanto, EDASPL não é fácil de pronunciar para usuários de língua inglesa, de modo a
letra E foi movido da frente para entre P e L.

5.2 A sintaxe

A sintaxe é inspirado por C, JavaScript e sintaxe da oxidação. Daspel é escrito para assemelhar-se
linguagens de programação imperativas, em termos de estruturas e de função de bloco.

5.3 Os tipos de dados

Em Daspel existem 5 tipos de dados fundamentais.

• int

• real

• bool

• corda

39
 • Lista

Há também o é nada tipo que é usado para os valores de erro. Fora dos cinco tipos, três deles
pode ser considerado como tipos primitivos: int, bens
e bool. o corda e Lista são estruturas de dados e ter uma implementação mais complexa.

As secções que se seguem, os tipos de dados será designado por usar uma fonte
mono-espaçada. Este é apenas visualmente separar os tipos de dados e conceitos com o mesmo
nome.

5,4 Integer

Em Daspel, o int é um assinado complemento de dois de 32 bits inteiro. Como tal, deve cobrir a gama de
números necessários para os cálculos simples um dispositivo IdC irão realizar. Concedida, não é dado que
cada dispositivo IdC tem um processador de 32 bits como também podem ser de 16 bits ou 8 bits. No
entanto, um processador de 16 bits é inteiramente capaz de lidar com dados de 32 bits e de 64 bits no custo
de passar mais tempo na instruções adicionais, em oposição aos dados de 16 bits. 32 bits é um tamanho
comumente usado para números inteiros e muitas vezes é o tamanho padrão.

Mas o que é que o usuário gostaria de usar inteiros menores para economizar espaço? O tipo dinâmico
systemwould torná-lo um pouco para especificar um tamanho c pouco mais especi fi para um número inteiro
em oposição a um sistema do tipo estático. Em outras línguas, geralmente há nenhuma maneira de
especificar o tamanho inteiro sem recorrer à criação de uma nova variável ou fundição. No entanto, Daspel
pode emprestar a anotação inteiro usado em oxidação. A sintaxe consiste em acrescentar o tipo de dados
no final do número. Por exemplo, 100i32 é um número inteiro de 32-bits com sinal com o valor de 100,
enquanto 9u8 é um inteiro de 8 bits sem sinal com o valor 9. poderia ter sido adicionado Este recurso, mas
por uma questão de simplicidade e devido a limitações de tempo, não foi adicionado nesta versão do
Daspel.

5.4.1 Integer Sintaxe

A sintaxe para o int tipo é exatamente o mesmo que em outras línguas. 1 deixe a = 1 ;

2 deixar b = 2 ;
3 deixar c = a + b;

5.5 real

O termo real é usado para representar os números decimais. Existem dois sub-tipos de reais:
números de ponto fixo e números de ponto flutuantes. Daspel usa a notação de ponto fixo. O tipo de
dados que representa números decimais é chamada real. Visualmente, não parece haver qualquer
diferença entre os dois tipos. No entanto, números de ponto fi xa são armazenados como números
inteiros. números de ponto fixo usar aritmética inteira em oposição a aritmética de ponto flutuante.
Isto dá-lhes uma vantagem quando se trata de velocidade de computação. Nos dispositivos que não
têm um processador de ponto flutuante [32] (FPU),

40
 fl ponto flutuante aritmética é muito lento. Para este projecto assume-se que os dispositivos da Internet das
coisas não têm uma FPU 1. Números de ponto flutuante são também ter uma precisão mais elevado do que os
números de ponto fixo devido aos bits de números utilizadas para representar as fracções serem maiores
para aveia fl. No entanto, a suposição é que o usuário de Daspel não vai exigir toda a precisão de uma bóia.
É muito mais conveniente usar o ponto fixo mais rápido.

real em Daspel é um número de ponto fixo de 32 bits assinado complemento de dois. Ele usa 16
bits para representar a parte inteira e 16 bits para representar a parte fraccionada. Referimo-nos a este
formato que o formato de Q [33], que é um formato utilizado para números de ponto fixo. Em outras
palavras, o real tem o Q16.16 formato. Mais especificamente, é uma Q15.16 porque um bit é usado para
o sinal. fracções de 16 bits são capazes de representar números decimais com uma precisão até pelo
menos 0,9999. A Figura 5.1 mostra como o número inteiro e os bits fraccionais são armazenados.

Assim como com números de pontos flutuantes, precisão pode ser perdida durante a
multiplicação e divisão. Isso ocorre porque nem sempre há espaço suficiente para representar a gama
completa dos bits fracionários.

Figura 5.1: Este padrão particular é o resultado da conversão de uma bóia com o valor de 5.865 a um
real.

5.5.1 Sintaxe real

1 deixe pi = 3 . 14
2 seja r = 2 ;
3 deixar área = pi * r * r;

5.6 booleana

Um valor booleano é um valor binário e pode ser tanto verdade ou falso.

5.6.1 Por que incluir boolean?

Booleana é uma representação clara de uma condição que é usado em estruturas condicionais. Eles fazem
as intenções programadores mais clara e pode tornar o código mais legível. Outras linguagens, como C e
JS, permitem inteiros para representar valores booleanos. Quaisquer números inteiros diferentes de zero é
verdadeiro e 0 é falso.

1 Isso geralmente é devido ao alto custo de FPUs.

41
 Esta abordagem pode ser considerada como sendo uma forma de fundição implícito entre tipos e
permitindo que um tipo para representar múltiplas formas de dados ao mesmo tempo. Não há nada
necessariamente errado com esta abordagem, mas em Daspel optamos por separar a dualidade de
inteiros C e, em vez separar o que em dois tipos distintos.

Se Daspel não apresentam estruturas condicionais, não seria mais necessário ter um tipo
booleano.

5,7 de Cordas

Cordas em Daspel são dinamicamente recipientes feitos sob medida para o texto codificado em Unicode.

5.7.1 Unicode

o corda Tipo utiliza codificação Unicode em vez de ASCII. É para torná-lo mais conveniente para os que não
falam inglês para enviar e receber mensagens de texto em uma língua que falam de seu dispositivo de Internet
das coisas.
Em um ponto durante o processo de criação, emojis e outros símbolos Unicode foram
consideradas como sendo parte da sintaxe. É, portanto, faz sentido para também fazer corda apoiar
texto Unicode.

5.7.2 Dinâmica Tamanho

corda é dimensionado de forma dinâmica, o que significa que pode crescer e encolher. O tamanho será feita
automaticamente pelo intérprete.
Daspel poderia ter usado cordas porte fixas, mas, em seguida, o usuário tem que certificar-se de
que a corda é grande o suficiente ao inserir novos dados nela. Daspel é suposto ser o mais simples
possível e usando cordas de tamanho dinamicamente o usuário tem uma coisa a menos para se
preocupar.

5.7.3 Caráter Individual

não Daspel não apresentam um tipo de dados separado para caracteres simples. Isso ocorre porque
um personagem pode ser expressa como uma corda e reduz a complexidade da linguagem. Claro,
isso significa que Daspel é ligeiramente menos eficientes, pois tem de atribuir cadeias de caracteres
individuais na pilha em vez de na pilha.

5.7.4 Sintaxe de String

corda usa a mesma sintaxe que a maioria das outras linguagens de programação. Sem Unicode
caracteres são mostrados neste exemplo porque L UMA O TEX não suporta símbolos Unicode. 1 deixar s
= "Esta é uma string" ;

2 deixe EMPTY_STRING = "" ;

42
 5.8 Lista

Lista é uma coleção que pode armazenar qualquer um dos tipos de dados Daspel. Assim como
corda, lista aloca dados na pilha. Isto permite que cresça e se encolher como elementos são
adicionados e removidos do Lista. A alocação é feita automaticamente pelo intérprete.

O problema com as listas de tamanho fixo é que o usuário tem que ter cuidado ao acrescentar
novos elementos. O usuário deve assegurar que a lista é sempre grande o suficiente para fi t novos
elementos. No caso de que não é, o usuário deve alocar uma lista maior. Em vez de, Lista isso funciona
para você nos bastidores. Este é, naturalmente, apoiada pelo objetivo de fazer Daspel o mais simples
possível.
Devido a limitações de tempo, a sintaxe para adicionar e remover elementos de um Lista Não
foram adicionados. No entanto, seria mais provável ser semelhantes aos encontrados na implantação
Python.

5.8.1 Lista de sintaxe

Lista tem a mesma sintaxe de listas em Python. Cada elemento na lista é separada por uma vírgula.

1 deixe = positivos [ 1 , 2 , 3 , 4 , 5 ];

2 deixe que qualquer = [ "Olá" , 13 , verdade ];

3 deixe = aninhados [ 1 , [ 2 ], [[ 3 ]]];
4 deixar empty_list = [];

5.9 Nil o tipo de erro

nada é um tipo de erro em Daspel. Ele representa a ausência de um valor. Ele também é usado para
representar um erro. Este tipo foi incluído de modo que seria possível retornar algum tipo de erro de
funções que ler dados de sensores e atuadores. Por exemplo, se o sensor de temperatura que não
está ligado e o programa tenta ler a temperatura, a função irá simplesmente devolver nada em vez de
um real. Ao invés de nada, valores padrão pode ser utilizado. Assim, no exemplo acima, em vez de
retornar um nada, a função pode retornar 0,0. Isso é problemático como 0.0 é também um valor
jurídico. Portanto, ter um valor de erro dedicada faz erros mais explícita e mais fácil de pegar.

5.10 Variáveis ​e declaração de variável

Como muitas outras línguas, Daspel tem variáveis. Uma variável é um recipiente chamado que armazena
um valor. Nesta seção vamos discutir como as variáveis ​são declaradas. Na seção de definição do
âmbito veremos onde as variáveis ​podem ser declaradas.

A palavra-chave para a declaração de variável em Daspel é deixei.

43
 5.10.1 Declaração Ambiguidade Variável

Nós vamos olhar para duas maneiras de declarar variáveis. Em JavaScript, nós declaramos uma nova
variável usando a var, vamos ou const palavra-chave ( const cria uma variável imutável). 1 seja x = 32 ;

2 X = x + 20 / 3 ;

Em Python, podemos declarar uma variável sem usar uma palavra-chave. 1 x = 32

2 X = x + 20 / 3

No entanto, há um problema com a implementação Python. Porque não há distinção entre uma
declaração de variável e uma atribuição, temos ambigüidade semântica. Considere o seguinte código
escrito em Python. 1 x = 1

2 E se condição:
3 x=2

O usuário pode ter a intenção de declarar uma nova variável X na declaração se-, mas em vez
termina upmutating o X acima. Thismay parecer uma questão trivial para programadores Python
experientes, mas pode levar a confusão entre os iniciantes e pode levar a Run-Time bugs. Com
declaração de variável explícita, podemos evitar esses tipos de bugs. 1 seja x = 1 ;

2 E se (Condição) {
3 x = 3 ; // transforma os x acima
4 seja x = 2 ; // Sombras x
5}

Para evitar esse tipo de ambiguidade, Daspel requer declarações de variáveis ​explícitas. Isso
nos dá uma clara distinção entre a declaração e atribuição.

5.10.2 Declaração Parte Variável

No escopo vamos discutir onde as variáveis ​podem ser declaradas. Por enquanto só sei que as
variáveis ​só pode ser declarada no início de cada escopo. Essa seção chamada a parte declaração da
variável. Como declarações de variáveis ​só pode ocorrer uma vez lugar por escopo, torna-se fácil para
verificar se há declarações de variáveis ​extraviado.

Uma parte de declaração variável consiste em três variantes. Se não houver variáveis ​para
declarar, a parte declaração está vazio ou totalmente omitido. A segunda variante consiste em uma
única declaração. A variante fi nal consiste de múltiplas declarações.

A questão é: como podemos representar a parte declaração da variável e é três estados de uma
forma simples e elegante?
Uma solução é a de exigir que cada variável a ser declarado separadamente como demonstrado
abaixo.

44
 1 deixe a = 1 ;
2 deixar b = "calor" ;
3 deixar c = [ 4 , 3 , 2 , 1 ];

A solução seguinte é o grupo de todas as declarações em um bloco. O bloco pode ser vazia ou
omitido se não houver variáveis ​locais. 1 # vazio

2 deixei {}
34 # solteiro

5 Seja {x = verdade }
67 # múltiplo

8 deixei {
9 a=1,
10 b = "calor" ,
11 c = [ 4 , 3 , 2 , 1 ],
12}

Uma terceira alternativa é a cadeia a declaração. Algo semelhante pode ser feito em linguagens
C-like. 1 # solteiro

2 seja x = verdade ;
34 # vazio

5 deixe a = 1 ,
6 b = "calor" ,
7 c = [ 4 , 3 , 2 , 1 ];

A última proposta é a alternativa mais simples que também acontece para exigir o mínimo de
caracteres. Assim, é a sintaxe mais adequado para a parte declaração da variável.

5.10.3 Variáveis ​e Scopes

Esta seção se aplica principalmente para as variáveis ​definidas no escopo da função.

Quando uma função de usuário definida é chamada, ela pode declarar algumas variáveis.
Quando a chamada de função é longo, os dados alocados precisa ser limpo. Em algumas línguas
isso é feito por um coletor de lixo. Em Daspel não há gestão de memória manual, mas não há
gerenciamento automático de memória. o corda e Lista tipos de dados que dados alocado no heap.
Para evitar preenchendo-se a pilha para o ponto onde ele é executado fora do espaço, Daspel
precisa limpar dados alocados. Então, quando as variáveis ​apontando para

corda e Lista Dados sair do escopo, o intérprete irá libertar automaticamente os dados no heap.

5.11 Escopo

Nesta seção nós vamos olhar para as regras de escopo em Daspel. Há um total de três escopos: o
escopo biblioteca, o alcance global e o escopo da função. O escopo da biblioteca é o escopo mais
externo, seguido pelo escopo global. o

45
 escopo de função só pode existir dentro do escopo global. Há apenas uma biblioteca e alcance global,
mas o usuário pode de fi ne muitas funções e, portanto, muitos escopos de função. No entanto, o escopo
de função não podem ser aninhados. Em outras palavras, você não pode de funções fi ne dentro de
funções.

5.11.1 Âmbito variável

O escopo variável determina onde as variáveis ​podem ser declaradas e onde podem ser acessados
​a partir. Dois projetos de declaração de variável foram considerados durante o design.

O projeto primeiro é emprestado de linguagens imperativas e permite que as variáveis ​para ser
declarado em qualquer lugar em um escopo. Na figura 5.2 vemos como variáveis ​em uma linguagem de
tipagem estática são declarados e quanto tempo eles vivem com base no escopo são definidos no. Este
projeto faz certas coisas um pouco mais complicadas como o intérprete tem que saber exatamente onde
uma variável é declarada em um âmbito de aplicação. Isso é para garantir que as expressões e
declarações não usam variáveis ​que não são tecnicamente ainda definida.

O segundo projeto simplesmente requer que todas as variáveis ​para ser declarado no início de cada
escopo. Embora não seja aplicada, esta prática não é incomum em programas em C, onde algumas
variáveis ​são reutilizados para diferentes fins, tais como contadores no para-loops.

Forçando declarações de variáveis ​para o topo de cada scopemakes um pouco mais simples para
projetar o analisador. Também torna mais clara de quantas variáveis ​são usadas por escopo. Por estas
razões, decidiu-se que as variáveis ​devem ser declaradas em uma parte declaração da variável. 1 {2

seja x = 1 , Y = 2 ;
3 # Algum código ...
4 Deixando z = 3 ; # <- ilegal! Deve ser declarado no topo
5}

1 var global; // Mora no âmbito global.

2 // Goes "fora do escopo" quando o
3 // programa termina.
4 {5
var x;
6 . . . // Alguns código ...
7 variar;
8 {
9 . . .
10 var x; // Sombras variável x.
11 // x no âmbito acima é intocado.
12 var z;
13 } // x e z ir fora do escopo aqui.
14} // x e y ir fora do escopo aqui.

Figura 5.2: Um exemplo de howvariables podem ser declarados em uma linguagem com um sistema de tipo
estático

46
 5.11.2 Âmbito Biblioteca

O escopo da biblioteca é o escopo mais externo e contém funções encontradas na biblioteca padrão.
Este escopo pode ser acessado de outros dois âmbitos. Note-se que este funções e variáveis
​definidas neste âmbito não pode ser alterado pelo usuário através de um script Daspel como é
definido na implementação do intérprete.

5.11.3 escopo global

Esse é o escopo o usuário vê quando ele ou ela está escrevendo programa Daspel. Neste âmbito,
variáveis ​e funções podem ser declarados. Variáveis ​devem ser declaradas no topo do escopo na
parte de declaração variável. Qualquer função definida neste âmbito pode ser acedido a partir de
outras funções, independentemente da ordem pela qual eles foram definidos. Em outras palavras,
Daspel evita a problemC tem em que uma função não pode acessar mais funções definidas abaixo, a
menos que o usuário declara os protótipos de função no topo da fi le ou em um cabeçalho fi le.

5.11.4 Função Âmbito

O escopo da função é a que existe no âmbito funções. Esse escopo é acessível apenas para a
função proprietária, ou seja, sem funções externas podem acessar seu conteúdo. 1 # O escopo global

2 # não pode ver o que está dentro

3 # foo ou barra
4 deixe glob = 10 ;
56 fn foo () {

7 # Pode ver glob e bar,

8 # mas não pode ver zap de bar
9} 10 11 fn Barra() {

12 # Pode ver glob e bar

13 # Pode ver zap
14 deixar zap = [];
15}

5.12 Operadores

Daspel inclui a aritmética padrão e operadores lógicos. tipos de dados em Daspel não pode ser
usado juntamente com estes operadores. A excepção é que int e real podem ser utilizados em
conjunto em operações aritméticas. Ao misturar os dois tipos, o valor resultante será sempre um real. Esta
é uma semelhante às como outras línguas fazê-lo, incluindo Python.

A razão pela qual os tipos não podem ser misturados e utilizados em conjunto pelos operadores é
porque nem sempre é claro o que a resposta deveria ser. Por exemplo,

47
 • plus +

• menos -

• multiplicação *

• divisão /

Tabela 5.1: operadores aritméticos

• igual ==

• não é igual! =

• não !

• maior que>

• maior ou igual> =

• menos de <

• inferior ou igual <=

Tabela 5.2: Operadores lógicos

o que deve o resultado de verdadeiro + 3 - "Olá" estar? É ambíguo e pode potencialmente criar
valores estranhos que podem apenas confundir o usuário e levar a bugs.

Há um operador especial usado para a verificação nada valores. Ele é chamado o operador
ponto de interrogação? e é semelhante ao nada? método encontrado em Ruby. Anexando o? para um
valor ou variável, Daspel irá realizar um
nada verificar o valor. Se for nada ele retorna verdade, senão ele retorna falso.

1 seja x = nil;
2 E se x? {
3 # . . .
4}

5.13 Demonstrações

1 vamos sum = 0 ;
2 para i in 1 .. 4 {
3 # i será 1, 2 depois 3
4 soma + = i;
5}

Daspel tem tipos de declaração: while-loop, para-loop, if-else e funções. Somente funções podem ser
definidas no escopo global. while-loop, loop for um if-else declarações pode ser definida em função
de escopo e podem ser aninhados.

48
 Funções não podem ser ser aninhadas dentro de funções ou outras declarações.
5.13.1 For Loop

O loop for é semelhante ao lacete encontrada na linguagem de programação Rust. A estrutura define
um valor acumulador e uma gama para repetir. A gama é denotado por dois int s separados por dois
pontos (..). O loop for usa chaves para capturar o corpo do loop.

A notação de intervalo expressa uma gama exclusiva. Mais especificamente:

<Start> .. <exclusivo-stop>. O número à esquerda é o valor primeiro designado para o acumulador. O
loop for, incrementa o acumulador por um para cada passagem. Ele parar quando o acumulador se
torna igual ao valor à direita. Por exemplo, 0..5 rendimentos 1, 2, 3, 4. Por meio de três pontos (...), a
faixa torna-se, inclusive, o que significa que leva um passo adicional antes de parar. Por exemplo, 0
... 5 rendimento 1, 2, 3, 4, 5

Neste ponto, não há nenhuma sintaxe para especificar o passo para a interação.

5.13.2 While Loop

O loop while é o mesmo que em outras linguagens de programação. É constituída por uma
expressão condicional e um corpo entre chaves. A expressão condicional deve retornar um valor
booleano. 1 enquanto t> 3 {

2 t/=2;
3}

5.13.3 Conditionals aka. If-Else

IF-Else funciona exatamente da mesma como em outros idiomas. Assim como o loop while, ele requer

uma expressão condicional, exceto para o caso mais. 1 E se x> 10 {

2 # . . .
3} outro E se x == 2 {
4 # . . .
5} outro {
6 # . . .
7}

5.13.4 Funções

Função em Daspel são declarados usando a fn palavra-chave, seguido do nome da função e os

parâmetros. A declaração função não declarar qualquer tipo de retorno, devido ao fato de que Daspel
é digitado dinamicamente. Como tal, a instrução de função é uma reminiscência do encontrado em
Python.
Para retornar um valor formar uma função, o Retorna declaração deve ser utilizado. Por padrão,
as funções de devolver o nada valor. 1 fn blink_led (pino, tempo, cor) {

2 # . . .
3}

49
 As funções são usadas para construir os manipuladores de eventos. , Antecedendo uma
anotação na frente da função, Daspel vai entender que este é um manipulador de eventos. As
anotações são usadas para especificar quais eventos a função deve lidar com ou quantas vezes a
função deve ser chamado. As anotações começar com o @ símbolo seguido por um nome e uma
condição opcional. Nas anotações, o usuário pode especificar o limite para o gatilho evento. Por
exemplo, para criar um manipulador que só é chamado quando a temperatura está acima de 20 graus
Celsius que escrever o seguinte: 1 @ temperatura> 30 C;

2 fn manipulador () {
3 # evento alça
4}

5.14 Things That Did Not fazê-lo ao Idioma

Nesta seção vamos brie olhar y fl no pensa que poderia ter sido uma parte da Daspel, mas não foram
incluídos por causa de limitações de tempo.

5.14.1 Função variádicos

Uma função variádica é uma função que aceita um número variável de argumentos [34]. Pode-se
argumentar que as funções variádicos não são necessárias em uma linguagem de tipagem dinâmica
como listas podem conter quaisquer tipos e tais listas podem imitar a funcionalidade variádica. 1 fn variádica
(* args) {

2 # args é uma lista

3} 45 variádica ( 1 , 2 , 3 );

6 variádica ( 2 );
789 fn normal (lista) {

10 # recebe um único argumento

11} 12 13 normal([ 1 , 2 , 3 ]);

14 normal([ 2 ]);

5.14.2 Tuple

Um tuplo é uma lista finito de elementos [35]. Tuples poderia ser usedwhen retorno de vários valores de
funções. No entanto, as listas podem ser utilizados para a mesma finalidade, de modo tuplas não
acrescentaria nada de valor para Daspel.

5.14.3 Tipo de anotação para os parâmetros de função

Permitindo que o usuário adicionar o tipo de parâmetros da função que tornaria mais fácil para ver o
que os argumentos são suposto ser. Eles também reduziria o

50
 quantidade de erros de verificação de tipo em tempo de execução como eles seriam pegos durante tipo de
verificação de tipo Dito isto, os scripts Daspel é suposto ser muito pequena, por isso seria fácil de figura para fora
os tipos de parâmetro de qualquer maneira. O usuário também pode simplesmente usar comentários para
documentar o tipo dos parâmetros.

5.14.4 Métodos Tipo de dados

No Rust linguagem de programação, tipos de dados primitivos implementar certos métodos. Isto
também se aplica para as estruturas de dados complexos, tais como cordas e vectores. Isso também
pode ser aplicado a Daspel. funções da biblioteca padrão para interagir e manipular tipos de dados
Daspel poderiam em vez disso ser implementados como métodos. Isto faria com que a língua se
sentir mais orientada a objeto, em oposição ao mix atual de imperativo, evento orientado e funcional.
1 # função std

2 seja x = [ 2 , 3 , 1 , 4 ];
3 tipo (x);
4 # x é agora [1, 2, 3, 4];
56 # construído no método

7 x.sort ();

5,15 Unicode Sintaxe

Meu supervisor sugerido o uso de símbolos Unicode para palavras-chave e nomes de função. A ideia era
ter um símbolo Unicode como uma forma alternativa para se referir a palavras-chave, funções, IO,
sensores e atuadores. Longas palavras-chave usar mais bytes, mas um símbolo Unicode usa 1-4 bytes,
dependendo do símbolo. Scripts que utilizam símbolos Unicode pode na maioria dos casos, ser menor e,
portanto, reduzir a quantidade de dados que tem de ser transferida para um dispositivo IdC. Isso também
significa que eles ocupam menos espaço na memória RAM e no disco no dispositivo Internet das coisas.

Abaixo você vai fi nd tabelas de símbolos Unicode. Note que apenas um símbolo seria usado
para cada conceito. Cada tabela mostra apenas as alternativas. Unicode não como palavras-chave
tornou na língua especi fi cação, pelo menos não nesta fase. Todos os símbolos foram encontrados
em https: //unicode-table.com/en/ e http://getemoji.com/.

51
 Nada

∅ U + 2205 ⌀ U + 2300 Ø U + 00D8

⊘ U + 2298 ⊗ U + 2297 • U + 2BBE

• U + 29B8 U + 1F6AB • U + 274c

✗ U + 2717 ☓ U + 2613 U + 1F5F4

U + 1F5F6 U + 1F5F5 U + 1F5F7

× U + 00D7 U + 1F5D9 • U + 2A2F

U + 1F480 ☠ U + 2620 U + 1F571

• U + 26A0 • U + 26D4 U + 1F635

U + 1F44E U + 1F4A3 U + 1F6A7

U + 1F4A9 • U + 2757

Tabela 5.3: Antes de resolução sobre tipagem dinâmica, tipos tinha de ser escrito. Esta tabela mostra os
símbolos para o valor nada. nada representa um erro ou um valor vazio, de modo que descreve Unicode
símbolos negativos foram preffered.

Enviar

U + 1F4E7 ✉ U + 2709

U + 1F583 U + 1F582

U + 1F4EE U + 1F4AC

U + 1F5E9
Tabela 5.4: Enviar meios para enviar uma mensagem. Uma carta ou fala bolha é uma boa
representação visual para enviar alguma coisa.

52
 Poder

U + 1F50B U + 1F5F2

• U + 26A1 U + 1F50C

Tabela 5.5: A palavra-chave de energia ou função retornaria um valor que representa howmuch bateria
for deixada.

Tempo / Temporizador

• U + 23F0 • U + 23F1

• U + 23F2 U + 1F570

⌛ U + 231B • U + 23F3

⌚ U + 231A

Tabela 5.6: Um relógio de representar o tempo e a função de tempo iria colocar o aparelho para dormir por
um fi speci ed duration-

De som (microfone)

U + 1F3A4 U + 1F508 U + 1F509

U + 1F50A U + 1F3B5 ♪ U + 266A

♫ U + 266b U + 1F3B6 U + 1F39C

U + 1F3A7 U + 1F442

Tabela 5.7: O microfone, ouvido e auscultadores dá uma indicação clara de que o sensor de usar.

53
 De som (alto-falante)

U + 1F3A4 U + 1F508 U + 1F509

U + 1F50A U + 1F3B5 ♪ U + 266A

♫ U + 266b U + 1F3B6 U + 1F39C

U + 1F399 U + 1F444

Tabela 5.8: Reproduzir som.

GPS

U + 1F310 U + 1F30E

U + 1F30D U + 1F30F

U + 1F5FA U + 1F6F0

U + 1F6F0 U + 1F4E1

Tabela 5.9: Terra do planeta e satélites foram os melhores fi t para GPS.

Temperatura

U + 1F321

Tabela 5.10: A representação mais simples e mais elegante para a temperatura é um termómetro
clássico.

54
 Umidade

U + 1F4A7 U + 1F4A6

Tabela 5.11: Foi difícil encontrar um bom símbolo para umidade. Gotas de água foram os mais
precisos como humidade representam a quantidade de vapor de água no ar.

Pressão

U + 1F32C U + 1F300 ☁ U + 2601

U + 1F327 • U + 26C5 U + 1F326

U + 1F32A U + 1F32B U + 1F301

U + 1F38F ↓ U + 2193 ⇩ U + 21E9

• U + 2B07 U + 1F83B U + 1F847

U + 1F89B

Tabela 5.12: Pressão também foi difícil de representar. Neste caso, a pressão representar pressão de
ar, de modo nuvens e para baixo setas foram foram a melhor coisa que eu poderia achar.

LED (single ou exibição)

U + 1F6A6 U + 1F4A1

☀ U + 2600 ☼ U + 263C

U + 1F308 U + 1F526

s
Tabela 5.13: A lâmpada é provavelmente a melhor alternativa para representar uma luz LED.

55
 Sensor de luz)

☀ U + 2600

☼ U + 263C

U + 1F308

Tabela 5.14: A luz sensor mede a luz. Ele não emite luz, mas detecta-lo, assim encontrando uma
representação precisa era complicado.

Monitor

U + 1F4FA

U + 1F5B5

U + 1F4BB

U + 1F5B3

Tabela 5.15: Um monitor é um pouco para a frente.

Ligado desligado

U + 1F5F8 ✓ U + 2713 ✔ U + 2714

✖ U + 2716 ✗ U + 2717 ✘ U + 2718

U + 1F197 • U + 270B U + 1F44D

U + 1F44E U + 1F592 U + 1F593

U + 1F44C

Tabela 5.16: On e Off representam a ação de virar um dispositivo ligado ou desligado. Eles também
são feitos para simbolizar a ação aceitar e rejeitar.

56
 laço

↺ U + 21BA ↻ U + 21BB

• U + 27F2 • U + 27F3

• U + 2940 • U + 2941

• U + 267b

Tabela 5.17: Em vez de escrever para ou enquanto, o usuário poderia usar um símbolo Unicode vez.

IF-ELSE

U + 1F914

Tabela 5.18: Um rosto pensamento simboliza uma escolha. O problema era que há boas alternativas
para else if e outro foram achados.

Função

λ U + 03BB U + 1D6CC

U + 1D77A U + 1D453

U + 1D487

Tabela 5.19: O símbolo função representa a estrutura de função. Lambda é muitas vezes usado para
funções e encerramentos.

57
58
 parte III

Implementação

59
Capítulo 6

Prova de conceito

6.1 O Objectivo da Implementação

A meta para a implementação é criar uma prova de conceito para o intérprete Daspel.

Nos capítulos seguintes, vamos olhar para o hardware do intérprete será executado. Também
vamos olhar para os sensores fornecidos e mudando os pixels na tela. Finalmente, vamos passar pela
implementação de código.

6.2 O hardware

Esta tese utiliza uma framboesa Pi 3Model B (RPI) como uma plataforma para o desenvolvimento e
execução do interpretador. O sentido HAT sensores add-on de tabuleiro são usados ​para testar leituras
ambiente pelos scripts.

6.3 O intérprete

O intérprete é constituída por várias peças.

• Digitalização, analisar e analisar roteiros Daspel.

• Gerando uma árvore de sintaxe abstrata.

• A criação de uma fila de eventos.

• Sondar um evento da fila e interpretá-lo.

Basicamente, quando o dispositivo recebe um novo script, tem que analisá-lo primeiro. O
intérprete verifica o novo script e verifica se há erros sintáticos. Depois de feito isso, uma sintaxe
Árvore abstrata (AST) é gerado. Esta árvore é uma estrutura de dados que representa o script. O
intérprete usa a AST para raciocinar sobre o programa. A partir daqui, o intérprete tem que verificar
se o scrip (AST) não contém quaisquer ações ilegais, como chamar uma função definida unde ou
usando um fi variável NED unde. Em seguida, uma piscina evento é inicializado. A piscina contém
eventos que o intérprete pode executar. Eventos dos sensores, o roteiro e IO é colocado na piscina
evento.

61
6.4 Source Code

O código para a implementação pode ser encontrado em minha página GitHub.

• https://github.com/CodeGradox/Master-interpreter

• https://github.com/CodeGradox/daspel-nom

• https://github.com/CodeGradox/sensehat-rs

• https://github.com/CodeGradox/Rust-Sense-Hat

• https://github.com/CodeGradox/IoT-Interpreter

6.5 Disclaimer

A implementação não é terminei porque eu corri para fora de tempo. No entanto, vou descrever o
que eu consegui implementar e como eu fiz isso.

62
Capítulo 7

O Raspberry Pi eo chapéu
Sense

7,1 framboesa Pi 3 Modelo B

A framboesa Pi 3 representa a terceira geração de framboesa Pi que é parte de uma série de

computadores de uma placa pequenas, do tamanho de um cartão de crédito [36, 37]. O RPI é um
poderoso dispositivo totalmente capaz de executar um sistema operativo, tal como uma distribuição
Linux. O dispositivo fornecido para esta tese veio com um cartão SD com o sistema operacional
Raspbian instalado. Raspbian é baseado no sistema operacional Debian e é otimizado para o
hardware Raspberry Pi [38]. Ele vem com um conjunto de ferramentas de software que pode ser
usado para a educação, programação e uso geral [36]. A lista completa do hardware especí fi cação
para o Raspberry Pi pode ser encontrada na figura 7.1.

Figura 7.1: A framboesa Pi 3 Modelo B. Fonte [39]

63
 • A 1.2GHz quad-core CPU ARMv8 64-bit

• 802.11n Wireless LAN

• Bluetooth 4.1

• Bluetooth Low Energy (BLE)

• 1GB de RAM

• 4 portas USB

• 40 pinos GPIO

• porta HDMI completa

• Conexão de Rede

• Combinado jack de 3,5 mm de áudio e vídeo composto

• interface da câmera (CSI)

• interface de exibição (DSI)

• slot para cartão Micro SD

• núcleo gráfico VideoCore IV 3D

Tabela 7.1: O Pi framboesa 3 Modelo B especi fi cação [36]

7.1.1 Software

Para este projeto nós tivemos que baixar e instalar algum software adicional para ser capaz de
implementar o intérprete Daspel. Os dois mais importantes peças de software foram a biblioteca
Sense HAT Python, que vem com o RTIMULib C ++ biblioteca, eo compilador Rust. O compilador
oxidação foi instalado usando rustup que é um instalador de cadeia ferramenta para oxidação. Rustup
também fornece Cargo, o gerenciador de pacotes para Rust que administra dependências externas
para um projeto de código. Outras ferramentas que eram necessários para o desenvolvimento nas
RPI foram SSH, GIT e Vim, mas apenas Vim necessário para ser instalado como os dois anteriores
foram já pré-instalado por Raspbian.

CHAPÉU 7,2 Sense

O chapéu Sense é uma placa add-on para o Raspberry Pi, feito especificamente para a missão Astro Pi [40].
A placa possui um display LED, um joystick e seis sensores que podem ser acessados ​através de uma
biblioteca Python. A lista completa de características podem ser encontradas na figura 7.3.

64
 Figura 7.2: O CHAPÉU sentido. Fonte [41]

7.2.1 Comunicação Sensor

Ambos os sensores e a matriz de LED 8x8 RGB usa o I 2 Protocolo C para comunicação. Na RPI, o I 2 C
tem que ser activado antes de os sensores HAT sentido, podem ser usadas. O kernel Linux fornece
funções C para I 2 comunicação C, tornando-se relativamente fácil escrever uma leitura personalizada
e escrever funcionalidade ao HAT Sense.

Encoding 7.2.2 Byte

Todos os dados no HAT Sense é codificado em little-endian.

7.2.3 Os sensores

Embora seis sensores diferentes da Sense website HAT especí fi ca, o conselho só tem três chips
sensores. Os sensores de pressão é uma sensores LPS25H, o sensor de humidade relativa é um
sensores HTS221 e o grau de liberdade 9 senors (DOF) é um sensor de LSM9DS1 [42]. Tanto o
LPS25H e os sensores HTS221 são capazes de ler a temperatura da pressão e humidade relativa,
respectivamente. O LSM9DS1 é uma IMU, que significa Inertial Unidade [43] Medição. A IMU é, na
verdade, três sensores: um acelerómetro 3D, 3D giroscópio e um 3Dmagnetometer. O utilizador pode
utilizar os dados da IMU afirmar o movimento o HAT Sense está experimentando [43]. A imagem na
figura 7.3 exibe os três eixos do HAT Sense pode detectar.

65
 • LPS25H (Pressão)

• HTS221 (humidade)

• LSM9DS1 (acelerómetro, giroscópio e magnetómetro)

Tabela 7.2: Os módulos de sensores Sentido HAT [42]

Figura 7.3: A orientação. Fonte [43]

7.2.4 O LEDMatrix

A matriz de LED RGB 8x8 é controlada LED2472G ligado a um ATTINY88 Atmel comunicar através de I 2 C
com o RPI [42]. O LEDmatrix tem uma taxa de refrescamento de 60 fps e resolução de cor de 15 bits [44].
Para usar o LEDmatrix, não é preciso usar o I 2 Protocolo C directamente. Em vez disso, o framebuffer do
visor pode ser lido a partir de fi le ou ser mapeada para memória com mmap. Um framebuffer é uma porção
da memória RAM que contém um mapa de bits que é utilizado para refrescar exibição de vídeo a partir de
um tampão de memória que contém o quadro completo de dados [45]. Na biblioteca Sense HAT Python o
framebuffer é lido a partir fi le primeiro. Em seguida, os novos dados são escritos para o fi le, que por sua
vez atualiza os pixels na matriz de LED.

alta Byte low Byte

R7 R6 R5 R4 R3 G7 G6 G5 G4 G3 G2 B7 B6 B3 B5 B4

Figura 7.4: A RGB 565 bits campo após um valor RGB 888 foi codificado pela biblioteca Python.

66
RGB 565

Os pixels no visor LED usar o formato de cor RGB 565. Cada pixel requer 16 bits de dados, onde 5 bits
são usados ​para valores de vermelho e azul, enquanto 6 bits são usados ​para valores verdes. Na
figura 7.4 podemos ver como cada pixel é formatado pela biblioteca Python Sense HAT. Mais
especificamente, a biblioteca aceita cores formatados como RGB 888, que é o formato padrão de cores
usado na web [46], e comprime-los para o formato RGB 565. Porque RGB 565 é um byte menor do
que RGB 888 (24 bits), alguns dados são perdidos durante a conversão. valores vermelhas e azuis
perder seus 3 fi cativas pedaços menos signi, enquanto os valores verdes só perder 2.

7.2.5 RTIMULib

O HAT API Python Sense fornece uma interface fácil de usar para a placa Sense HAT. No entanto,
os dados do sensor não é acedida pela API directamente, mas através de uma biblioteca C ++
chamado RTIMULib [47], que é mantida pela Fundação framboesa. A biblioteca é escrito em
orientada a objeto C ++ e usa especi fi bibliotecas Linux c C para comunicação através I 2 C.
RTIMULib é capaz de detectar vários tipos de sensores ambientais e imus, incluindo aqueles
encontrados na placa Sentido HAT. RTIMULib também cria um configurações fi le que permite que o
usuário altere as configurações de cada sensor.

• Uma matriz de LED RGB 8x8

• A cinco botão joystick

• giroscópio

• Acelerômetro

• Magnetômetro

• Temperatura

• Pressão barométrica

• Umidade

Tabela 7.3: O sentido HAT especi fi cação [40, 48]

7.2.6 Erros em temperaturas de Leitura

Devido ao design do conselho Sense HAT, é impossível ler a temperatura exata do HAT Sense
quando montado diretamente acima da RPI. As leituras de temperatura irá mostrar os valores que
são muito maiores do que aquilo que é suposto ser. Isto é causado pelo calor gerado a partir da CPU
RPI e o ar quente em torno do RPI acaba por afectar as leituras dos sensores. Para combater este
fenómeno, o HAT Sense

67
teria de ser separado da RPI ou as leituras que têm que ser calibrados. No entanto, leituras precisas
não eram uma preocupação primordial para a implementação, por isso, a questão foi ignorada.

68
Capítulo 8

Implementação

8.1 Critérios

Os critérios para o intérprete Daspel são os seguintes:

• O tamanho do binário deve ser tão pequena quanto possível.

• Ela deve ter uma pegada pequena da memória.

• Ele deve usar o mínimo de energia possível.

• Ele deve ser capaz de rodar em qualquer dispositivo Internet das coisas.

• Deve ser capaz de alternar execução de scripts.

• Ele deve ser robusta, o que significa que nunca deve falhar.

8.2 Implementação Idioma

O primeiro passo de escrever o intérprete Daspel é escolher uma linguagem de programação. Com
base nos critérios da seção acima, meu supervisor e eu decidi não usar linguagens que utiliza a
coleta de lixo para gerenciamento de memória. Isto exclui linguagens como Python e Java ou
intérpretes como Node.js. Uma das razões é que essas línguas têm uma pegada de memória maior
do que línguas com gerenciamento de memória manual. A segunda razão é que a coleta de lixo leva
tempo e pode em algumas implementações causar o programa para fazer uma pausa durante a
execução. dispositivos da Internet das coisas usam sistemas operacionais em tempo real, assim que
ter uma pausa para recuperar memória não é um cenário que queremos tratar. Dito isto, Java é a
linguagem de programação mais popular para o desenvolvimento da Internet das coisas, seguido de
JavaScript em 3º lugar [28].

Em outros casos Java e JavaScript são usados ​no servidor e a porta de entrada, o que significa
que o dispositivo de Internet das coisas não usar esses idiomas diretamente. Em outra nota, seria
possível se comunicar com o HAT Sense

69
dispositivo através do eu 2 Protocolo C com Java, JS e Python através dependências externas. Isto
torna possível
Atendendo ao prazo para a tese, é preferível que a linguagem de implementação torna mais fácil
para representar cordas porte dinâmicos e listas. A língua ou seu ecossistema (bibliotecas de
terceiros) deve fornecer suporte a texto Unicode. Quanto menos tempo é gasto em lidar lidar com
aqueles mais tempo pode ser gasto na implementação.

8.2.1 Python

Python foi brie fl y considerou mesmo que a linguagem é interpretada e usa gerenciamento
automático de memória. A razão para escolher Python é porque a API Sense HAT é escrito em
Python. Isto significa que somente o scanner, analisador e intérprete teria de ser implementada.

8.2.2 C

C é a segunda linguagem de programação mais utilizado no mundo [49]. C também é a segunda língua
mais utilizada Programação usado em Internet das coisas [28]. A linguagem C é pequeno e simples.
Tem uma pegada pequena da memória e executa muito bem e ele pode gerar pequenos binários. A
linguagem permite que o desenvolvedor para interagir de perto com o hardware. Como podemos ver, C
é uma escolha muito promissor. Ele se ajusta aos requisitos perfeitamente. Ele também é portátil e ele
provavelmente irá suportar mais plataformas do que seus concorrentes. No entanto, não foi escolhido
devido às seguintes razões.

Originalmente, C foi planejado para ser usado como a linguagem de implementação para o intérprete
Daspel. No entanto, eu não sou um programador C experiente, nem sou muito apreciador de C. Este é,
reconhecidamente, uma das razões pelas quais eu não queria usar C. Eu também não querem gastar o
tempo na implementação de listas de tamanho de forma dinâmica e cordas em C. Além disso, eu também
teria de lidar com o gerenciamento de memória manual. Com isto quero dizer que eu teria que manter o
controle de malloc alocações e eu teria que garantir que eu estou usando livre

nos lugares certos. I foram na sua maioria usando Java durante o meu tempo na universidade e, portanto, têm
muito pouca experiência com gerenciamento de memória manual. Para ser claro, eu estou ciente de
ferramentas que podem verificar se há vazamentos de memória, use após fi comportamento NED livre e unde
em programas C. Estas ferramentas de fi nitivamente ter sido uma grande ajuda.

As listas podem ser fácil de implementar usando listas ligadas. Cordas, por outro lado, deve
suportar caracteres Unicode. Como resultado, o analisador também deve ter para ser capaz de analisar
símbolos Unicode.
Daspel é digitado de forma dinâmica e o intérprete deve, portanto, ser capaz de representar
tipos dinâmicos. A maneira mais fácil de fazer isso é usando sindicatos tag como mostrado na figura
8.1. Com uniões marcadas torna-se possível para representar vários tipos de dados através de uma
única estrutura. Ele também torna possível mudar uma variável dinâmica para outro tipo, alterando o
valor da união e trocar a tag enum. A questão é que eu teria que ter o cuidado de verificar sempre a
tag antes de alterar o valor da união como o valor pode ser um ponteiro.

70
 1 # incluir "Stdio.h"
2 # incluir "Stdbool.h"
34 typedef enum TypeKind {

5 Integer, Boolean, String

6} TypeKind;
78 typedef struct {

9 enum TypeKind tipo;

10 União Valor {
11 int num;
12 boleano booleano;
13 Caracteres * Str;

14 } valor;
15} Tipo;
16 17 Digite type_new_int ( int v) {

18 Tipo T;
19 t.kind = Int;
20 t.value.num = v;
21 Retorna t;
22}

Figura 8.1: A união marcado em C

Finalmente, o RTIMULib não pode ser utilizado por C directamente, tal como aplicado em C ++. C
não pode chamar funções C ++. Isto é devido à desconfiguração do nome da função e método nomes
feitos pelo compilador do C ++. usando o externo "C" construir vai impedir que os ++ compilador
FromName nomes das funções calandrar C.

Uma solução consiste em reescrever as partes necessárias para RTIMULib C. Uma solução mais
rápida é a escrever um invólucro C. O invólucro age como uma interface que permite C para fazer
chamadas indiretos sobre funções C ++. O invólucro é apenas um cabeçalho C fi le que tem a sua função
implementada em C ++. Tanto o código C ++ e o invólucro são compilados em conjunto por um compilador
C ++, tal como gcc ou tinido. Um programa C pode, então, basta usar o fi cabeçalho le e chamar as
funções de cabeçalho como funções normais C.

8.2.3 C ++

Como C, C ++ é uma linguagem popular usado para aplicações da Internet das coisas e ele classifica
6 na lista de popularidade [28]. Com C ++ eu seria capaz de escrever o intérprete em praticamente
da mesma forma que eu faria com C. O principal benefício de usar C ++ é que a biblioteca RTIMULib
pode ser usa diretamente. C ++ também tem o std :: string e std :: Vector tipos de fi nida em sua
biblioteca padrão. Ambos os tipos podem alocar dados na pilha, e se re-size automaticamente. Estes
tipos também implementar um método destruidor, o que significa que quando uma variável que
possui um std :: string ou std :: Vector sai do escopo, os dados alocado é liberado automaticamente.
Isto torna mais fácil

71
implementar corda Daspels e tipos de lista. A questão é que não é possível usar esses tipos dentro de
uma união de sindicatos só suportam tipos de dados primitivos. Para resolver isso, eu teria que usar a
biblioteca Boost e usar o Qualquer tipo. o Qualquer tipo é capaz de reter mais complexos tipos de
dados e fornece uma maneira segura para verificar o tipo do valor.

I acabou não escolhendo C ++, porque eu não queria depender da biblioteca de impulso para a
implementação e eu não tinha certeza se iria mesmo compilar sobre o Raspberry Pi. Além disso, eu
tenho zero de experiência com programação C ++ e estou um pouco tendenciosa contra C ++. Dito
isto, creio que C ++ é um bom candidato devido à sua portabilidade, pegada AndMemory velocidade.

8.2.4 Rust

Rust é uma linguagem de programação de sistemas desenvolvido pela Mozilla. Ela teve a sua libertação
estável fi primeiro em 2015 [50]. Rust pretende competir contra C ++ em termos de desempenho, segurança
e consumo de memória [51]. Segurança neste contexto, significa que as garantias Rust Tipo de solidez,
segurança memória e evita que os dados-raças. O compilador Rust impede que a maioria, se não todas as
operações inseguras durante tempo de compilação usando análise estática e manter o controle da posse de
dados.

Rust tem Corda e Vec, que são estruturas de dados semelhantes aos
std :: string e std :: Vector. A diferença é que as cordas de oxidação são UTF-8 codificado. Rust também tem
construído em sindicatos marcados que são chamados de Enum. Em contraste com uniões de C / C ++,
enumerações na oxidação pode armazenar qualquer tipo, seja uma estrutura, ponteiro ou um tipo de dados
simples. Estes Enums trabalhar de forma semelhante como tipo de dados faz no ML padrão.

Rust pode chamar funções em código C, mas não pode chamar funções C ++. Para fazer um
trabalho de implementação Rust com o RTIMULib, ele deve usar um invólucro C ou re-implementar o
RTIMULib em Rust.
O compilador oxidação depende do compilador back-end LLVM para traduzir a sua representação
intermediário (IV) para montagem [52]. O compilador C / C ++, Clang, também usa LLVM. Como tal, é
possível que o código Rust e C ++ pode ser compilado para binários semelhantes. O problema com o
compilador Rust é que é usado estática ligando em vez de ligação dinâmica que pode resultar é binários
maiores. Isso pode ser um problema para certas plataformas da Internet das coisas com capacidade espaço
muito limitado.

Para além de que, geralmente oxidação realiza de forma semelhante ao código C ++ em termos de
velocidade de execução. alguns benchmarks 1 comparando Rust, C ++ e C podem ser encontrados no computador
Language Benchmarks Jogo 2.

!!!!! Box Plot AQUI! !!!!!

Acabei escolhendo Rust devido às razões acima mencionadas e porque eu Ammore familiarizado
com a programação Rust. Rust lida com a maioria, se não todos gerenciamento de memória por si só e
ele impõe seguras práticas de codificação, graças à análise estática durante tempo de compilação.

1 Benchmarks não são a forma mais adequada de comparar desempenho de linguagem, por isso, ter os resultados com

um grão de sal.
2 https://benchmarksgame.alioth.debian.org/

72
8.2.5 Conclusão

A linguagem de implementação não é muito importante para o intérprete como é apenas uma prova
de conceito que será executado em um dispositivo bastante poderoso. Dito isto, se o objetivo era
criar uma implementação mais realista, eu provavelmente teria escolhido C sobre Rust. Isso ocorre
porque C tem suporte para muito mais arquiteturas de CPU, o que torna mais portátil.

configuração 8.3 Trabalho

Há pelo menos duas maneiras de interagir com o Raspberry Pi. A primeira é para conectar um
monitor, um teclado e um mouse de computador diretamente para a RPI. Isso nos permite usar o RPI
como um computador normal, como o sistema operacional Raspbian apresenta uma interface gráfica
do usuário. O ambiente de trabalho pode ser desativado se é preferível o uso direto da interface de
linha de comando.

A segunda abordagem é para se conectar à Raspberry Pi com SSH através de um computador

remoto. Isto é fácil de configurar em casa, onde é possível definir um endereço IP estático na sua
rede pessoal. Por outro lado, o Raspberry Pi não parece ser capaz de se conectar à Eduroam WiFi
em IFI. A solução é usar um cabo Ethernet e ligar o RPI para um computador e executar SSHover a
conexão local. ParaWindows, existe um programa chamado MobaXterm que é uma interface gráfica
do usuário para conexões SSH. Ele também pode abrir remoto fi les em um editor local. Isso permite
que você usar ambientes de programação no Windows para escrever para programar fi les localizado
na Raspberry Pi, se você não quiser usar o Vim ou o Emacs sobre SSH normal.

Quando eu primeiro começou a trabalhar no Raspberry Pi eu estava usando a primeira

abordagem. Depois de um tempo muito confuso ter dois teclados, dois rato do computador e
twomonitors todos na mesma mesa, então eu mudei para usar o SSH em seu lugar. Comecei a usar
MobaXterm depois que eu comecei a trabalhar na implementação Rust.

8.3.1 Software Obrigatório

A única peça importante de software que deve ser baixado é o compilador Rust, pois não é parte da
distribuição Raspbian. Para testar e afirmar que o código de oxidação está a interagir
adequadamente com o dispositivo Sentido HAT é usando o módulo HAT Python sentido. Este
módulo também deve ser baixado, mas ao contrário Rust está disponível através do gerenciador de
pacotes Raspbian. A biblioteca RTIMULib é instalado juntamente com o módulo Python.

O módulo Python instala alguns exemplos de programas que mostram como usar o módulo
Python ea biblioteca do RTIMULib C ++. Estes programas foram útil quando se tenta entender como
trabalhar com o HAT Sense.

73
8.4 Portando a biblioteca Sense HAT para Rust

Inicialmente, o intérprete deveria ser escrito em C. O trabalho primeiro começou com fi guring como
usar a biblioteca C ++ RTIMULib de C.
O código em RTIMULib é programado como orientada por objectos C ++ e que fornece várias
classes que representam os sensores e imus. Através do código de exemplo fornecido vemos que
um objeto de configurações é criado primeiro. A classe Configurações contém informações sobre
calibração, freqüências de votação e I 2 C endereços para os sensores suportados e imus. A classe
Configurações inicialmente tenta achar e ler um ini fi le que contém as definições. Se tal fi le é
encontrado, ele irá criar um fi RTIMULib.ini locais le e salvar as configurações padrão nele. O objecto
Definições é passada a uma pressão, humidade e objectos Imu, que usam as configurações para a
calibração. Cada sensor e IMU apoiado pelo RTIMULib tem a sua própria classe. Quando se utiliza o
HAT sentido, RTIMULib vai criar uma instância da classe LPS25H, a classe e a HTS221 SM9DS1,
que são subclasses de pressão, humidade e IMU respectivamente. Todas as três classes contêm
métodos com especificações algoritmos fi cos para ler e escrever a sua componente de hardware
designado.

8.4.1 Escrevendo o invólucro C

Como afirmado anteriormente, não é possível para o código C para chamar funções C ++ diretamente. Para ser
capaz de usar uma biblioteca C ++ a partir de C um invólucro deve ser criado primeiro. Através do invólucro
torna-se possível para converter tipos de C ++ para tipos C. O invólucro proporciona uma interface que o código
C pode ver e usar para interagir com o código de C ++. Essencialmente, C simplesmente chama as funções de
mensagens publicitárias declarados declarados em um cabeçalho fi le. A implementação efectiva destas funções
reside em C ++ fi cheiros que seguem as convenções de C ++.

Desde classes não existe no C, o invólucro deve usar ponteiros especiais, chamados ponteiros
opacos, que C pode usar em seu lugar. Para facilitar as coisas, uma única classe Wrapper é criado.
Esta classe contém todos os quatro objetos necessários para usar o HAT Sense, com métodos para
leitura e escrita de dados para os sensores e a IMU. Desde C não tem conceito de classes, também
não tem o conceito de métodos. Não é possível utilizar o ponteiro opaco da classe de invólucro era
um objeto C ++ directamente em C. Em vez disso, o invólucro declara funções C, que leva um
ponteiro envoltório opaco como um parâmetro. As funções, em seguida, converter o ponteiro opaco
para a classe apropriada C ++ e chamar o método apropriado antes de finalmente voltar.

Há um problema com o código de chamada C ++ a partir de C: exceções. C não tem noção de

exceções, vamos exceções sozinho C ++. Assim, se o C ++ foram a jogar um, o código C não seria
capaz de lidar com isso. No melhor dos casos, o programa só iria falhar. Para evitar isso, as funções de
mensagens publicitárias deve tentar capturar todas as exceções, tanto quando lançar o ponteiro opaco
e ao chamar os métodos do objeto. A implementação do invólucro C nunca chegou longe o suficiente
para fornecer um bom mecanismo para transmitir uma mensagem para o código C sobre erros que
possam ter ocorrido.

74
 Os métodos para a classe Wrapper estavam imitando a implementação Python do módulo
Sense HAT e o invólucro fez de fato funcionam. Em retrospecto, teria sido possível para a porta a
implementação C ++ quase diretamente para o código C em vez de escrever um wrapper. RTIMULib
usar funções C para ler e escrever sobre o que eu 2 protocolo C e toda a calibração e cálculos podem
ser facilmente implementado em C. No entanto, isso poderia exigir algum tempo para fazer como há
um monte de calibração e cálculos necessários para a leitura do IMU. Os sensores de pressão e de
humidade são bastante simples para interagir com a comparação.

8.4.2 O Framebuffer

O módulo Sentido HAT implementa a funcionalidade para interagir com a matriz de LEDs. Pode
escrever um pixel de cada vez, encha a tela inteira ou limpá-la junto com girar a imagem exibida no
momento. É também capaz de exibir imagens de pixel 8x8 e texto.

Vamos olhar para duas maneiras de acessar o framebuffer matriz de LED. A primeira
abordagem é a utilização pelo módulo Python e envolve escrito ao framebuffer como uma fi le,
enquanto a abordagem C é a de mapa de memória do framebuffer.

O módulo Python primeiros NDS fi e salva o caminho para o framebuffer quando é iniciado.
Nunca grava novos dados de pixel para o framebuffer diretamente. Em vez disso, ele grava todos os
novos dados a uma matriz numpy bidimensional que atua como o quadro atual. O módulo escreve
este quadro para o framebuffer apenas como ela seria gravar dados em um normais fi le. Os
dispositivos Sense HAT atualiza a matriz de LED com o novo quadro automaticamente. É
interessante notar que o fi framebuffer le é reaberto cada vez que o programa atualiza o quadro.
chamada freqüente nas funções de desenho pode levar a tempos de execução mais lenta porque o
programa tem que esperar para operações de IO para ler o fi le.

Com o mapeamento de memória, somos capazes de escrever diretamente para o framebuffer.

Um exemplo de como usar o framebuffer em C pode ser encontrada no jogo Cobra desde que está
localizado no exemplo pasta Sense HAT. Os jogos usa a matriz de LED para exibir o estado do jogo
actual. A abordagem é semelhante ao módulo Python, pois tem de localizar a correta primeiro
framebuffer fi. Ele usa uma estrutura com uma matriz 8x8 de 16 bits como uma moldura. O
framebuffer é, então, memória mapeada para a estrutura que está localizado na pilha. O programa
pode acessar qualquer índice do quadro e ler ou escrever os seus dados diretamente. Qualquer
alteração feita no conjunto resulta em uma mudança no framebuffer, que por sua vez muda a
imagem exibida no momento.

Para a implementação C I optar por usar memorymapping permanente. Isto significa que o
framebuffer é memorymapped para toda a duração do programa. Isto é porque eu pretendia acesso
ao framebuffer para ser o mais rápido possível no. No entanto, isso pode não ser a melhor solução,
como os dispositivos de destino tem muito pouca memória disponível. É também uma solução
subpar se o visor nunca é usado pelo script. Uma solução melhor seria ter a calcular intérprete
quantas vezes o script chama para a tela. Ele pode, então, determinar se ele deve abrir o framebuffer
permanente ou não.

75
8.4.3 reimplementando o módulo Sentido HAT a partir de C à ferrugem

Uma implementação da oxidação por interagir com a matriz de LED foi feita em paralelo com a
implementação C. Ele se virou para fora que já existia um módulo Rust para interagir com o
framebuffer. Este módulo utiliza um invólucro da oxidação por funções de C, tais como mapeamento
de memória, e fornece uma interface para escrever para a região de memória mapeada.
Reescrevendo as funções C da minha aplicação C do HAT Sense foi bastante trivial. Ambas as
implementações acabou tendo a mesma funcionalidade.

Em algum ponto a implementação ligado foco de C para Rust. Por, em seguida, apenas o
código C foi capaz de interagir com os sensores, graças ao invólucro RTIMULib. A implementação
Rust deveria utilizar o wrapper C como ferrugem não tem uma interface de função externa (FFI) para
C ++. Isso significa que Rust tem que ir através do código C para interagir com C ++, enquanto a
implementação C interage com C ++ diretamente. No final de Fevereiro, um módulo de oxidação
para o sentido HAT foi libertado [53].
Ele fornece apenas
funcionalidade para a pressão leitura e umidade em sua versão atual. Este módulo foi bifurcada e a
funcionalidade framebuffer foi adicionado. Trabalho foi iniciado para adicionar a capacidade de ler
dados da IMU, mas neste momento ponto foi acabando eo módulo HAT Rust Sense teve de ser
deixado inacabado. Vale a pena mencionar que o terceiro módulo de Rust Sense Hat não usa um
wrapper para a biblioteca RTIMULib, mas em vez de cópias a implementação C ++ RTIMULib
diretamente. Em outras palavras, ele usa o I 2 Protocolo C para se comunicar com os sensores e
LEDmatrix na placa Sentido HAT.

8.5 A Análise Análise Lexical e Sintaxe

A primeira fase da interpretação começa com a conversão do texto do programa em uma sintaxe
Árvore abstrata (AST). Este é o trabalho scanners. O primeiro passo é converter sub-cordas de
fichas, enquanto ignorando espaços em branco, novas linhas e comentários. É o trabalho scanners
para executar a varredura e gerar os tokens. O analisador usa os tokens para gerar uma árvore de
análise (AST). Ele é responsável por verificar que o programa é seguir a sintaxe correta. Quaisquer
erros encontrados durante esta fase retorna um erro. Por exemplo, o leitor pode achar um símbolo
ilegal enquanto o scanner pode detectar uma sequência ilegal de fichas.

8.5.1 O scanner

Nenhum trabalho foi realizado no scanner até que a sintaxe de Daspel estava começando a tomar
forma. Neste ponto, a linguagem de implementação tinha mudado para Rust. Alguns exemplos de
scanners escritos em Rust foram encontrados na Internet e foram usados ​para a inspiração. A mecânica
central do scanner é que ele se comporta como um iterador. O programa de entrada é lida a partir fi le e
é armazenado em uma string. O objeto do scanner leva uma referência seqüência da cadeia de entrada
e cria um peekable Caracteres iterador da cadeia. Um carvão animal na oxidação é um 32-bit UTF-8
carácter codificado. Mais especificamente, um char é um valor escalar Unicode [54]. O scanner tem um
método chamado next_token qual

76
retorna um token. Um token é um tipo de enumeração que pode representar palavras-chave, tipos de
dados e ers fi identi. Quando o next_token é chamado, os auges do scanner primeiros na próxima Caracteres
no fi le. Em seguida, realiza uma correspondência de padrão na char para fi gura que ação a ser
executada. Por exemplo, se espia um ", então ele sabe que é o início da string literal. O scanner em
seguida, chama o método responsável por strings literais de varredura que por sua vez retornam um
símbolo literal string. O scanner está acabado quando o iterador interno seja esgotada , que acontece
quando o fim da fi le é alcançada (o fim da cadeia de entrada). o scanner é muito modular e torna mais
fácil para adicionar ou remover os tokens para procurar.

O scanner lê toda a fi le em uma cadeia em vez de lê-lo linha por linha. O problema é que ele
tem para alocar espaço suficiente para fi t toda a entrada, em vez de apenas alocar uma linha de
cada vez. Dito isto, se todo o roteiro não contém quaisquer novas linhas, o todo fi le acabaria sendo
lidos para a memória RAM de qualquer maneira. Este potencial problema não é um problema para o
Raspberry Pi, considerando suas especi fi cações, mas para um dispositivo muito pequeno ele
poderia se tornar um problema se os scripts podem se tornar muito grande em tamanho. A segunda
questão é que a implementação atual do scanner não permite que ele para retroceder. Isto significa
que uma vez que alguns CHAR ou texto foi lido, ele não pode ser lido novamente. Isto é devido à
forma como iterators trabalhar. Uma solução alternativa seria necessário mudar a forma como o itera
scanner sobre a corda. Em vez de criar um Caracteres iterador, o scanner pode acompanhar a
posição actual ea última posição token. Ele move o índice cur pos com base em um predicado eo Caracteres
s entre os dois índices é uma subsequência. Os sinais gerados são baseadas no significado
semântico dos sub-cordas. Esta é a abordagem do Go Idioma Lexer eo Rust Lexer usar. Esta
abordagem permite que o scanner voltar atrás e espreitar à frente com mais facilidade do que a
nossa aplicação, mas também deve levar símbolos Unicode em considerações durante a
digitalização.

8.5.2 O Analisador

O analisador não foi terminei porque não houve tempo suficiente para implementá-lo. Comecei a
trabalhar em duas implementações diferentes; um parser escrito à mão e um gerador de parser. O
analisador primeiro deveria simplesmente aceitar uma referência string (da entrada fi le) e criar
internamente um objeto scanner. O analisador, então, usar o scanner para gerar tokens. Seria,
então, usar fichas para determinar a construção sintaxe atual. Por exemplo, um sinal Token ::
Function significaria o analisador está olhando para o início de uma instrução de função. O
analisador irá em seguida, chamar o método manipulador sintaxe apropriada que irá verificar a
sequência de entrada de símbolos. Se a sequência é sintacticamente correcto, o método vai devolver
um AST

objeto. Este analisador é um analisador decente recursiva. Isto significa que os métodos de sintaxe
usar recursão de atravessar a entrada. Como tal, a implementação será semelhante a notação EBNF
do synatx Daspel.
A segunda variante do analisador é criado usando a grade nom 3 [ 55], que

3 Caixas são o que as bibliotecas são chamados no ecossistema Rust

77
é um combinator analisador. Nom permite ao usuário criar pequenas analisadores e combiná-los para
fazer maior analisador, que é feito com a ajuda de macros ferrugem. Quando as macros são
expandidos durante a compilação, eles geram uma grande máquina de estado que pode analisar um u8
fatia (um Caracteres* em C). Usando nom torna a redundante scanner, como nom atua como um
scanner e analisador. As macros analisador acabar parecendo a notação EBNF eles estão
representando.

A desvantagem de usar nom é que ele se expande para uma grande máquina de estado. Mais
especificamente, é gerar muitas linhas de declarações correspondência de padrões. Como resultado, o
binário fi le pode se tornar maior do que o binário de um scanner de mão escrita e analisador. No lado ip fl
torna-se relativamente fácil adicionar novos analisadores para cada construtor de linguagem. Este
analisador é, no seu estado atual, só é capaz de expressões de análise.

8.6 Representando o tipo de dados Real em Rust

Uma implementação simples para analisar reais foi adicionado quando eu estava trabalhando no scanner.
o real Tipo de dados são representados como uma estrutura na
implementação. A estrutura é chamada real e tem um membro do tipo
i32. o i32 é uma assinou dois inteiro complemento em Rust. Note-se que não há é construído no tipo real
em Rust, apenas aveia FL. A estrutura tem um método que leva uma string como um argumento e
produz um Real. A cadeia deve ser uma representação textual de um número decimal.

8.6.1 Operações aritméticas

operações aritméticas com o Real é bastante trivial. Subtração e adição é feito é da mesma maneira
que você faria com inteiros regulares. Não há operações adicionais são necessários. Por outro lado,
multiplicação e divisão são um pouco mais complicado. números de ponto fixo pode ser representada
pelo formato de número Q [33]. Nosso real é um número de ponto fixo com o Q15.16 formato. Quando
multiplicar dois reais, o formato produtos torna-se Q30.32 [56]. Isto significa que o produto requer 62
bits, o que é, obviamente, muito mais do que a nossa i32 pode representar. Para lidar com isso,
precisamos lançar ambos os fatores para um I64, multiplicá-los, mudar o produto de 16 bits para a
direita e finalmente lançá-lo de volta a um i32. Para a divisão, se nós apenas dividir os dois reais, nós
perder a parte fracionária. O processo é quase idêntico ao multiplicação. Nós lançamos tanto para I64, mudar
o dividendo de 16 bits para a esquerda, dividir e finalmente lançou o quociente de i32. Infelizmente,
tanto multiplicação e divisão pode resultar em perda de bits fracionários, também conhecido como
perda de precisão. Como você pode ter notado, estamos apenas usando operações inteiras. Isto
significa que as operações são rápidos, muito mais rápido do que a aritmética de ponto flutuante fl,
especialmente se o dispositivo não tem um FPU.

O tipo real pode ser usado em operações aritméticas com números de tipo i32 e f32. Isto torna
mais fácil lidar com inteiros e reais durante a interpretação como Daspel permite que os dois tipos de
dados a ser utilizado em conjunto em operações aritméticas. Uma variável uma do tipo lata real

78
ser usado como este: a + 3 - (2 * a) ou 3,14 + A + A - 1.2. Isso funciona porque Rust irá traduzir uma
operação aritmética para uma chamada de método. Por exemplo, a + 3 torna-se a.add (3).

79
80
 parte IV

Resumo

81
Capítulo 9

Conclusão

O objetivo para esta tese era criar uma linguagem de programação adequada para a Internet das coisas. A
linguagem tinha de ser pequeno, simples e fácil de usar por pessoas que são novos para o campo da
programação e da Internet das coisas.
Eu olhei para a Internet das coisas em termos de ambos os sensores e hardware. Eu analisei o
platformand estabeleceu as restrições e necessidades para o desenvolvimento em dispositivos da
Internet das coisas. Além disso, eu olhei como criar uma linguagem de programação para a Internet das
coisas que leva estes restrição em conta.

9.1 Análise

Para este projeto eu de fi nitivamente passei muito tempo em tentar escrever o intérprete, em vez de
se concentrar em fazer um design sólido para Daspel.
Eu também acho que o uso de um sistema de tipo dinâmico ao longo de um sistema de tipo estático
foi um erro menor. Isso ocorre porque tipagem dinâmica pode levar a executar erros de tempo devido ao
tipo de desencontros que é algo tipagem estática evitaria. No entanto, eu também acredito que tipagem
dinâmica é mais adequado para as pessoas que são novos para a programação, que são o público alvo
para este projecto.

9.2 Trabalhos Futuros

Há muito trabalho a ser feito. Em primeiro lugar, Daspel precisa ser fl Eshed em termos da mecânica
do núcleo. Ele também precisa de uma biblioteca padrão sólida. Além disso, os mecanismos exatos
da do intérprete deve estar totalmente concebido e implementado.

Há tranquilos algumas coisas que faltam inDaspel, mas seria emocionante ver a linguagem
totalmente implementado e usado no mundo real. Acho Daspel tem o potencial para ser usado como
material didático para as crianças a fazê-los interessados ​na programação e também para
ensinar-lhes conceitos de programação. Internet das coisas é piar e dispositivos como o Raspberry
Pi já está sendo usado como parte da educação em outros países. Ao adicionar sensores os esses
computadores de placa única, juntamente com Daspel, as crianças

83
ser capaz de criar aplicativos que podem interagir com o mundo real. Eu acho que este tipo de
interação entre hardware, software e educação é a maneira mais criativa para ensinar programação
para as mentes dos jovens.

84
Bibliografia

[1] MIT. Sratch linguagem de programação. URL: https: / / zero. mit. edu /
(Visitado em 2017/04/27). [2]

Internet das Coisas. De 2016. URL: https://en.wikipedia.org/wiki/Internet_ of_things ( visitou em

2016/10/21). [3] Rob van der Meulen. Gartner diz que 6,4 bilhões Connected "Coisas" Will

Estar em uso em 2016, um aumento de 30 por cento a partir de 2015. 2015. URL: https: // www.

gartner.com/newsroom/id/3165317 ( visitou em 2016/05/23). [4] sensor. De 2012. URL: http: / / whatis.

TechTarget. com / de fi nição / sensor

(Visitado em 2016/10/07). [5] O que é um sensor de humidade / Dew? URL: http:

//www.futureelectronics.
com / en / sensores de humidade /-dew.aspx ( visitou em 2016/10/21). [6] O que é o GPS -

Sistema de Posicionamento Global? URL: http: / / www.

sensorland.com/ ( visitou em 2016/10/21). [7] Energia baixa. URL: https: / / www. Bluetooth .

com / o - é - Bluetooth -
tecnologia / Bluetooth - tecnologia - básico / baixa - energia ( visitou em 2016/08/26). [8] Wi-Fi

Alliance apresenta baixo consumo de energia, de longo alcance Wi-Fi HaLow ™. URL:

https:. //www.wi- fi org / news-events / newsroom / wi-fi halow fi-

aliança-introduceslow-power-longo alcance Wi-( visitou em 2016/10/22). [9] Rahul. Internet das
coisas Wiki. URL: http: // internetofthingswiki .com /
requisitos-internet-de-coisas / 236 / ( visitou em 2016/08/26). [10] O que é a Integração 3D? URL:

http: //www.3dincites. com / 3d- incita -

conhecimento-portal / o que-é-3d-integração / ( visitou em 2016/05/23). [11] Harald Bauer, Mark

Patel, e Jan Veira. A Internet das coisas Dimensionamento

-se a oportunidade. 2014. URL: http://www.mckinsey.com/industries/ high-tech / nossas percepções-/
the-internet-de-coisas-dimensionamento-up-the-oportunidade
(Visitado em 2016/05/23). [12] Bluetooth. URL: https: // en .wikipedia. org / wiki / Bluetooth ( visitou

em
2016/10/22). [13] Google Beacons. URL: https://developers.google.com/beacons/ ( visitado

on 2016/10/22). [14]

iBeacon para desenvolvedores. URL: https: / / desenvolvedor. maçã . com / ibeacon /

(Visitado em 2016/10/22).

85
[15] Bluetooth Low Energy. URL: https: / / www. Bluetooth . com / o - é -
tecnologia Bluetooth / Bluetooth tecnologia básico / de baixa energia ( visitou em 2016/10/22).
[16] Wikipedia Bluetooth Low Energy. URL: https://en.wikipedia.org/wiki/

Bluetooth_low_energy ( visitou em 2016/10/22). [17] Bluetooth® 5 quadruplica gama, duplica a

velocidade, aumenta a difusão de dados

capacidade de 800%. URL: https://www.bluetooth.com/news/pressreleases/ 2016/06/16 /
-bluetooth5-quadruplica-rangedoubles-speedincreases-databroadcasting-capacidade-por-800 ( visitou
em 2016/10/22). [18] Análise do futuro do WiFi: 802.11ah HaLow, 802.11ad (e outros).

2015. URL: http: // www. Ligante- labs.com/future- de wi-fi- 802- 11ah- 80211ad / ( visitou em
2016/10/07). [19] gama WiFi. 2015. URL: http://mwrf.com/active- componentes / s- que-

di ff-erência entre-IEEE-80211af e-80211ah ( visitou em 2016/10/07). [20] Botão AWS Internet

das coisas. URL: https://aws.amazon.com/iot/button/ ( visitou em

2016/10/22). [21] Qual é a diferença entre IEEE 802.11af e 802.11ah? 2015. URL:

http://mwrf.com/active-components/what-s-di ff erência-entre- ieee80211af-e-80211ah ( visitou

em 2016/10/22). [22] Documentação. URL: https://www.scriptr.io/documentation ( visitou em

2017/03/31). [23] Libelium lança Waspmote Plug & Sense. URL: http: / / www.

energyharvestingjournal.com/articles/4843/libelium-launches-waspmoteplug-and-sense ( visitou
em 2012/10/25). [24] Waspmote Plug & Sense! Catálogo. URL: http://liste.raspibo.org/wws/

d_read / meteo / Libelium / waspmote_plug_and_sense_catalogue.pdf

(Visitado em 2017/03/31). [25] Tessel 2. URL: https://tessel.io/ ( visitou em 2017/04/27). [26] Tessel

2. URL: https://www.sparkfun.com/products/13841?ref=tessel.io

(Visitado em 2017/04/27). [27] Construa aplicativos de desktop multiplataforma com JavaScript, HTML

e CSS. 2017.
URL: https://electron.atom.io/ ( visitou em 2017/04/27). [28]

Internet das coisas desenvolvedor Levantamento de 2016. De 2016. URL: https: // www. slideshare. net /

IanSkerrett / IOT-developer-pesquisa-2016 ( visitou em 2017/04/14). [29] Node.js. 2017. URL: https://en.wikipedia.org/wiki/Node.js#Threading

(Visitado em 2017/04/27). [30] Seth Thompson. Introdução. 2015. URL: https: //

desenvolvedores. Google .
com / v8 / ( visitou em 2017/04/27). [31] TwoHardThings. URL: https://martinfowler.com/bliki/TwoHardThings.

html ( visitou em 2017/03/29). [32] unidade de ponto flutuante. URL: https://en.wikipedia.org/wiki/Floating-point_

unidade ( visitou em 2017/01/29).

86
[33] Q (formato de número). 2017. URL: https: / / en. wikipedia. org / wiki / Q_
(formato numérico) ( visitou em 2017/05/01). [34] função variádicos. 2017. URL: https://en.wikipedia.org/wiki/Variadic_

function ( visitou em 2017/05/01). [35] Tuple. 2017. URL: https: / / en. wikipedia. org / wiki / Tuple

( visitou em
2017/05/01). [36] Raspberry Pi 3 MODELO B. URL: https: / / www. Raspberry Pi . org /

produtos / framboesa-pi-3-modelo-b / ( visitou em 2017/01/10). [37] Raspberry Pi. URL: https://en.wikipedia.org/wiki/Raspberry_Pi

( visitado
on 2017/03/28). [38] Bem-vindo ao Raspbian. URL: https: / / www. raspbian. org / ( visitou em

2017/01/10). [39] URL: https://d1dr2mxwsd2nqe.cloudfront.net/media/catalog/product/

cache / 1 / imagem / 9df78eab33525d08d6e5fb8d27136e95 / 2/5/252522540. jpg ( visitou em

2017/03/30). [40] HAT sentido. URL: https://www.raspberrypi.org/products/sense-hat/

(Visitado em 2017/01/13). [41] URL: https: / / d1dr2mxwsd2nqe. CloudFront. net / media /

catálogo /
produto / cache / 1 / imagem / 9df78eab33525d08d6e5fb8d27136e95 / r / a /
raspisensehat3.jpg ( visitou em 2017/03/30). [42] HAT sentido. URL: https: // pinagem. xyz / pinagem
/ sense_hat ( visitou em
2017/03/29). [43] Movimento. URL: https://www.raspberrypi.org/learning/astro-pi-guide/

sensores / movement.md ( visitou em 2017/04/22). [44] ASTRO PI: ESPECIFICAÇÕES TÉCNICAS DE

VOO DE HARDWARE. URL: https: // www.

raspberrypi.org/blog/astro-pi-tech-specs/ ( visitou em 2017/04/17). [45] Suavizador de quadros. 2017.

URL: https: / / en. wikipedia. org / wiki / Framebu er ff

(Visitado em 2017/04/17). [46] Tantek Çelik et al. CSS Módulo Cor Nível 3. 2011. URL: https: //

www.
w3.org/TR/css3-color/#rgb-color ( visitou em 2017/03/30). [47] RTIMULib - um versátil C ++ e

Python 9-DOF, 10-DOF e 11-DOF IMU

biblioteca. URL: https: // github. com / RPI - Distro / RTIMULib ( visitou em 2017/03/30). [48] HAT
sentido. URL: https: / / www. Raspberry Pi . org / documentation /

hardware / senso-hat / ( visitou em 2017/03/29). [49] Índice TIOBE para abril de 2017. De 2016. URL:

http://www.tiobe.com/tiobe_
índice ( visitou em 2017/04/14). [50] Versão 1.0.0 (2015/05/15). URL: https: //github.com/rust -

lang / ferrugem /
blob / mestre / RELEASES.md ( visitou em 2017/04/15). [51] Garantir a segurança de memória

em Rust. 2014. URL: https://air.mozilla.org/

-Garantindo-memory-segurança-oxidação / ( visitou em 2017/04/17).

87
[52] Projetos criados com o LLVM. URL: http: // llvm. org / ProjectsWithLLVM /
(Visitado em 2017/04/15). [53]

Jonathan Pallant. sensehat. 2017. URL: https://crates.io/crates/sensehat

(Visitado em 2017/04/07). [54] Primitive tipo char. URL: https: lang.org/std/primitive.char

//doc.rust-.
html ( visitou em 2017/04/17). [55] Geoffroy Couprie. nom. 2017. URL: https: / / caixas. io /

grades / nom
(Visitado em 2017/04/07). [56] Gabriel Ivăncescu. Ponto Fixo Aritmética e truques. 2017. URL: http:

//x86asm.net/articles/ fi xed- ponto- arithmetic- e- truques / ( visitou em 2017/05/01).

88