2023

Desenvolvimento
Assembly para
ARM Wearables &
IoT

PABLO FELIPE CAMPELO

PROFESSOR | Mario Pego

 Desenvolvimento Assembly para
ARM Wearables & IoT

1. O Echo Loop é um anel lançado pela Amazon que

permite a execução de comandos na assistente
pessoal “Alexa“. Maiores detalhes podem ser
acessados aqui.

a) Quais são os dois tipos de sensores utilizados como

entrada neste vestível?

Os dois sensores de entrada são o sensor de áudio,

onde possuem dois microfones e um sensor de toque,
na parte superior.

b) Quais são os dois tipos de atuadores que são

responsáveis pela saída do Echo Loop?

Os tipos dos atuadores são um Speak (alto-falante) e

um Vibrador ressonante háptico piezoelétrico.

c) O Echo Loop utiliza que tipo de saída (ativa, passiva

ou ambas)?

A saída seria passiva para o Speak e ativa para o

Vibrador.

Qual a tecnologia de comunicação utilizada para

conectar o Echo Loop ao smartphone?

Bluetooth 5.0 compatível, Hands-Free Profile (HFP)

suporte para áudio e chamada, Serial Port Profile para
conectividade Bluetooth para telefones Android e iPod
Accessory Protocol para conectividade Bluetooth para
iPhones.

1
 Desenvolvimento Assembly para
ARM Wearables & IoT

2. Uma engenheira deverá prototipar um totem para

medição de temperatura das pessoas antes que elas
acessem uma empresa, com o objetivo de impedir a
entrada de pessoas com febre (prevenção à doenças).
Considerando que a plataforma de prototipagem
deverá ser a Arduino, responda:

a) Qual o modelo adequado de dispositivo de entrada

(sensor)?

Iremos utilizar um sensor de temperatura infravermelho

corporal IR MLX90614.

b) Qual o modelo adequado da placa para

processamento?

Arduino Uno.

c) Qual o modelo da tela ou display adequado para o

protótipo?

Display 16×2 I2C Backlight azul.

d) Qual o código no IDE Arduino para esse protótipo

(considere o uso de bibliotecas)?

O código, assim como, as bibliotecas e passo a passo,

estão todas no link a seguir:

Fonte: https://www.arduinoecia.com.br/sensor-de-
temperatura-mlx90614-arduino/

2
 Desenvolvimento Assembly para
ARM Wearables & IoT

3. Simule no “Tinkercad” um protótipo com sensor

ultrassônico e placa Arduino UNO que acenda um led
verde quando a distância do sensor ao obstáculo for
maior ou igual a 100 cm, acenda um led amarelo
quando a distância for menor que 100 cm e maior que
50cm e que ative um “buzzer” e acenda um led
vermelho quando a distância for menor ou igual a 50
cm. Apresente os seguintes itens:

a) o código.
// C++ code
//
char degree = 176; //ASCI valor para grau
const int buzzerPin = 9;

int distancia = 0;

#define LED_VERDE 5
#define LED_LARANJA 6
#define LED_VERMELHO 7

void setup()
{
Serial.begin(9600);
pinMode(LED_VERDE, OUTPUT);
pinMode(LED_LARANJA, OUTPUT);
pinMode(LED_VERMELHO, OUTPUT);

pinMode(buzzerPin, OUTPUT);
}

void loop()
{
// Define a variável "distancia" como informações
// que o sensor está recebendo
distancia = 0.01723 * readUltrasonicDistance(3, 2);
// Imprimi no Monitor Serial a distância que o
// Sensor está recebendo
Serial.print("Distancia em cm:");
Serial.println(distancia);

// Condição 1
if (distancia >= 100) {

3
 Desenvolvimento Assembly para
ARM Wearables & IoT

// Liga o LED verde

digitalWrite(LED_VERDE, HIGH);
digitalWrite(LED_LARANJA, LOW);
digitalWrite(LED_VERMELHO, LOW);
} else if (distancia <= 50) {
// Mostra se o circuito está funcionando e mostra
// distância proxima
digitalWrite(LED_VERDE, LOW);
digitalWrite(LED_LARANJA, LOW);
digitalWrite(LED_VERMELHO, HIGH);
} else {
// Mostra se o circuito está funcionando e mostra
// distância media
digitalWrite(LED_VERDE, LOW);
digitalWrite(LED_LARANJA, HIGH);
digitalWrite(LED_VERMELHO, LOW);
ativarBuzzer();
}
delay(10); // Delay a little bit to improve simulation
performance
}

void ativarBuzzer(){

analogWrite(buzzerPin, 127);
delay(500);
analogWrite(buzzerPin,0);
delay(500);
}

long readUltrasonicDistance(int triggerPin, int echoPin)

{
pinMode(triggerPin, OUTPUT); // Clear the trigger
digitalWrite(triggerPin, LOW);
delayMicroseconds(2);

// Sets the trigger pin to HIGH state for 10

microseconds
digitalWrite(triggerPin, HIGH);
delayMicroseconds(10);

digitalWrite(triggerPin, LOW);
pinMode(echoPin, INPUT);
// Reads the echo pin, and returns the sound wave travel
time in microseconds

return pulseIn(echoPin, HIGH);

}

4
 Desenvolvimento Assembly para
ARM Wearables & IoT

b) o esquema elétrico de ligação dos componentes.

c) o link para o acesso do projeto no Tinkercad.

Fonte:
https://www.tinkercad.com/things/6NRKcMDR9rl-
copy-of-medidor-de-
distancia/editel?sharecode=ftax5ITafZRp-
sIbWRktrdPUhNAMwmXoMeAHKcic1SI

d) um exemplo de aplicação prática deste protótipo.

Em aula mencionamos alguns, porém, como esse

possui leds e buzzer, podemos levar em consideração
o sensor de aproximação dos veículos. Onde, quanto
mais próximo o sensor se aproxima de um obstáculo
mais barulho faz com o buzzer, em forma decrescente,
e as cores variam de verde, laranja até chegar no
vermelho.

5
 Desenvolvimento Assembly para
ARM Wearables & IoT

4. Durante as aulas da disciplina “Desenvolvimento

Assembly para ARM: Wearables & IoT” optamos por
prototipar na plataforma Arduino, utilizando seu
ambiente de desenvolvimento integrado e a
linguagem C. O código em Assembly, abaixo,
implementa o programa “Blink” que faz um led
acender e apagar durante intervalos de tempo.
void setup() {

asm volatile (

"sbi %0, %1 \n\t" //pinMode(13, OUTPUT);

:: "I" (_SFR_IO_ADDR(DDRB)), "I" (DDB5)

);

void loop() {

asm volatile (

"sbi %0, %1 \n\t" //LED on

"call OneSecondDelay \n\t" //delay

"cbi %0, %1 \n\t" //LED off

"call OneSecondDelay \n\t" //delay

6
 Desenvolvimento Assembly para
ARM Wearables & IoT

"rjmp 4f \n\t" //exit

"OneSecondDelay: \n\t"

"ldi r18, 0 \n\t" //delay 1 second

"ldi r20, 0 \n\t"

"ldi r21, 0 \n\t"

"1: ldi r24, lo8(400) \n\t"

"ldi r25, hi8(400) \n\t"

"2: sbiw r24, 1 \n\t" //10x around this loop = 1ms

"brne 2b \n\t"

"inc r18 \n\t"

"cpi r18, 10 \n\t"

"brne 1b \n\t"

"subi r20, 0xff \n\t" //1000 x 1ms = 1 second

"sbci r21, 0xff \n\t"

7
 Desenvolvimento Assembly para
ARM Wearables & IoT

"ldi r24, hi8(1000) \n\t"

"cpi r20, lo8(1000) \n\t"

"cpc r21, r24 \n\t"

"breq 3f \n\t"

"ldi r18, 0 \n\t"

"rjmp 1b \n\t"

"3: \n\t"

"ret \n\t"

"4: \n\t" //exit

:: "I" (_SFR_IO_ADDR(PORTB)), "I" (PORTB5)

: "r18", "r20", "r21", "r24", "r25"

);

8
 Desenvolvimento Assembly para
ARM Wearables & IoT

O mesmo programa pode ser escrito no IDE Arduino com o

código abaixo, utilizando Linguagem C e as bibliotecas
incluídas no IDE.

void setup() {

// initialize digital pin LED_BUILTIN as an output.

pinMode(LED_BUILTIN, OUTPUT);

void loop() {

digitalWrite(LED_BUILTIN, HIGH); // turn the LED on (HIGH is the voltage level)

delay(1000); // wait for a second

digitalWrite(LED_BUILTIN, LOW); // turn the LED off by making the voltage LOW

delay(1000); // wait for a second

O código Assembly após carregado na placa ocupa 498 bytes e

o código em C ocupa 924 bytes. Com base nos códigos acima e
nos conhecimentos adquiridos nas aulas, responda:

9
 Desenvolvimento Assembly para
ARM Wearables & IoT

a) Para quais situações específicas seria mais recomendada a

programação em linguagem Assembly?

A linguagem Assembly é usada para programar situações que

precisam de eficiência, controle e velocidade, como sistemas
operacionais, microcontroladores e trabalhos críticos. Todavia,
também permite criar ações complexas e entender melhor o
computador. Exemplos aonde Assembly é usado para:

a) Programar sistemas operacionais, como o Linux, que

precisam acessar diretamente o hardware do computador.

b) Programar microcontroladores e sistemas eletrônicos,

como calculadoras, freezers e aeronaves, que possuem
pouca memória e processamento.

c) Programar trabalhos críticos, como medições de tempo,

que requerem uma boa performance e precisão.

b) Quais as vantagens em utilizar uma linguagem de alto nível

no desenvolvimento de nossa disciplina?

A maioria dos desenvolvedores escolhe linguagens de alto nível

quando a legibilidade, a manutenção e a portabilidade são
importantes, mas não é só isso, a linguagem de alto nível:

a) É mais fácil de aprender, entender e escrever, pois possui

uma sintaxe mais próxima da linguagem humana;

b) É mais produtiva, pois permite criar aplicações web com

mais recursos e funções, usando menos linhas de código;

10
 Desenvolvimento Assembly para
ARM Wearables & IoT

c) É mais portátil, pois pode rodar em diferentes sistemas

operacionais e plataformas, sem precisar de muitas
alterações;

Porém, comparado ao Assembly possui algumas desvantagens,

é mais lenta do que a linguagem de baixo nível, pois precisa ser
compilada e ser traduzida a código de máquina e é menos
flexível, em questões de acessar diretamente o hardware do
computador.

c) Quais alterações devem ser feitas no código Assembly para

que o LED permaneça ligado durante 3s e apagado durante 3s?

void setup() {

asm volatile (

"sbi %0, %1 \n\t" //pinMode(13, OUTPUT);

:: "I" (_SFR_IO_ADDR(DDRB)), "I" (DDB5)

);

11
 Desenvolvimento Assembly para
ARM Wearables & IoT

void loop() {

asm volatile (

"sbi %0, %1 \n\t" //LED on

"call OneSecondDelay \n\t" //delay
"call OneSecondDelay \n\t" //delay
"call OneSecondDelay \n\t" //delay
"cbi %0, %1 \n\t" //LED off
"call OneSecondDelay \n\t" //delay
"call OneSecondDelay \n\t" //delay
"call OneSecondDelay \n\t" //delay
"rjmp 4f \n\t" //exit

"OneSecondDelay: \n\t"
"ldi r18, 0 \n\t" //delay 1 second
"ldi r20, 0 \n\t"
"ldi r21, 0 \n\t"

"1: ldi r24, lo8(400) \n\t"

"ldi r25, hi8(400) \n\t"
"2: sbiw r24, 1 \n\t" //10x around this loop = 1ms
"brne 2b \n\t"
"inc r18 \n\t"
"cpi r18, 10 \n\t"
"brne 1b \n\t"

"subi r20, 0xff \n\t" //1000 x 1ms = 1 second

"sbci r21, 0xff \n\t"
"ldi r24, hi8(1000) \n\t"
"cpi r20, lo8(1000) \n\t"
"cpc r21, r24 \n\t"
"breq 3f \n\t"

"ldi r18, 0 \n\t"

"rjmp 1b \n\t"

"3: \n\t"
"ret \n\t"

"4: \n\t" //exit

:: "I" (_SFR_IO_ADDR(PORTB)), "I" (PORTB5)

: "r18", "r20", "r21", "r24", "r25"

);
}

12
 Desenvolvimento Assembly para
ARM Wearables & IoT

d) Em quais aplicações reais a programação Assembly é

utilizada?

Na questão “a” menciono algumas, mas exemplificarei uma

aplicação especificamente:

Uma aplicação real programada em Assembly é o Linux, um

sistema operacional de código aberto desenvolvido por Linus
Torvalds e outros colaboradores em 1991.

O Linux foi escrito principalmente em Assembly e C, usando o

GNU Assembler (GAS), um montador gratuito e de código
aberto. O Linux possui um núcleo (kernel) que gerencia os
recursos do hardware, como memória, processador, disco, rede
etc. e uma interface gráfica (GUI) que permite ao usuário
interagir com o sistema.

13