03 SuP Microprocessador ARM Cortex Software

EN2617 – SμP: processadores ARM – conjunto de instruções e linguagem ASSEMBLY
João Ranhel
Bom dia,
Boa tarde,
Boa noite..!
⟡ Aula passada... João Ranhel
Interface p/ DEPURAÇÃO (debug)
núcleo (CORE) processador

A ARM criou o padrão de barramentos Advanced

Microcontroller Bus Architecture (AMBA)
usado em todos os µC baseados em ARM core.
Matriz de barramentos AHB

(advanced high-performance bus)
de alta velocidade...
(liga FLASH, RAM e ROM)
Ponte (bus bridge)

com bus de periféricos
de baixa velocidade
Barramento APB
(advanced peripheral bus) que
interliga os periféricos...
A31..A0 Controle
R0
R1
ADDRESS REG R2
R3
R4
R5
R6
++ R7
R8
NÚCLEO ( CORE ) R9 decodificador
R10
simplificado R11 de instruções
R12
de um processador R13 (SP) e
ARM R14 (LR)
R15 (PC)
controle
cpsr
A bus banco de
registradores
Multiplic. B bus
BS
ALU
ALU bus
DATA OUT DATA IN
barramento de dados D31..D0

R0
➢ Toda a memória e periféricos estão mapeados em 32 bits! R1
R2
0xFFFFFFFF R3
R4
R5
R6
R7
R8
R9
R10
R11
R12
R13 (SP)
R14 (LR)
R15 (PC)
cpsr
banco de
registradores
0x00000000
Periféricos internos
mapeados pelo fabricante do chip
(timers, watchdog, UART, SPI, I2C...)

(ponte) bus-bridge barramento de periféricos


pinos físicos do CI...

apenas conferindo alguns pinos !!!

⟡ Aula de hoje... João Ranhel
Como transformar uma sequência de

instruções em comportamento
desejado para o sistema eletrônico...
⟡ Arquitetura ARM – descontruindo uma palavra de instrução João Ranhel
Formato típico de uma instrução :

(instruções podem ter um, dois ou três operandos...)
operation code reg destino , operando 2

Formato típico de uma instrução:


MOV R0 , R1
resultado... ( R0  R1 )


MOV R0 , R1
operation code reg destino , reg fonte , operando 2



MOV R0 , R1

ADD R2 , R3 , #0xA
resultado... ( R2  R3 + 10 )


MOV R0 , R1

ADD R2 , R3 , #0xA
resultado... ( R2  R3 + 10 )
Instruções no ARM:
✓ 32 bits – full instructions (complexas – com todos os operandos)
✓ 16 bits (thumb) – mais simples (economizam memória – programas menores)

Instruções ARM são 32 bits (normais) ou 16 bits (Thumb) como abaixo:


Exemplo:
SUBNE r0, r1, r2
se (NEQ) r0 = r1– r2
⟡ Arquitetura ARM – conjunto de instruções (Cortex M3/M4 - ISA) João Ranhel
instrução Operando Descrição Ação executada

ADC, ADCS {Rd,} Rn, Op2 Add with Carry Rd ← Rn + Op2 + Carry, ADCS updates N,Z,C,V
ADD, ADDS {Rd,} Rn, Op2 Add Rd ← Rn + Op2, ADDS updates N,Z,C,V
ADD, ADDS {Rd,} Rn, #imm12 Add Immediate Rd ← Rn + imm12, ADDS updates N,Z,C,V
ADR Rd, label Load PC-relative Address Rd ← <label>
AND, ANDS {Rd,} Rn, Op2 Logical AND Rd ← Rn AND Op2, ANDS updates N,Z,C
ASR, ASRS Rd, Rm, <Rs|#n> Arithmetic Shift Right Rd ← Rm>>(Rs|n), ASRS updates N,Z,C
B label Branch PC ← label
BFC Rd, #lsb, #width Bit Field Clear Rd[(width+lsb–1):lsb] ← 0
BFI Rd, Rn, #lsb, #width Bit Field Insert Rd[(width+lsb–1):lsb] ← Rn[(width-1):0]
BIC, BICS {Rd,} Rn, Op2 Bit Clear Rd ← Rn AND NOT Op2, BICS updates N,Z,C
BKPT #imm Breakpoint Prefetch abort or enter debug state
BL label Branch with Link LR ← next instruction, PC ← label
BLX Rm Branch reg with link LR←next instr addr, PC←Rm[31:1]
BX Rm Branch register PC ← Rm
CBNZ Rn, label Comp & Branch if Non-zero PC ← label if Rn != 0
CBZ Rn, label Compare & Branch if Zero PC ← label if Rn == 0
CLREX - Clear Clear local processor exclusive tag
CLZ Rd, Rm Count Leading Zeros Rd ← number of leading zeros in Rm
CMN Rn, Op2 Compare Negative Update N,Z,C,V flags on Rn + Op2
CMP Rn, Op2 Compare Update N,Z,C,V flags on Rn ̶ Op2
CPSID i Disable specified (i) interrupts optional change mode
CPSIE i Enable specified (i) interrupts optional change mode
instrução operando Descrição Ação executada

DMB - Data Memory Barrier, ensure memory access order
DSB - Data Synchronization Barrier, ensure completion of access
EOR, EORS {Rd,} Rn, Op2 Exclusive OR, Rd ← Rn XOR Op2, EORS updates N,Z,C
ISB - Instruction Synchronization Barrier
IT - If-Then Condition Block
LDM Rn{!}, reglist Load Multiple Regs, increment after <reglist> = mem[Rn], Rn ++ after each mem access
LDMDB, LDMEA Rn{!}, reglist Load Multiple Regs, decrement before <reglist> = mem[Rn], Rn - - before each mem access
LDMFD, LDMIA Rn{!}, reglist <reglist> = mem[Rn], Rn ++ after each mem access
LDR Rt, [Rn, #offset] Load Register with Word, Rt ← mem[Rn + offset]
LDRB, LDRBT Rt, [Rn, #offset] Load Register with Byte, Rt ← mem[Rn + offset]
LDRD Rt, Rt2, [Rn,#offset] Load Register with two words Rt ← mem[Rn + offset], Rt2 ← mem[Rn + offset + 4]
LDREX Rt, [Rn, #offset] Load Register Exclusive Rt ← mem[Rn + offset]
LDREXB Rt, [Rn] Load Reg Exclusive with Byte Rt ← mem[Rn]
LDREXH Rt, [Rn] Load Reg Exclusive with Half-word Rt ← mem[Rn]
LDRH, LDRHT Rt, [Rn, #offset] Load Reg with Half-word Rt ← mem[Rn + offset]
LDRSB, LDRSBT Rt, [Rn, #offset] Load Reg with Signed Byte Rt ← mem[Rn + offset]
LDRSH, LDRSHT Rt, [Rn, #offset] Load Reg with Signed Half-word Rt ← mem[Rn + offset]
LDRT Rt, [Rn, #offset] Load Register with Word Rt ← mem[Rn + offset]
LSL, LSLS Rd, Rm, <Rs|#n> Logic Shift Left Rd ← Rm << Rs|n, LSLS update N,Z,C
LSR, LSRS Rd, Rm, <Rs|#n> Logic Shift Right Rd ← Rm >> Rs|n, LSRS update N,Z,C

MLA Rd, Rn, Rm, Ra Multiply with Accumulate Rd ← (Ra + (Rn*Rm))[31:0]
MLS Rd, Rn, Rm, Ra Multiply with Subtract Rd ← (Ra – (Rn*Rm))[31:0]
MOV, MOVS Rd, Op2 Move Rd ← Op2, MOVS updates N,Z,C
MOVT Rd, #imm16 Move Top Rd[31:16] ← imm16, Rd[15:0] unaffected
MOVW, MOVWS Rd, #imm16 Move 16-bit Constant Rd ← imm16, MOVWS updates N,Z,C
MRS Rd, spec_reg Move from Special Register Rd ← spec_reg
MSR spec_reg, Rm Move to Special Register spec_reg ← Rm, Updates N,Z,C,V
MUL, MULS {Rd,} Rn, Rm Multiply Rd ← (Rn*Rm)[31:0], MULS updates N,Z
MVN, MVNS Rd, Op2 Move NOT Rd ← 0xFFFFFFFF EOR Op2, MVNS updates N,Z,C
NOP - No Operation
ORN, ORNS {Rd,} Rn, Op2 Logical OR NOT, Rd ← Rn OR NOT Op2, ORNS updates N,Z,C
ORR, ORRS {Rd,} Rn, Op2 Logical OR, Rd ← Rn OR Op2, ORRS updates N,Z,C
POP reglist Canonical form of LDM SP! <reglist>
PUSH reglist Canonical form of STMDB SP! <reglist>
RBIT Rd, Rn Reverse Bits, for (i = 0; i < 32; i++): Rd[i] = RN[31–i]
REV Rd, Rn Reverse Byte Order in a Word Rd[31:24]←Rn[7:0], Rd[23:16]←Rn[15:8],
Rd[15:8]←Rn[23:16], Rd[7:0]←Rn[31:24]
REV16 Rd, Rn Reverse Byte Order in a Half-word, Rd[15:8]←Rn[7:0], Rd[7:0]←Rn[15:8],
Rd[31:24]←Rn[23:16], Rd[23:16]←Rn[31:24]
REVSH Rd, Rn Reverse Byte order in Low Half-word and Rd[15:8]←Rn[7:0], Rd[7:0]←Rn[15:8],
sign extend, Rd[31:16]←Rn[7]*&0xFFFF
ROR, RORS Rd, Rm, <Rs|#n> Rotate Right, Rd ← ROR(Rm, Rs|n), RORS updates N,Z,C
RRX, RRXS Rd, Rm Rotate Right with Extend, Rd ← RRX(Rm), RRXS updates N,Z,C
RSB, RSBS {Rd,} Rn, Op2 Reverse Subtract, Rd ← Op2 ̶ Rn, RSBS updates N,Z,C,V

SBC, SBCS {Rd,} Rn, Op2 Subtract with Carry, Rd ← Rn–Op2–NOT(Carry), updates NZCV
SBFX Rd, Rn, #lsb, #width Signed Bit Field Extract, Rd[(width–1):0] = Rn[(width+lsb–1):lsb],
Rd[31:width] = Replicate(Rn[width+lsb–1])
SDIV {Rd,} Rn, Rm Signed Divide, Rd ← Rn/Rm
SEV - Send Event
SMLAL RdLo, RdHi, Rn, Rm Signed Multiply with Accumulate, RdHi,RdLo ← signed(RdHi,RdLo + Rn*Rm)
SMULL RdLo, RdHi, Rn, Rm Signed Multiply, RdHi,RdLo ← signed(Rn*Rm)
SSAT Rd, #n, Rm{,shift #s} Signed Saturate, Rd ← SignedSat((Rm shift s), n). Update Q
STM Rn{!}, reglist Store Multiple Registers
STMDB, STMEA Rn{!}, reglist Store Multiple Regs Decrement Before
STMFD, STMIA Rn{!}, reglist Store Multiple Regs Increment After
STR Rt, [Rn, #offset] Store Register with Word, mem[Rn+offset] = Rt
STRD Rt,Rt2,[Rn,#offset] Store Register with two Words, mem[Rn+offset] = Rt, mem[Rn+offset+4] = Rt2
STREX Rd, Rt, [Rn,#offset] Store Register Exclusive if allowed, mem[Rn + offset] ← Rt, clear exclusive tag, Rd ← 0.
. Else Rd ← 1
STREXB Rd, Rt, [Rn] Store Register Exclusive Byte, mem[Rn] ← Rt[15:0] or mem[Rn] ← Rt[7:0],
clear exclusive tag, Rd ← 0. Else Rd ← 1
STREXH Rd, Rt, [Rn] Store Register Exclusive Half-word, mem[Rn] ← Rt[15:0] or mem[Rn] ← Rt[7:0],
clear exclusive tag, Rd ← 0. Else Rd ← 1
STRH, STRHT Rt, [Rn, #offset] Store Half-word, mem[Rn + offset] ← Rt[15:0]
STRT Rt, [Rn, #offset] Store Register with Translation, mem[Rn + offset] = Rt
SUB, SUBS {Rd,} Rn, Op2 Subtraction, Rd ← Rn ̶ Op2, SUBS updates N,Z,C,V
SUB, SUBS {Rd,} Rn, #imm12 Subtraction, Rd ← Rn-imm12, SUBS updates N,Z,C,V
SVC #imm Supervisor Call
SXTB {Rd,} Rm {,ROR #n} Sign Extend Byte, Rd ← SignExtend((Rm ROR (8*n))[7:0])
SXTH {Rd,} Rm {,ROR #n} Sign Extend Half-word, Rd←SignExtend((Rm ROR (8*n))[15:0])

TBB [Rn, Rm] Table Branch Byte PC ← PC+ZeroExtend(Memory(Rn+Rm,1)<<1)
TBH [Rn, Rm, LSL #1] Table Branch Halfword PC←PC+ZeroExtend(Memory(Rn+Rm<<1,2)<<1)
TEQ Rn, Op2 Test Equivalence Update N,Z,C,V on Rn EOR Operand2
TST Rn, Op2 Test Update N,Z,C,V on Rn AND Op2
UBFX Rd, Rn, #lsb, #width Unsigned Bit Field Extract Rd[(width–1):0] = Rn[(width+lsb–1):lsb],
Rd[31:width] = Replicate(0)
UDIV {Rd,} Rn, Rm Unsigned Divide, Rd ← Rn/Rm
UMLAL RdLo, RdHi, Rn, Rm Unsigned Multiply with Accumulate, RdHi,RdLo ← unsigned(RdHi,RdLo + Rn*Rm)
UMULL RdLo, RdHi, Rn, Rm Unsigned Multiply, RdHi,RdLo ← unsigned(Rn*Rm)
USAT Rd, #n, Rm{,shift #s} Unsigned Saturate, Rd←UnsignedSat((Rm shift s),n), Update Q
UXTB {Rd,} Rm {,ROR #n} Unsigned Extend Byte, Rd ← ZeroExtend((Rm ROR (8*n))[7:0])
UXTH {Rd,} Rm {,ROR #n} Unsigned Extend Halfword, Rd ← ZeroExtend((Rm􀀃 ROR􀀃 (8*n))[15:0])
WFE - Wait For Event and Enter Sleep Mode
WFI - Wait for Interrupt and Enter Sleep Mode
➢ Recordando o conceito de sub-rotina ( ou chamada de função )
trecho do
código...
sub-rotina
trecho do
código...
programas chamam funções (sub-rotinas) para

executar algoritmos repetitivos
exemplos: calcular o seno de uma função, ordenar

trecho do caracteres numa string, enviar um byte por uma porta de
código... comunicação serial, ler um dado do conversor ADC, etc.

label: sub1
trecho do
código...
BL sub1 sub-rotina
BX LR
trecho do
código...
Alguns processadores têm funções de call & return para

BLGE sub1 chamar e retornar de sub-rotinas automaticamente...
No ARM isso é feito pela chamada da instrução:
BL (branch to label), LR ← next instruction, PC ← label
trecho do que salva o endereço de retorno no registrador R14 (LR)
código...
** para retornar, carregamos o PC com valor de R14 por meio
da chamada da função BX com o operando LR

label: sub1
trecho do
código...
BL sub1 sub-rotina
É obrigação do
BX LR programador preservar os
trecho do valores dos registradores
código... para continuar o programa
depois de retornar da
sub-rotina !!!
BL sub1
trecho do
código...
➢ Recordando o conceito de PILHA ... (como preservar conteúdo dos registradores)
trecho do
código...
trecho do
código...
trecho do
código...
Alguém se recorda do conceito de PILHA
dado 6
dado 5
trecho do
dado 4
código...
dado 3
dado 2
....
trecho do
código... R13 (SP)
Pilha: estrutura de dados (na RAM) baseada no

princípio Last In First Out (LIFO), ou seja "último a
trecho do
entrar, primeiro que sair" caracterizando um
código...
empilhamento de dados.
dado 6
dado 5
trecho do
dado 4
código...
dado 3
dado 2
dado 1
trecho do
código...  primeiro dado a ser recuperado R13 (SP)
Pilha: estrutura de dados (na RAM) baseada no

princípio Last In First Out (LIFO), ou seja "último a
entrar, primeiro que sair" caracterizando um
trecho do empilhamento de dados.
código...
O STACK POINTER (SP ou R13) mantém o endereço do último valor
empurrado na pilha!
dado n
PUSH {R0,R4-R7} R7
dado 5
trecho do
dado 4
código...
dado 3
sub-rotina dado 2
R0 dado 1
trecho do
código... Funcionamento principal da pilha:
✓ nas entradas das sub-rotinas, empurre para a pilha os valores
dos registradores que serão modificados
✓ PUSH {lista de registradores} empurra dados na pilha...
✓ na saída (no retorno) da sub-rotina, recupere os valores dos
registradores salvos na pilha.
trecho do
código... ✓ a instrução segue a ordem e salva o registrador de menor índice na lista
na menor posição de memória da pilha dentro dessa instrução...
dado n
PUSH {R0,R4-R7} dado 5
trecho do
dado 4
código...
dado 3
sub-rotina dado 2
dado 1
POP {R0,R4-R7}
BX LR
trecho do
código... Funcionamento principal da pilha:
✓ nas saída das sub-rotinas, puxe os dados de volta da pilha para
recarregar os registradores...
✓ POP {lista de registradores} recupera os valores dos registradores
trecho do ✓ a cada PUSH ou POP o registrador SP (R13) é atualizado

automaticamente pela unidade de controle da CPU.
código...
➢ Conceito de INTERRUPÇÃO ...
Alguém se recorda do conceito de INTERRUPÇÃO?

trecho do
código...
trecho do
código...
trecho do
código...
Bart Simpsons - Matt Groening - Fox Broadcasting Company

➢ Eventos no mundo real são imprevisíveis : você não sabe quando

eles podem ocorrer...
trecho do
código... ➢ Fazer seu código verificar cada um dos eventos aos quais seu
sistema vai responder não é boa tática!
trecho do
código...
trecho do
código...

trecho do
➢ Melhor é que o mundo te avise que alguns eventos ocorreram e
“desperte” certa parte do seu código para responder a esse evento
trecho do
código...
trecho do
código...

trecho do
trecho do ➢ Uma forma de o mundo avisar que um evento merece atenção do

código... seu código é (entre outras táticas) por meio de interrupções!
trecho do
código...

trecho do
trecho do ➢ Uma forma de o mundo avisar que um evento merece atenção do

código... seu código é (entre outras táticas) por meio de interrupções!
➢ Para atender a uma interrupção você deve escrever um pedaço de

código chamado “INTERRUPT SERVICE ROUTINE” ou ISR
trecho do
código... ➢ ISR funcionam como as sub-rotinas que vimos antes e podem ser
disparadas por hardware ou por software.

Interrupt Service Routine
dado n
PUSH {PC, R0,R3-R5} PC
dado 5
trecho do
dado 4
código...
dado 3
sub-rotina dado 2
R0 dado 1
trecho do
código...
INTERRUPÇÕES e a pilha:
✓ É necessário empurrar o conteúdo do PC (R15) na pilha para que
o programa saiba onde estará a próxima instrução!
✓ Especialmente porque você não sabe QUANDO uma interrupção
trecho do vai ocorrer, é boa prática salvar os registradores na pilha assim
código... que entramos numa ISR.

dado n
PUSH {PC, R0,R3-R5} PC
dado 5
trecho do
dado 4
código...
dado 3
sub-rotina dado 2
R0 dado 1
POP {PC, R0,R3-R5}
BX LR
trecho do
código... INTERRUPÇÕES e a pilha:
✓ Note que outro pedido de interrupção pode ocorrer quando a CPU
está executando uma ISR. Isso se chama nested interruption
(interrupção aninhada)
✓ O procedimento de empurrar na pilha os registradores e
especialmente o PC garante tanto o endereço correto de retorno
trecho do quando a recuperação dos valores dos registradores.
código...

trecho do
código...
sub-rotina
trecho do
código...
O endereço de retorno é obtido ao empurrar o PC na pilha, ok !!!
Mas, a interrupção pode ocorrer a qualquer momento, e não temos uma
instrução branch no meio do código para desviar para a ISRn, da forma:
BL (branch to ISRn), LR ← next instruction, PC ← label

trecho doEntão COMO a CPU sabe onde começa a sub-rotina de interrução?
código...
** Para solucionar o problema temos, em geral, uma TABELA com os
endereços iniciais das ISRs, geralmente preenchida pelo compilador.

Aqui chega a requisição de Interrupção.
O NVIC busca endereço da ISR na tabela,
2 para saber como fazer o branching.
1
trecho do
código...
sub-rotina
trecho do
código...
Flash ARM possui um controlador de interrupções, chamado

ISRn Nested Vectored Interrupt Controller (NVIC) .
Outros µP/ µC também possuem controlador similar...
3 O NVIC recebe sinais de periféricos (timers, pinos GPIO, avisos
ISR2
ISR1 de falhas como divisão por zero, etc.), busca na tabela de
ISR0 vetores de interrupção o endereço da respectiva ISRn, e
executa um branch especial com o endereço inicial da ISR.

trecho do
sub-rotina
código...
➢ Propriedades das INTERRUPÇÕES:
trecho do ➢ Podem ser geradas por software ou hardware

código... ➢ ISR são como sub-rotinas e funcionam ≈ da mesma forma
➢ Algumas interrupções podem ser mascaradas (ou seja, podemos
impedir temporariamente que alguns pedidos de interrupções
Flash sejam feitos)
ISRn ➢ Há ainda interrupções que NÃO podem ser mascaradas por serem
cruciais para o funcionamento do sistema (ex: reset, DZ e outras)
ISR2
ISR1
ISR0
........ R0 ➢ Exemplos da instrução MOV

........ R1
........ R2
........ R3 MOV R0, #0x1A
........ R4
........ R5
........ R6
........ R7
........ R8
........ R9
........ R10
........ R11
........ R12
........ R13
........ R14
........ R15
........ R0
destino... ➢ Exemplos da instrução MOV
........ R1
........ R2
........ R3 MOV R0, #0x1A
........ R4
........ R5
........ R6
........ R7
........ R8
........ R9
........ R10
........ R11
........ R12
........ R13
........ R14
........ R15
0x0000001A R0
destino... ➢ Exemplos da instrução MOV
........ R1 valor imediato (kte)
........ R2
........ R3 MOV R0, #0x1A
........ R4
........ R5
........ R6
........ R7
........ R8 prefixo hexa...
........ R9
........ R10
........ R11
........ R12
........ R13
........ R14
........ R15
0x0000001A R0 ➢ Exemplos da instrução MOV

0x00000A08 R1
........ R2
........ R3 MOV R0, #0x1A
........ R4
........ R5 MOV R1, #2568
........ R6 decimal
(atente ao limite – 12 BITS)
........ R7
........ R8
........ R9
........ R10
........ R11
........ R12
........ R13
........ R14
........ R15

0x00000A08 R1
0xFFFFFFF7 R2
........ R3 MOV R0, #0x1A
........ R4
........ R5 MOV R1, #2568
........ R6
MVN R2, #8
........ R7
........ R8
........ R9 faz o complemento-1 de 8 e carrega em R2
........ R10
OBS: atualiza carry... uma soma com carry em
........ R11 seguida equivale à subtração em complemento-2
........ R12
........ R13
........ R14
........ R15

0x00000A08 R1
0xFFFFFFF7 R2
0x0000FABC R3 MOV R0, #0x1A
........ R4
........ R5 MOV R1, #2568
........ R6
MVN R2, #8
........ R7
........ R8
MVW R3, #0xFABC
........ R9
........ R10
........ R11
........ R12
........ R13 Para carregar 32 bits num registrador é
preciso usar 2 instruções: MVW e MVT !
........ R14 (não existem nos µC Cortex M0, M0+ e M1)
........ R15

0x00000A08 R1
0xFFFFFFF7 R2
0xCADEFABC R3 MOV R0, #0x1A
........ R4
........ R5 MOV R1, #2568
........ R6
MVN R2, #8
........ R7
........ R8
MVW R3, #0xFABC
........ R9
........ R10 MVT R3, #0xCADE
........ R11
........ R12
........ R13 Para carregar 32 bits num registrador é
preciso usar 2 instruções: MVW e MVT !
........ R14 (não existem nos µC Cortex M0, M0+ e M1)
........ R15

0x00000A08 R1
0xFFFFFFF7 R2
0x0000001A R4
........ R5 MOV R1, #2568
........ R6
MVN R2, #8
........ R7
........ R8
MVW R3, #0xFABC
........ R9
........ R10 MVT R3, #0xCADE
........ R11
........ R12 MVT R4, R0
........ R13
........ R14
........ R15

0x00000A08 R1
0xFFFFFFF7 R2
0x0000001A R4
........ R5 MOV R1, #2568
........ R6
MVN R2, #8
........ R7
........ R8
MVW R3, #0xFABC
........ R9
........ R10 MVT R3, #0xCADE
........ R11
........ R12 MVT R4, R0
........ R13
........ R14
........ R15
➢ Exemplos da instrução LOAD / STORE

0x0000001A R0
MEMÓRIA: dado endereço
0x00001A08 R1
0xDEDEBABA 0X00001A00
0xFFFFFFF7 R2
0x12345678 0X00001A04
0xCADEFABC R3
0xA1BABACA 0X00001A08
0x0000001A R4
0x0A987650 0X00001A0C
........ R5
0x0003001A 0X00001A10
........ R6
0x00050050 0X00001A14
........ R7
instrução... 0x0001FABC 0X00001A18
........ R8
0x00000000 0X00001A1C
........ R9 LDR R5, [R1] 0X00001A20
0x11111111
........ R10 0X00001A24
0xCACAFEDE
........ R11
........ R12
........ R13
........ R14
........ R15

0x0000001A R0
0x00001A08 R1
0xFFFFFFF7 R2
0x12345678 0X00001A04
0xCADEFABC R3 endereço na
memória 0xA1BABACA 0X00001A08
0x0000001A R4
0x0A987650 0X00001A0C
........ R5
0x0003001A 0X00001A10
........ R6
0x00050050 0X00001A14
........ R7
........ R8
0x00000000 0X00001A1C
........ R9 LDR R5, [R1] 0X00001A20
0x11111111
........ R10 0X00001A24
0xCACAFEDE
........ R11
........ R12
........ R13
........ R14
........ R15

0x0000001A R0
0x00001A08 R1
0xFFFFFFF7 R2
0x12345678 0X00001A04
0xCADEFABC R3
0xA1BABACA 0X00001A08
0x0000001A R4
0x0A987650 0X00001A0C
0xA1BABACA R5
0x0003001A 0X00001A10
........ R6
0x00050050 0X00001A14
........ R7
........ R8
0x00000000 0X00001A1C
........ R9 LDR R5, [R1] 0X00001A20
0x11111111
........ R10 0X00001A24
0xCACAFEDE
........ R11
........ R12
destino do dado
........ R13
........ R14
........ R15

0x0000001A R0
0x00001A08 R1
0xFFFFFFF7 R2
endereço na 0x12345678 0X00001A04
0xCADEFABC R3
memória 0xA1BABACA 0X00001A08
0x0000001A R4
0x0A987650 0X00001A0C
0xA1BABACA R5
0x0003001A 0X00001A10
........ R6
0x00050050 0X00001A14
........ R7
........ R8
0x00000000 0X00001A1C
........ R9 LDR R5, [R1] 0X00001A20
0x11111111
........ R10 0X00001A24
STR R3, [R1] 0xCACAFEDE
........ R11
........ R12
........ R13
........ R14 dado
(conteúdo a ser transferido)
........ R15

0x0000001A R0
0x00001A08 R1
0xFFFFFFF7 R2
0x12345678 0X00001A04
0xCADEFABC R3
0xCADEFABC 0X00001A08
0x0000001A R4
0x0A987650 0X00001A0C
0xA1BABACA R5
0x0003001A 0X00001A10
........ R6
0x00050050 0X00001A14
........ R7
........ R8
0x00000000 0X00001A1C
........ R9 LDR R5, [R1] 0X00001A20
0x11111111
........ R10 0X00001A24
........ R11
........ R12
........ R13
........ R14
........ R15

0x0000001A R0
0x00001A08 R1
endereço da 0xDEDEBABA 0X00001A00
0xFFFFFFF7 R2
memória 0x12345678 0X00001A04
0xCADEFABC R3 é calculado:
0x0000001A R4
0x0A987650 0X00001A0C
0xA1BABACA R5 [ R1+8 ] (offset)
1A08H + 8 = 1A10H 0x0003001A 0X00001A10
........ R6
0x00050050 0X00001A14
........ R7
........ R8
0x00000000 0X00001A1C
........ R9 LDR R5, [R1] 0X00001A20
0x11111111
........ R10 0X00001A24
........ R11
........ R12 LDR R7, [R1,8]
........ R13
........ R14
........ R15

0x0000001A R0
0x00001A08 R1
0xFFFFFFF7 R2
0x12345678 0X00001A04
0xCADEFABC R3
0x0000001A R4
0x0A987650 0X00001A0C
0xA1BABACA R5
0x0003001A 0X00001A10
........ R6
0x00050050 0X00001A14
0x0003001A R7
........ R8
0x00000000 0X00001A1C
........ R9 LDR R5, [R1] 0X00001A20
0x11111111
........ R10 0X00001A24
........ R11
........ R12 LDR R7, [R1,8]
........ R13
........ R14
........ R15 destino do dado

0x0000001A R0
0x00001A08 R1
0xFFFFFFF7 R2
0x12345678 0X00001A04
0xCADEFABC R3
0x0000001A R4
0x0A987650 0X00001A0C
0xA1BABACA R5
0x0003001A 0X00001A10
........ R6
0x00050050 0X00001A14
0x0003001A R7
........ R8
0x00000000 0X00001A1C
........ R9 LDR R5, [R1] 0X00001A20
0x11111111
........ R10 0X00001A24
........ R11
........ R12 LDR R7, [R1,8]
........ R13
........ R14
........ R15

0x0000001A R0 Note que nessas instruções R1
0x00001A08 R1 funciona como um apontador
R2 (pointer) e não foi modificado;
0xFFFFFFF7
embora exista variações das 0x12345678 0X00001A04
0xCADEFABC R3 instruções LDR e STR que alteram
0x0000001A R4 o valor dos apontadores!
0x0A987650 0X00001A0C
0xA1BABACA R5
0x0003001A 0X00001A10
........ R6
0x00050050 0X00001A14
0x0003001A R7
........ R8
0x00000000 0X00001A1C
........ R9 LDR R5, [R1] 0X00001A20
0x11111111
........ R10 0X00001A24
........ R11
........ R12 LDR R7, [R1,8]
........ R13
........ R14
........ R15
➢ Diretivas para compilador ASSEMBLY

0x0000001A R0
0x00001A08 R1 Em um arquivo definimos a diretiva (uma constante)
0xFFFFFFF7 R2 .equ KTE1, 0x87654321
0xCADEFABC R3
0x0000001A R4
0xA1BABACA R5
........ R6
0x0003001A R7
........ R8
........ R9
........ R10
........ R11
........ R12
........ R13
........ R14
........ R15

0x0000001A R0
0xCADEFABC R3
0x0000001A R4
0xA1BABACA R5 Noutro arquivo, usamos a kte numa função...
........ R6
@ uma certa sub-rotina começa aqui...
0x0003001A R7
........ R8 ...
LDR R0, =KTE1
........ R9
@ outras linhas do código...
........ R10
...
........ R11
........ R12
........ R13
........ R14
........ R15

0x0000001A R0
0xCADEFABC R3
0x0000001A R4
0xA1BABACA R5 Noutro arquivo, usamos a kte numa função...
........ R6
@ uma certa sub-rotina começa aqui...
0x0003001A R7
........ R8 ...
LDR R0, =KTE1
........ R9
@ outras linhas do código...
........ R10
...
........ R11
........ R12 @ final da sub-rotina...
........ R13 .word 0x87654321

........ R14
........ R15

0x0000001A R0 .equ KTE1, 0x87654321
0x00001A08 R1 sub-rotina (função)
0x . . . . . . . . 0X000F1000
0xFFFFFFF7 R2
0x4806 0X000F1004
0xCADEFABC R3
0x . . . . . . . . 0X000F1008
0x0000001A R4
0x . . . . . . . . 0X000F100C
0xA1BABACA R5
0x . . . . . . . . 0X000F1010
........ R6
@ uma certa sub-rotina começa aqui... 0x . . . . . . . . 0X000F1014
0x0003001A R7
0x . . . . . . . . 0X000F1018
........ R8 ...
LDR R0, =KTE1 0x . . . . . . . . 0X000F101C
........ R9
@ outras linhas do código... 0x87654321 0X000F1020
........ R10
... 0xCACAFEDE 0X000F1024
........ R11
Valor da constante
........ R12 @ depois do final da sub-rotina...
.word 0x87654321 final da sub-rotina...

........ R13
........ R14
0X000F1004 R15

0x0000001A R0 .equ KTE1, 0x87654321
0x00001A08 R1 sub-rotina (função)
0x . . . . . . . . 0X000F1000
0xFFFFFFF7 R2
0x4806 0X000F1004
0xCADEFABC R3
distância ao final da 0x . . . . . . . . 0X000F1008
0x0000001A R4 sub-rotina não muda...
0x . . . . . . . . 0X000F100C
0xA1BABACA R5
0x . . . . . . . . 0X000F1010
........ R6
@ uma certa sub-rotina começa aqui... 0x . . . . . . . . 0X000F1014
0x0003001A R7
0x . . . . . . . . 0X000F1018
........ R8 ...
LDR R0, [PC,24] 0x . . . . . . . . 0X000F101C
........ R9
@ outras linhas do código... 0x87654321 0X000F1020
........ R10
... 0xCACAFEDE 0X000F1024
........ R11
Valor da constante
........ R12 @ depois do final da sub-rotina...
........ R13 .word 0x87654321

........ R14 O compilador usa um offset (24) relativo ao PC [R15],
porque se a sub-rotina for recompilada em outro
0X000F1008 R15
endereço da memória, o acesso à KTE1 permanece.
➢ Diferenças entre MOV e LDR/STR

0x0000001A R0
0x00001A08 R1
0x . . . . . . . . 0X000F1000
0xFFFFFFF7 R2
0x4806 0X000F1004
0xCADEFABC R3
0x . . . . . . . . 0X000F1008
0x0000001A R4
0x . . . . . . . . 0X000F100C
0xA1BABACA R5 ➢ Move é usado geralmente para
0x . . . . . . . . 0X000F1010
........ R6 deslocar conteúdos entre
registradores (interno à CPU) 0x . . . . . . . . 0X000F1014
0x0003001A R7 ou valores imediatos (kts) 0x . . . . . . . . 0X000F1018
........ R8
0x . . . . . . . . 0X000F101C
........ R9 ➢ LDR e STR são usadas para
mover conteúdo entre a CPU e 0x87654321 0X000F1020
........ R10 a memória (RAM ou ROM) 0X000F1024
0xCACAFEDE
........ R11
........ R12
➢ Ao acessar a memória deve-se definir um endereço, que
........ R13 estará em um registrador (direto), ou será calculado a
........ R14 partir do conteúdo de um registrador + offset !
........ R15
0x0000001A R0 ➢ Instruções ARITMÉTICAS e LÓGICAS ...

0x00001A08 R1
➢ Nenhuma instrução aritmética e lógica ocorre
0xFFFFFFF7 R2 diretamente na memória – sempre os
0xCADEFABC R3 operadores são registradores
0x0000001A R4
0xA1BABACA R5
SUB R1, R2, #5 // lê-se: r1 = r2-5
........ R6
0x0003001A R7
........ R8
........ R9
........ R10
........ R11
........ R12
........ R13
........ R14
........ R15

0x00001A08 R1
0x0000001A R4
0xA1BABACA R5
SUB R1, R2, #5 // lê-se: r1 = r2-5
........ R6
0x0003001A R7 ADD R2, R3, R3 LSL #2 // lê-se: r2 = r3+(r3*4)
........ R8
........ R9
........ R10
........ R11
........ R12
........ R13
........ R14
........ R15

0x00001A08 R1
0x0000001A R4
0xA1BABACA R5
SUB R1, R2, #5 // lê-se: r1 = r2-5
........ R6
........ R8
........ R9 ADDEQ R5, R5, R6 // se (flag EQ) r5 = r5+r6
........ R10
........ R11
........ R12
........ R13
........ R14
........ R15

0x00001A08 R1
0x0000001A R4
0xA1BABACA R5
SUB R1, R2, #5 // lê-se: r1 = r2-5
........ R6
........ R8
........ R9 ADDEQ R5, R5, R6 // se (flag EQ) r5 = r5+r6
........ R10
AND R4, R3, R7 // lê-se: r4 = r3(i) AND r7(i)
........ R11
........ R12
........ R13
........ R14
........ R15
⟡ Arquitetura ARM – exemplo de programa assembly. João Ranhel
















⟡ Resumo da aula de hoje... João Ranhel
➢ Instruções do ARM podem ser 32 bits ou 16 bits (thumb)

➢ Instruções possuem 1, 2 ou 3 operandos
➢ As instruções MOV são geralmente usadas para mover dados entre
registradores ou com valores imediatos
➢ Operações com a memória usam as instruções LOAD ou STORE e os
registradores funcionam como apontadores de endereços de memória
➢ Compiladores podem usar offset relativo ao PC para armazenar constantes ao
final de sub-rotinas para facilitar
➢ Todas as operações aritméticas/lógicas usam registradores como operandos
➢ Não há operações aritméticas e lógicas direto na memória
➢ Chamadas de sub-rotinas são feitas com branching (BL e BX), que guardam
automaticamente o endereço de retorno em LR e depois retornam ao PC
➢ É dever do programador preservar conteúdo dos registradores nas chamadas de
sub-rotinas, quando for necessário
➢ ARM busca instruções (fetch) ao mesmo tempo em que decodifica e executa as
instruções em andamento – processo chamado pipeline.
⟡ Resumo da aula de hoje... João Ranhel
➢ As instruções da arquitetura ARM são executadas em pipeline.

➢ Toda instrução tem um código (que define a ação), e operandos (usados na operação)
Opcode DestReg, Operand2

Opcode DestReg, SrcReg, Operand2
SUB R1, R2, #5 // lê-se: r1 = r2 - 5
ADD R2, R3, R3 LSL #2 // lê-se: r2 = r3 + (r3*4)
ADDEQ R5, R5, R6 // se (flag EQ) r5 = r5 + r6
LDR R0, [R1] // r0 = val mem cujo end está em r1 (pointer *r1)
MOV R0, #0x101 // r0 = valor imediato (101 hexa) = 257 decimal
STRNEB R2, [R3, R4] // se (flag NEQ) o endereço *(r3+r4) = r2

⟡ Aulas seguintes... João Ranhel
➢ Não vamos nos fixar em desenvolver programas em linguagem assembly ARM...

- arquiteturas modernas, como ARM, focam em programação em “C”
- isso permite que o desenvolvedor “migre” de um processador para outro
- Isso melhora a manutenção e escalabilidade dos projetos de eletrônica embarcada...
➢ Vamos focar (nas aulas teóricas) em compreender os periféricos agregados ao ARM...

- coprocessadores e circuitos de arbitragem de barramento (DMA, INTERRUPÇÃO, etc)
- periféricos de comunicação serial (SPI, I2C, USART, CAN, etc...)
- periféricos de interface geral (GPIO)
- periféricos de conversão (ADC e DAC) e de saída analógica (PWM)
- periféricos temporizadores (Watchdog, RTC, timers de uso geral, etc)
⟡ Aulas seguinte ... João Ranhel
➢ CONJUNTO DE INSTRUÇÕES e a forma de operação do ARM.
Obrigado...
Até a próxima aula.

03 SuP Microprocessador ARM Cortex Software

Enviado por

Direitos autorais:

Formatos disponíveis

03 SuP Microprocessador ARM Cortex Software

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

03 SuP Microprocessador ARM Cortex Software

Enviado por

Direitos autorais:

Formatos disponíveis

EN2617 – SμP: processadores ARM – conjunto de instruções e linguagem ASSEMBLY

⟡ Aula passada... João Ranhel

Interface p/ DEPURAÇÃO (debug)

núcleo (CORE) processador

⟡ Aula passada... João Ranhel

A ARM criou o padrão de barramentos Advanced

Matriz de barramentos AHB

Ponte (bus bridge)

⟡ Aula passada... João Ranhel

DATA OUT DATA IN

barramento de dados D31..D0

⟡ Aula passada... João Ranhel

⟡ Aula passada... João Ranhel

⟡ Aula passada... João Ranhel

⟡ Aula passada... João Ranhel

(ponte) bus-bridge barramento de periféricos

⟡ Aula passada... João Ranhel

⟡ Aula passada... João Ranhel

pinos físicos do CI...

⟡ Aula passada... João Ranhel

apenas conferindo alguns pinos !!!

⟡ Aula de hoje... João Ranhel

Como transformar uma sequência de

⟡ Arquitetura ARM – descontruindo uma palavra de instrução João Ranhel

Formato típico de uma instrução :

operation code reg destino , operando 2

⟡ Arquitetura ARM – descontruindo uma palavra de instrução João Ranhel

Formato típico de uma instrução:

operation code reg destino , operando 2

⟡ Arquitetura ARM – descontruindo uma palavra de instrução João Ranhel

Formato típico de uma instrução:

operation code reg destino , operando 2

operation code reg destino , reg fonte , operando 2

⟡ Arquitetura ARM – descontruindo uma palavra de instrução João Ranhel

Formato típico de uma instrução:

operation code reg destino , operando 2

operation code reg destino , reg fonte , operando 2

⟡ Arquitetura ARM – descontruindo uma palavra de instrução João Ranhel

Formato típico de uma instrução:

operation code reg destino , operando 2

operation code reg destino , reg fonte , operando 2

✓ 32 bits – full instructions (complexas – com todos os operandos)

✓ 16 bits (thumb) – mais simples (economizam memória – programas menores)

⟡ Arquitetura ARM – descontruindo uma palavra de instrução João Ranhel

Instruções ARM são 32 bits (normais) ou 16 bits (Thumb) como abaixo:

⟡ Arquitetura ARM – descontruindo uma palavra de instrução João Ranhel

⟡ Arquitetura ARM – descontruindo uma palavra de instrução João Ranhel

⟡ Arquitetura ARM – conjunto de instruções (Cortex M3/M4 - ISA) João Ranhel

instrução Operando Descrição Ação executada

⟡ Arquitetura ARM – conjunto de instruções (Cortex M3/M4 - ISA) João Ranhel

instrução operando Descrição Ação executada

⟡ Arquitetura ARM – conjunto de instruções (Cortex M3/M4 - ISA) João Ranhel

instrução operando Descrição Ação executada

⟡ Arquitetura ARM – conjunto de instruções (Cortex M3/M4 - ISA) João Ranhel

instrução operando Descrição Ação executada

⟡ Arquitetura ARM – conjunto de instruções (Cortex M3/M4 - ISA) João Ranhel

instrução operando Descrição Ação executada

⟡ Arquitetura ARM – conjunto de instruções (Cortex M3/M4 - ISA) João Ranhel

➢ Recordando o conceito de sub-rotina ( ou chamada de função )