Felipe Electronic

A Malha ao redor de Q1 está mal projetada, para o leitor mais atento, se considerarmos o momento de condução onde temos em Q2 a seguinte condição IE máximo, e motando um circuito equivalente, a junção VCE iria enxergar uma fonte de tensão formada pela junção VBE de Q1, ao passo que o FTE vai enxergar uma segunda fonte de tensão formada pela junção VCE de Q2, assim, a condição de operação de Q1 fica preso ao quanto de potência o FTE está a dissipar, se a malha de Q2 cai em saturação f**eu o transistor frita. O circuito fucionaria de forma menos pior(nao digo melhor) se ele garantisse a operação do circuito em região ativa, reduzindo a dissipação no transistor Q2. Eu optaria por conectar esse mesmo resistor do coletor de Q1 a alimentação, formando uma fonte de corrente, cujo o ponto de operação é controlado pelo resultado da soma entre os sinais de entradae o de realimentação, além disso, com isso fixa - se um ponto de operação padrão nesse transistor.

@Carol Moneta, Contribuindo para ideia do seu voltímetro, considere a utilização de um ICL7107 da Intersil, é um CI fácil de obter e relativamente barato, a saída dele já é decodificada para colcoares os displays de 7 segmentos, o ponto mais critico desse projeto é o circuito de entrada para medida de tensão em que o divisor de entrada deve ser calculado. Segue o link: http://www.eeweb.com/project/sudheer_gupta/how-to-build-digital-voltmeter-circuit-using-icl7107 Se tiver dúvidas estamos ai. Abs.

Só um detalhe, a limitação de frequência que um PLL pode fornecer é imposta ao estágio VCO que este possui, no datasheet o parâmetro fmax é de 1.9MHz para uma alimentação de 15Vcc e 0.7MHz para 5Vcc. para funcionar bem mesmo, seria interessante projetar um VCO externo ao 4046, e utilizar esse no lugar do que é fornecido on-chip. Se quiser um VCO com amplo range de frequências procure por "oscilador ring" no google, ou opte por um gerador de sinais mais sofisticados, talvzer alguma coisa baseada em síntese digital como o ad9833. Abs.

E devia entrar em desespero mesmo por se preocupar agora que falta 1 mês. De qualquer forma, é possível fazer sim, graças ao suporte amplo fornecido pela comunidade do Arduino. Checou que no site existe um link para o repositório no github para um framework prontinho pro Arduino? https://github.com/adafruit/Adafruit-Fingerprint-Sensor-Library Sobre o resto do projeto, você precisa dar mais detalhes e mostrar o que ja fez e o que esta te dando dor de cabeça amigo, no mais, estamos ai. Abs.

Deixa eu ver se entendi: - voce tem uma tabela de que tem a forma de cada linha, está essa tabela em qual memoria? programa ou RAM? - A estrutura de repetição que você quer funciona escrevendo uma linha de pixels ate que passar por todas as tabelas? No geral nao parece nada complexo de se fazer usando o metodo de "computed goto" dos PIC16, armazenando aquele conjunto de Retlw, o fator critico da sua implementação seria o correto tamanho de cada linha, afim de calcular um offset correto para pular de uma tabela a outra... Vale lembrar, nao é o tipo de coisa feita com algumas poucas instruções, fique ciente disso. Verei o que consigo extrair com as informações que você deu afinal fazem uns poucos anos que nao mexo com PIC16... EDIT: Foi o melhor que conseguir pensar com as 35 instruções do PIC16 em 15 minutos que tive livre aqui no trabalho, tem que verificar a sintaxe de uma diretiva ou outra, mas esse principio creio que funciona bem, estamos chegando proximo as limitações de endereçamento indireto no PIC16. Em micros da "moda" isso em assembly (que dirá em C) seria feito com o pé nas costas. mas é o que temos. De uma olhada: ; Exemplo de stream de linhas com PIC16;; Autor FSN =P;#define PIXEL_LINHA .128 ;largura de cada linha em pixels #define SIZEOF_LINHA (PIXEL_LINHA / 8) ;offset para jump computado entre tabelas#define TABELA_BASE 0x2FF ;endereco base onde ficam localizada as tabelascblock 0x20reg0 ;registros de uso geralreg1 ;reg2 ;reg3 ;pixelBCount ;contador de pixels por bytepixelLCount ;contador de pixels por linhapix ;lineCount ;contador de linhas a imprimir na tela;; WriteFrame(); Essa funcao é a mais alto nivel, escreve N linhas a partir ; do endereço definido em tabela base; reg0 - numero de linhas;;WriteFrame:movf reg0, w ;movwf lineCount ; toma a contagem de linhas:movlw SIZEOF_LINHA ;movwf reg2 ; prepara o tamanho de cada linhamovlw high(TABELA_BASE); toma a primeira linha a receber...movwf reg1 ;movlw low(TABELA_BASE);movwf reg0 ;call LineWrite ;escreve a linha apontada no primeiro endereçomovlw SIZEOF_LINHA ;movwf reg2 ; prepara o tamanho de cada linhamovlw high (TABELA_BASE + (SIZEOF_LINHA * 1)); toma a segunda linha a receber...movwf reg1 ;movlw low(TABELA_BASE + (SIZEOF_LINHA * 1));movwf reg0 ;call LineWrite ;escreve a linha apontada no primeiro endereçomovlw high (TABELA_BASE + (SIZEOF_LINHA * 2)); toma a segunda linha a receber...movwf reg1 ;movlw low(TABELA_BASE + (SIZEOF_LINHA * 2));movwf reg0 ;call LineWrite ;escreve a linha apontada no primeiro endereço...;repita por N linhas....nao fiz iterativo,pois precisaria;de pelo menos uma multiplicação 8x8, e no PIC isso nao;é tarefa trivial :Dreturn;; PixWrite();; Rotina que escreve um certo numero de pixels de uma linha; reg0 - pixel a ser escrito;;PixWrite:movf reg0,w ;movwf pixmovlw .8 ;movwf pixelBCount ;inicializa contador de pixelsPixWrLoop:movf PORTA, w ;movwf reg0 ;toma o valor corrente de PORTAbcf reg0,0 ;Limpa RA0rlf pix,f ;extrai pixel bit a bitmovf STATUS,w ;andlw 0x01 ; o valor do pixel esta em Ciorwf reg0,w ;movwf PORTA ;escreve o pixel em Ra0decfz pixelBCount,f ;goto PixWrLoop ;return ;encerra sub;; LineWrite();; Rotina que escreve uma determinada linha de pixels.; reg0:1 endereço da linha na memoria de programa; reg2 tamanho da linha em (pixels / byte);LineWrite:movf reg2, wmovwf pixelLCount ;inicializa contador de pixels por linhamovf reg1, w ;movwf PCLATH ;inicializa a buscamovf reg0,w ;prepara calculo do offset:movwf reg2 ;LineWrLoop:call GetLine ;toma o byte da linha apontada por w:mowvf reg0 ;toma o pixel da linha a ser escritocall PixWrite ;escreve os 8 pixels empacotados no bytebcf STATUS,C ;precisamos do carry p/ inc 16bitsincf reg2,f ;aponta ao proximo bytemovf STATUS,w ;andlw 0x01 ;addlw .0 ;addwf reg1,f ;movf reg1, w ; movwf PCLATH ;prepara para apontar ao proximo byte movf reg2, w ; decfz pixelLCount,f ;goto LineWrLoop ;repete ate transmitir toda a linhareturn ;tudo ok! ;; GetLine(); Essa rotina toma uma linha da tabela salva na flash; PCLATH ja deve estar configurado e aparte alta vai em W:;GetLine:movwf PCL ;ORG TABELA_BASE + (SIZEOF_LINHA * 0)retlw b'00000000'retlw b'11110000' ...;Pixels da linha 1, cada bit é um pixel;devem conter SIZEOF_LINHAS para cada 8pixelsORG TABELA_BASE + (SIZEOF_LINHA * 1)retlw b'00000000'retlw b'11110000' ...;Pixels da linha 1, cada bit é um pixel;devem conter SIZEOF_LINHAS para cada 8pixelsORG TABELA_BASE + (SIZEOF_LINHA * 2)retlw b'00000000'retlw b'11110000' ...;Pixels da linha 1, cada bit é um pixel;devem conter SIZEOF_LINHAS para cada 8pixels;E por ai vai ate acabar as linhas, ou a memoria de ;programa... Bem agora é com voce, se tiver duvidas, volte que vejo o que posso fazer, tem uma turma do PIC aqui que anda bem mais fera que eu pra essas coisas pessoal se errei algo grotesco por favor corrijam sem piedade. Abs.

Veja essa discussão a respeito do programador: http://www.sonsivri.to/forum/index.php?topic=28520.0 Nesse mesmo link tem um outro para download do software de programação. Só acho que se o oobjetivo foi comprar um gravador de microcontroladores Microchip (PIC), creio que perdeste dinheiro, o foco desse programador é para memórias eeprom, como a série 24 e 93, que são fabricadas por Atmel e Microchip. Pelo que li esse gravador suporta apenas alguns microcontroladores da atmel que possuem interface ISP. Abs.

Basicamente, é importante conhecer a estrutura de uma memória eeprom, ou melhor, estrutura de uma memoria em geral. Vamos pensar em unidades de bytes, por exemplo...quantos bytes possui um int16? dois certo? Cada posição de endereço da eeprom do PIC, corresponde a apontar para 1 byte na memoria eeprom dele, então se queremos guardar um int16 serao necessarios logo duas posições de endereço certo? o que se traduz em fazer a escrita duas vezes, em dois endereços diferentes, no caso do pic que é little endian, geralmente escreve - se primeiro o high byte e depois o low byte. Da uma olhada nesse exemplo, a rotina eeprom_write, mais interna seria a interna do CCS: /* Exemplo de escrita de um int16 na eeprom:*/void EepromWrite16(uint16_t data, uint16_t address){ uint8_t lowByte, highByte; //divide o int16 em dois bytes: highByte = (uint8_t)(data >> 8); lowByte = (uint8_t)(data &0xFF); //Escreve respeitando o fato do pic ser little endian: //primeiro o highbyte: eeprom_write(highByte, address); //Agora o low byte eeprom_write(lowByte, address + 1);} O processo de leitura é basicamente o inverso. Abs.

Então, imaginei que a memoria RAM seria pouca. o problema é que esse recurso é limitado (e muito) nos PIC16, principalmente essese mais antigos como o 628A. Esse PIC se me lembro bem tem 256B de RAM, ou seja não só sua tabela esta limitada como também você esgotou toda a RAM do processador Para PICs com mais que esse valor de RAM, você pode terá que fazer acesso banco a banco, o que é um verdadeiro saco, e é capaz de ainda por cima esgotar a RAM de novo. Tem certeza que nao vale investir em um microcontrolador mais moderno, até o PIC18 vale. Uma opção como ja citada antes seria colocar uma memória RAM externa, e por o PIC16 para controla-la, não é uma tarefa fácil, o acesso pode ficar bem leeeeento visto que todos os sinais de sincronismo vão ficar a cargo do processador. Além disso tem o outro problema que você acabou de enfrentar, endereçar mais que 256B de memória, muitos micros de 8Bits possuem alternativas para endereçamentode 16bits permitindo acesso linear a 64KB de memoria, no caso do pic a coisa deve ser feita na mão, ou seja concatenar dois registradores de 8bits e implementar aritmética básica de 16bits para controlar os ponteiros. o Problema é que o PIC16 nao oferece nada de suporte para 16bits, então é tudo na mão, veja como ficaria pra incrementar um ponteiro de 16bits: ;;Exemplo de incremento de endereço de 16bits;;cblock 0x20 reg0 ;registros de uso geral reg1 reg2 reg3 Adr:2 endc;;Incremento16bits;Inc16: incf Adr,f ;incrementa byte menos significativo movf STATUS,w ;toma o status andlw 0x01 addlw .0 ;soma dummy, pois a parte alta do segundo operando é semrpe 0 addwf Adr+1,f ;soma a parte alta ;nesse momento Adr0:1 foi incrementado por 1 unidade. melhor pensar bem qual caminho vai tomar a partir de agora que seu projeto esta ficando mais complexo.} Abs.

Sim é um valor decimal, estou reservando exatos 24 bytes da RAm para sua tabela. O endereçamento direto do PIC é composto por FSR:INDF, ao passo que FSR aponta ao endereço, para ler ou escrever nesse endereço é necessario escrever por INDF. sim, a mesma coisa. So que o movfw nada mais que que movf x, w emulado. No Pic16 nao existe quase nada a suporte de endereçamento, não sei nesses novos PIC16 enhanced core, a turma que conheço que trabalha com eles me falou que melhorou muito. A partir do PIC18 a coisa melhora pois voce possui tres FSRs que endereçam até 64KB de memoria RAM, alem de modos de incremento e decremento automático e acesso indexado sem alterar o endereço base. Tudo respondido? Abs.

então, o que fiz foi o metodo para uma leitura byte a byte, mais elementar possível. veja que você nao especificou por exemplo, onde estará a imagem, na RAM? Memoria de programa? veja ainda que acesso indireto pelo FSR, é um dos métodos mais eficientes para leitura de stream de dados na RAM. Veja que o lento é relativo, você por exemplo não cogitou, elevar o clock do seu microcontrolador por exemplo. E vale lembrar que pelo baixo custo do PIC seria pedir muito instruções de um unico ciclo de máquina para endereçamento indireto. E mais um fator de complexidade que você não especificou, como vai ler os pixels(indices), sequencialmente? ou aplicando offsets, isso tambéem deixa a leitura mais lenta. Basicamente se fosse pra transmitir diretamente um vetor de dados que esta na memoria RAM para um POrt daria pra fazer assim: Tem um pequeno overhead, mas a leitura da RAM para o PORTA é feita em 2 instruções, veja que todo tipo de rotina que envolvam vetores de dadosm voce deve nao apenas colocar os tempos de leitura ou escrita, mas também deve reservar um adicional para overhead ou seja atualização dos pontos de leitura e escrita, nao sei se a rotina acima resolve o seu problema. Se a imagem estiver alocada na memoria de programa, ai sim, prepare se pra aumentar o clock pois o acesso em flash é mais lento ainda. Uma sugestão veja essa discussão que explica sobre endereçamento com os registros FSR e INDF: http://www.piclist.com/techref/microchip/fsr.htm Abs

O unico porém do exemplo postado pelo colega @vtrx situa-se no fato dessa tabela estar em code space, ou seja se for usar por exemplo o conceito de frameBuffer para processar, ou modificar uma imagem em runtime, ele não serve, é uma solução muito boa para amrazenamento de constantes no caso uma imagem constante. Para uma matriz 2x2 por exemplo, um vetor vetor unico de dados é o bastante, como o colega @vtrx ja disse, estruturas de dados em asssembly tomam sempre a forma de tabelas, o que mudam são os offsets para acesso aos elementos dela, e a aritmética disponível no PIC é o que vai determinar a quantidade de cabelos que vai perder para implementar uma estrutura de dados mais sofisticada. Abs.

@Vicente Cesar, Implementar um vetor indexado em assembly para PIC, pode não parecer mas é uma tarefa trivial se souberes como funciona o par de registros INDF e FSR, usando a capacidade de endereçamento direto basta que você reserve a quantidade de bytes que sua tabela deve ocupar em memoria (ou seja numero de posições x numero de bytes que cada posição ocupa), com isso, basta carregar o FSR com o endereço inciial da tabela e adicionar um offset a posição que desejas. Veja esse exemplo beeem genérico, o processo de leitura vou deixar sem implementar pra você pensar um pouco e entender o conceito. Segue: ;;;Simples exemplo de tabela em assembly:;;cblock 0x20...reg0 ;registros de uso geralreg1reg2reg3tabela : 16 ;reserva dados para uma tabela de 16bytes....mais vaiaveis suas aquiendc;; exemplo de escrita na sua tabela em ram space:; passa o o indice a ser escrito em reg0, valor em reg1;escreveTabelaIndice: movlw Tabela ;toma o endereco base da tabela movwf FSR ;FSR aponta ao inicio da tabela movf reg0,w ;toma o indice que vai acessar addwf FSR,f ;faz FSR apontar para a posicao a escrever movf reg1,w ; movwf INDF ;escreve na posicao desejada return ;pronto, dado escrito, o processo del eitura eh analogo Abs

Boa observação @vtrx, porém tem um ponto que pode ser pesado, o que vale mais, perder alguns ciclos e fazer alguns bitwises para leituras quebradas em ports diferentes, ou gastar a CPU inteira apenas para ter a comodidade de posicionais os IOs da forma que bem entender? Eu vejo o uso de interfaces dessas por microcontroladores pequenos, que são muitas vezes usados como hardware periferico inteligente e precisam falar com algum master. Abs.

@, Estamos ai pra ajudar Abs.

Ops, pois é faltou esse pequeno detalhe como citado pela Isadora. Senão não funciona

Não faria isso para fazer uma leitura, vale lembrar que dependendo do valor da resistência fixada em VCC e dado ao valor limitado da impedância de entrada do A/D é possivel que se tenha um valor errôneo de tensão. o ideal seria tomar a saida do divisor de tensão e utilizar um simples seguidor de tensão para obter uma saíad de baixa impedância do ponto a ser medido. Isso nao vai acontecer pelos motivos que ja citei, por exemplo se ele colocar um resistor de 500K, mesmo que o resistor em paralelo com o ADC fosse de 10M, em paralelo com pifios 2.5K de impedancia de entrada do ADC, formaria um Req equivalente fazendo a tensão "sumir" nesse ponto, e aparecendo quase que em sua totalidade no resistor de 500K, mesmo ele sendo menor que o de 1 Mega. Um circuito assim seria o ideal: Em lugar de R3 você ligaria a porta analógica do teu Arduino, e prefira amplificadores operacionais com porta de entrada baseada em JFETs, garantindo assim uma elevadissima impedancia de entrada para medida, e uma iimpedancia de saida de baixo valor para envio do sinal ao A/D. Abs.

Acho isso um tanto como genérico, é evidente que quem vem do 8bits, quando pula para um 32 aprende mais facilmente e cai menos em problemas de arquitetura pois ja tem uma cultura de programar ao lado do manual de referência. Acho que o conceito de "pensa que sabe" pode estar em qualquer lugar, inclusive com a turma do Arduino (que vai vejam só um AVR de 8bits). Quando falo de cultura é essa, por exemplo essa da PLL de 64MHz eu conhecia também, pois em algum momento da minha vida eu li o manual do tiny, e olha que essa não é uma informação que esta nas entranhas do HW. Sobre a USB, nem precisa ser um tinny, procure pelo projeto USBasp, eles emulam apenas o kernel da USB usando um mega comum, sem essa PLL presente nos tinys mais modernos.

@Robson Lopes, tudo bem? Bit banging é legal e chato ao mesmo tempo, fiz esse pequeno transceiver UART bem rudimentar numa meia hora que fiquei ocioso no trabalho, acho que da pra você ter uma ideia de como sair manipulando os bits, repare no entanto que o codigo é generico e precisa ser entendido e adaptado aos poucos para seu chip, além disso as rotinas de delay qye vão dar o baudRate tambem nao foram implementadas (uartDelay e HalfDelay) vou deixar isso a seu criterio como estudo extra. No mais, se tiver duvidas pergunta ai que a gente responde, agora o codigo: ;;Transceiver UART rudimentar para PIC16;Autor: FSN;;cblock 0x20 ;declara algumas variaveistxCharrxChartmpreceivedCharbitCountintconTempstatusTempendc;;; UartTx - Envia um caractere pela Uart em bitbanging; O caractere é passado em w, o TX fica em RB0 para melhorar a performance;;UartTx: movf INTCON, w ;faz um push em intcon movwf intconTemp ; bcf INTCON, GIE ; movf STATUS, w ;faz um push em status movwf statusTemp ; clrf tmp ; movwf txChar ;passa para o buffer de transmissao movlw bitCount, .8 ;numero de bits a transmitir bcf STATUS, C ;derruba o carry bcf PORTB,0 ;gera o startbitTxLoop: call uartDelay ;aguarda o tempo de 1 bit rrf txChar,f ;rotaciona o bit de transmissao corrente pelo carry movf PORTB,w ; movwf tmp ; movlw 0xFE ; andwf tmp,f ;faz reset virtual do pino de TX movf STATUS,w ;toma o carry, nele contem o bit a ser transmitido andlw 0x01 ; iorwf tmp, w ; movwf PORTB ;Finalmente transfere o novo bit ao pino de TX TxLoop_a: decfsz bitCount,f ;repete ate transmitir todos os bits goto TxLoop ; bsf PORTB,0 ;stop bit call uartDelay ; movf statusTemp,w ;restaura o estado dos registtrps movwf STATUS ; movf intconTemp,w ; movwf INTCON ;restaura interrupts return ;;; UartRx - Retira um caractere vindo do bitbanging; O caractere retorna em w;;UartRx: movf STATUS,w ; movwf statusTemp ;salva resgitrador de status btfss receivedChar,7;checa se tem caractere no buffer goto NoChar ; bcf receivedChar,7;indica que nao tem mais caractere a recberNoChar: movf statusTemp,w ; movwf STATUS ;restaura contexto aritmetico movf rxChar, w ;toma o caractere return ;;ReceiveISR: rotina para tomada de caracterese pela UART;;ReceiveISR: movf STATUS, w ;faz um push em intcon movwf statusTemp ; ;O primeiro bit é sempre o start movlw .8 ; movwf bitCount ;quantidade de bits a receber: clrf rxChar ; call halfDelay ;aguarta um tempo igual a metade do bit bcf STATUS,C ; ReceiveLoop: call uartDelay ;aguarda o tempo de bit: rlf PORTB,w ;toma estado do bit recebido movwf tmp ; rlf tmp ;desloca mais uma posicao para ficar no bit3 swapf tmp,f ;troca os nibbles e desloca para o bit7 MSB movlw 0x80 ; andwf tmp,w ;mascara o que nao interessa iorwf rxChar,f ;finalmente insere no buffer rrf rxChar,f ;roda a direira, LSBs First decfsz bitCount,f goto ReceiveLoop ;repete ate receber todos os bits bsf receivedChar,7 ;sinaliza que tem caractere no buffer movf statusTemp,w ; movwf STATUS ;restaura contexto retfie ;encerra rotina de recepcao.

Ops, queira me desculpar, ciclo de clock, não dá devido as próprias caracteristicas do PIC, seu pipeline, que por conseguinte divide o clock de entrada por 4. Logo pra toda e qualquer frequência de clock que você usar, admita que o PIC roda a essa frequência dividida por 4, triste mas tem suas vantagens uma vez que a maioria esmagadora das intruções levam 1 ciclo de máquina. Abs.

Perai, antes me esclareça, quando você diz na mão é fazer uma software UART? Ou usando hardware para comunicação serial que já existe no PIC e quais os registradores? Vale lembrar que programas: UART, I2C, SPI e etc consomem e muita CPU do processador, para tratar todos os eventos de comunicação. Mas vamos lá esclareça isso, que ja podemos começar a te nortear. Abs

Claro, assim: nop ;gasta 1 ciclo de clock sem fazer nada Essencialmente quando você chama qualquer subrotina a atraves da insgtrução Call, o processador irá guardar uma pilha, o endereço corrente acrescido de mais 1, quando, dentro da subrotina você usa a instrução return, o processador move o valor salva no topo da pilha para o contador de programa e que desvia e retorna do ponto onde ele fez a chamada call. Abs.

é esse tipo de comentário que acaba com a credibilidade do fórum. Inclusive se a turma do assembly ler isso... @Vicente Cesar, para resolver suas dúvida existe mais de um caminho, o dito timer que você aparenta querer, é o famigerado delay, aquele que você especifica quantos segundos o programa deve aguardar para continuar operando, embora seja umas solução simples ela peca pelo fato da CPU ficar parada enquanto o tal delay aguarda e você fica impedido de realizar alguma outra tarefa, para tal existem formas mais sofisticadas baseadas em callbacks, onde você pode guardar o par PC:PCLATH e desviar o fluxo do programa de forma temporária, quando o timer estourar...a propria subrotina faz um "pop" desse par e o prgrama retorna da onde parou. Para tal preciso de mais informações, então vou admitir que queira a solução mais simples. Veja esse simples delay: cblock 0x20 ;area de variaveiscontadorSegundoscontadorMiliscontadorBaseintconTempendc;; DelayBase; Essa funcao executa um delay em base de tempo de 10ms;DelayBase: movlw .100 ; movwf contadorMilis ; movlw .249 ;valor empirico para delay preciso de 1ms a 4MHz movwf contadorBase ;DelayBaseLoop: clrwdt ; + 1cy decfsz contadorBase,f ; + 1cy goto DelayBaseLoop ; + 2cy decfsz contadorMilis,f ; cada vez que chegar nesse ponto ; significa que se passou 1ms goto DelayBaseLoop-2 ; return ;;; DelaySegundos; Essa funcao faz a CPU ficar parada por N segundos ate um maximo de 25; onde para cada segundo deve ser passado um valor igual a 10; obs o parametro deve ser passado em wDelaySegundos: movwf contadorSegundos movf INTCON,w movwf intconTemp ;salva contexto fazendo push em intcon bcf INTCON,GIE ;derruba interrupcao call DelayBase ;delay de 10ms decfsz contadorSegundos ; goto $-1 ;repete ate zerar o contador movf intconTemp,w ; movwf INTCON ;restaura interrupcoes return ; Usando: ;; Seu código...;movlw .10call DelaySegundos ;fica travado aqui por 1 segundo;; continue seu codigo; De mais detalhes para sabermos se outras aproximações podem ajuda - lo melhor. Abs.

Permitam - me ser mais críticos, não me batam por favor, rs: Isso é pensamento típico de quem nunca viu o que se tem por trás do Arduino (não estou dizendo que seja o caso) mas para fins de esclarecimento, o Arduino nada mais é que um processador AVR (ARM nos mais parrudos) com um bootloader programado, e uma pequena (sim pequena) pilha de software para abstrair o hardware, os stacks prontos são trabalhos relizados pela comunidade, sim gente como nós, e para tacar mais lenha na fogueira, PIC programado usando - se de ferramentas como MikroC e CCS tendem a ter tanta ou mais abstração por trás do hardware que você É OBRIGADO a usar, pois a ferramenta é fechada, o que não ocorre no caso do Arduino, onde você pode desenvolver em modo bare-metal sem usar uma linha da framework, ou o firmware inteiro em assembly, ai fica minha questão, que ferramenta que é para os fracos? Eu particularmente sei do outro lado, que tem muito "programador de embarcados" que tem apenas algum conhecimento sobre Arduino, mas isso não serve de embasamento pra jogar pedra na ferramenta, acho que antes de tudo vale uma exploração criteriosa em cima da ferramenta que é aberta, se você não gostou de como ela é, então modifique é open pra isso. PS.: Não sou nenhum usuário ávido do Arduino, recomendo a amigos meus sempre num momento certo, nunca como ferramenta inicial, mas eu tive o prazer de acompanhar o nascimento da ferramenta quando nem se falava em FT232 para realizar o flash dela. Peço desculpas se fugi muito do tópico. Abs.

Discordo, o tipo de projeto não é dos mais triviais, mas hoje se tem material a rodo para começar a projetar seu proprio VANT, o caso é que nao é necessário partir logo de cara para o mais complicado, ao amigo autor do tópico sugiro que comece seus estudos pelos quadrotores, a grande vantagem é a baixa complexidade da mecânica envolvida, o maior esforço mesmo é o ajuste por SW, mas nada de outro mundo, ainda mais com o Arduino e suas frameworks disponiveis. Aqui um bom material pra vocÊ começar: http://wiki.openpilot.org/display/Doc/Basic+QuadCopter https://courses.edx.org/courses/TUMx/AUTONAVx/2T2014/info http://www.scoutuav.com/2011/12/13/low-cost-arduino-based-auto-stabilizing-system/ Vejam que a maioria desses projetos são feitos por makers e não profissionais, eu mesmo tenho um projetinho em mente e no papel, para um quadrotor, preciso de tempo hahaha. Abs

Didaticamente: 0xFFFF = 0xFF00 | 0x00FF, Especificamente o "|" significa um bitwise or, ou seja faz or entre todos os bits, para formar a variavel de 16 bits. Especificamente no seu caso, voce le o valor do accel em dois bytes, e precisa formar uma variavel unica de 16bits, para tal a primeira leitura que contem o byte mais significativo é deslocada para os 8 bits superiores usando um shift por 8 ( << 8), ao fazer isso voce adiciona tambem 8 zeros aos bits menos significativos, ao tomar a segunda leitura, voce deve juntar a parte baixa ao resultado, como nos bits inferiores so temos zeros e pela algebra de boole: A or 0 = A (onde A é uma variavel qualquer) fazemos simplesmente uma or entre esses zeros e o valor, montando seu resultado em 16 bits. Veja que tambem uma soma poderia ser usada também, pois é analogo a uma soma decimal. espero que esclareça. Abs.