'vhdl code'에 해당되는 글 5건

  1. 2010.01.09 8051 VHDL Code
  2. 2010.01.09 VHDL Basic 6
  3. 2010.01.09 VHDL Basic 5
  4. 2010.01.09 VHDL Basic 4 (2)
  5. 2010.01.08 VHDL Basic 2
Studyhard/80512010.01.09 02:59
-- -- 8052 compatible microcontroller, with internal RAM & ROM 
-- -- Version : 0300 
-- -- Copyright (c) 2001-2002 Daniel Wallner (jesus@opencores.org) 
-- -- (c) 2004-2005 Andreas Voggeneder (andreas.voggeneder@fh-hagenberg.at) 
-- -- All rights reserved 
-- -- Redistribution and use in source and synthezised forms, with or without 
-- -- modification, are permitted provided that the following conditions are met: 
-- -- Redistributions of source code must retain the above copyright notice, 
-- -- this list of conditions and the following disclaimer. 
-- -- Redistributions in synthesized form must reproduce the above copyright 
-- -- notice, this list of conditions and the following disclaimer in the 
-- -- documentation and/or other materials provided with the distribution. 
-- -- Neither the name of the author nor the names of other contributors may 
-- -- be used to endorse or promote products derived from this software without 
-- -- specific prior written permission. 
-- -- THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND 
-- -- CONTRIBUTORS "AS IS" 
-- -- AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, 
-- -- THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 
-- -- PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE 
-- -- LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 
-- -- CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 
-- -- SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 
-- -- INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 
-- -- CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 
-- -- ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 
-- -- POSSIBILITY OF SUCH DAMAGE. 
-- -- Please report bugs to the author, but before you do so, please 
-- -- make sure that this is not a derivative work and that 
-- -- you have the latest version of this file. 
-- -- The latest version of this file can be found at: 
-- -- http://www.opencores.org/cvsweb.shtml/t51/ 
-- -- Limitations : 
-- -- File history : 

library IEEE; 
use IEEE.std_logic_1164.all; 
use work.T51_Pack.all; 

entity T8052 is 
generic( tristate : integer := 0; -- 
ROMAddressWidth : integer := 13; 
IRAMAddressWidth : integer := 8; 
XRAMAddressWidth : integer := 11); 
port( Clk : in std_logic; 
Rst_n : in std_logic; 
P0_in : in std_logic_vector(7 downto 0); 
P1_in : in std_logic_vector(7 downto 0); 
P2_in : in std_logic_vector(7 downto 0); 
P3_in : in std_logic_vector(7 downto 0); 
P0_out : out std_logic_vector(7 downto 0); 
P1_out : out std_logic_vector(7 downto 0); 
P2_out : out std_logic_vector(7 downto 0); 
P3_out : out std_logic_vector(7 downto 0); 
INT0 : in std_logic; 
INT1 : in std_logic; 
T0 : in std_logic; 
T1 : in std_logic; 
T2 : in std_logic; 
T2EX : in std_logic; 
RXD : in std_logic; 
RXD_IsO : out std_logic; 
RXD_O : out std_logic; 
TXD : out std_logic; -- External XRAM Wishbone: 
XRAM_WE_O : out std_logic; 
XRAM_STB_O : out std_logic; 
XRAM_CYC_O : out std_logic; 
XRAM_ACK_I : in std_logic; 
XRAM_DAT_O : out std_logic_vector(7 downto 0);
XRAM_ADR_O : out std_logic_vector(15 downto 0);
XRAM_DAT_I : in std_logic_vector(7 downto 0) ); 
end T8052; 

architecture rtl of T8052 is 
component ROM52 
port( 
Clk : in std_logic; 
A : in std_logic_vector(ROMAddressWidth - 1 downto 0); 
D : out std_logic_vector(7 downto 0) ); 
end component; 
component SSRAM 
generic
AddrWidth : integer := 16; 
DataWidth : integer := 8 ); 
port( 
Clk : in std_logic; 
CE_n : in std_logic; 
WE_n : in std_logic; 
A : in std_logic_vector(AddrWidth - 1 downto 0); 
DIn : in std_logic_vector(DataWidth - 1 downto 0); 
DOut : out std_logic_vector(DataWidth - 1 downto 0) ); 
end component; 
constant ext_mux_in_num : integer := 8; --63; 
type ext_mux_din_type is array(0 to ext_mux_in_num-1) of std_logic_vector(7 downto 0); 
subtype ext_mux_en_type is std_logic_vector(0 to ext_mux_in_num-1); 
signal Ready : std_logic; 
signal ROM_Addr : std_logic_vector(15 downto 0); 
signal ROM_Data : std_logic_vector(7 downto 0); 
signal RAM_Addr,RAM_Addr_r : std_logic_vector(15 downto 0); 
signal XRAM_Addr : std_logic_vector(15 downto 0); 
signal RAM_RData : std_logic_vector(7 downto 0); 
signal RAM_DO : std_logic_vector(7 downto 0); 
signal RAM_WData : std_logic_vector(7 downto 0); 
signal RAM_Rd : std_logic; 
signal RAM_Wr : std_logic; 
signal RAM_WE_n : std_logic; 
signal zeros : std_logic_vector(15 downto XRAMAddressWidth); 
signal ram_access : std_logic; 
signal mux_sel : std_logic; 
signal mux_sel_r : std_logic; 
signal ext_ram_en : std_logic; 
signal int_xram_sel_n : std_logic; 
signal IO_Rd : std_logic; 
signal IO_Wr : std_logic; 
signal IO_Addr : std_logic_vector(6 downto 0); 
signal IO_Addr_r : std_logic_vector(6 downto 0); 
signal IO_WData : std_logic_vector(7 downto 0); 
signal IO_RData : std_logic_vector(7 downto 0); 
signal IO_RData_arr : ext_mux_din_type; 
signal IO_RData_en : ext_mux_en_type; 
signal P0_Sel : std_logic; 
signal P1_Sel : std_logic; 
signal P2_Sel : std_logic; 
signal P3_Sel : std_logic; 
signal TMOD_Sel : std_logic; 
signal TL0_Sel : std_logic; 
signal TL1_Sel : std_logic; 
signal TH0_Sel : std_logic; 
signal TH1_Sel : std_logic; 
signal T2CON_Sel : std_logic; 
signal RCAP2L_Sel : std_logic; 
signal RCAP2H_Sel : std_logic; 
signal TL2_Sel : std_logic; 
signal TH2_Sel : std_logic; 
signal SCON_Sel : std_logic; 
signal SBUF_Sel : std_logic; 
signal P0_Wr : std_logic; 
signal P1_Wr : std_logic; 
signal P2_Wr : std_logic; 
signal P3_Wr : std_logic; 
signal TMOD_Wr : std_logic; 
signal TL0_Wr : std_logic; 
signal TL1_Wr : std_logic; 
signal TH0_Wr : std_logic; 
signal TH1_Wr : std_logic; 
signal T2CON_Wr : std_logic; 
signal RCAP2L_Wr : std_logic; 
signal RCAP2H_Wr : std_logic; 
signal TL2_Wr : std_logic; 
signal TH2_Wr : std_logic; 
signal SCON_Wr : std_logic; 
signal SBUF_Wr : std_logic; 
signal UseR2 : std_logic; 
signal UseT2 : std_logic; 
signal UART_Clk : std_logic; 
signal R0 : std_logic; 
signal R1 : std_logic; 
signal SMOD : std_logic; 
signal Int_Trig : std_logic_vector(6 downto 0); 
signal Int_Acc : std_logic_vector(6 downto 0); 
signal RI : std_logic; 
signal TI : std_logic; 
signal OF0 : std_logic; 
signal OF1 : std_logic; 
signal OF2 : std_logic; 
begin 
Ready <= '0' 
when ( XRAM_ACK_I='0' and (ext_ram_en and ram_access)='1') 
else '1'; 
XRAM_ADR_O <= XRAM_Addr(15 downto 0); -- Registered address
XRAM_DAT_O <= RAM_WData; 
XRAM_CYC_O <= ext_ram_en and ram_access; 
XRAM_STB_O <= ext_ram_en and ram_access; 
XRAM_WE_O <= RAM_Wr; 
process (Rst_n,clk) 
begin 
if Rst_n='0' 
then IO_Addr_r <= (others =>'0'); 
RAM_Addr_r <= (others =>'0'); 
mux_sel_r <= '0'; 
elsif clk'event and clk = '1' 
then IO_Addr_r <= IO_Addr; 
if Ready = '1' 
then RAM_Addr_r <= RAM_Addr; 
end if; mux_sel_r <= mux_sel; 
end if; 
end process; 
XRAM_Addr <= RAM_Addr_r; 
rom : ROM52 
port map
Clk => Clk, 
A => ROM_Addr(ROMAddressWidth - 1 downto 0), 
D => ROM_Data); 
zeros <= (others => '0'); 
g_rams0 : if XRAMAddressWidth > 15 
 generate ext_ram_en <= '0'; -- no external XRAM end   
 generate; 
g_rams1 : if XRAMAddressWidth < 16 and XRAMAddressWidth > 0   
generate ext_ram_en <= '1' 
 when XRAM_Addr(15 downto XRAMAddressWidth) /=  zeros else '0'; 
end generate; 
ram_access <= '1' 
when (RAM_Rd or RAM_Wr)='1' 
else '0'; -- xram bus access is pipelined. -- so use registered signal for selecting read data 
RAM_RData <= RAM_DO when mux_sel_r = '0' 
else XRAM_DAT_I; -- select data mux 
mux_sel <= ext_ram_en; -- internal XRAM select signal is active low. 
-- so internal xram is selected when external XRAM is not selected (ext_ram_en = '0') int_xram_sel_n <= ext_ram_en; 
RAM_WE_n <= not RAM_Wr; 
g_ram : if XRAMAddressWidth > 0 
generate ram : SSRAM 
generic map( AddrWidth => XRAMAddressWidth) 
port map
Clk => Clk, 
CE_n => int_xram_sel_n, 
WE_n => RAM_WE_n, 
A => XRAM_Addr(XRAMAddressWidth - 1 downto 0), 
DIn => RAM_WData, 
DOut => RAM_DO); 
end generate; 
core51 : T51 
generic map( 
DualBus => 1, 
tristate => tristate, 
t8032 => 0, 
RAMAddressWidth => IRAMAddressWidth) 
port map
Clk => Clk, 
Rst_n => Rst_n, 
Ready => Ready, 
ROM_Addr => ROM_Addr, 
ROM_Data => ROM_Data, 
RAM_Addr => RAM_Addr, 
RAM_RData => RAM_RData, 
RAM_WData => RAM_WData, 
RAM_Rd => RAM_Rd, 
RAM_Wr => RAM_Wr, 
Int_Trig => Int_Trig, 
Int_Acc => Int_Acc, 
SFR_Rd_RMW => IO_Rd, 
SFR_Wr => IO_Wr, 
SFR_Addr => IO_Addr, 
SFR_WData => IO_WData, 
SFR_RData_in => IO_RData); 
glue51 : T51_Glue 
generic map( tristate => tristate) 
port map
Clk => Clk, 
Rst_n => Rst_n, 
INT0 => INT0, 
INT1 => INT1, 
RI => RI, 
TI => TI, 
OF0 => OF0, 
OF1 => OF1, 
OF2 => OF2, 
IO_Wr => IO_Wr, 
IO_Addr => IO_Addr, 
IO_Addr_r => IO_Addr_r, 
IO_WData => IO_WData, 
IO_RData => IO_RData_arr(0), 
Selected => IO_RData_en(0), 
Int_Acc => Int_Acc, 
R0 => R0, 
R1 => R1, 
SMOD => SMOD, 
P0_Sel => P0_Sel, 
P1_Sel => P1_Sel, 
P2_Sel => P2_Sel, 
P3_Sel => P3_Sel, 
TMOD_Sel => TMOD_Sel, 
TL0_Sel => TL0_Sel, 
TL1_Sel => TL1_Sel, 
TH0_Sel => TH0_Sel, 
TH1_Sel => TH1_Sel, 
T2CON_Sel => T2CON_Sel, 
RCAP2L_Sel => RCAP2L_Sel, 
RCAP2H_Sel => RCAP2H_Sel, 
TL2_Sel => TL2_Sel, 
TH2_Sel => TH2_Sel, 
SCON_Sel => SCON_Sel, 
SBUF_Sel => SBUF_Sel, 
P0_Wr => P0_Wr, 
P1_Wr => P1_Wr, 
P2_Wr => P2_Wr, 
P3_Wr => P3_Wr, 
TMOD_Wr => TMOD_Wr, 
TL0_Wr => TL0_Wr,
TL1_Wr => TL1_Wr, 
TH0_Wr => TH0_Wr, 
TH1_Wr => TH1_Wr, 
T2CON_Wr => T2CON_Wr, 
RCAP2L_Wr => RCAP2L_Wr, 
RCAP2H_Wr => RCAP2H_Wr, 
TL2_Wr => TL2_Wr, 
TH2_Wr => TH2_Wr, 
SCON_Wr => SCON_Wr, 
SBUF_Wr => SBUF_Wr, 
Int_Trig => Int_Trig); 
tp0 : T51_Port 
generic map( tristate => tristate) 
port map
Clk => Clk, 
Rst_n => Rst_n, 
Sel => P0_Sel, 
Rd_RMW => IO_Rd, 
Wr => P0_Wr, 
Data_In => IO_WData, 
Data_Out => IO_RData_arr(1), 
IOPort_in => P0_in, 
IOPort_out => P0_out); 
IO_RData_en(1) <= P0_Sel; 

tp1 : T51_Port 
generic map( tristate => tristate) 
port map
Clk => Clk, 
Rst_n => Rst_n, 
Sel => P1_Sel, 
Rd_RMW => IO_Rd, 
Wr => P1_Wr, 
Data_In => IO_WData, 
Data_Out => IO_RData_arr(2), 
IOPort_in => P1_in, 
IOPort_out => P1_out); 
IO_RData_en(2) <= P1_Sel; 

tp2 : T51_Port 
generic map( tristate => tristate) 
port map
Clk => Clk, 
Rst_n => Rst_n, 
Sel => P2_Sel, 
Rd_RMW => IO_Rd, 
Wr => P2_Wr,
Data_In => IO_WData, 
Data_Out => IO_RData_arr(3), 
IOPort_in => P2_in, 
IOPort_out => P2_out); 
IO_RData_en(3) <= P2_Sel; 

tp3 : T51_Port 
generic map( tristate => tristate) 
port map
Clk => Clk, 
Rst_n => Rst_n, 
Sel => P3_Sel, 
Rd_RMW => IO_Rd, 
Wr => P3_Wr, 
Data_In => IO_WData, 
Data_Out => IO_RData_arr(4), 
IOPort_in => P3_in, 
IOPort_out => P3_out); 
IO_RData_en(4) <= P3_Sel; 

tc01 : T51_TC01 
generic map( FastCount => 0, tristate => tristate) 
port map
Clk => Clk, 
Rst_n => Rst_n, 
T0 => T0, 
T1 => T1, 
INT0 => INT0, 
INT1 => INT1, 
M_Sel => TMOD_Sel, 
H0_Sel => TH0_Sel, 
L0_Sel => TL0_Sel, 
H1_Sel => TH1_Sel, 
L1_Sel => TL1_Sel, 
R0 => R0, 
R1 => R1, 
M_Wr => TMOD_Wr, 
H0_Wr => TH0_Wr, 
L0_Wr => TL0_Wr, 
H1_Wr => TH1_Wr, 
L1_Wr => TL1_Wr, 
Data_In => IO_WData, 
Data_Out => IO_RData_arr(5), 
OF0 => OF0, OF1 => OF1); 
IO_RData_en(5) <= TMOD_Sel or TH0_Sel or TL0_Sel or TH1_Sel or TL1_Sel; 

tc2 : T51_TC2 
generic map( FastCount => 0, tristate => tristate) 
port map( 
Clk => Clk, 
Rst_n => Rst_n, 
T2 => T2, 
T2EX => T2EX, 
C_Sel => T2CON_Sel, 
CH_Sel => RCAP2H_Sel, 
CL_Sel => RCAP2L_Sel, 
H_Sel => TH2_Sel, 
L_Sel => TL2_Sel, 
C_Wr => T2CON_Wr, 
CH_Wr => RCAP2H_Wr, 
CL_Wr => RCAP2L_Wr, 
H_Wr => TH2_Wr, 
L_Wr => TL2_Wr, 
Data_In => IO_WData, 
Data_Out => IO_RData_arr(6), 
UseR2 => UseR2, 
UseT2 => UseT2, 
UART_Clk => UART_Clk, 
F => OF2); 
IO_RData_en(6) <= T2CON_Sel or RCAP2H_Sel or RCAP2L_Sel or TH2_Sel or TL2_Sel; 

uart : T51_UART 
generic map( FastCount => 0, tristate => tristate) 
port map
Clk => Clk, 
Rst_n => Rst_n, 
UseR2 => UseR2, 
UseT2 => UseT2, 
BaudC2 => UART_Clk, 
BaudC1 => OF1, 
SC_Sel => SCON_Sel, 
SB_Sel => SBUF_Sel, 
SC_Wr => SCON_Wr, 
SB_Wr => SBUF_Wr, 
SMOD => SMOD, 
Data_In => IO_WData, 
Data_Out => IO_RData_arr(7), 
RXD => RXD, 
RXD_IsO => RXD_IsO, 
RXD_O => RXD_O, 
TXD => TXD, 
RI => RI, 
TI => TI); 
IO_RData_en(7) <= SCON_Sel or SBUF_Sel; 
tristate_mux: 
if tristate/=0 
generate drive: for i in 0 to ext_mux_in_num-1; 
generate IO_RData <= IO_RData_arr(i); 
end generate; 
end generate; 
std_mux: if tristate=0 
generate process(IO_RData_en,IO_RData_arr) 
begin IO_RData <= IO_RData_arr(0); 
for i in 1 to ext_mux_in_num-1 loop 
if IO_RData_en(i)='1' 
then IO_RData <= IO_RData_arr(i); 
end if; 
end loop; 
end process; 
end generate; 
end; 

저작자 표시 비영리 변경 금지
신고
Posted by 리얼한놈
Studyhard/VHDL2010.01.09 02:31
과제
 * JK플립플롭이 Project 폴더 내에 있어야 한다.
library ieee;
use ieee.std_logic_1164.all;

entity upcount is
port( cclk, logic : in std_logic;
     q : buffer std_logic_vector (3 downto 0));
end upcount;

architecture arc of upcount is
component jk_f
port( j, k, clk : in std_logic;
      q, n_q  : buffer std_logic);
end component;
begin
ff3: jk_f port map(j => logic, k => logic, clk =>q(2), q=>q(3));
ff2: jk_f port map(j => logic, k => logic, clk =>q(1), q=>q(2));
ff1: jk_f port map(j => logic, k => logic, clk =>q(0), q=>q(1));
ff0: jk_f port map(j => logic, k => logic, clk =>cclk, q=>q(0));

end arc;


VHDL Basic 6

-상태머신(State Machine)
    -State Machine의 정의
- 순차회로시스템의 원하는 동작을 모델링하는 도구
- 외부 입력과 시스템 클럭에 의해 State가 천이되고, State에 의존되어 출력 값 결정 
- 여러 개의 State로 구성, 복잡한 시스템 설계에 적합 (예 : 마이크로프로세서)

   -State Machine의 종류
-Moore Machine
-Mealy Machine

    # Mealy Machine
출력이 현재상태와 입력값에 의존

# Moore Machine
출력이 현재 상태에만 의존되는 모델


 - 두 모델의 차이점


◯ Moore Machine : 출력회로의 입력이 현재의 상태인 레지스터의 값으로만 결정, 출력의 변화는  Clock과 동기되어 발생. 
◯ Mealy Machine : 출력회로의 입력이 현재 레지스터의 값과 입력값 두 가지를 가짐. 따라서 입력값의 변화가 있게되면 Clock과 동기하지 않더라도 그 출력값은 변화

    - 두 모델의 공통점
◯ 입력과 현재의 상태에 의해 다음 상태 변화

- 설계 예시

   architecture arc of mode is                  --Begin 시작 전에 삽입

type state_type is (stay, ready, action); -- State 머신 상태 설정(3가지 상태) 
signal state : state_type;                -- State_type 을 Signal 로 설정


- Integer 및 Variable 구문
 - Integer 변수
   - 알고 있는 Vector 형과 마찬가지로 사용할 변수의 범위를 지정하는데 사용
   - 벡터형 보다 변수가 차지하는 셀의 수가 더 작다
   - 범위를 좀더 자세히 지정할 수 있다.

   * 설계 예시
    entity Counter is
port ( a : in integer range 0 to 255; -- < = in std_logic_vector(7 downto 0);
     b : out integer range 0 to 255; -- < = out std_logic_vector(7 donwto 0);
    end counter ;

      범위를 실수형으로 지정함으로써 좀더 자세한 선언이 가능함을 알 수 있다.
 
 -Variable 구문 
  - Process 내에서만 사용 되며, 내적 변수이다
  - 합성 보다는 중간 연산 단계에서 주로 이용된다.
  - Variable에서 사용되는 대입기호는   :=    
  
   
  * 설계 예시
   Process(clk, clear, load)
Variable cnt : integer range 0 to 255;
begin
    if(조건) then
cnt := 0;

  
 *Variable은 내적 변수이기 때문에 Process 가 끝나면 그 값을 잊어버린다. 때문에 값을 보존 시키기 위해선
  Signal에 최종 값을 대입시켜야 한다. 



 
과제 
- Integer 형을 이용한 10 Counter 를 설계하시오
- 20Mhz 를 1초로 분주시오
- 2상 여자 Stepmotor 구동기를 설계하시오 

저작자 표시 비영리 변경 금지
신고
Posted by 리얼한놈
Studyhard/VHDL2010.01.09 02:23
JK 플립플롭

LIBRARY ieee;  
USE ieee.std_logic_1164.ALL;   
-
ENTITY ex IS
PORT(n_cp, j, k   : IN    std_logic;
         q        : BUFFER std_logic);
END ex;

ARCHITECTURE arc OF ex IS
SIGNAL jk : std_logic_vector (1 DOWNTO 0);
BEGIN
jk<=j&k;
PROCESS (n_cp, j, k)
BEGIN
IF (n_cp'EVENT AND n_cp= '0') THEN        -- Negative edge trigger
CASE jk IS
WHEN "00" => q <= q; -- Hold
WHEN "01" => q <= '0'; -- Reset
WHEN "10" => q <= '1'; -- Set
WHEN "11" => q <= NOT q; -- Toggle
WHEN OTHERS => q <= q;
END CASE;
END IF; 
END PROCESS;
END arc;

* 다른 플립플롭도 설계 후 시뮬레이션을 확인하길 바랍니다. ^ ^

VHDL Basic 5

 - 비동기식 상승 카운터
   비동기식 상승 카운터는 동기식처럼 클럭을 공통으로 사용하지 않고 앞쪽에 있는 플립플롭의 출력이 뒤쪽에 있는 플립플롭의 클럭으로 사용된다. 위 회로는 하강모서리 트리거 방식이므로 클럭이 1에서 0으로 떨어지는 순간 동작하게 된다.


- 비동기식 하강 카운터
   상승 카운터와 반대로 역순으로 카운트되는 것을 말한다. 매 클럭 수 마다 1씩 감소한다

- 비동기식 MOD-N 카운터
  mod-N 카운터는 N개의 카운터 순서를 반복하는 카운터를 말한다. 10진 카운터는 mod-10, 12진 카운터는 mod-12, 4비트 2진 카운터는 mod-16 이다.
  
  EX) MOD -6 카운터

 - 과제 
JK 플립 플롭을 이용하여 상승 카운터, 하강 카운터를 만들어 본다. 

설계 예시 (Shift Register)

 - JK플립플롭읠 4개로 직렬 연결하여 구성, 처음 JK 플립플롭에 J=1,K=0 을 넣고, Clock은 4개에 동시에 집어 넣는다. 다음 JK플립플롭은 이전 플립플롭의 출력 Q, /Q를 각각 J,K에 넣어준다. 그리고 Waveform 파일을 확인하면 차례로 Shift 되는 걸 확인할 수 있다.

저작자 표시 비영리 변경 금지
신고
Posted by 리얼한놈
Studyhard/VHDL2010.01.09 02:12
4 비트 전가산기 설계
 - 1비트 가산기
library ieee;
use ieee.std_logic_1164.all;

entity ADD is
port( a,b,c: in std_logic;
sum,cout : out std_logic);
end ADD;

architecture arc of ADD is
begin
sum <= (a xor b)xor c ;
cout <= (a and b) or ((a xor b) and c);
end arc;

 * 4비트 전 가산기 설계하기 전에 위의 1비트 가산기가 Project 폴더 안에 있어야 한다.

 - 4비트 전가산기
library ieee;
use ieee.std_logic_1164.all;

entity FA4 is
port(a, b :in std_logic_vector(3 downto 0);
cin : in std_logic;
sum : out std_logic_vector(3 downto 0);
cout: buffer std_logic_vector(2 downto 0);
carry: out std_logic);
end FA4;

architecture arc of FA4 is
 component ADD port( a,b,c: in std_logic;
sum,cout : out std_logic);
 end component;

begin
f0: ADD port map(a=>a(0),b=>b(0),c=>cin,cout=>cout(0),sum=>sum(0));
f1: ADD port map(a=>a(1),b=>b(1),c=>cout(0),cout=>cout(1),sum=>sum(1));
f2: ADD port map(a=>a(2),b=>b(2),c=>cout(1),cout=>cout(2),sum=>sum(2));
f3: ADD port map(a=>a(3),b=>b(3),c=>cout(2),cout=>carry,sum=>sum(3));
end arc;

 - 시뮬레이션 파형은 각자 확인해 보도록 한다.


VHDL Basic 4

- Clock Pulse 로 동작하기 
  - 일반적으로 if 구문을 쓸 때, 
if (A=1) then      < = 이런 식으로 Cording한다.
     그럼, Clock Pulse는 어떻게 Cording 할 수 있을까?

if(clock'EVENT and clock ='1') then   <= Rising Edge Trigger

if(clock'EVENT and clock ='0') then   <= Falling Edge Trigger 

     위의 보기처럼 Clock 과 동기화 시킬 경우 선언된 if 문 안에 원하는 Source를 Cording 하면 된다.

* 단, 비동기와 동기가 겹칠 경우 
ex) if(A=1) then
   elsif(clock'EVENT and clock='1')then
   elsif(B = 0) then

동기화된 EVENT를 먼저 코딩해주고 비동기 EVENT 를 아래쪽에 코딩하자



-래치 (Latch) 및 플립플롭(Flip Flop) 설계
 - 기본 개념
   • 안정 상태
- 회로의 외부로부터 입력을 가하지 않는 한 본래의 상태를 유지
   • 두 가지 안정 상태
- Q = 1, /Q = 0 상태 혹은 그 반대인 상태
   • 래치
- 레벨 트리거에 의해서 동작, 1상태인 동안 입력의 변화를 출력에 반영
   • 플립플롭
- 엣지 트리거(Edge Trigger)에 의해서 동작, 클럭 펄스가 나타나기 바로 이전의 입력이
 출력에 반영되어 다음 클럭 펄스가 나타날 때까지 그 상태를 유지함
   • 비동기 동작
- 입력 신호의 변화가 일어 나면 그에 따라 동작 하는 것
   • 동기식 동작
- 클럭 펄스라는 시간적인 신호로 모든 플립플롭이 펄스에 동기가 되어 동작을 하는 것

* 비동기와 동기식 동작의 차이점을 잘 이해하도록 한다.

○ S-R 플립플롭
그림 - S-R 플립플롭

- 펄스입력은 다른 2개의 입력에 대한 인에이블 신호의 역할을 한다.
  뒷 부분의 두 NAND 게이트 출력은 CP 입력이 0에 머물러 있는 한 논리 값 1을 갖는다. 
  이것이 기본 플립플롭의 정지 조건이다.

표 - S-R FF 의 진리표

○ D 래치 및 D 플립 플롭
 - D 래치(Latch)

그림 - D 래치.

- D래치는 제어 신호가 0 일 때 과거의 값을 가지고 오고, 과거의 값이 없으면 X(무변화)이다.
   제어신호가 1일 때, 1인 동안에 입력 값에 의해서 결과 값이 변화 한다.



 - D 플립플롭(Flip Flop)

 - D 래치와는 달리 클럭의 상승이나 하강일 때 입력값에 의해 출력 값이 정해진다

○ J- K 플립플롭
그림 - J-K 플립플롭

- J K 플립플롭은 SR 플립플롭에서의 비결정 상태를 명백히 구분해 준다. 입력 J,K는 플립플롭을 각각 셋하고 클리어학 위하여 S,R처럼 동작한다. J 입력은 셋, K 입력은 리셋을 위한 것이다. 


○ T 플립플롭

 - T 플립플롭은 J-K 플립플롭을 단일 입력 형태로 고쳐 놓은 것이다. T라는 이름은 플립플롭의 토글, 즉 그의 상태를 반전(보수화)시킬 수 있는데 기인한다.


- 과제
 - 각 래치, 플립플롭을 VHDL 언어로 코딩해본다.

저작자 표시 비영리 변경 금지
신고
Posted by 리얼한놈
Studyhard/VHDL2010.01.08 00:30
AND, OR, NAND, NOR, XOR, XNOR 설계 예시

library ieee;
use ieee.std_logic_1164.all;

entity AAAA is
port(a, b : in std_logic;
    x  : out std_logic_vector(5 downto 0));
end AAAA;

architecture arc of AAAA is
begin
x(0) <= a and b;
x(1) <= a or b;
x(2) <= a nand b;
x(3) <= a nor b;
x(4) <= a xor b;
x(5) <= a xnor b;
end arc;
x : out std_logic_vector (5 downto 0);  <- ????

C 언어에서 배열과 같은 의미로 이해하면 빠를 듯 싶다. 
std_logic 형으로 여러개를 설계 하는 것보다, 같은 형태의 출력 핀이면 std_logic_vector 형이 간편하다.
입력도 마찬가지로 vector 형으로 정의가 가능하다

(5 downto 0) < =   000000     (왼쪽 첫 번째 비트가 5번, 오른쪽 마지막 비트가 0번)
(0 downto 5) < =   000000     (왼쪽 첫 번째 비트가 0번, 오른쪽 마지막 비트가 5번)  




VHDL Basic 2


VHDL 은 C 와 마찬가지로 조건문이 가능하다.

(1) IF ELSE 문 (괄호 안에 조건)
- IF (            ) THEN
- IF (  )THEN
 ELSIF(   ) THEN     < = 조건이 들어갈땐 ELSIF 
- IF (  ) THEN
 ELSE < = 조건이 없을 땐 ELSE 
* 마지막엔 항상 END IF 로 마무리를 해주는 센스!

(2) CASE 문
- CASE ( 대상   )   IS
WHEN " 상태  "   = > 출력 <=  값
WHEN OTHERS   = > 출력 <=  값
* 마지막엔 END CASE;

(3) FOR LOOP 문
- FOR I IN 0 TO 7 LOOP
Y(I) <= A(I) AND B(I);

(4) SELECT 문
WITH 대상 SELECT
출력 <= "값" WHEN 상태,
"값"    WHEN 상태,
"값" WHEN 상태,
"값" WHEN 상태;
* 마지막엔 END SELECT;
* VHDL에서 모든 조건문은 architecture 안에 process 문에 쓰여 져야 한다.
- 예
architecture arc of KITEL is
begin
process(a)   -- architecture 안에 process는 여러 개가 와도 된다.
begin   -- process 시작
if (a ="0")then   -- 조건문의 대상은 process(대상 ) 에 정의 되어야한다  
b <= '1';  -- 한 비트일 때는 ‘0’    2개 이상일 때는 “00”  
elsif(a ="1")then    
b <= '0';  -- 마땅히 조건이 없으면 NULL; 처리를 하여도 무방하다.
end if;
end process;              -- process 끝, process 가 여러개일 때는 병렬로 동시에 실행된다
end arc;  -- process 안에서는 순차 architecture안의 process는 병렬처리
과제
(1) 7segment Decoder 동작을 하는 7447 IC를 설계
(2) MUX 와 DEMUX 를 각각 설계













 

저작자 표시 비영리 변경 금지
신고
Posted by 리얼한놈

티스토리 툴바