IAR C + STM32 Interrupções

[ze]

Que tal assim...

Código: Selecionar todos

#define   BIT_0   1<<0
#define   BIT_1   1<<1
#define   BIT_2   1<<2
#define   BIT_3   1<<3
#define   BIT_4   1<<4
#define   BIT_5   1<<5
#define   BIT_6   1<<6
#define   BIT_7   1<<7
#define   BIT_8   1<<8
#define   BIT_9   1<<9
...
#define   BIT_31   1<<31

Fala sério Por falar em falar sério, sabia que o IAR C não entende a definição de bits 0b01010101 ? Mas algum sem noção com muita noção e sem ter o que fazer criou isso:

Código: Selecionar todos

#define B8__(x) ((x&0x0000000fLU)?1:0) \
+((x&0x000000f0LU)?2:0) \
+((x&0x00000f00LU)?4:0) \
+((x&0x0000f000LU)?8:0) \
+((x&0x000f0000LU)?16:0) \
+((x&0x00f00000LU)?32:0) \
+((x&0x0f000000LU)?64:0) \
+((x&0xf0000000LU)?128:0)
#define HEX__(n) 0x##n##LU
#define b8(d) ((unsigned char)B8__(HEX__(d)))
/* for upto 16-bit binary constants, MSB first */
#define b16(dmsb,dlsb) (((unsigned short)b8(dmsb)<< \
+ b8(dlsb))
/* for upto 32-bit binary constants, MSB first */
#define b32(dmsb,db2,db3,dlsb) (((unsigned long)b8(dmsb)<<24) \
+ ((unsigned long)b8(db2)<<16) \
+ ((unsigned long)b8(db3)<< \
+ b8(dlsb))
/* Sample usage:
b8(01010101) = 85
b16(10101010,01010101) = 43605
b32(10000000,11111111,10101010,01010101) = 2164238933
*/


Agora isso

Código: Selecionar todos

#define BCD2BYTE( b ) ( ( ( ( ( b ) >> 4 ) & 0x0f ) * 10 ) + ( ( b ) & 0x0f ) )
#define BYTE2BCD( b ) ( ( ( ( b ) / 10 ) << 4 ) + ( ( b ) % 10 ) )
unsigned char bcd2byte(unsigned char d)
{
return BCD2BYTE(d);
}
//-----------------------------------------------------
unsigned byte2bcd(unsigned char d)
{
return BYTE2BCD(d);
}

também pode não ser totalmente inútil quando isso...

Código: Selecionar todos

#define setbit(var,bitno) ((var) |= 1 << (bitno))
#define clrbit(var,bitno) ((var) &= ~(1 << (bitno)))
#define xorbit(var,bitno) ((var) ^= 1 << (bitno))

Sei lá ... é pouco mas é o 'pagamento' das lustradas de bits que tenho . A propósito consegui fazer funcionar o stm32 na simulação do proteus... uhhull.
abç

[ze]

Afff... pqp....
quer saber porquê agora funcionou na simulação proteus?
O proteus considera o bit 11 do RCC_APB2ENR como habilitação do TIMER2 e não o bit 0 do RCC_APB1ENR como manda o manual

64.png

http://www.jkelec.co.kr/img/lecture/cortex_app/img/64.png

O código abaixo funciona

Código: Selecionar todos

  RCC_APB2ENR=0x0000080c;//0b100000001100; //TIM1? PORTA PORTB
  RCC_APB1ENR=0x00000000;//0b0001; //timer2!!
//  RCC_APB1ENR.TIM2EN=1;

Basta desabilitar o bit 11 TIMER1 !!!! que o treco nem roda e dá a mensagem

Código: Selecionar todos

Access to register of unclocked peripheral at 0x40000000 cause BUS_FAULT [U1_CM3CORE]

que juro pro 6 que lia unlocked !! carai.. se o treco tá destravado, porquê o aviso pow??!

Não basta escovar bits. Tem que dar uma uma lustrada e mais uma cuspidinha e passar um paninho no bit.. Fala sério!! tnc pow!

[denis]

Nada melhor do que rodar no hardware de verdade.

[ze]

Olá amigo @Guri ou vc que está a ler e tem contato com o compilador mikroc @ st32f0xxx...
Desisti do IAR pouco depois de criar este tópico e fui de mikroc mais mastigadinho. Excelente dica do amigo @guri. aos poucos supero a fase de escovar bits .

Estou tentando usar a lib adc do mikroc A minha dificuldade é com a função Adc_Read(canal). Ela trava em si. Algo como espera o bit EOC e ele não vem. Por acaso, isso já vos aconteceu e conseguiu contornar?
http://download.mikroe.com/documents/co ... ibrary.htm
Usei a ADCx_Get_Sample() com relativo sucesso. Mas com ela, aparentemente não posso ler canais aleatórios. O valor do anterior interfere no próximo. Tem que ser sequencial e crescente. Como a seguir...
Sinistramente, agora há pouco na fase de escovação de bit, consegui sucesso programando manualmente os registros

Código: Selecionar todos

double ad[5];

void read_adc(unsigned char channel)
{
unsigned char i;
unsigned int tmout=65000;
ADC_CR.ADEN=1;//liga conversor
while(!ADC_CR.ADRDY);

ADC_CHSELR=(1<<8)|(1<<9)|(1<<16)||(1<<17)|(1<<18);//1<<channel;
ADC_SMPR=0b111; //o mais lento
ADC_CCR|=(1<<24)|(1<<23)|(1<<22);//.TSEN_bit=1;
ADC_CR.ADSTART=1;//inicia conversão
for(i=0;i<5;i++)
  {
  while(!ADC_ISRbits.EOC);//&&(tmout--)); //espera converter
  ad[i]=ADC_DR;
  }
ADC_CR.ADEN=0;
ADC_CR.ADSTART=0;//inibe
}

Mas de um instante pra outro resolveu criar vida própria e travar o bit EOC (por isso o time out que não resolveu pois o dado sai errado)
...
Percebo também ao fazer...

Código: Selecionar todos

ADC1_Init(); //2x...
ADC1_Init(); //...esta megda trava

Também to com muita vontade usar a V de referência interna. ADC1_Init_Advanced(_ADC_INTERNAL_REF); // set internal reference used
... but...
Not all MCUs support advanced configuration. Please, read the appropriate datasheet before utilizing this library.

[julian camargo]

Oh Zéééééééé´....... não vi vc mencionar se esta usando a biblioteca Std_PeriphDriver da ST, parece que não.

Coisas do tipo GPIOB_ODR^=0xffffffff não são nada amigáveis de entender, a primeira vista.

Acredito que teria sido melhor vc ter iniciado esse projeto incluindo a biblioteca Std_PeriphDriver e usando as funções de setup de hardware que estão nela.

Com ela, é muito mais fácil de fazer e entender o que esta acontecendo.

Veja o exemplo abaixo de como criar uma interrupção por pino:

cpp code

void EXTI1Config(void)
{
  GPIO_InitTypeDef GPIO_InitStructure;
  EXTI_InitTypeDef EXTI_InitStructure;
  NVIC_InitTypeDef NVIC_InitStructure;

  RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB, ENABLE);

  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_1;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
  GPIO_Init(GPIOB, &GPIO_InitStructure);

  RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO, ENABLE);
  GPIO_EXTILineConfig(GPIO_PortSourceGPIOB, GPIO_PinSource1);

  EXTI_InitStructure.EXTI_Line = EXTI_Line1;
  EXTI_InitStructure.EXTI_Mode = EXTI_Mode_Interrupt;
  EXTI_InitStructure.EXTI_Trigger = EXTI_Trigger_Falling;
  EXTI_InitStructure.EXTI_LineCmd = ENABLE;
  EXTI_Init(&EXTI_InitStructure);

  NVIC_InitStructure.NVIC_IRQChannel = EXTI1_IRQn;
  NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0x0F;
  NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0x0F;
  NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
  NVIC_Init(&NVIC_InitStructure);
}

Depois disso é só incluir a rotina de interrupçao abaixo:

cpp code

void EXTI1_IRQHandler(void) 
{
   
    if (EXTI_GetITStatus(EXTI_Line1) != RESET)  
   {

         // Escreva aqui o que vc quer fazer quando ocorrer a interrupçao.

        EXTI_ClearITPendingBit(EXTI_Line1);
    }
}

Concorda que fica mais fácil de entender ?

[ze]

Obrigado pela sugestão amigo Camargo. Apesar de infelizmente eu não usar o compilador "dono" das suas sugestões. Já me envolvi com o mikro c que também tem algumas facilitações mas agora me enrosquei em gerar uma interrupt com o comparador do stm32f051. Por acaso vc (ou vc que está lendo) já teve contato com isso @mikro c? Estou tentando ter sucesso lendo o reference manual e as vezes o google que está ajudando bem pouco ou nada. Cheguei a isso...
https://github.com/nitsky/stm32-example ... 30x_comp.c
...mas como percebes se trata de outro compilador. O que quero saber essencialmente é onde está o vetor de interrupção do comparador. O ref manual diz apenas que "EXTI line 22 is connected to the comparator 2 output" que é o que quero usar. Com o timer2 tive sucesso com

Código: Selecionar todos

NVIC_IntEnable(IVT_INT_TIM2); // Enable timer interrupt

e

Código: Selecionar todos

void tim2() iv IVT_INT_TIM2  ics ICS_AUTO
{...

Me resta saber onde e como é habilitada a do comparador. Tentei

Código: Selecionar todos

void initCOMP(void)
{
NVIC_IntEnable(IVT_INT_EXTI0_1); //Enable COMPARADOR NVIC eu que xutei
COMP_CSR.COMP2EN=1; //habilita COMPARADOR
EXTI_IMR|=1<<22; //habilita interrupt comparador  ... é o que interpretei do d.s.
EXTI_EMR|=1<<22;
COMP_CSR.COMP2INSEL0=1; //1/2
COMP_CSR.COMP2INSEL1=1;// VREF
}

e

Código: Selecionar todos

void COMPARADOR() iv IVT_INT_EXTI0_1 ics ICS_AUTO
{

mas ainda sem sucesso. Também não consigo achar rapidão qual é o endereço do vetor do comparador pra eu criar na unha. Segundo o help posso fazer algo como...

Código: Selecionar todos

void interrupt org 0xaaaa... // aaaa o end referente a interrupt

Agradeço

é sério... enquanto digitava a choradeira acima dei um alttab literal e mental meio que vi no ref manual tal vetor ADC_COMP. Observando o do timer2, meio que chutei

Código: Selecionar todos

NVIC_IntEnable(IVT_INT_ADC_COMP); //Enable COMPARADOR NVIC  ... um xute menos incerto!!

compilou, não deu erro e... ainda não deu... Vou colocar alguns bits no microscópio...

[julian camargo]

Qual processador vc esta usando?

[ze]

stm32f051c8t6 ... ligeiramente diferente e mais barato ainda do que o mais difundido stm32f103xxx
Grato

[julian camargo]

Pelo que estou vendo aqui, o stm32f051c8t6 não tem EXTI line 22.

Nesse modelo especifico da família F0, a interrupção gerada pelos Comparadores se dá na IRQ12 denominada: ADC1_COMP_IRQn = 12. (ADC1, COMP1 and COMP2 Interrupts)

[ze]

Grato pela análise amigo Camargo. De fato não consegui ver a menção da tal irq12 no ref manual. Mas sim nele vi "EXTI line 22 is connected to the Comparator 2 output".
Obtive sucesso com

Código: Selecionar todos

void initCOMP(void)
{
//RCC_APB2ENRbits.SYSCFGEN=1; //já habilitei antes
NVIC_IntEnable(IVT_INT_ADC_COMP); //Enable COMPARADOR NVIC
//COMP_CSRBits.COMP2EN=1; //habilita COMPARADOR
COMP2EN_bit=1; //habilita COMPARADOR
//EXTI_IMR|=1<<22; //habilita interrupt COMPARADOR 2
EXTI_IMRbits.MR22=1; //habilita interrupt COMPARADOR 2
EXTI_RTSR|=1<<22; //não vi struct pra ele por isso fiz na unha. Foi o pulo do gato se não não pula pra interrupt
//COMP_CSR.COMP2INSEL0=0;
//COMP_CSR.COMP2INSEL1=0;// 1/4 VREF interna
//COMP_CSR.COMP2INSEL2=0;
COMP2INSEL0_bit=0;
COMP2INSEL1_bit=0; //1/4 VREF interna
COMP2INSEL2_bit=0;
COMP2HYST0_bit=1; //histerese alta
COMP2HYST1_bit=1;
COMP2POL_bit=1; //inverte
COMP_CSRbits.WNDWEN=0; //comparador janela=off //só pra garantir
}

e

Código: Selecionar todos

void COMPARADOR() iv IVT_INT_ADC_COMP ics ICS_AUTO
{
if(EXTI_PR.B22)   //se comparador has trigger the interrupt
  {
  EXTI_PR|=1<<22;   //ZERA FLAG INTERRUPT = senão não sai da interrupt
  BUZZ=1; //teste
  delay1(100000);
  BUZZ=0;
  }
}

Taí o "ovo de colombo" a quem interessar possa...
Agora o desafio é corrigir o "encavalamento" de interrupts pois uso a do timer2 e de vez em quando "descarrilha". Tem o lance da prioridade que ajustei pro timer2 mas mesmo assim ainda se perde. Sei que é no loop principal pois coloquei um led no timer2 e este ainda pisca. Menos mal. Vou colocar todas as variáveis como globais e diminuir a otimização pra ver que merdadá....
Agradeço mais uma vez, caro leitor e membros participantes, por acompanhar minha saga. Espero que não vos seja totalmente inútil.

[julian camargo]

Muito estranho isso que achei. Verificando o arquivo "Stm32f0xx.h" da família F0, achei coisa diferente. Veja a função da interrupção numero 12.
Veja também que a interrupção EXTI line 22 não existe nesta tabela.

Que estranho, tem certeza que esta funcionando?

Código: Selecionar todos

#if defined (STM32F051)
/******  STM32F051  specific Interrupt Numbers *************************************/
  WWDG_IRQn                   = 0,      /*!< Window WatchDog Interrupt                               */
  PVD_IRQn                    = 1,      /*!< PVD through EXTI Line detect Interrupt                  */
  RTC_IRQn                    = 2,      /*!< RTC through EXTI Line Interrupt                         */
  FLASH_IRQn                  = 3,      /*!< FLASH Interrupt                                         */
  RCC_IRQn                    = 4,      /*!< RCC Interrupt                                           */
  EXTI0_1_IRQn                = 5,      /*!< EXTI Line 0 and 1 Interrupts                            */
  EXTI2_3_IRQn                = 6,      /*!< EXTI Line 2 and 3 Interrupts                            */
  EXTI4_15_IRQn               = 7,      /*!< EXTI Line 4 to 15 Interrupts                            */
  TS_IRQn                     = 8,      /*!< Touch sense controller Interrupt                        */
  DMA1_Channel1_IRQn          = 9,      /*!< DMA1 Channel 1 Interrupt                                */
  DMA1_Channel2_3_IRQn        = 10,     /*!< DMA1 Channel 2 and Channel 3 Interrupts                 */
  DMA1_Channel4_5_IRQn        = 11,     /*!< DMA1 Channel 4 and Channel 5 Interrupts                 */
  ADC1_COMP_IRQn              = 12,     /*!< ADC1, COMP1 and COMP2 Interrupts                        */
  TIM1_BRK_UP_TRG_COM_IRQn    = 13,     /*!< TIM1 Break, Update, Trigger and Commutation Interrupts  */
  TIM1_CC_IRQn                = 14,     /*!< TIM1 Capture Compare Interrupt                          */
  TIM2_IRQn                   = 15,     /*!< TIM2 Interrupt                                          */
  TIM3_IRQn                   = 16,     /*!< TIM3 Interrupt                                          */
  TIM6_DAC_IRQn               = 17,     /*!< TIM6 and DAC Interrupts                                 */
  TIM14_IRQn                  = 19,     /*!< TIM14 Interrupt                                         */
  TIM15_IRQn                  = 20,     /*!< TIM15 Interrupt                                         */
  TIM16_IRQn                  = 21,     /*!< TIM16 Interrupt                                         */
  TIM17_IRQn                  = 22,     /*!< TIM17 Interrupt                                         */
  I2C1_IRQn                   = 23,     /*!< I2C1 Interrupt                                          */
  I2C2_IRQn                   = 24,     /*!< I2C2 Interrupt                                          */
  SPI1_IRQn                   = 25,     /*!< SPI1 Interrupt                                          */
  SPI2_IRQn                   = 26,     /*!< SPI2 Interrupt                                          */
  USART1_IRQn                 = 27,     /*!< USART1 Interrupt                                        */
  USART2_IRQn                 = 28,     /*!< USART2 Interrupt                                        */
  CEC_IRQn                    = 30      /*!< CEC Interrupt                                           */

[ze]

Pior , ou melhor, melhor que sim amigo. Veja bem que estou literalmente a acessar/manipular os registros e bits do mc. Este include seu aí provavelmente é pra algo ou algo como o número da prioridade default do sistema.
Caso persista a curiosidade, dá uma olhadela https://www.element14.com/community/ser ... Manual.pdf página 162 (no que usei era 215 mas tudo bem).
De fato observo numa página acima a tal position 12 que, de novo, penso ser algo como a prioridade default dele. O 22 que menciono é o bit do registrador.
Ah sim... penso que se a tal interrupt number 12 tem alguma relevância maior, acho que quem cuida disso é a função NVIC_IntEnable(IVT_INT_ADC_COMP) que não quero saber o que ela faz nos registros...

Agora estou na batalha com a eeprom dele que ele não tem mas tem como emular como o mastigado Flash_Write_HalfWord(add,dd) do mikcroc. Este quero usar como está e não quero brigar com os bits. Um (01) dos problemas é precisei apagar FlashErarePage() uma página de 1K pra reescrever 1 byte e ... mais tarde falo mais sobre...

E é agora... acho que tal função usa rotina da rom algo como que está no boot loader do mc, será que chuto certo? Queria escrever e apagar 1 byte (de fato um word) só.
Ainda sobre isso, vou precisar escrever a cada vez que desliga o sistema e sei que isto tem um limite de gravação aliás bem pequeno. Vc (ou vc) tem/conhece algum algoritimo pra gravar em posições alternadas de flash de modo a aumentar no número de gravações? E outra, caso apague uma posição já apagada (FFFFFFFF) provavelmente não vai contar como gravação, né?

[ze]

Me autorespondendo, com uns cliques achei o termo wear leveling cujo princípio é justamente prolongar a vida da eeprom, flash e afins. Pois bem ... não achei com rapidez uma maneira de sobreescrever um byte sem antes ter que apagá-lo. E também com o mc @mikroc em questão, não há função pra isso a não ser a tal FLASH_ErasePage(addr) que com alguma intuição vi uma menção muito pequena no ref. man. que cada página tem 1K. Isso deve dar uma luz ao amigo @guri "do lado" ( viewtopic.php?f=13&t=18680 ) que se quiser, ele que venha aqui...
Pois bem de novo, teorizei um sistema wear leveling da seguinte forma:
-separo 1k da flash para eeprom
-gravo no 1º byte (word)
-a cada vez que sistema sobe, verifica se byte não tá gravado (!=0xffffffff) e incrementa uma variável ate achar. Reserva
-ao desligar (interrupt comparador), grava no endereço apontado por esta variável.
-ao atingir 1K (0x400) apaga FLASH_ErasePage( ) os 1K e recomeça
Com isso, ao invés de 10K gravações, posso ter 10M
Vc consegue perceber alguma falha nesta teoria 100% original?

[julian camargo]

De acordo com os manuais, os STM32 suportam no mínimo 10k ciclos de gravação em cada pagina de memória.
Obrigatoriamente vc tem que apagar TODA a pagina de memória entes de gravar qualquer coisa nova. Não há como gravar apenas um único byte por vez.

Geralmente se usa a flash como EEPROM para gravar parâmetros de funcionamento da placa, setup da maquina que o MCU controla, cadastro de controles remoto de portões etc.
Ou seja, dados que não vão se alterar durante longos períodos de tempo.

O que pretende gravar na flash?
Calcule com que frequência vc estima que deverá atualizar a flash. Por exemplo: 10 vezes ao dia te dará 3 anos de vida de uma única pagina. (aproximadamente)
A melhor forma de usar a flash como EEPROM já foi mencionada aqui em post anterior.

Crie uma estrutura contendo todas a variáveis que serão gravadas na flash.
Coloque nesta estrutura um contador de gravações, que deverá ser incrementado toda vez que fizer uma gravação.

No boot do processador, leia a flash e transfira os dados para aquela estrutura e trabalhe com eles durante o programa.
Só grave a estrutura na flash se houver alteração de alguma variável da estrutura, incremente aquele contador de gravações antes de gravar.

Estipule um valor limite para esse contador. Quando chegar nesse valor, mude de pagina.

Após a gravação, faça uma leitura do que foi gravado e compare os valores com a estrutura original. Assim vc também conseguirá saber se houve algum erro de gravação, isso pode indicar também que aquela pagina da flash esta atingindo o fim de vida.

[ze]

Obrigado amigo.
Cheguei a cogitar o lance do relativamente complexo contador de gravações mas aí tive a epifania minimalista de ir gravando sequencialmente até atingir 1k ,apagar a página e recomeçar. O pulo do gato é mesmo procurar o endereço que estiver com 0xffff e só se tiver havido alteração no word. No caso só preciso gravar 1 word mesmo. Aquela sequencia que mencionei deve me dar bom resultado. O caso extremamente extremo e improvável é uma gravação por hora. Este sistema permitiria teóricos 10 milhões de horas o que já nos é bem mais que suficiente.

Outra coisa...Confesso que estou com dificuldade pra entender como é selecionado o canal ad a nível de registradores. As funções que criei dos posts passados tentei algumas formas sem sucesso total. Apelei pros mastigados do mikroc mas tive que fazer adaptações. P.ex. ele não alterna direto entre canal 8 e 14. Tive que ler 9,10,11,12,13 na sequencia pra ele chavear corretamente pro 14. Sem contar que tiver que ler de 0 a 7 pra obter o 8. Por hora isso me satisfez...

É isso...

abç