Rogerio Fiorotti

Pessoal utilizo o XC8 Pro e tenho a assinatura mensal junto a Microchip, porém neste mês troquei minha máquina (Laptop) e a assinatura é atrelada à um número denominado Host que é definido pelo seu equipamento. Em outras palavras minha assinatura não serve para a máquina atual e a orientação do Microchip é cancelar a atual e comprar outra para a nova máquina. Fiquei chateado com essa informação e minha pergunta é existe algum método para habilitação alternativa?

3 horas atrás, test man*~ disse:

Coloca a frequencia de corte e o valor do capacitor que ele te dará o valor da resistencia e os demais dados "Calculate the R and C values for the filter at a given frequency":

http://sim.okawa-denshi.jp/en/CRlowkeisan.htm

Bacana esse site mas estou precisando para sw em C.

Grato.

6 horas atrás, Isadora Ferraz disse:

Um R e um C devem dar conta. No sw, faça a soma de 8 (16,32.64...) leituras em intervalos de tempo e divida por 8 (16,32,64...)

Quem procura, acha. Se achou?

É no sw em C, já vi isso em algum lugar mas não consegui desenvolver, você tem algum exemplo?

Pessoal estou procurando ajuda em um filtro passa_baixa eficiente para ser aplicado na conversão a/d onde realizo a leitura da saída de um acelerômetro com saida analógica.

Grato.

Finalmente!

Depois de longo trabalho sucesso em meu projeto, consegui realizar o sistema de comunicação one wire entre meu projeto com PIC12F1840 e e a caixa de programação JetiBox (JetiModel). 

Agradeço a ajuda e a paciência de todos.

Exatamente Isadora Y é gerado a partir do do canal analógico e X utilizo em outro processo, a finalidade é ter um pequeno delay na perseguição "rs..." de Y por X onde posso eliminar possíveis ruídos..

Pessoal alguém já ouviu a expressão perseguindo uma variável?

Vou explicar melhor!

Uma variável X está sempre tentando se igualar a outra variável Y somando ou subtraindo 1 (de 1 em 1) não importando o valor de Y, X estará sempre tentando se igualar.

Alguém tem uma sugestão?

Grato.

Rogério

Informação nova, o JETIBOX trabalha como Slave e só envia informações ao Master (que seria minha plaquinha) das teclas pressionadas e recebe de retorno os valores alterados.

Ex. Em uma memória do Master (plaquinha)  está registrado valor 100 e envia ao Slave (JETBOX) esse valor e mostra no display, utilizando os botões vou incrementando ou decrementando o valor e vai registrando na memória do Master.

11 minutos atrás, aphawk disse:

@Rogerio Fiorotti ,

 

O que voce postou é apenas a descrição do protocolo utilizado nesse Jeti. É pareçido com a descrição do protocolo de comunicação do FRSKY.

 

Agora, não tem nenhuma informação de como utilizar esse aparelho que voce comprou. Esse tá sendo o problema.

 

E creio que isso não tem nada a ver com a programação de um simples Pic. Na verdade, pode permitir programar alguns parâmentos utilizados pelo protocolo.

 

Eu uso algo pareçido na telemetria de meus RC, mas uso um aparelho desse tipo que você comprou apenas para mudar o ID de sensores quando são usados mais de um no mesmo aeromodelo, como por exemplo poder utilizar dois sensores de tensão de baterias LIPO em meu avião que usa duas baterias, uma para o sistema de ignição eletrônica, e outra para todo o restante.

 

Ajuda a gente com mais informações, ou melhor ainda, o manual desse seu aparelho, ok ?

 

Paulo

 

 

 

Então Paulo, o que o fabricante forneceu é somente o arquivo que postei acima sobre o protocolo, e o que você comentou sobre o FRSKY é semelhante ao que quero.

8 minutos atrás, Isadora Ferraz disse:

ok. Vou tentar traduzir o que entendi pois pode não ser totalmente inútil. Se não estiver correto, não ligo ok?

 

-você tem um botão e led que usa para interagir com seu sistema de timer

-que substituir/evoluir pra algo mais interativo e inteligente tipo um IHM

-como seu mc tem poucos pinos, achou interessante a opção 1wire

Tudo bem até aqui? Então vejamos...

 

Dei mais uma lida rápida no pdf. Infelizmente não consegui ver nada que solucione seu problema. P.ex. não vi comandos pra escrever no display e ler botões. Acho que são os principais

 

Uma opção curiosa e talvez + em conta é um simples shiftregister 74hc595 e um display 16x2. Com 3 pinos do mc você escreve nele e lê as teclas. Vão sobrar 2 pinos para I/O. Se precisar de mais, +1 74hc595

Mas se insistir naquilo, vai ter que correr atrás de mais informações, pois só com aquelas só mesmo o chuck noris

 

Se achar que deve, informe como o atual botão/led interagem com o usuário. Achei bacaninha este minimalismo (meu mundo)

 

idem

 

Veja o funcionamento do minimalismo, rs...

Meu projeto é um temporizador para aeromodelo controlado a cabo tecnicamente falando o VCC (Voo Circular a Cabo), este timer controla o tempo de pré voo (tempo de espera para a rotação do motor), tempo de voo, rotação do motor, trem de pouso e também utiliza um acelerômetro de 3 eixos para medir a aceleração centrípeta e a aceleração linear corrigindo a velocidade do aeromodelo durante o voo.

Utilizo o compilador CCS e a pic 12F1840 e hoje todo o ajuste do timer é realizado por botão e LED (piscadas) estou com dificuldades de aceitação no mercado americano por esse motivo e minha opção é utilizar uma caixa de programação como descrita anteriormente.

Alguns fabricantes utilizam essas caixas e optei nesta por estar pronta bastando desenvolver a interface para meu projeto, e é ai que a coisa esta pegando pois o fabricante só se prontificou em fornecer aquele documento do protocolo.

Bom é isso se você não achar isso o suficiente para me ajudar espero que outros possam.

www.cltimer.com

Bom, se eu já tivesse conseguido fazer algo do gênero não estaria aqui solicitando ajuda, dentro dessa caixa tem um MC dda linha 18F cujo firmware é dedicado a comunicação por um fio e já vi desenvolvedores utilizando-a em pic12f mas os caras não dão nenhuma dica sequer.

Agora o que você quer que e mostre? algum conhecimento?

Saber pra que serve eu sei, só não sei como fazer......por exemplo: você monta um temporizador com um PIC cujo valor do tempo está registrado em endereço de sua memória e para alterar esse valor usaria essa caixa para isso.

Quando conectada lê o valor da memória do PIC altera e grava...

Pode ser que esu esteja enganado mas o 12F675 não tem PWM embutido, então você pode usar a solução acima.

Colega tenta isso.

#include <12F675.h>
#device ADC=8

#FUSES INTRC_IO                 //Internal RC Osc, no CLKOUT
#FUSES NOMCLR                   //Master Clear pin used for I/O

#use delay(internal=4000000)

int1 flag20RTCC = 1;       //indica se já completaram 20 RTCC
int1 flagPULSO_ALTO = 0;  //indica se o pulso esta em nível alto
int contRTCC = 0;         //contador de RTCC

#INT_TIMER0
void  TIMER0_isr(void) 
{
  contRTCC++;
  
   if(contRTCC==7)
   {
     set_TIMER0(102);
   }

   
   if(contRTCC==8) 
   {
      flag20RTCC=1;
      contRTCC=0;
   }
}

#INT_TIMER2
void  TIMER2_isr(void) 
{
    if(flag20RTCC==1)       // DISPARO DO PULSO NIVEL ALTO PWM
   {
      flag20RTCC=0;
      output_high(PIN_A4); //ESC
      flagPULSO_ALTO=1;
   }   
   
   
   if(flagPULSO_ALTO==1)      // CONTROLE DO PULSO NIVEL BAIXO PWM
   {
               
      if(contRTCC==4)
      {   
         flagPULSO_ALTO=0;
         output_low(PIN_A4);  
      }
      
   }
}

void main()
{
   setup_timer_0(RTCC_INTERNAL|RTCC_DIV_1|RTCC_8_bit);
   setup_timer_2(T2_DIV_BY_16,4,1);
   setup_comparator(NC_NC);
   enable_interrupts(INT_TIMER0);
   enable_interrupts(INT_TIMER2);
   enable_interrupts(GLOBAL);

   while(TRUE)
   {
      //TODO: User Code
   }

}

Pessoal recentemente comprei uma caixa de programação chamada JETIBox cujo fabricante informa o tipo de protocolo que utiliza para desenvolvedores, porém estou perdidinho e gostaria de dicas o que fazer para funcionar com meu projeto.

Utilizo PIC 12f1840e a minha ideia é utilizar essa caixa para alterar valores da memória da PIC, anexo como funciona o protocolo.

Grato.

Rogério Fiorotti 

EX_Bus_protokol_v121_EN.pdf

 

1) Sobre a mensagem de erro do CCS:

http://www.ccsinfo.com/faq.php?page=interrupts_disabled

 

Repare que a comunicação acontece baseada no tempo então se uma interrupção ocorrer durante a comunicação (provavelmente ocorrerá pois a comunicação é extremamente lenta) a comunicação falhará e o escravo não receberá o dado corretamente, pior ainda, o mestre ou o escravo pode travar em alguma das função 'while', essa é a desvantagem de não haver um linha para o clock 

 

Se fosse algo por hardware beleza você carregaria o valor e o hardware o enviaria, como não é, você deverá desabilitar as interrupções antes de de escrever ou ler algo do escravo.

 

---

 

2) Sim, se você mudar o pino (do escravo) não funcionará mesmo, como eu disse em algum dos posts anteriores... Repare que o escravo usa interrupção externa (que é um pino fixo) se você colocar em outro a interrupção não ocorre e o escravo se quer notará que o mestre tentou se comunicar, quando isso ocorre a função ler ou escrever retornará o valor 1 para indicar que o escravo não respondeu.

 

Para não usar a interrupção externa seria necessário o escravo verificar a cada 200mS (no máximo) se o mestre está tentado se comunicar... Alterando o código dá para fazer isso...

 

Quanto ao hardware não funcionar...

Qual a velocidade do oscilador e a configuração (XT, HS... PLL, CPUDIV) que você está usando no hardware real?

Como não tenho um PIC12F1840 não é possível eu montar o hardware real para fazer o teste  minha única ideia é algum erro nos FUSES referentes ao oscilador. 

 

Bom....a velocidade no escravo está em 32Mhz e o fuse #FUSES INTRC_IO, reparei que quando tiro o fio de comunicação a PIC volta a funcionar (o Led pisca)  então deve haver algo na interrupção externa.

Eu não preciso de velocidade na comunicação e sim precisão nos dados lidos e escritos na memória do escravo. Talvez não utilizar a interrupção externa seria mais estável..

Vixi xD, foi falha minha (fiz o código muito tarde HEHE), o mestre estava esperando o escravo indicar o término da escrita na EEPROM mas não esta esperando ele liberar a linha... E isso estava causando problema... Segue o novo código:

 

http://www.4shared.com/rar/b4ySljv6ce/18F2550_12F1840_ONEW.html?

 

Linha adicionada:

  // Espera o escravo colocar a linha em low para indicar que que a  // escrita na EEPROM terminou.  while(pino_one_wire) {}  //espera o escravo liberar a linha  while(!pino_one_wire) {} // <<--- ESTA LINHA FOI ADICIONADA

 

Uma coisa... Se você escrever 'zero' ou 'um' em um pino (registrador LATX ou PORTX) o sinal só irá para o valor escrito após o pino ser colocado como saída...

 

Qualquer coisa posta ai (enquanto ainda tenho tempo  )

Algumas dúvidas:

1)

Utilizando o simulador do Proteus funciona uma beleza, mas no hardware não vai.

Na compilação aparece a seguinte mensagem:

Interrupts disable during call to prevent re_entrancy (@delay-1ms)

E creio que isso não está deixando a PIC funcionar.

2) Quando tento mudar o bit da porta A do escravo pra utilizar outro pino ai nem no proteus funciona.

Sei que estou sendo muito exigente, mas reconheço que sua boa vontade está sendo super preciosa.

Muito Obrigado. 

Deu certo ai?

Não deu, a porta não vai pra nivel zero.

Os endereços dos registradores variam de família para família... Você pode ver os endereços na "TABLE 5-1: SPECIAL FUNCTION REGISTER MAP" do datasheet do PIC18F2550.

 

Ficaria assim:

#bit pino_one_wire    = 0xF81.3  // bit 3 do registrador PORTB (PORTB.3)#bit direcao_one_wire = 0xF93.3  // bit 3 do registrador TRISB (TRISB.3)

Repare que o pino só irá para zero quando ele for saída (TRISB.3 = 0) caso contrário (TRISB.3 = 1) ele ficará como entrada (alta impedância) e flutuará para para nível alto por causa do PULL-UP.

Putz, fantástico!!!!! Sabe quando eu iria conseguir desenvolver isso, levaria um mês no mínimo...rssss

 

Muito obrigado, vou implementar e depois retorno com o resultado.

 

Rogério

Estou com um problema na inicialização do one_wire onde a porta que estou utilizando não vai pra zero.

Utilizo um 18F2550 e a porta é a B3 segundo manual os endereços dos registradores são:

 

Ai está o código, o 12F está operando a 32MHz (8MHz TCY) se essa frequencia for abaixa o código provavelmente apresentará erro, mas se você quiser eliminar o erro conseguirá alterando o código... Outra coisa, a comunicação é extremamente lenta ~100Hz (repare o quadrado vermelho na figura), você conseguirá aumentar essa frequência alterando o código ou entendendo ele e criando um novo... Não há uma verificação de erro, então nada garante que o valor enviado foi igual ao recebido... O escravo usa interrupção externa pino RA2...O código foi muito mas muito pouco testado HEHE!!

 

A comunicação ficou como eu disse acima.

O mestre coloca a linha em nível baixo por 200mS e então a libera;

O escravo confirma a sua rpesença levando a linha para o nível baixo por 10mS e então a libera;

O mestre envia 1 bit indicando a operação (escrita ou leitura);

E então envia 1 byte indicando o endereço;

   Se a operação for de escrita envia um byte com o valor a ser escrito;

   Se a operação for de leitura libera a linha e aguarda o escravo enviar o valor;

 

para representar um bit com o valor 1 é enviado um pulso 2mS em nível baixo e 6mS em nível alto.

para representar um bit com o valor 0 é enviado um pulso 6mS em nível baixo e 4mS em nível alto.

 

Esse PIC possui DAC em? Só faltou o zero crossing detector 

 

Imagem:

 

Mestre:

#include <16F628A.h>#FUSES PUT                     //Power Up Timer#FUSES NOMCLR                  //Master Clear pin used for I/O#FUSES BROWNOUT                //Reset when brownout detected#FUSES NOLVP                   //No low voltage prgming, B3(PIC16) or B5(PIC18) used for I/O#FUSES NOCPD                   //No EE protection#FUSES NOPROTECT               //Code not protected from reading#use delay(internal=4MHz)#define LED PIN_B0#define DELAY 500/******************************************************************************/// O código precisa dos bits dos registradores TRIS e PORT referente ao pino.#bit pino_one_wire    = 0x06.4  // bit 4 do registrador PORTB (PORTB.4)#bit direcao_one_wire = 0x86.4  // bit 4 do registrador TRISB (TRISB.4)#include <EEPROM_ONE_WIRE.c>/******************************************************************************/void main(){  unsigned int valor_lido1, valor_lido2, valor_lido3, status;    inicializar_one_wire();    status = escrever_eeprom_onewire(0, 8); // Escreve 8 na posição 0 da EEPROM do escravo  escrever_eeprom_onewire(1, 5);          // Escreve 5 na posição 1 da EEPROM do escravo  escrever_eeprom_onewire(2, 2);          // Escreve 2 na posição 2 da EEPROM do escravo  //if(status == 1)    // significa que o escravo não respondeu ao chamdo do mestre      // Lendo o valor armezenado na posição 0 da EEPROM do escravo  valor_lido1 = ler_eeprom_onewire(0, status);   // Lendo o valor armezenado na posição 1 da EEPROM do escravo  valor_lido2 = ler_eeprom_onewire(1, status);   // Lendo o valor armezenado na posição 0 da EEPROM do escravo  valor_lido3 = ler_eeprom_onewire(2, status); //if(status == 1)    // significa que o escravo não respondeu ao chamdo do mestre        while(true)  {    output_low(LED);    delay_ms(DELAY);    output_high(LED);    delay_ms(DELAY);  }}

 

Escravo:

#include <12F1840.h>#device ADC=10#FUSES PUT                     //Power Up Timer#FUSES NOMCLR                  //Master Clear pin used for I/O#FUSES NOPROTECT               //Code not protected from reading#FUSES NOCPD                   //No EE protection#FUSES NOBROWNOUT              //No brownout reset#FUSES NOCLKOUT                //I/O function on OSC2#FUSES NOIESO                  //Internal External Switch Over mode disabled#FUSES NOFCMEN                 //Fail-safe clock monitor disabled#FUSES NOWRT                   //Program memory not write protected#FUSES NOSTVREN                //Stack full/underflow will not cause reset#FUSES BORV19                  //Brownout reset at 1.9V#FUSES NOLVP                   //No low voltage prgming, B3(PIC16) or B5(PIC18) used for I/O#use delay(internal=32MHz)#define LED PIN_A0#define DELAY 500#bit pino_one_wire_escrita = 0X10C.2     // Para escrever LATA.2#bit pino_one_wire_leitura = 0x00C.2     // PARA ler PORTA.2#bit direcao_one_wire      = 0x08C.2     // TRISA bit 2 para mudar a direção do pino#define _input   1#define _output  0#define _low     0#define _high    1#define _escrita 1#define _leitura 0#INT_EXTvoid  EXT_isr(void) {  unsigned int16 _aux = 0;  unsigned int _i, _address = 0, _value = 0, _value_read = 0;  short _operacao;    pino_one_wire_escrita = _low;     // Prepara o pino com o valor 0    while(!pino_one_wire_leitura) {}  // Espera o mestre liberar a linha  delay_ms(1);                        direcao_one_wire = _output;       // Coloca zero na linha para indicar ao mestre                                    // que este escravo está presente  delay_ms(10);                     // Deixa em baixo por 10mS  direcao_one_wire = _input;        // Libera o barramento    while(pino_one_wire_leitura) {}   // Espera o mestre iniciar o envio do bit de comando    // Pegando o bit de comando  do {    delay_us(1);    _aux++;  }while(!pino_one_wire_leitura);   // Conta o tempo em que a linha ficou em nível baixo    if(_aux < 2001) {                 // menor que 2mS (2000uS) é igual a 1 recebido, operação de escrita    _operacao = _escrita;  }    else {                          // maior  que 2mS é igual a 0 recevido, operação de leitura      _operacao = _leitura;    }    // Pegando o endereço da Operação  _aux = 0;  for(_i = 0; _i < 8; _i++) {    while(pino_one_wire_leitura) {} // Espera a linha ser colocada em zero        do {      delay_us(1);      _aux++;    }while(!pino_one_wire_leitura);   // Conta o tempo em que a linha ficou em nível baixo          if(_aux < 2001) {                 // menor que 2mS (2000uS) é igual a 1 recebido      bit_set(_address, _i);          // então seta o bit correspondente.    }    // A variável _address é iniciada com zero então não há a necessidade de zerar    // o bit caso o valor recebido for zero.    _aux = 0;  }    if(_operacao == _escrita) {    // Pega o valor a ser escrito no endereço enviado pelo mestre    _aux = 0;    for(_i = 0; _i < 8; _i++) {      while(pino_one_wire_leitura) {}   // Espera a linha ser colocada em zero            do {        delay_us(1);        _aux++;      }while(!pino_one_wire_leitura);   // Conta o tempo em que a linha ficou em nível baixo              if(_aux < 2001) {                 // menor que 2mS (2000uS) é igual a 1 recebido        bit_set(_value, _i);            // então seta o bit correspondente.      }      // A variável _value é iniciada com zero então não há a necessidade de zerar      // o bit caso o valor recebido for zero.      _aux = 0;    }   write_eeprom (_address, _value);   direcao_one_wire = _output;          // Coloca a linha em zero para indicar que a escrita terminou   delay_us(5);   direcao_one_wire = _input;   }    else {                                // Se a operação for de leitura      _value_read = read_eeprom(_address);// Lê o valor armazenado na posição _address      delay_ms(20);                       // Espera o mestre se preparar para o recebimento            for (_aux = 0; _aux < 8; _aux++) {        if(bit_test(_value_read, _aux)) { // Verifica o bit a ser enviado se for 1          direcao_one_wire = _output;     // Pino em nível baixo 0          delay_ms(2);                    // por 2mS (bit 1)          direcao_one_wire = _input;      // Pino em nível alto 1          delay_ms(8);                    // por 8mS              }          else {                          // Se for 0            direcao_one_wire = _output;   // Pino em nível baixo 0            delay_ms(6);                  // por 6mS (bit 0)            direcao_one_wire = _input;    // Pino em nível alto 1            delay_ms(4);                  // por 4mS          }      }             }}  void main(){  direcao_one_wire = _input;    ext_int_edge(H_TO_L);         // Necessário para o código funcionar corretamente  enable_interrupts(INT_EXT);   // habilita a interrupção externa - Interrupção na transição de ALTO para BAIXO  enable_interrupts(GLOBAL);    // habilita todas as interrupções  //Example blinking LED program  while(true)  {    output_low(LED);    delay_ms(DELAY);    output_high(LED);    delay_ms(DELAY);  }}

 

Download:

http://www.4shared.com/rar/6f4eiBSzba/ONE-WIRE_PIC_PIC.html?

 

Putz, fantástico!!!!! Sabe quando eu iria conseguir desenvolver isso, levaria um mês no mínimo...rssss

Muito obrigado, vou implementar e depois retorno com o resultado.

Rogério

não consegue, claro. Peço a gentileza de googlar "1wire protocol". Com um pouco de criatividade, pode até conversar pelo sinal de alimentação ou alimentar pelo sinal não necessariamente nesta odem

Boa sorte!

Passei a tarde toda pesquisando, mas não encontrei algo que realmente dê uma luz para o meu caso.

De = pra = ...

uma (01) opção...

habilite a comunicação serial e faça no mestre TXREG=valor e no escravo eepromwrite(endereco,RXREG). 'valor' de um vai pro 'endereco' do outro

 

Ok, mas como vou conseguir ler o valor da eeprom no escravo antes de gravar em uma unica via de comunicação?

 

Tenho um código com comunicação I2C entre PICS (o Slave funciona da mesma forma que o DS1307 em termos de recebimento e envio de dados), porém são usados dois fios/pinos.

 

Para um único fio talvez seja legal fazer algo que funcione como o DHT11...

Daí o mestre poderia enviar 1 bit para o comando (ler ou escrever) + 1 byte para o endereço onde a operação vai ocorrer

   Se for escrita + 1 byte com o dado;

   Se for leitura o mestre libera a linha (pino como entrada) e aguarda o Slave enviar o byte...

 

Poderia ser usado um resistor de PULL-UP assim ambos os PICS apenas colocam a linha em nível baixo (nível alto = pino como entrada) evitando curto.

 

Eu estou meio na correria, poderia fazer o exemplo mas acho que quando sobrar tempo você já terá resolvido o problema 

Qual compilador você está usando?

 

Estou utilizando CCS e a PIC de onde quero ler e gravar é a 12F1840. Mas quando você tiver um tempinho gostaria de ver seu exemplo, eu aguardo...Obrigado.

Ok, mas como vou conseguir ler o valor da eeprom no escravo antes de gravar em uma unica via de comunicação?

Estou utilizando CCS e a PIC de onde quero ler e gravar é a 12F1840. Mas quando você tiver um tempinho gostaria de ver seu exemplo, eu aguardo...Obrigado.

Ah, tenho que utilizar um fio só mesmo...

Prezados estou precisando pra concluir meu projeto exemplos de comunicação entre PIC´s utilizando 1 fio, onde consigo ler e alterar valores gravados na EEprom de uma delas.

Abraços.

Rogério

Existem no mercado "caixas" que são utilizadas para alterar ajustes de determinados equipamentos, como exemplo o Jetbox da Jetimodel que é utilizados para alterar parâmetros de seus equipamentos.

Preciso desenvolver algo semelhante, onde quero utilizar o mesmo recurso para alterar valores gravados na eeprom de meu projeto.