Прерывания Cortex-M3, HardFault_Handler Опции

[rat]

Пробую прерывания в EFM32TG210. Пакет IAR 6.3 Код настройки:

//_______*** RTC ***_______

/* Enable RTC clock */
CMU->LFACLKEN0 |= CMU_LFACLKEN0_RTC;

RTC->IEN |= RTC_IEN_COMP0;

RTC->CTRL = RTC_CTRL_COMP0TOP | RTC_CTRL_DEBUGRUN;

RTC->COMP0 = 0x10000;

RTC->IFC = RTC_IFC_COMP0;

NVIC_EnableIRQ(RTC_IRQn);

RTC->CTRL |= RTC_CTRL_EN;

Хандлер:

void RTC_IRQHandler(void);
{
int current_time, next_time;

RTC->IFC = RTC_IFC_COMP0;

RTC->COMP0 = 0x10000;

GPIO->P[1].DOUT = (( 1<< 13) & (~(GPIO->P[1].DOUT)));
}

В дебугере вхожу в хандлер по шагам F11, процесс "зависает" - вернее начинает бежать не по шагам, как будто F5 нажал, когда останавливаешь, то в дизассемблере всякие BusFault_Handler, DebugMon_Handler, HardFault_Handler и т.д. Я прерывания не так настраиваю?

[batisto4ka]

CODE

void EXTI1_IRQHandler(void)
{
static uint8_t ADC1_Channel=1;
static unsigned char Command=ReadChannelData_0;
static unsigned char Channel;
static uint32_t temp=0;
static uint32_t temp1=0;
static uint8_t lenght=0;
static uint32_t mul=0;
static float k=0;
static float b=0;
static uint8_t ADCBuf_ind;
static uint8_t HR_ind;
static uint8_t adcMode;


if (EXTI->PR&(1<<1)) // Прерывание от EXTI1
{
EXTI_ClearITPendingBit(EXTI_Line1);
k=(float)ReadFromFlash(HR_ADDRESS+F_K_ADC*2)/100000;
b=(float)ReadFromFlash(HR_ADDRESS+F_B_ADC*2)/100000;

if (IfValid(ADC_MODE_REG,ReadFromFlash(HR_ADDRESS+F_ADC_MODE_REG*2)))
adcMode=ReadFromFlash(HR_ADDRESS+F_ADC_MODE_REG*2);
else adcMode=0x40;
if ((adcMode==0x20)||(adcMode==0x40))
{
if ((adcMode>>1)&0x01)
{
lenght=3;
mul=0x10000;
}
else
{
lenght=2;
mul=0x100;
}
switch (ADC1_Channel)
{
case 1: {
Channel=ReadChannelData_0;
Command=WriteToModeChannel_2;
HR_ind=ADC_CODE_1;
ADCBuf_ind=0;
ADC1_Channel++;
} break;
case 2: {
Channel=ReadChannelData_1;
Command=WriteToModeChannel_3;
HR_ind=ADC_CODE_2;
ADCBuf_ind=1;
ADC1_Channel++;
} break;
case 3: {
Channel=ReadChannelData_2;
Command=WriteToModeChannel_4;
HR_ind=ADC_CODE_3;
ADCBuf_ind=2;
ADC1_Channel++;
} break;
case 4: {
Channel=ReadChannelData_3;
Command=WriteToModeChannel_1;
HR_ind=ADC_CODE_4;
ADCBuf_ind=3;
ADC1_Channel=1;
} break;
}
temp=WriteToADC(SPI_1,Channel,8,SPI1);
while (lenght)
{
temp1=WriteToADC(SPI_1,0x00,8,SPI1);
temp=temp+temp1*mul;
mul=mul/0x100;
lenght--;
}
HoldingRegister[HR_ind]=temp; //код ацп
ADCBuffer[ADCBuf_ind]=(float)temp*k+b;
temp=WriteToADC(SPI_1,Command,8,SPI1);
temp=WriteToADC(SPI_1,adcMode,8,SPI1); //16bit resolution
}
}
}
uint8_t WriteToADC(uint8_t type,uint8_t firstParam, uint8_t secondParam, SPI_TypeDef * thirdParam)
{
uint8_t temp=0;

if (type==SPI_1)
temp=WriteSPI(thirdParam,firstParam);
else
temp=WriteSoftSPI(firstParam,secondParam);
return temp;
}
uint8_t WriteSPI(SPI_TypeDef * SPIx,uint8_t val)
{
SPIx->DR = val;
while (!(SPIx->SR & SPI_SR_RXNE));//while(!(SPI1->SR & 0x01));
return SPIx->DR;

}
uint8_t WriteSoftSPI(uint8_t val, uint8_t data_lenght)
{
uint8_t c;

for(c = 0; c < data_lenght; c++)
{
// ADC_Delay(ADC_TIM);
CLR_SCK_ADC1();

if(val & 0x80)
SET_SDI_ADC1();
else
CLR_SDI_ADC1();

// ADC_Delay(ADC_TIM);
SET_SCK_ADC1();
// ADC_Delay(ADC_TIM);
val <<= 1;
if(SDO_ADC1())
val |= 0x01;
}

return val;
}
/*===============================================================================
=====*/
void ADC_Delay (TIM_TypeDef* TIMx)
{
TIMx->CR1|=0x01;
while(!TIMx->SR&TIM_FLAG_Update) {}
TIMx->CR1&=~0x01;
}

Вот и получается, что первый АЦП опрашивается через аппаратный эспиай МК и подвисает на while while (!(SPIx->SR & SPI_SR_RXNE)), а второй АЦП опрашивается программно реализованным эспиай и подвисает на функции задержки на while(!TIMx->SR&TIM_FLAG_Update) {}.

Сообщение отредактировал batisto4ka - Mar 20 2012, 08:41