[tolich86 0]

Собственно вопрос к тем, кто уже сталкивался с этим аналоговым семейством.

 

Есть проект (100% рабочий) написанный для LPC1114.

Все прерывания, какие нужно (внешние пины + UART + таймеры) работают без нареканий.

Ну и SYSTICK соответственно, куда без него :)

 

В дальнейшем развитии проекта потребовалось поиметь ЦАП, в результате пришлось применить LPC11A14

С ЦАПом никаких проблем, в пробном примере синусоида очень красивая получилась :)

Вот только кроме SYSTICK больше никаких прерываний на этом кристалле нет :(

 

В отладке (среда LPCXpresso) смотрю на NVIC, вроде все битики правильно устанавливаются, как и в LPC11xx.

А в п/п прерывания никак не попасть, ни в таймерные, ни во внешние.

UART не проверял, в этом проекте он не нужен.

 

Подскажите, в чем может быть дело, и чем-же отличаются LPC11A14 и LPC1114 кроме ЦАПа, ведь ядро, по моему, должно бы тем-же :01:

Изменено 16 октября, 2013 пользователем IgorKossak
censored

[megajohn 3]

вчера с этим столкнулся но на IAR

в 6,3 стартапы с векторами DefaultHalndler

а в 6,5 вектора вроде в норме но не компилится

 

вообщем, выложите файлы cortex_m.s или startup_lpc11xx.s ( в иар так называются, а как у вас увы не знаю )

[nowhow 0]

Скорее всего, изменили таблицу векторов прерываний, столкнулся с этим когда переходил с lpc11xx на lpc11Uxx.

[tolich86 0]

Ниже приведен код файла cr_startup_lpc11a.c

 

//*****************************************************************************
//   +--+	   
//   | ++----+   
//   +-++	|  
//	 |	 |  
//   +-+--+  |   
//   | +--+--+  
//   +----+	Copyright © 2012 Code Red Technologies Ltd.
//
// LPC11A Microcontroller Startup code for use with Red Suite
//
// Version : 120418
//
// Software License Agreement
// 
// The software is owned by Code Red Technologies and/or its suppliers, and is 
// protected under applicable copyright laws.  All rights are reserved.  Any 
// use in violation of the foregoing restrictions may subject the user to criminal 
// sanctions under applicable laws, as well as to civil liability for the breach 
// of the terms and conditions of this license.
// 
// THIS SOFTWARE IS PROVIDED "AS IS".  NO WARRANTIES, WHETHER EXPRESS, IMPLIED
// OR STATUTORY, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF
// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE APPLY TO THIS SOFTWARE.
// USE OF THIS SOFTWARE FOR COMMERCIAL DEVELOPMENT AND/OR EDUCATION IS SUBJECT
// TO A CURRENT END USER LICENSE AGREEMENT (COMMERCIAL OR EDUCATIONAL) WITH
// CODE RED TECHNOLOGIES LTD. 
//
//*****************************************************************************
#if defined (__cplusplus)
#ifdef __REDLIB__
#error Redlib does not support C++
#else
//*****************************************************************************
//
// The entry point for the C++ library startup
//
//*****************************************************************************
extern "C" {
extern void __libc_init_array(void);
}
#endif
#endif

#define WEAK __attribute__ ((weak))
#define ALIAS(f) __attribute__ ((weak, alias (#f)))

// Code Red - if CMSIS is being used, then SystemInit() routine
// will be called by startup code rather than in application's main()
#if defined (__USE_CMSIS)
#include "D:\LPCXpresso_4.3.0_1023\workspace\CMSIS_CORE_LPC11Axx\inc\LPC11Axx.h"
#endif

//*****************************************************************************
#if defined (__cplusplus)
extern "C" {
#endif

//*****************************************************************************
//
// Forward declaration of the default handlers. These are aliased.
// When the application defines a handler (with the same name), this will 
// automatically take precedence over these weak definitions
//
//*****************************************************************************
 void ResetISR(void);
WEAK void NMI_Handler(void);
WEAK void HardFault_Handler(void);
WEAK void SVC_Handler(void);
WEAK void PendSV_Handler(void);
WEAK void SysTick_Handler(void);
WEAK void IntDefaultHandler(void);
//*****************************************************************************
//
// Forward declaration of the specific IRQ handlers. These are aliased
// to the IntDefaultHandler, which is a 'forever' loop. When the application
// defines a handler (with the same name), this will automatically take
// precedence over these weak definitions
//
//*****************************************************************************

void PIN_INT0_IRQHandler (void) ALIAS(IntDefaultHandler);
void PIN_INT1_IRQHandler (void) ALIAS(IntDefaultHandler);
void PIN_INT2_IRQHandler (void) ALIAS(IntDefaultHandler);
void PIN_INT3_IRQHandler (void) ALIAS(IntDefaultHandler);
void PIN_INT4_IRQHandler (void) ALIAS(IntDefaultHandler);
void PIN_INT5_IRQHandler (void) ALIAS(IntDefaultHandler);
void PIN_INT6_IRQHandler (void) ALIAS(IntDefaultHandler);
void PIN_INT7_IRQHandler (void) ALIAS(IntDefaultHandler);
void GINT0_IRQHandler (void) ALIAS(IntDefaultHandler);
void GINT1_IRQHandler (void) ALIAS(IntDefaultHandler);
void ACMP_IRQHandler (void) ALIAS(IntDefaultHandler);
void DAC_IRQHandler (void) ALIAS(IntDefaultHandler);
void SSP1_IRQHandler (void) ALIAS(IntDefaultHandler);
void I2C_IRQHandler (void) ALIAS(IntDefaultHandler);
void TIMER16_0_IRQHandler (void) ALIAS(IntDefaultHandler);
void TIMER16_1_IRQHandler (void) ALIAS(IntDefaultHandler);
void TIMER32_0_IRQHandler (void) ALIAS(IntDefaultHandler);
void TIMER32_1_IRQHandler (void) ALIAS(IntDefaultHandler);
void SSP0_IRQHandler (void) ALIAS(IntDefaultHandler);
void USART_IRQHandler (void) ALIAS(IntDefaultHandler);
void ADC_IRQHandler (void) ALIAS(IntDefaultHandler);
void WDT_IRQHandler (void) ALIAS(IntDefaultHandler);
void BOD_IRQHandler (void) ALIAS(IntDefaultHandler);
void FMC_IRQHandler (void) ALIAS(IntDefaultHandler);

//*****************************************************************************
//
// The entry point for the application.
// __main() is the entry point for redlib based applications
// main() is the entry point for newlib based applications
//
//*****************************************************************************
//
// The entry point for the application.
// __main() is the entry point for Redlib based applications
// main() is the entry point for Newlib based applications
//
//*****************************************************************************
#if defined (__REDLIB__)
extern void __main(void);
#endif
extern int main(void);
//*****************************************************************************
//
// External declaration for the pointer to the stack top from the Linker Script
//
//*****************************************************************************
extern void _vStackTop(void);

//*****************************************************************************
#if defined (__cplusplus)
} // extern "C"
#endif
//*****************************************************************************
//
// The vector table.  Note that the proper constructs must be placed on this to
// ensure that it ends up at physical address 0x0000.0000.
//
//*****************************************************************************
extern void (* const g_pfnVectors[])(void);
__attribute__ ((section(".isr_vector")))
void (* const g_pfnVectors[])(void) = {
&_vStackTop,				  // The initial stack pointer
ResetISR,					 // The reset handler
NMI_Handler,				  // The NMI handler
HardFault_Handler,			// The hard fault handler
0,							// Reserved
0,							// Reserved
0,							// Reserved
0,							// Reserved
0,							// Reserved
0,							// Reserved
0,							// Reserved
SVC_Handler,				  // SVCall handler
0,							// Reserved
0,							// Reserved
PendSV_Handler,			   // The PendSV handler
SysTick_Handler,			  // The SysTick handler

// LPC11A specific handlers
PIN_INT0_IRQHandler,		  // 16+ 0: Pin interrupt
PIN_INT1_IRQHandler,		  // 16+ 1: Pin interrupt
PIN_INT2_IRQHandler,		  // 16+ 2: Pin interrupt
PIN_INT3_IRQHandler,		  // 16+ 3: Pin interrupt
PIN_INT4_IRQHandler,		  // 16+ 4: Pin interrupt
PIN_INT5_IRQHandler,		  // 16+ 5: Pin interrupt
PIN_INT6_IRQHandler,		  // 16+ 6: Pin interrupt
PIN_INT7_IRQHandler,		  // 16+ 7: Pin interrupt
GINT0_IRQHandler,			 // 16+ 8: Port interrupt
GINT1_IRQHandler,			 // 16+ 9: Port interrupt
ACMP_IRQHandler,			  // 16+10: Analog Comparator
DAC_IRQHandler,			   // 16+11: D/A Converter
0,							// 16+12: Reserved
0,							// 16+13: Reserved
SSP1_IRQHandler,			  // 16+14: SSP1
I2C_IRQHandler,			   // 16+15: I2C
TIMER16_0_IRQHandler,		 // 16+16: 16-bit Timer0
TIMER16_1_IRQHandler,		 // 16+17: 16-bit Timer1
TIMER32_0_IRQHandler,		 // 16+18: 32-bit Timer0
TIMER32_1_IRQHandler,		 // 16+19: 32-bit Timer1
SSP0_IRQHandler,			  // 16+20: SSP0
USART_IRQHandler,			 // 16+21: USART
0,							// 16+22: Reserved
0,							// 16+23: Reserved
ADC_IRQHandler,			   // 16+24: A/D Converter
WDT_IRQHandler,			   // 16+25: Watchdog Timer
BOD_IRQHandler,			   // 16+26: Brown Out Detect
FMC_IRQHandler,			   // 16+27: IP2111 Flash Memory Controller
0,							// 16+28: Reserved
0,							// 16+29: ReserveD
0,							// 16+30: Reserved
0,							// 16+31: Reserved

};

//*****************************************************************************
// Functions to carry out the initialization of RW and BSS data sections. These
// are written as separate functions rather than being inlined within the
// ResetISR() function in order to cope with MCUs with multiple banks of
// memory.
//*****************************************************************************
__attribute__ ((section(".after_vectors")))
void data_init(unsigned int romstart, unsigned int start, unsigned int len) {
unsigned int *pulDest = (unsigned int*) start;
unsigned int *pulSrc = (unsigned int*) romstart;
unsigned int loop;
for (loop = 0; loop < len; loop = loop + 4)
	*pulDest++ = *pulSrc++;
}

__attribute__ ((section(".after_vectors")))
void bss_init(unsigned int start, unsigned int len) {
unsigned int *pulDest = (unsigned int*) start;
unsigned int loop;
for (loop = 0; loop < len; loop = loop + 4)
	*pulDest++ = 0;
}

//*****************************************************************************
// The following symbols are constructs generated by the linker, indicating
// the location of various points in the "Global Section Table". This table is
// created by the linker via the Code Red managed linker script mechanism. It
// contains the load address, execution address and length of each RW data
// section and the execution and length of each BSS (zero initialized) section.
//*****************************************************************************
extern unsigned int __data_section_table;
extern unsigned int __data_section_table_end;
extern unsigned int __bss_section_table;
extern unsigned int __bss_section_table_end;

//*****************************************************************************
// Reset entry point for your code.
// Sets up a simple runtime environment and initializes the C/C++
// library.
//*****************************************************************************
__attribute__ ((section(".after_vectors")))
void
ResetISR(void) {

//
// Copy the data sections from flash to SRAM.
//
unsigned int LoadAddr, ExeAddr, SectionLen;
unsigned int *SectionTableAddr;

// Load base address of Global Section Table
SectionTableAddr = &__data_section_table;

// Copy the data sections from flash to SRAM.
while (SectionTableAddr < &__data_section_table_end) {
	LoadAddr = *SectionTableAddr++;
	ExeAddr = *SectionTableAddr++;
	SectionLen = *SectionTableAddr++;
	data_init(LoadAddr, ExeAddr, SectionLen);
}
// At this point, SectionTableAddr = &__bss_section_table;
// Zero fill the bss segment
while (SectionTableAddr < &__bss_section_table_end) {
	ExeAddr = *SectionTableAddr++;
	SectionLen = *SectionTableAddr++;
	bss_init(ExeAddr, SectionLen);
}

#ifdef __USE_CMSIS
SystemInit();
#endif

#if defined (__cplusplus)
//
// Call C++ library initialisation
//
__libc_init_array();
#endif

#if defined (__REDLIB__)
// Call the Redlib library, which in turn calls main()
__main();
#else
main();
#endif
//
// main() shouldn't return, but if it does, we'll just enter an infinite loop
//
while (1) {
;
}
}

//*****************************************************************************
// Default exception handlers. Override the ones here by defining your own
// handler routines in your application code.
//*****************************************************************************
__attribute__ ((section(".after_vectors")))
void NMI_Handler(void)
{
while(1)
{
}
}
__attribute__ ((section(".after_vectors")))
void HardFault_Handler(void)
{
while(1)
{
}
}
__attribute__ ((section(".after_vectors")))
void SVC_Handler(void)
{
while(1)
{
}
}
__attribute__ ((section(".after_vectors")))
void PendSV_Handler(void)
{
while(1)
{
}
}
__attribute__ ((section(".after_vectors")))
void SysTick_Handler(void)
{
while(1)
{
}
}

//*****************************************************************************
//
// Processor ends up here if an unexpected interrupt occurs or a specific
// handler is not present in the application code.
//
//*****************************************************************************
__attribute__ ((section(".after_vectors")))
void IntDefaultHandler(void)
{
while(1)
{
}
}

 

Скорее всего, изменили таблицу векторов прерываний, столкнулся с этим когда переходил с lpc11xx на lpc11Uxx.

 

Собственно говоря в таблицу вообще не лазил, понадеялся на то, что в CMSIS все будет прописано правильно.

Ну не зря-же эту самую CMSIS везде описывают, как идеальное средство для быстрого переноса программ ...

Изменено 17 октября, 2013 пользователем Толич