Entrar    Registrar

IAR C + STM32 Interrupções

Software e Hardware para uC STM

Moderadores: aluis-rcastro, 51

  • Autor
    Mensagem

Re: IAR C + STM32 Interrupções

Mensagempor ze » 06 Ago 2019 20:42

:D
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 :lol: 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ç
Avatar do usuário
ze
Dword
 
Mensagens: 1645
Registrado em: 05 Jun 2007 14:32

Re: IAR C + STM32 Interrupções

Mensagempor ze » 07 Ago 2019 12:07

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!
Você não está autorizado a ver ou baixar esse anexo.
Avatar do usuário
ze
Dword
 
Mensagens: 1645
Registrado em: 05 Jun 2007 14:32

Re: IAR C + STM32 Interrupções

Mensagempor denis » 07 Ago 2019 12:17

Nada melhor do que rodar no hardware de verdade.
denis
Byte
 
Mensagens: 231
Registrado em: 06 Mar 2007 12:29
Localização: Americana - SP

Re: IAR C + STM32 Interrupções

Mensagempor ze » 07 Jan 2020 20:48

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)
:x ... :evil:
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.
:cry:
Avatar do usuário
ze
Dword
 
Mensagens: 1645
Registrado em: 05 Jun 2007 14:32

Re: IAR C + STM32 Interrupções

Mensagempor julian camargo » 17 Jan 2020 15:58

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 ?
julian camargo
Nibble
 
Mensagens: 54
Registrado em: 31 Ago 2019 19:50

Re: IAR C + STM32 Interrupções

Mensagempor ze » 28 Jan 2020 16:09

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...
Avatar do usuário
ze
Dword
 
Mensagens: 1645
Registrado em: 05 Jun 2007 14:32

Re: IAR C + STM32 Interrupções

Mensagempor julian camargo » 28 Jan 2020 22:02

Qual processador vc esta usando?
julian camargo
Nibble
 
Mensagens: 54
Registrado em: 31 Ago 2019 19:50

Re: IAR C + STM32 Interrupções

Mensagempor ze » 29 Jan 2020 09:19

stm32f051c8t6 ... ligeiramente diferente e mais barato ainda do que o mais difundido stm32f103xxx
Grato
Avatar do usuário
ze
Dword
 
Mensagens: 1645
Registrado em: 05 Jun 2007 14:32

Re: IAR C + STM32 Interrupções

Mensagempor julian camargo » 29 Jan 2020 19:22

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)
julian camargo
Nibble
 
Mensagens: 54
Registrado em: 31 Ago 2019 19:50

Re: IAR C + STM32 Interrupções

Mensagempor ze » 30 Jan 2020 08:04

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.
Avatar do usuário
ze
Dword
 
Mensagens: 1645
Registrado em: 05 Jun 2007 14:32

Re: IAR C + STM32 Interrupções

Mensagempor julian camargo » 30 Jan 2020 10:57

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                                           */
julian camargo
Nibble
 
Mensagens: 54
Registrado em: 31 Ago 2019 19:50

Re: IAR C + STM32 Interrupções

Mensagempor ze » 30 Jan 2020 12:48

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é?
Avatar do usuário
ze
Dword
 
Mensagens: 1645
Registrado em: 05 Jun 2007 14:32

Re: IAR C + STM32 Interrupções

Mensagempor ze » 31 Jan 2020 10:30

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?
Avatar do usuário
ze
Dword
 
Mensagens: 1645
Registrado em: 05 Jun 2007 14:32

Re: IAR C + STM32 Interrupções

Mensagempor julian camargo » 09 Fev 2020 15:39

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.
julian camargo
Nibble
 
Mensagens: 54
Registrado em: 31 Ago 2019 19:50

Re: IAR C + STM32 Interrupções

Mensagempor ze » 25 Fev 2020 20:47

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ç
Avatar do usuário
ze
Dword
 
Mensagens: 1645
Registrado em: 05 Jun 2007 14:32

Anterior

Voltar para STMicroelectronics

Quem está online

Usuários navegando neste fórum: Nenhum usuário registrado e 1 visitante