Indeksowanie macierzy macierzy z sygnałem w Kansas Lava

Question

Próbuję zaimplementować czasowe multipleksowanie do sterowania 7-segmentowym wyświetlaczem z 4 cyframi: urządzenie ma 7 nóg danych i 4 anody, więc jeśli chcesz wyświetlić cztery różne cyfry, najpierw musisz ustawić anody na 0001, a nogi danych na swoje segmenty; następnie po pewnym czasie ustaw anody na 0010 i zaktualizuj nogi danych; i tak dalej.

Próbuję wprowadzić to w Kansas Lava. Jednak kompilator Xilinx odrzuca wygenerowany VHDL z błędem typu (i patrząc na wygenerowany kod, myślę, że to prawda).

Po pierwsze, mój kod Lavy: w zasadzie implementuje sygnał z sekwencji [0, 1, 2, 3, 0, ...], a następnie używa operatora .!. z Language.KansasLava.Signal do indeksowania do parametru macierzy macierzy. Wartość anody generowana jest przez obrót 0001 w każdym takcie po lewej.

{-# LANGUAGE TypeFamilies #-} 
{-# LANGUAGE ScopedTypeVariables #-} 
{-# LANGUAGE DataKinds #-} 
import Language.KansasLava 
import Hardware.KansasLava.Boards.Papilio.LogicStart -- from http://github.com/gergoerdi/kansas-lava-papilio 
import Data.Sized.Matrix 
import Data.Sized.Unsigned as Unsigned 
import Data.Bits 

driveSS :: forall clk sig n. (Clock clk, sig ~ Signal clk, Size n, Rep n, Num n, Integral n) => Matrix n (Matrix X7 (sig Bool)) -> SevenSeg clk ActiveLow n 
driveSS segss = SevenSeg (fmap bitNot anodes) segs high 
    where 
    clkAnode :: sig Bool 
    clkAnode = divideClk (Witness :: Witness X8) 

    selector :: sig n 
    selector = counter clkAnode 

    segss' :: sig (Matrix n (Matrix X7 Bool)) 
    segss' = pack . fmap pack $ segss 

    segs :: Matrix X7 (sig Bool) 
    segs = unpack $ segss' .!. selector 

    anodes :: Matrix n (sig Bool) 
    anodes = rotatorL clkAnode 

test_sseg :: Fabric() 
test_sseg = do 
    sw <- switches 
    let sw' = cropAt sw 1 
    sseg $ driveSS $ matrix [sw', zero, zero, zero] 
    where 
    zero = matrix $ replicate 7 low 

divideClk :: forall c sig ix. (Clock c, sig ~ Signal c, Size ix) => Witness ix -> sig Bool 
divideClk _ = counter high .==. (0 :: sig (Unsigned ix)) 

counter :: (Rep a, Num a, Clock c, sig ~ Signal c) => sig Bool -> sig a 
counter inc = loop 
    where 
    reg = register 0 loop 
    loop = mux inc (reg, reg + 1) 

rotatorL :: (Clock c, sig ~ Signal c, Size ix, Integral ix) => sig Bool -> Matrix ix (sig Bool) 
rotatorL step = fromUnsigned loop 
    where 
    reg = register 1 loop 
    loop = mux step (reg, rotateL reg 1) 

fromUnsigned :: (sig ~ Signal c, Size ix) => sig (Unsigned ix) -> Matrix ix (sig Bool) 
fromUnsigned = unpack . coerce Unsigned.toMatrix 

main :: IO() 
main = do 
    writeVhdlPrelude "lava-prelude.vhdl" 
    kleg <- reifyFabric $ do 
     board_init 
     test_sseg 
    writeVhdlCircuit "hello" "hello.vhdl" kleg 
    writeUCF "hello.ucf" kleg 

Więc gdy próbuję skompilować wygenerowany VHDL, dostaję komunikat o błędzie:

ERROR:HDLParsers:800 - "/home/cactus/prog/lava/hello/src/hello.vhdl" Line 85. Type of sig_24_o0 is incompatible with type of sig_28_o0. 

Odpowiednie linie z hello.vhdl to:

type sig_24_o0_type is array (7 downto 0) of std_logic_vector(0 downto 0); 
signal sig_24_o0 : sig_24_o0_type; 

signal sig_25_o0 : std_logic_vector(1 downto 0); 

type sig_28_o0_type is array (3 downto 0) of std_logic_vector(6 downto 0); 
signal sig_28_o0 : sig_28_o0_type; 

sig_24_o0 <= sig_28_o0(to_integer(unsigned(sig_25_o0))); 

Rodzaj sig_24_o0 wydaje źle ; Myślę, że powinno to być albo array (6 downto 0) of std_logic_vector(0 downto 0) lub std_logic_vector(6 downto 0), ale nie wiem, co Lava używa tych std_logic_vector(0 downto 0).

Answer 1

skończyło się pracy wokół tego przez multipleksowanie per-drutu zamiast multipleksowanie cały autobus:

segss' :: Matrix X7 (Matrix n (sig Bool)) 
segss' = columns . joinRows $ segss 

segs :: Matrix X7 (sig Bool) 
segs = fmap (nary selector) segss' 

użyciu funkcji pomocnika

nary :: forall a clk sig n. (Clock clk, sig ~ Signal clk, Rep a, Size n, Rep n) => sig n -> Matrix n (sig a) -> sig a 
nary sel inps = pack inps .!. sel 

VHDL wygenerowany przez ten kompiluje dobrze; chociaż nie mam pojęcia, czy powoduje to, że wynikowy układ jest bardziej skomplikowany (a może nawet prostszy).