1 / 47

Tutorial EDK – Embedded Development Kit

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

wren
Télécharger la présentation

Tutorial EDK – Embedded Development Kit

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript


  1. TutorialEDK – Embedded Development Kit REVISADO POR MORAES EM 31/maio/2012

  2. 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

  3. Definição • O XPS permite a criação de arquiteturas de hardware microprocessadas, disponibilizando dois IPs de processadores: • Softcore MicroBlaze (Xilinx) • Hardcore PowerPC405 (IBM)

  4. 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

  5. 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

  6. 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/

  7. I – Criação da arquitetura base, para uma dada placa de prototipação

  8. Criação do projeto • Executar na linha de comando - Criar um novo projeto • xps (pode demorar...)

  9. Criação do projeto – seleção da placa

  10. Criação do projeto – número de processadores

  11. Criação do projeto – memória do processador

  12. 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)

  13. Escolha das aplicações de teste • São geradas duas aplicações exemplos – teste de memória e teste de periféricos

  14. Resumo do projeto • Verifique as mensagens e Finish

  15. Gerado o sistema de base obtemos a seguinte janela

  16. II – Inserção de um periférico do usuário com suporte à interrupção

  17. 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

  18. O periférico vai ser adicionado a estrutura do projeto atual Nomear o periférico: sugiro usar o mesmo nome - interrupt

  19. 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 Operiférico gerará uma interrupção, sensível a nível

  20. 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

  21. Aqui tem muita informação útil Depois: finish

  22. Arquitetura do sistema • O periferico.vhd é o wrapper entre o barramento OPB e a lógica do usuário. A princípio não precisa alterar. • Ouser_logic é onde o usuário escreve seu hardware.

  23. 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

  24. Segunda etapa : inclusão do periférico no projeto Importar o periférico ao projeto

  25. Importar o periférico cujo template foi modificado na etapa anterior

  26. 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

  27. 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.

  28. A janela seguinte permite acrescentar novos arquivos Olhar que os últimos dois arquivos VHDL compilados referem-se aos arquivos VHDL editados nas etapas anteriores

  29. Indicar que este periférico irá se comunicar pelo barramento PLB, em modo escravo

  30. 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

  31. 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)

  32. 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

  33. Gerar endereço para o novo periférico

  34. III – Geração do bitstreame software do usuário

  35. 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!

  36. 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)

  37. 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

  38. 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, 0); // copiar os defines do .h r2 = INTERRUPT_mReadSlaveReg1(XPAR_INTERRUPT_0_BASEADDR, 0); r3 = INTERRUPT_mReadSlaveReg2(XPAR_INTERRUPT_0_BASEADDR, 0); r4 = INTERRUPT_mReadSlaveReg3(XPAR_INTERRUPT_0_BASEADDR, 0); xil_printf("%d %d %d %d\n\r", r1, r2, r3, r4 ); } Protótipo em: <file>\microblaze_0\include\interrupt.h Endereço em: <file>\microblaze_0\include\xparameters.h

  39. 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

  40. 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

  41. IV – Utilização do Sistemair para um PCnão resolvida a questão do downloand e serial no LINUX

  42. Trabalho a fazer • Depois de validado o projeto, realizar no Linux com uma interface serial

  43. 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

  44. Download do bitstream • Device Configuration  Download • Ou pode-se utilizar o impact, arquivo download.bit (dentro do diretório implementation)

  45. Visualização dos resultados Termina aqui – a outra seção não foi atualizada

  46. VI – Debug passo a passo(opcional)

  47. 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”

More Related