Tutorial
EDK – Embedded Development Kit
REVISADO POR MORAES
EM 31/maio/2012
Definição
• O XPS é um ambiente com ferramentas de software
para projetar sistemas embarcados
• O XPS (Xilinx Plataform Studio) é uma interface
gráfica que permite o projeto, debug e verificação de
sistemas embarcados.
• XPS possui repositórios de cores IPs e drivers
Definição
• O XPS permite a criação de arquiteturas de hardware
microprocessadas, disponibilizando dois IPs de
processadores:
• Softcore MicroBlaze (Xilinx)
• Hardcore PowerPC405 (IBM)
Definição
• Permite a criação de periféricos com lógica definida
pelo usuário
• Utiliza o barramento CoreConnect da IBM para
conectar e comunicar processadores e periféricos.
Duas interfaces são usadas:
- PLB (Processor Local Bus)
- OPB (On-chip Peripheral Bus)
• Os periféricos da arquitetura de hardware do
sistema são mapeados em memória
Tutorial
Passos para construção de um sistema embarcado
•
•
•
•
•
•
•
•
•
Criar um novo projeto no XPS
Escolher uma plataforma alvo
Escolher o processador
Configurar o processador
Configurar interfaces de I/O
Especificar periféricos internos
Projetar o software
Gerar bitstream
Fazer o download do bitstream
Começando
Iremos desenvolver este tutorial na máquina kriti
• Logar-se na kriti
• ssh -X kriti.inf.pucrs.br
• Setar as variáveis de ambiente
• source /soft64/source_gaph
• module load ise/11.1
• Ir para o diretório de trabalho
• mkdir tut_xilinx
• cd tut_xilinx/
I – Criação da arquitetura base, para
uma dada placa de prototipação
Criação do projeto
- Executar na linha de comando
xps
- Criar um novo projeto
(pode demorar...)
Criação do projeto – seleção da placa
Criação do projeto – número de processadores
Criação do projeto – memória do processador
Escolha dos periféricos
- Escolha os periféricos,
removendo DDR, Ethernet
Flash
- Escolher a interface serial
DCE (as portas seriais são
diferentes – atenção!)
- Configure a serial para
57600 bps
- Na sequência NÃO insira
memórias cache (next)
Escolha das aplicações de teste
- São geradas duas aplicações exemplos – teste de memória e teste
de periféricos
Resumo do projeto
- Verifique as mensagens e Finish
Gerado o sistema de base obtemos a seguinte janela
II – Inserção de um periférico do
usuário com suporte à interrupção
A criação de um periférico é feita em três etapas: (1) criação do template; (2) inclusão do
periférico no projeto; (3) conexão do periférico
Criar Periférico
O periférico vai ser adicionado
a estrutura do projeto atual
Nomear o periférico: sugiro
usar o mesmo nome - interrupt
Escolha do modo de
comunicação – PLB
Notar que pode-se
usar FSL
Seleção de suporte a reset, registradores
mapeados em memória, interrupção
Configuração da interrupção
Next na janela de
Slave Interface
Desmarcar
O periférico gerará
uma interrupção,
sensível a nível
Definição do número de registradores mapeados em memória
(MUITO IMPORTANTE): neste exemplo utilizaremos 4
Interface com o barramento PLB - padrão
Interface com o ModelSim – deixar em branco
Marcar a geração de projeto e de
auxílio para drivers
Aqui tem muita
informação útil
Depois: finish
Arquitetura do sistema
PERIFÉRICO DO USUÁRIO
MicroBlaze
OPB
periférico.vhd
IPIF
User_logic.vhd
OUTROS
PERIFÉRICOS
•
O periferico.vhd é o wrapper entre o barramento OPB e a lógica do usuário.
A princípio não precisa alterar.
•
O user_logic é onde o usuário escreve seu hardware.
INCLUSÃO DE FUNCIONALIDADES AO TEMPLATE CRIADO PARA O PERIFÉRICO
•Abrir o arquivo <diretório>\pcores\interrupt_v1_00_a\hdl\vhdl\user_logic.vhd
•Observar que foi incluída na entity o pino de interrupção (linha 118):
•
IP2Bus_IntrEvent
: out std_logic_vector(0 to C_NUM_INTR-1)
•Observar o código entre as linhas 239 – 269 que gera a interrupção. Só mudar o
tamanho do COUNT_SIZE para 27 (interrupção mais rápida):
Processo de
geração de
interrupção
Segunda etapa : inclusão do periférico no projeto
Importar o periférico ao projeto
Importar o periférico
cujo template foi
modificado na etapa
anterior
Identificar o periférico e a respectiva versão do driver
(é interrupt – eu (Moraes) que esqueci do t)
Selecionar o periférico previamente criado
Responder yes
Dizer que o periférico está descrito em VHDL
Indicar a ordem de compilação:
Se o periférico tem mais códigos VHDL
insere-se os novos fontes na próxima janela
Recomenda-se olhar o conteúdo.
•
•
A janela seguinte permite acrescentar novos arquivos
Olhar que os últimos dois arquivos VHDL compilados referem-se aos arquivos
VHDL editados nas etapas anteriores
Indicar que este periférico irá se comunicar
pelo barramento PLB, em modo escravo
•
Pino de interrupção: notar que foi detectado - indicar o que o mesmo é
sensível ao nível lógico
Definir sensitividade
e prioridade da
interrupção
Next  Next  Finish
Terceira etapa: conexão do periférico
Adicione o periférico ao sistema e o conecte ao barramento PLB
Conecte-o ao barramento
Inserir o periférico
(duplo clique ou arraste)
LIGANDO OS FIOS DE INTERRUPÇÃO ENTRE SI
2. Defina o sinal que informará a
Microblaze da interrupção
1. Defina a rede de interrupção
selecionando new_conection – o nome
é criado automaticamente
Gerar endereço para o novo periférico
III – Geração do bitstream
e software do usuário
Hardware  generate netlist  longo...
Ao final:
------------------------------No Partitions were found in this design.
------------------------------NGCBUILD Design Results Summary:
Number of errors:
0
Number of warnings:
0
Writing NGC file "../implementation/system.ngc" ...
Total REAL time to NGCBUILD completion: 1 sec
Total CPU time to NGCBUILD completion:
1 sec
Writing NGCBUILD log file "../implementation/system.blc"...
NGCBUILD done.
Done!
• Modifique o interrupt_handler
– <diretório>/drivers/interrupt_v1_00_a/src/interrupt.c
– Acrescente no final da função
INTERRUPT_Intr_DefaultHandler (linha 66):
INTERRUPT_mWriteSlaveReg0(baseaddr, 0, 1);
– O significado é: ao ocorrer a interrupção pelo
hardware do usuário, a função interrupt_handler
escreve o valor 1 no registrador 0 do periférico (ele
será utilizado como semáforo)
Abrir e editar o código fonte da aplicação
Marcar a aplicação
TestApp_Memory
como Inativa
Marcar a aplicação
TestApp_Peripheral
para inicializar
BRAM (ou seja, vai
ser carregada no
bitstream)
Abrir o código C
Escrevendo o software com suporte a interrupção
• Lembrar: já temos o interrupt_handler alterado
• Inclua entre os includes e o main o seguinte código
– Impressão dos 4 registradores internos do periférico de interrupção
#include "interrupt.h"
void print_registers()
{ Xuint32 r1, r2, r3, r4;
r1 = INTERRUPT_mReadSlaveReg0(XPAR_INTERRUPT_0_BASEADDR,
r2 = INTERRUPT_mReadSlaveReg1(XPAR_INTERRUPT_0_BASEADDR,
r3 = INTERRUPT_mReadSlaveReg2(XPAR_INTERRUPT_0_BASEADDR,
r4 = INTERRUPT_mReadSlaveReg3(XPAR_INTERRUPT_0_BASEADDR,
xil_printf("%d %d %d %d\n\r", r1, r2, r3, r4 );
0);
0);
0);
0);
// copiar os defines do .h
}
Protótipo em: <file>\microblaze_0\include\interrupt.h
Endereço em: <file>\microblaze_0\include\xparameters.h
Ao final do código main inclua:
{
int i, j, vet[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
print("-- **** 2012/1 ** prototipacao - teste de interrupcao
-----\r\n");
microblaze_enable_interrupts();
INTERRUPT_Intr_DefaultHandler( (void*) XPAR_INTERRUPT_0_BASEADDR);
INTERRUPT_EnableInterrupt((void*) XPAR_INTERRUPT_0_BASEADDR);
for(i=0; i<20; i++) {
INTERRUPT_EnableInterrupt((void*) XPAR_INTERRUPT_0_BASEADDR);
j=i%10;
// escreve nos 3 registradores iniciais do periférico (o primeiro reg é um semaforo)
INTERRUPT_mWriteSlaveReg1(XPAR_INTERRUPT_0_BASEADDR, 0, vet[j]+10);
INTERRUPT_mWriteSlaveReg2(XPAR_INTERRUPT_0_BASEADDR, 0, vet[j]+20);
INTERRUPT_mWriteSlaveReg3(XPAR_INTERRUPT_0_BASEADDR, 0, vet[j]+30);
// aguarda que a interrupo ocorra para imprimir os valores dos registradores
while( ! (INTERRUPT_mReadSlaveReg0(XPAR_INTERRUPT_0_BASEADDR, 0)));
// limpa o semaforo
INTERRUPT_mWriteSlaveReg0(XPAR_INTERRUPT_0_BASEADDR, 0, 0);
print_registers();
}
}
Inicializa o controlador de interrupção,
escreve no periférico, aguarda a interrupção
e imprime os valores escritos
Compilação e geração do bitstream
• Hardware  Generate Bitstream
• Só a primeira vez, demora
• Software  Build All User Application
• Device Configuration  Update Bitstream
– A cada alteração do software – update bitstream
IV – Utilização do Sistema
ir para um PC
não resolvida a questão do downloand
e serial no LINUX
Trabalho a fazer
• Depois de validado o projeto, realizar no
Linux com uma interface serial
Conexão com a porta serial
• Abrir o aplicativo HyperTerminal (do
windows) e configurar a conexão como
abaixo: (em accessories communication)
Para determinar a velocidade da serial olhar em
<diretório>/microblaze_0/include/xparameters.h
os parâmetros da UART:
/* Definitions for peripheral RS232_DCE */
#define XPAR_RS232_DCE_BASEADDR 0x84000000
#define XPAR_RS232_DCE_HIGHADDR 0x8400FFFF
#define XPAR_RS232_DCE_DEVICE_ID 0
#define XPAR_RS232_DCE_BAUDRATE 57600
#define XPAR_RS232_DCE_USE_PARITY 0
#define XPAR_RS232_DCE_ODD_PARITY 0
#define XPAR_RS232_DCE_DATA_BITS 8
Download do bitstream
• Device Configuration  Download
• Ou pode-se utilizar o impact, arquivo
download.bit (dentro do diretório implementation)
Visualização dos resultados
Termina aqui – a outra seção não foi atualizada
VI – Debug passo a passo
(opcional)
Debug usando GDB e execução passo a passo
•
Seguir as instruções do documento (funciona da mesma forma para a versão 10)
http://www.inf.pucrs.br/~moraes/prototip/lab3/EDK8.1_Spartan3.pdf das páginas 26 a 20,
sessão “Debugging the Design”