infrarossi VHDL

[urakiki]

Ciao a tutti,

Qualcuno potrebbe fornirmi un codice VHDL che attua il infrarossi.

 

[echo47]

Si prega di chiarire in che modo uno HDL si riferisce a una lunghezza d'onda della luce.

 

[urakiki]

Ci dispiace per info mancanza.

Vorrei progettare un ricevitore IR con interfaccia APB.La possibilità di sostenere RC5 o formato NEC.

 

[rsrinivas]

è l'APB AMBA.
IR è u analogico può acquistare chiunque da un negozio di hobby, ma assicuratevi che sia una lunghezza d'onda corrisponde con il Tx IR.quindi i dati di esempio dal Rx IR (dipende da come la trasmissione @ ur fine trasmissione) bcos u need a convertirlo in prima digitale poi, quando ur fatto con questo u necessità di interfaceit per il bus APB Modulo di creazione di ur o design come master o slave per i quali u need a file wrapper writea.

 

[ship_baba]

--################################################ ################################################## #######
- Questo codice implementa un decoder RC5 controls.It infrarossi per telecomando a infrarossi attende l'attività si verifica
- E poi inizia il campionamento signal.First i bit di inizio deve essere valido, allora la toggle bit viene campionato,
- Seguita da cinque bit del sistema e, infine, i sei bit di comando.La seconda fase di ciascun bit viene utilizzato
- Di verificare i dati, ogni volta che i dati non sembrano essere validi, il campionamento è stoppen e nessun dato o interrompere
- È stato generated.The e registri dati sono doppio buffer.Un attesa di interrupt viene cancellata dalla lettura
- Il registro di stato e il registro è stato cancellato dalla lettura del sistema o al registro di comando.
--################################################ ################################################## #######

- Registri:
- [Nome] [addr] [7] [6] [5] [4] [3] [2] [1] [0]
- Status x0 0 0 0 0 0 0 TOG RF
- Controllo x1 IE IT 0 0 0 0 0 0
- Sistema x2 0 0 0 S4 S3 S2 S1 S0
- Comando x3 0 0 C5 C4 C3 C2 C1 C0

- TOG - Toggle, mostra lo stato del bit ricevuto toggle
- RF - Registrati piena, quando i nuovi dati sono disponibili ad alta
- IE - Interrupt Enable, generare un interrupt quando il decoder è abilitato e dati ricevuti
- IT - Attiva Attiva / disattiva il decoder
- Sx - System, il 5 bit del sistema del codice ricevuto RC5
- Cx - Command, il Comando 6 bit del codice ricevuto RC5

--################################################ ################################################## #######

library IEEE;
uso IEEE.std_logic_1164.ali;

entità RC5 è
port (CLK: in std_logic; - segnale di clock
rst: in std_logic; - reset logica Basso
RD: in std_logic; - la logica a bassa leggere
WR: in std_logic; - la logica a bassa scrittura
CS: in std_logic; - chip logico basso selezionare
RC5: in std_logic; - infrarosso dati di ingresso
addr: in std_logic_vector (1 downto 0); - Indirizzo di ingresso bus
data_in: in std_logic_vector (7 downto 0); - ingresso bus dati
data_out: out std_logic_vector (7 downto 0); - uscita
int: out std_logic); - la logica a bassa interrupt output
end entity;

RTL architettura di RC5 è
- frequenza di clock di sistema in un'ora Hz.The è preferito ad essere un multiplo intero di 2248Hz
costante SYS_CLK: integer: = 200.000; - Esempio: 200kHz
CLKS4BIT costante: integer: = SYS_CLK/562; - Calcolare il numero di clock in bici in ogni bittime RC5 (che è 1.778ms)
BUSOFF costante: std_logic: = 'Z'; - Impostare a 'Z' quando si effettua bidirezionale bus

- I segnali generati da Decoder ...
STATI tipo è (IDLE, START, A LEVETTA, SISTEMA DI COMANDO, arrivo);
stato del segnale: STATI; - gli Stati per i frame di dati RC5

segnale interstate: integer range 0-1;
bit_cnt segnale: range intero 0 a 5; - Sportello Unico per bit di dati
sys_buf segnale, sys_reg: std_logic_vector (4 downto 0);
com_buf segnale, cmd_reg: std_logic_vector (5 downto 0);

toggle_buf segnale, toggle_reg, reg_full, clk_en: std_logic;
enable_bit segnale, int_enable, campione: std_logic; - i segnali generati da Scrivere - clock di campionamento

- I segnali generati da ClockGen ...
CNT segnale: integer range da 0 a CLKS4BIT;

iniziare

- Questo sequenze di macchina a stati tramite una sequenza di bit previsto RC5 dopo un primo bordo è stato rilevato.
- La prima metà di ciascun bit bifase viene utilizzato come designatore dei dati.La seconda metà è utilizzata per
- Verifica.Quando una di queste parti secondo fallisce, l'intera trasmissione è considerato non valido e
- Nessun dato viene mantenuto e non interrupt generato.

Decoder: processo (RST, CLK)
iniziare
if (rst = '0 ') then sys_reg <= (others => '0');
cmd_reg <= (others => '0 ');
toggle_reg <= '0 ';
clk_en <= '0 ';
interstate <= 0;
state <= IDLE;
elsif (clk'event e clk = '1 ') then
if (state = idle e rc5 = '1 'e interstatali = 0) allora
clk_en <= '1 ';
interstate <= 1;
end if;
if (campione = '1 '), poi interstate <= interstatali 1;
caso è stato
quando IDLE => interstate <= 0;
if (interstate = 1) then
if (RC5 = '1 ') poi stato <= START;
else clk_en <= '0 ';
end if;
end if;
quando START =>
if (interstate = 0) allora
if (RC5 = '1 ') poi state <= IDLE;
clk_en <= '0 ';
end if;
altro
if (RC5 = '0 ') poi state <= IDLE;
clk_en <= '0 ';
else stato <= TOGGLE;
end if;
end if;
quando TOGGLE =>
if (interstate = 0) allora toggle_buf <= non rc5;
else state <= IDLE;
interstate <= 0;
if (toggle_buf = rc5) poi stato <= sistema;
bit_cnt <= 0;
end if;
end if;
Quando il sistema =>
if (interstate = 0) allora sys_buf <= (non rc5) & sys_buf (4 downto 1);
else interstate <= 0;
bit_cnt <= bit_cnt 1;
if (sys_buf (4) / = rc5) poi state <= IDLE;
end if;
if (bit_cnt = 4) poi stato <= comando;
bit_cnt <= 0;
end if;
end if;
quando il comando =>
if (interstate = 0) allora com_buf <= (non rc5) & com_buf (5 downto 1);
else interstate <= 0;
bit_cnt <= bit_cnt 1;
if (com_buf (5) / = rc5) poi state <= IDLE;
end if;
if (bit_cnt = 5) poi stato <= Fine;
end if;
end if;
quando FINISH =>
if (interstate = 0) allora
if (RC5 = '1 ') poi state <= IDLE;
end if;
altro
state <= IDLE;
clk_en <= '0 ';
if (RC5 = '0 ') then sys_reg <= sys_buf;
cmd_reg <= com_buf;
toggle_reg <= toggle_buf;
reg_full <= '1 ';
end if;
end if;
quando gli altri => state <= IDLE;
interstate <= 0;
end case;
end if;
end if;
Decoder fine processo;

- I dati sono attaccato sul fronte di discesa di RD (e quindi un ampio pronto sul fronte di discesa, in cui i dati sono
- Leggi da parte della CPU).

Lettura: processo (RST, RD)
iniziare
if (rst = '0 ') then data_out <= (others => BUSOFF);
elsif (rd'event e rd = '0 ') then
if (cs = '0 ') then
addr caso è
quando "00" => data_out <= "000000" & toggle_reg & reg_full;
quando "01" => data_out <= int_enable & enable_bit & "000000";
when "10" => data_out <= "000" & sys_reg;
quando "11" => data_out <= "00" & cmd_reg;
when others => null;
end case;
else data_out <= (others => BUSOFF);
end if;
end if;
fine processo di lettura;

- I dati vengono registrati sul fronte di salita del segnale WR.

Scrivere: processo (RST, WR)
iniziare
if (rst = '0 ') then int_enable <= '0'; enable_bit <= '0 ';
elsif (wr'event e WR = '1 ') then
if (cs = '0 ') then
addr caso è
quando "01" => int_enable <= data_in (7); enable_bit <= data_in (6);
when others => null;
end case;
end if;
end if;
Scrivere fine processo;

- Il generatore di clock produce il clock di campionamento per i dati RC5 Un impulso di campione viene prodotta in un quarto
- Ed a tre quarti di ciascun bit.(al centro di ogni livello bifase)

ClockGen: processo (clk_en, clk)
iniziare
if (clk_en = '0 '), poi campione <= '0'; cnt <= 0;
elsif (clk'event e clk = '1 '), poi campione <= '0'; cnt <= cnt 1;
if (cnt = CLKS4BIT) allora campione <= '1 ';
elsif (cnt = (CLKS4BIT * 3)), poi campione <= '1 ';
elsif (cnt = ((CLKS4BIT * 4) - 1)) allora cnt <= 0;
end if;
end if;
ClockGen fine processo;

- Un interrupt viene generato al momento il registro di stato è scritta (quindi il registro di stato
- Deve essere aggiornato l'ultima) Quando uno inizia a leggere l'azione del dispositivo, l'interrupt viene cancellato.
- NOTA: è possibile perdere un interrupt, vale a dire quando una sequenza viene ricevuta una nuova, mentre la CPU host
- È occupato lettura dei registri.Che è comunque un evento raro in quanto sequenze RC5 dovrebbe avere
- Un tempo di ripetizione di 114 ms.E 'possibile avere un nuovo intterrupt attesa per l'azione di leggere alla fine.

Interrupt: processo (RST, CS, RD, reg_full)
iniziare
if (rst = '0 'o (cs = '0' e v = '0 ')), allora int <= '1';
elsif (reg_full'event e reg_full = '1 ') then
if (int_enable = '1 '), allora int <= '0'; end if;
end if;
processo di fine interrupt;

end rtl;