moo package:clash-prelude

moore :: (KnownDomain dom, NFDataX s) => Clock dom -> Reset dom -> Enable dom -> (s -> i -> s) -> (s -> o) -> s -> Signal dom i -> Signal dom o

clash-prelude Clash.Explicit.Moore Clash.Explicit.Prelude Clash.Explicit.Prelude.Safe

Create a synchronous function from a combinational function describing a moore machine

macT
:: Int        -- Current state
-> (Int,Int)  -- Input
-> (Int,Int)  -- Updated state
macT s (x,y) = x * y + s

mac
:: KnownDomain dom
=> Clock dom
-> Reset dom
-> Enable dom
-> Signal dom (Int, Int)
-> Signal dom Int
mac clk rst en = moore clk rst en macT id 0

>>> simulate (mac systemClockGen systemResetGen enableGen) [(0,0),(1,1),(2,2),(3,3),(4,4)]
[0,0,1,5,14...
...

Synchronous sequential functions can be composed just like their combinational counterpart:

dualMac
:: KnownDomain dom
=> Clock dom
-> Reset dom
-> Enable dom
-> (Signal dom Int, Signal dom Int)
-> (Signal dom Int, Signal dom Int)
-> Signal dom Int
dualMac clk rst en (a,b) (x,y) = s1 + s2
where
s1 = moore clk rst en macT id 0 (bundle (a,x))
s2 = moore clk rst en macT id 0 (bundle (b,y))

mooreB :: (KnownDomain dom, NFDataX s, Bundle i, Bundle o) => Clock dom -> Reset dom -> Enable dom -> (s -> i -> s) -> (s -> o) -> s -> Unbundled dom i -> Unbundled dom o

clash-prelude Clash.Explicit.Moore Clash.Explicit.Prelude Clash.Explicit.Prelude.Safe

A version of moore that does automatic Bundleing Given a functions t and o of types:

t :: Int -> (Bool, Int) -> Int
o :: Int -> (Int, Bool)

When we want to make compositions of t and o in g using moore, we have to write:

g clk rst en a b c = (b1,b2,i2)
where
(i1,b1) = unbundle (moore clk rst en t o 0 (bundle (a,b)))
(i2,b2) = unbundle (moore clk rst en t o 3 (bundle (c,i1)))

Using mooreB however we can write:

g clk rst en a b c = (b1,b2,i2)
where
(i1,b1) = mooreB clk rst en t o 0 (a,b)
(i2,b2) = mooreB clk rst en t o 3 (c,i1)

moore :: (HiddenClockResetEnable dom, NFDataX s) => (s -> i -> s) -> (s -> o) -> s -> Signal dom i -> Signal dom o

clash-prelude Clash.Prelude Clash.Prelude.Moore Clash.Prelude.Safe

Create a synchronous function from a combinational function describing a moore machine

macT
:: Int        -- Current state
-> (Int,Int)  -- Input
-> Int        -- Updated state
macT s (x,y) = x * y + s

mac
:: HiddenClockResetEnable dom
=> Signal dom (Int, Int)
-> Signal dom Int
mac = moore mac id 0

>>> simulate @System mac [(0,0),(1,1),(2,2),(3,3),(4,4)]
[0,0,1,5,14,30,...
...

Synchronous sequential functions can be composed just like their combinational counterpart:

dualMac
:: HiddenClockResetEnable dom
=> (Signal dom Int, Signal dom Int)
-> (Signal dom Int, Signal dom Int)
-> Signal dom Int
dualMac (a,b) (x,y) = s1 + s2
where
s1 = moore macT id 0 (bundle (a,x))
s2 = moore macT id 0 (bundle (b,y))

mooreB :: (HiddenClockResetEnable dom, NFDataX s, Bundle i, Bundle o) => (s -> i -> s) -> (s -> o) -> s -> Unbundled dom i -> Unbundled dom o

clash-prelude Clash.Prelude Clash.Prelude.Moore Clash.Prelude.Safe

A version of moore that does automatic Bundleing Given a functions t and o of types:

t :: Int -> (Bool, Int) -> Int
o :: Int -> (Int, Bool)

When we want to make compositions of t and o in g using moore, we have to write:

g a b c = (b1,b2,i2)
where
(i1,b1) = unbundle (moore t o 0 (bundle (a,b)))
(i2,b2) = unbundle (moore t o 3 (bundle (c,i1)))

Using mooreB however we can write:

g a b c = (b1,b2,i2)
where
(i1,b1) = mooreB t o 0 (a,b)
(i2,b2) = mooreB t o 3 (c,i1)

mooreDF :: (KnownDomain dom, NFDataX s) => Clock dom -> Reset dom -> Enable dom -> (s -> i -> s) -> (s -> o) -> s -> DataFlow dom Bool Bool i o

clash-prelude Clash.Prelude.DataFlow

Create a DataFlow circuit from a Moore machine description as those of Clash.Prelude.Moore

module Clash.Explicit.Moore

clash-prelude

Whereas the output of a Mealy machine depends on current transition, the output of a Moore machine depends on the previous state. Moore machines are strictly less expressive, but may impose laxer timing requirements.

module Clash.Prelude.Moore

clash-prelude