Interrupções e Bit Shift

Olá pessoal, tudo joia?
Fiquei meio sumido aqui do forum por conta de faculdade mas to de volta. hehehe

Estou desenvolvendo pro trabalho final um projeto que gera um sinal de video PAL pelo PIC.
Como o tempo é uma coisa importantissima, primeiramente resolvi usar a biblioteca Delays.h e controlar exatamente como seria o meu sinal.
funcionou perfeitamente, e vou mostrar o resultado no video de apresentação.

O problema é que resolvi desenvolver uma biblioteca um pouco mais complexa baseada em interrupções.

Primeira duvida:
Estou usando o Timer0 para interrupções que ocorrem a cada 4 microssegundos. Pelas minhas contas eu teria que colocar o prescaler de 1 para 1 mesmo e a contagem se iniciar do 208 (usando 8 bits). Estou confiando nas contas, porque nao sei como debugar isso.

Segunda duvida:
A biblioteca baseia cada linha da TV a ser desenhada em uma variavel unsigned int, que tem 16 bits.
Cada bit dessa variavel seria o Output do pino a cada estouro da interrupção.
por exemplo:

Código:

unsigned int buffer = 0b0001000100001000;

primeiro estouro vai ler -> 0b0001000100001000;
segundo estouro vai ler -> 0b0001000100001000;
terceiro estouro vai ler -> 0b0001000100001000;
quarto estouro vai ler -> 0b0001000100001000;

e assim por diante.....

Como a interrupcao é gerada a cada 4us, ele vai levar 64 us para ler todos os bits - tempo exato para uma linha do sinal -

Estou lendo através de uma mascara de bits. assim:

Código:

unsigned int mascara = 0b1000000000000000;

a cada interrupcao eu dou um shift pra direita:

Código:

mascara >>=1;

e estou pegando cada valor assim:

Código:

 Valor_lido = buffer & mascara;

quando a mascara se iguala a zero, eu seto ela como 65356 (0b1000000000000000);

até aí tudo lindo na teoria... mas nao sei porque ele simplemente nao funciona.
Nao sei bem certo qual é o problema, mas me parece que está entre 3 coisas:

-O valor lido usando a mascara nao esta sendo lido corretamente
-A interrupcao nao esta sendo gerada num intervalo de 4us
- Nao está fazendo o Shift da mascara.



Alguém pode me dar uma luz? hehehe desculpem o post imenso.. mas é que já perdi varias noites e nao sei o que tá acontecendo.
Abraços!

Olá Righi,

Bom te ver novamente no forum,
Fico feliz por seu projeto ter dado certo com o uso do delays e quero muito ver este vídeo. É uma pena nao poder ver o seu projeto pessoalmente...
Grava ele bem detalhado para nós ok? Se tiver um tempo posta um resumo no forum em um tópico sobre PAL pelo PIC, porque eu conheço um monte de pessoas que gostariam de fazer este projeto.
Acho ótimo seu investimento em interrupções para este projeto. Delays "travam" o microcontrolador o que atrapalha a elaboração de outros projetos usando o PAL pelo PIC.
Vamos a sua dúvida:

1- Eu refiz as contas e encontrei também 208 para um prescaler de 1 para 1 e o clock em 48MHz. Para debugar isto você teria que mandar mudar o estado de uma porta digital dentro da interrupção e usar um ociloscópio. Eu acredito que isto está certo.

2- O tempo para que ele faça o deslocamento da máscara e a comparação com o buffer para atribuir no valor_lido é de 2.583333 micro segundos.

Código:


mascara >>=1;
Valor_lido = buffer & mascara;


Equivale a 31 instruções (de maquina) e 2.583333 Mais um pouco para mudar a porta que voce esta usando...

Você está levando em consideração o tempo que gasta da entrada na interrupção até a mudança da porta de saída? Pode ser este o problema da sincronia do seu projeto. A máscara (tanto no deslocamento quanto na atribuição) está funcionando. E a interrupção está em 4 micro segundos. Se não esse tempo me fala que vou pensar mais um pouco no seu projeto.

Abraços,
Bruno S. Avelar

Muito obrigado pela resposta Bruno, realmente parece que ele estava fazendo mais instruções do que deveria e avacalhando o timming.
Arrumei algumas coisas aqui e ele gerou um sinal mais claro, mas ainda não está ideal. Estudando a biblioteca PIC PAL vi uma solução interessante.

atualmente estou fazendo assim:

tenho uma variavel linha e outra chamada buffer.
A buffer contem a informacao da linha que será desenhada.


na interrupção tenho:

Código:


if(!linha)
{
  PINO0 = 0;
  linha = buffer;
}
else
{
 PINO0=1;
}
PINO1 = linha;
linha >>=1;



Ao setar o pino1 = linha percebi que o valor do pino 1 passa a ser igual ao do bit 0 da variavel linha.

O problema é que a operação de shift mais a atribuição da linha inteira ao pino leva muito tempo.


A solução proposta pela PICPAL foi reservar o PORT inteiro, atribuir o buffer ao PORT, e dar um shift dentro do PORT.
Economizando, assim a atribução da linha.

Ainda não testei completamente essa solução porque tenho que mudar alguns pinos de saida, mas assim que tiver resultado, coloco aqui.

Muito obrigado mais uma vez pela ajuda.

Adaptei meu programa ao PORT todo, mas encontrei agora um problema meio complicado de resolver.
Olhando o datasheet vi que o melhor PORT pra eu usar seria o PORTD, contudo alguns leds compartilham esse bit, fazendo com que não funcione direito meu programa.

Achei que o ideal seria fazer com o PORTB, pois ele tem todos os 8 bits disponiveis para uso. Mas olhando melhor vi que ele compartilha alguns bits com a Interrupção, estou certo??

Mas se isso acontece, como o PORTB é usado no display de 7 segmentos e conseguimos usar-lo junto com o Timer0?

Vou interromper o tópico só pra postar o meu video.

Desculpem a qualidade horrorosa, mas só tinha um celular a disposição.
Assim que conseguir melhorar o projeto, eu filmo outro em uma definição maior.

Seu projeto ficou muito bom. Gostei muito do vídeo.
Acredito que agora é usar a biblioteca que você desenvolveu para criar telas a serem projetadas na televisão.
Você está de parabéns.
Vou pensar no seu problema com as portas do KIT e venho com umas sugestão em breve.

O Maumau passou uma página sobre este tema muito interessante. Infelizmente ele usa o PIC 16 e esta em assembly. Mas a teoria é bem explicada e com figuras e códigos fonte bem claros. Deixo o link para vocês:

http://www.rickard.gunee.com/projects/video/pic/howto.php

Abraços,
Bruno S. Avelar

Bruno, foi nesse site e em alguns outros que eu me baseei pra programar o meu projeto.
Muito bem explicado aí! gostei demais.
Uma coisa interessante que li é que como a tv exige a tela sendo desenhada constantemente, onde eles vão fazer a lógica do game?

Os caras mostraram que as primeiras linhas não são desenhadas e eles usam esse tempo pra implementar a lógica do jogo. Achei bem interessante a solução.
Agora entendo porque alguns videogames antigos a tela de jogo só começava mesmo mais pra baixo, no topo da tela era uma linha preta.

nessa screen dá pra ver claramente isso acontecendo:


Estou reescrevendo a biblioteca baseada em interrupções tomando como base algumas tecnicas e dicas que andei lendo e pesquisando. Posto o resultado auqi o mais rápido possível.

Abraços!