Keil LPC2138

[andreumberto]

Olá amigos,
eu estou migrando o meu projeto do IAR para o Keil, mas defrontei com um problema que não consigo encontrar o que pode estar acontecendo.
Fiz um programa simples, ele está compilando e debugando corretamente, mas quando eu gravo o arquivo .hex no microcontrolador não funciona nada. Eu estou desconfiado que estou deixando de fazer alguma configuração no Keil. Aklguem tem alguma idéia ai?
Gravei outro arquivo .hex gerado pelo IAR e esá tudo certo.
Alguem que utiliza o Keil com LPC2138 pode passar para mim um printSreen da tela de configuração dele?

Valeu pela força
André

[austrax]

Fala André,

Vou ressucitar meu lpc2148 e faço um exemplo aqui pra te mandar. Aí vc compara e tenta descobrir o que está acontecendo.

[MarcusPonce]

Eu seguiria os passos:

a)
Informar ao Keil no menu Project/Options for target que está usando um LPC2138 na aba Device. Na mesma janela, aba Target informe o clock. Na aba Output ligue o "create hex file". Parece que este você fez.


b)No startup.s:
ligue VPBDIV,
faça vpbdiv: vpb clock = cpu clock,
xclkdiv = cpu clock/4
ligue PLL setup (atenção: estou usando xtal = 12Mhz)
msel = 5
psel = 2
ligue MAM setup
MAM control = fully enabled
MAM timing = 3

Se seu projeto usa muito espaço para variáveis ou arrrays que são alocadas e desalocadas em run time então você tem que ajustar manualmente o HEAP, pois o Keil não faz isso. Ele aloca o mesmo espaço na RAM seja para o LPC2132 ou LPC2138 e é pouco.
Mude no startup.s:
Heap Size = 0x0000 1000 (alocando 4kbytes, por exemplo)


c)
Quando seu projeto sendo migrado é compilado no Keil, aparece alguma warning ?


[/img]

[andreumberto]

então...

quando eu configuro lá no menu Project/Options na aba Target para ele operar com o cristal de 20MHz ele não altera sozinho estes parametros do arquivo Startup.s?

Acho que tá ai o meu problema, estou usando o cristal de 20MHz.
Eu sou meio lerdo para entender esta coisa clock, lá no IAR já ficava tudo certinho.

segue a baixo como esta configurado o Startup.s>

Marcus, me ajuda ai para alterar os parametros para ele operar com 20MHz?

Valeu.

;/*****************************************************************************/
;/* STARTUP.S: Startup file for Philips LPC2000 */
;/*****************************************************************************/
;/* <<< Use Configuration Wizard in Context Menu >>> */
;/*****************************************************************************/
;/* This file is part of the uVision/ARM development tools. */
;/* Copyright (c) 2005-2007 Keil Software. All rights reserved. */
;/* This software may only be used under the terms of a valid, current, */
;/* end user licence from KEIL for a compatible version of KEIL software */
;/* development tools. Nothing else gives you the right to use this software. */
;/*****************************************************************************/


;/*
; * The STARTUP.S code is executed after CPU Reset. This file may be
; * translated with the following SET symbols. In uVision these SET
; * symbols are entered under Options - ASM - Define.
; *
; * REMAP: when set the startup code initializes the register MEMMAP
; * which overwrites the settings of the CPU configuration pins. The
; * startup and interrupt vectors are remapped from:
; * 0x00000000 default setting (not remapped)
; * 0x80000000 when EXTMEM_MODE is used
; * 0x40000000 when RAM_MODE is used
; *
; * EXTMEM_MODE: when set the device is configured for code execution
; * from external memory starting at address 0x80000000.
; *
; * RAM_MODE: when set the device is configured for code execution
; * from on-chip RAM starting at address 0x40000000.
; *
; * EXTERNAL_MODE: when set the PIN2SEL values are written that enable
; * the external BUS at startup.
; */


; Standard definitions of Mode bits and Interrupt (I & F) flags in PSRs

Mode_USR EQU 0x10
Mode_FIQ EQU 0x11
Mode_IRQ EQU 0x12
Mode_SVC EQU 0x13
Mode_ABT EQU 0x17
Mode_UND EQU 0x1B
Mode_SYS EQU 0x1F

I_Bit EQU 0x80 ; when I bit is set, IRQ is disabled
F_Bit EQU 0x40 ; when F bit is set, FIQ is disabled


;// <h> Stack Configuration (Stack Sizes in Bytes)
;// <o0> Undefined Mode <0x0-0xFFFFFFFF:8>
;// <o1> Supervisor Mode <0x0-0xFFFFFFFF:8>
;// <o2> Abort Mode <0x0-0xFFFFFFFF:8>
;// <o3> Fast Interrupt Mode <0x0-0xFFFFFFFF:8>
;// <o4> Interrupt Mode <0x0-0xFFFFFFFF:8>
;// <o5> User/System Mode <0x0-0xFFFFFFFF:8>
;// </h>

UND_Stack_Size EQU 0x00000000
SVC_Stack_Size EQU 0x00000008
ABT_Stack_Size EQU 0x00000000
FIQ_Stack_Size EQU 0x00000000
IRQ_Stack_Size EQU 0x00000080
USR_Stack_Size EQU 0x00000400

ISR_Stack_Size EQU (UND_Stack_Size + SVC_Stack_Size + ABT_Stack_Size + \
FIQ_Stack_Size + IRQ_Stack_Size)

AREA STACK, NOINIT, READWRITE, ALIGN=3

Stack_Mem SPACE USR_Stack_Size
__initial_sp SPACE ISR_Stack_Size

Stack_Top


;// <h> Heap Configuration
;// <o> Heap Size (in Bytes) <0x0-0xFFFFFFFF>
;// </h>

Heap_Size EQU 0x00000000

AREA HEAP, NOINIT, READWRITE, ALIGN=3
__heap_base
Heap_Mem SPACE Heap_Size
__heap_limit


; VPBDIV definitions
VPBDIV EQU 0xE01FC100 ; VPBDIV Address

;// <e> VPBDIV Setup
;// <i> Peripheral Bus Clock Rate
;// <o1.0..1> VPBDIV: VPB Clock
;// <0=> VPB Clock = CPU Clock / 4
;// <1=> VPB Clock = CPU Clock
;// <2=> VPB Clock = CPU Clock / 2
;// <o1.4..5> XCLKDIV: XCLK Pin
;// <0=> XCLK Pin = CPU Clock / 4
;// <1=> XCLK Pin = CPU Clock
;// <2=> XCLK Pin = CPU Clock / 2
;// </e>
VPBDIV_SETUP EQU 0
VPBDIV_Val EQU 0x00000000


; Phase Locked Loop (PLL) definitions
PLL_BASE EQU 0xE01FC080 ; PLL Base Address
PLLCON_OFS EQU 0x00 ; PLL Control Offset
PLLCFG_OFS EQU 0x04 ; PLL Configuration Offset
PLLSTAT_OFS EQU 0x08 ; PLL Status Offset
PLLFEED_OFS EQU 0x0C ; PLL Feed Offset
PLLCON_PLLE EQU (1<<0) ; PLL Enable
PLLCON_PLLC EQU (1<<1) ; PLL Connect
PLLCFG_MSEL EQU (0x1F<<0) ; PLL Multiplier
PLLCFG_PSEL EQU (0x03<<5) ; PLL Divider
PLLSTAT_PLOCK EQU (1<<10) ; PLL Lock Status

;// <e> PLL Setup
;// <o1.0..4> MSEL: PLL Multiplier Selection
;// <1-32><#-1>
;// <i> M Value
;// <o1.5..6> PSEL: PLL Divider Selection
;// <0=> 1 <1=> 2 <2=> 4 <3=> 8
;// <i> P Value
;// </e>
PLL_SETUP EQU 1
PLLCFG_Val EQU 0x00000024


; Memory Accelerator Module (MAM) definitions
MAM_BASE EQU 0xE01FC000 ; MAM Base Address
MAMCR_OFS EQU 0x00 ; MAM Control Offset
MAMTIM_OFS EQU 0x04 ; MAM Timing Offset

;// <e> MAM Setup
;// <o1.0..1> MAM Control
;// <0=> Disabled
;// <1=> Partially Enabled
;// <2=> Fully Enabled
;// <i> Mode
;// <o2.0..2> MAM Timing
;// <0=> Reserved <1=> 1 <2=> 2 <3=> 3
;// <4=> 4 <5=> 5 <6=> 6 <7=> 7
;// <i> Fetch Cycles
;// </e>
MAM_SETUP EQU 1
MAMCR_Val EQU 0x00000002
MAMTIM_Val EQU 0x00000003


; External Memory Controller (EMC) definitions
EMC_BASE EQU 0xFFE00000 ; EMC Base Address
BCFG0_OFS EQU 0x00 ; BCFG0 Offset
BCFG1_OFS EQU 0x04 ; BCFG1 Offset
BCFG2_OFS EQU 0x08 ; BCFG2 Offset
BCFG3_OFS EQU 0x0C ; BCFG3 Offset

;// <e> External Memory Controller (EMC)
EMC_SETUP EQU 0

;// <e> Bank Configuration 0 (BCFG0)
;// <o1.0..3> IDCY: Idle Cycles <0-15>
;// <o1.5..9> WST1: Wait States 1 <0-31>
;// <o1.11..15> WST2: Wait States 2 <0-31>
;// <o1.10> RBLE: Read Byte Lane Enable
;// <o1.26> WP: Write Protect
;// <o1.27> BM: Burst ROM
;// <o1.28..29> MW: Memory Width <0=> 8-bit <1=> 16-bit
;// <2=> 32-bit <3=> Reserved
;// </e>
BCFG0_SETUP EQU 0
BCFG0_Val EQU 0x0000FBEF

;// <e> Bank Configuration 1 (BCFG1)
;// <o1.0..3> IDCY: Idle Cycles <0-15>
;// <o1.5..9> WST1: Wait States 1 <0-31>
;// <o1.11..15> WST2: Wait States 2 <0-31>
;// <o1.10> RBLE: Read Byte Lane Enable
;// <o1.26> WP: Write Protect
;// <o1.27> BM: Burst ROM
;// <o1.28..29> MW: Memory Width <0=> 8-bit <1=> 16-bit
;// <2=> 32-bit <3=> Reserved
;// </e>
BCFG1_SETUP EQU 0
BCFG1_Val EQU 0x0000FBEF

;// <e> Bank Configuration 2 (BCFG2)
;// <o1.0..3> IDCY: Idle Cycles <0-15>
;// <o1.5..9> WST1: Wait States 1 <0-31>
;// <o1.11..15> WST2: Wait States 2 <0-31>
;// <o1.10> RBLE: Read Byte Lane Enable
;// <o1.26> WP: Write Protect
;// <o1.27> BM: Burst ROM
;// <o1.28..29> MW: Memory Width <0=> 8-bit <1=> 16-bit
;// <2=> 32-bit <3=> Reserved
;// </e>
BCFG2_SETUP EQU 0
BCFG2_Val EQU 0x0000FBEF

;// <e> Bank Configuration 3 (BCFG3)
;// <o1.0..3> IDCY: Idle Cycles <0-15>
;// <o1.5..9> WST1: Wait States 1 <0-31>
;// <o1.11..15> WST2: Wait States 2 <0-31>
;// <o1.10> RBLE: Read Byte Lane Enable
;// <o1.26> WP: Write Protect
;// <o1.27> BM: Burst ROM
;// <o1.28..29> MW: Memory Width <0=> 8-bit <1=> 16-bit
;// <2=> 32-bit <3=> Reserved
;// </e>
BCFG3_SETUP EQU 0
BCFG3_Val EQU 0x0000FBEF

;// </e> End of EMC


; External Memory Pins definitions
PINSEL2 EQU 0xE002C014 ; PINSEL2 Address
PINSEL2_Val EQU 0x0E6149E4 ; CS0..3, OE, WE, BLS0..3,
; D0..31, A2..23, JTAG Pins


PRESERVE8


; Area Definition and Entry Point
; Startup Code must be linked first at Address at which it expects to run.

AREA RESET, CODE, READONLY
ARM


; Exception Vectors
; Mapped to Address 0.
; Absolute addressing mode must be used.
; Dummy Handlers are implemented as infinite loops which can be modified.

Vectors LDR PC, Reset_Addr
LDR PC, Undef_Addr
LDR PC, SWI_Addr
LDR PC, PAbt_Addr
LDR PC, DAbt_Addr
NOP ; Reserved Vector
; LDR PC, IRQ_Addr
LDR PC, [PC, #-0x0FF0] ; Vector from VicVectAddr
LDR PC, FIQ_Addr

Reset_Addr DCD Reset_Handler
Undef_Addr DCD Undef_Handler
SWI_Addr DCD SWI_Handler
PAbt_Addr DCD PAbt_Handler
DAbt_Addr DCD DAbt_Handler
DCD 0 ; Reserved Address
IRQ_Addr DCD IRQ_Handler
FIQ_Addr DCD FIQ_Handler

Undef_Handler B Undef_Handler
SWI_Handler B SWI_Handler
PAbt_Handler B PAbt_Handler
DAbt_Handler B DAbt_Handler
IRQ_Handler B IRQ_Handler
FIQ_Handler B FIQ_Handler


; Reset Handler

EXPORT Reset_Handler
Reset_Handler


; Setup External Memory Pins
IF EF:EXTERNAL_MODE
LDR R0, =PINSEL2
LDR R1, =PINSEL2_Val
STR R1, [R0]
ENDIF


; Setup External Memory Controller
IF EMC_SETUP <> 0
LDR R0, =EMC_BASE

IF BCFG0_SETUP <> 0
LDR R1, =BCFG0_Val
STR R1, [R0, #BCFG0_OFS]
ENDIF

IF BCFG1_SETUP <> 0
LDR R1, =BCFG1_Val
STR R1, [R0, #BCFG1_OFS]
ENDIF

IF BCFG2_SETUP <> 0
LDR R1, =BCFG2_Val
STR R1, [R0, #BCFG2_OFS]
ENDIF

IF BCFG3_SETUP <> 0
LDR R1, =BCFG3_Val
STR R1, [R0, #BCFG3_OFS]
ENDIF

ENDIF ; EMC_SETUP


; Setup VPBDIV
IF VPBDIV_SETUP <> 0
LDR R0, =VPBDIV
LDR R1, =VPBDIV_Val
STR R1, [R0]
ENDIF


; Setup PLL
IF PLL_SETUP <> 0
LDR R0, =PLL_BASE
MOV R1, #0xAA
MOV R2, #0x55

; Configure and Enable PLL
MOV R3, #PLLCFG_Val
STR R3, [R0, #PLLCFG_OFS]
MOV R3, #PLLCON_PLLE
STR R3, [R0, #PLLCON_OFS]
STR R1, [R0, #PLLFEED_OFS]
STR R2, [R0, #PLLFEED_OFS]

; Wait until PLL Locked
PLL_Loop LDR R3, [R0, #PLLSTAT_OFS]
ANDS R3, R3, #PLLSTAT_PLOCK
BEQ PLL_Loop

; Switch to PLL Clock
MOV R3, #(PLLCON_PLLE:OR:PLLCON_PLLC)
STR R3, [R0, #PLLCON_OFS]
STR R1, [R0, #PLLFEED_OFS]
STR R2, [R0, #PLLFEED_OFS]
ENDIF ; PLL_SETUP


; Setup MAM
IF MAM_SETUP <> 0
LDR R0, =MAM_BASE
MOV R1, #MAMTIM_Val
STR R1, [R0, #MAMTIM_OFS]
MOV R1, #MAMCR_Val
STR R1, [R0, #MAMCR_OFS]
ENDIF ; MAM_SETUP


; Memory Mapping (when Interrupt Vectors are in RAM)
MEMMAP EQU 0xE01FC040 ; Memory Mapping Control
IF EF:REMAP
LDR R0, =MEMMAP
IF EF:EXTMEM_MODE
MOV R1, #3
ELIF EF:RAM_MODE
MOV R1, #2
ELSE
MOV R1, #1
ENDIF
STR R1, [R0]
ENDIF


; Initialise Interrupt System
; ...


; Setup Stack for each mode

LDR R0, =Stack_Top

; Enter Undefined Instruction Mode and set its Stack Pointer
MSR CPSR_c, #Mode_UND:OR:I_Bit:OR:F_Bit
MOV SP, R0
SUB R0, R0, #UND_Stack_Size

; Enter Abort Mode and set its Stack Pointer
MSR CPSR_c, #Mode_ABT:OR:I_Bit:OR:F_Bit
MOV SP, R0
SUB R0, R0, #ABT_Stack_Size

; Enter FIQ Mode and set its Stack Pointer
MSR CPSR_c, #Mode_FIQ:OR:I_Bit:OR:F_Bit
MOV SP, R0
SUB R0, R0, #FIQ_Stack_Size

; Enter IRQ Mode and set its Stack Pointer
MSR CPSR_c, #Mode_IRQ:OR:I_Bit:OR:F_Bit
MOV SP, R0
SUB R0, R0, #IRQ_Stack_Size

; Enter Supervisor Mode and set its Stack Pointer
MSR CPSR_c, #Mode_SVC:OR:I_Bit:OR:F_Bit
MOV SP, R0
SUB R0, R0, #SVC_Stack_Size

; Enter User Mode and set its Stack Pointer
MSR CPSR_c, #Mode_USR
IF EF:__MICROLIB

EXPORT __initial_sp

ELSE

MOV SP, R0
SUB SL, SP, #USR_Stack_Size

ENDIF


; Enter the C code

IMPORT __main
LDR R0, =__main
BX R0


IF EF:__MICROLIB

EXPORT __heap_base
EXPORT __heap_limit

ELSE
; User Initial Stack & Heap
AREA |.text|, CODE, READONLY

IMPORT __use_two_region_memory
EXPORT __user_initial_stackheap
__user_initial_stackheap

LDR R0, = Heap_Mem
LDR R1, =(Stack_Mem + USR_Stack_Size)
LDR R2, = (Heap_Mem + Heap_Size)
LDR R3, = Stack_Mem
BX LR
ENDIF


END

[MarcusPonce]

Realmente o Keil não altera o necessário no startup.s quando você informa o valor do clock. Como você pode escolher entre algumas combinações para o mesmo cristal de forma a equilibrar consumo x velocidade, acho que eles teriam que fazer uma janela mais complexa para escolher e ainda não quiseram investir tempo nisso.

No lugar de alterar o startup.s mudando no código, eu prefiro usar aquela aba que permite alterar direto alguns parâmetros. Ela fica na janela do startup.s logo embaixo do espaço com o código. As janelas de arquivos .c ou .h não apresentam esta aba. Você tem esta aba aí ?

[andreumberto]

Sim acho que é esta aqui "Configuration Wizard", lá tem as configurações assim....

PLL Setup:
MSEL: PLL Multiplier Slection = 5
PSEL: PLL Divider Selection = 2

MAM Setup:
MAM Control = Fully Enabled
MAM Timing = 3


Alterando estes parametros é suficiente para setar em 20MHz?
Poderia me explicar como funciona isso?

Abraços
André

[austrax]

Para calcular esses parametros supondo que o clock de operação desejado seja 60MHz:

MSEL = Clock de operação desejado / valor do cristal
MSEL = 60MHz/20MHz = 3

Como o CCO (oscilador controlado por corrente) deste uC trabalha entre 156MHz e 320MHz temos que achar um valor para o PSEL que multiplicado por (2 x Clock de operação desejado) fique entre esses valores. No caso temos 2 x 60MHz = 120MHz. Se colocarmos o PSEL = 2 teremos 240MHz no CCO.

MSEL=3
PSEL=2

[barboza]

As alterações de clock na janela options, target só se aplica para o modo debug, onde altera a base de tempo da simulação, não alterando nenhum código para isso.

[andreumberto]

Foi dificil de entender mas acho que peguei..

mas o seguinte não resolvei o meu problema, o hardware continua sem funcionar.
To fazendo algo bem simples para que isso funcione mas assim mesmo não tá rolando

Segue o programa exatamente como ele está no meu arquivo .c
outra coisa, ele tá dando uma warning sobre o void main(void)

xx.c(24): warning: #951-D: return type of function "main" must be "int"

--------------------------------------------------

#include <lpc21xx.h> //Microcontrolador utilizado

void main( void )
{
long tempo; //Declara a variável tempo

IO0DIR=0X80000000; //Configura o GPIO0 deixando o pino P031 como saída
IO0PIN=0x00000000; //Inicializa o GPIO em 0

while( 1 )
{
IO0SET=0x80000000; //Liga a saída P031

for (tempo=0;tempo<=40000;tempo++); //Delay para piscar o led

IO0CLR=0x80000000; //Desliga a saída P031

for (tempo=0;tempo<=40000;tempo++); //Delay para piscar o led

}

}

[austrax]

Coloque int main(void) e o warning irá sumir...

Verificou se o porto 0.14 está com pull-up e se o VBat não está em 0 ou flutuando?

[MarcusPonce]

Boa a idéia de testar com um programa mais simples.

O warning sobre main não poder ser void e ter que ser int: não se preocupe.

Estou sem tempo para testar em um hardware, mas verifiquei no simulador do Keil que:

a) se você ligar "Optimize for Time" e ajustar Optimization: level 3 (-O3) então o compilador remove os loops e portanto cada ciclo dura menos de 1us e no pino temos alguns MHz.

b) Se desligar as otimizações então cada ciclo dura alguns ms.

Não sei como você está monitorando o pino. Se você só tem indicação com um LED então coloque o loop para contar até 4000000 (4 milhões)

Este programa funciona se você compilar no IAR ?

[andreumberto]

sim, compilando no IAR e gravando no meu uC ele roda tudo certo, mas com o aquivos .hex gerado pelo keil ele não esta rodando. Eu esotu querendo mudar para o keilpois acho mais intuitovo utlizar ele. Ja usava o keil para programar 8051 e nunca tive problemas serios. Eu instalei um modulo MDK que serve para o ARM, Estou pensando em desinstalar e instalar novamente.
Vou fazer isso amanha e depois eu conto que aconteu, se vc tiver alguma ideia no que pode estar havendo da um toque ai.
Abraços.
Andr[e

[austrax]

Qual versão do keil está usando?

Meu hardware com o 2148 sumiu, mas fiz uma simulação no proteus 7.4 SP3 e tá rodando legal. Veja se dá certo

http://www.megaupload.com/?d=DNWEUMPZ


Para testar no hardware, vá nas opções do Target e na aba Linker, marque a opção "Use Memory Layout from Target Dialog". Observe se no seu projeto essa opção está setada.

Abraço

[andreumberto]

austrax, realmente era isso, falta marcar "Use Memory Layout from Target Dialog".
o que isso faz?
Faz a leitura da memoria interna do uC?

Que otimo, ele tá meio pirado mas agora já tá funcionando.
Valeu ai gelera pela ajuda. deu tudo certo, perdi um tempão só por causa dessa coisa.

Abraços.
André.

[austrax]

Fala André

Essa opção habilita o uso do layout de memória que é configurado na aba Target. Que bão que deu certo.

Abraço
David