Safe Haskell | None |
---|---|
Language | Haskell2010 |
- mealy :: (s -> i -> (s, o)) -> s -> Signal i -> Signal o
- mealyB :: (Bundle i, Bundle o) => (s -> i -> (s, o)) -> s -> Unbundled' i -> Unbundled' o
- (<^>) :: (Bundle i, Bundle o) => (s -> i -> (s, o)) -> s -> Unbundled' i -> Unbundled' o
- cmealy :: SClock clk -> (s -> i -> (s, o)) -> s -> CSignal clk i -> CSignal clk o
- cmealyB :: (Bundle i, Bundle o) => SClock clk -> (s -> i -> (s, o)) -> s -> Unbundled clk i -> Unbundled clk o
Mealy machine synchronised to the system clock
:: (s -> i -> (s, o)) | Transfer function in mealy machine form:
|
-> s | Initial state |
-> Signal i -> Signal o | Synchronous sequential function with input and output matching that of the mealy machine |
Create a synchronous function from a combinational function describing a mealy machine
mac :: Int -- Current state -> (Int,Int) -- Input -> (Int,Int) -- (Updated state, output) mac s (x,y) = (s',s) where s' = x * y + s topEntity :: Signal (Int, Int) -> Signal Int topEntity = mealy mac 0
>>>
simulate topEntity [(1,1),(2,2),(3,3),(4,4),...
[0,1,5,14,30,...
Synchronous sequential functions can be composed just like their combinational counterpart:
dualMac :: (Signal Int, Signal Int) -> (Signal Int, Signal Int) -> Signal Int dualMac (a,b) (x,y) = s1 + s2 where s1 = mealy mac 0 (bundle' (a,x)) s2 = mealy mac 0 (bundle' (b,y))
:: (Bundle i, Bundle o) | |
=> (s -> i -> (s, o)) | Transfer function in mealy machine form:
|
-> s | Initial state |
-> Unbundled' i -> Unbundled' o | Synchronous sequential function with input and output matching that of the mealy machine |
A version of mealy
that does automatic Bundle
ing
Given a function f
of type:
f :: Int -> (Bool, Int) -> (Int, (Int, Bool))
When we want to make compositions of f
in g
using mealy
, we have to
write:
g a b c = (b1,b2,i2) where (i1,b1) =unbundle'
(mealy f 0 (bundle'
(a,b))) (i2,b2) =unbundle'
(mealy f 3 (bundle'
(i1,c)))
Using mealyB
however we can write:
g a b c = (b1,b2,i2) where (i1,b1) = mealyB f 0 (a,b) (i2,b2) = mealyB f 3 (i1,c)
:: (Bundle i, Bundle o) | |
=> (s -> i -> (s, o)) | Transfer function in mealy machine form:
|
-> s | Initial state |
-> Unbundled' i -> Unbundled' o | Synchronous sequential function with input and output matching that of the mealy machine |
Infix version of mealyB
Mealy machine synchronised to an arbitrary clock
:: SClock clk |
|
-> (s -> i -> (s, o)) | Transfer function in mealy machine form:
|
-> s | Initial state |
-> CSignal clk i -> CSignal clk o | Synchronous sequential function with input and output matching that of the mealy machine |
Create a synchronous function from a combinational function describing a mealy machine
mac :: Int -- Current state -> (Int,Int) -- Input -> (Int,Int) -- (Updated state, output) mac s (x,y) = (s',s) where s' = x * y + s clk100 = Clock d100 topEntity :: CSignal 100 (Int, Int) -> CSignal 100 Int topEntity = cmealy clk100 mac 0
>>>
csimulate clk100 clk100 topEntity [(1,1),(2,2),(3,3),(4,4),...
[0,1,5,14,30,...
Synchronous sequential functions can be composed just like their combinational counterpart:
dualMac :: (CSignal 100 Int, CSignal 100 Int) -> (CSignal 100 Int, CSignal 100 Int) -> CSignal 100 Int dualMac (a,b) (x,y) = s1 + s2 where s1 = cmealy clk100 mac 0 (bundle clk100 (a,x)) s2 = cmealy clk100 mac 0 (bundle clk100 (b,y))
:: (Bundle i, Bundle o) | |
=> SClock clk | |
-> (s -> i -> (s, o)) | Transfer function in mealy machine form:
|
-> s | Initial state |
-> Unbundled clk i -> Unbundled clk o | Synchronous sequential function with input and output matching that of the mealy machine |
A version of cmealy
that does automatic Bundle
ing
Given a function f
of type:
f :: Int -> (Bool,Int) -> (Int,(Int,Bool))
When we want to make compositions of f
in g
using cmealy
, we have to
write:
g clk a b c = (b1,b2,i2) where (i1,b1) =unbundle
clk (cmealy clk f 0 (bundle
clk (a,b))) (i2,b2) =unbundle
clk (cmealy clk f 3 (bundle
clk (i1,c)))
Using cmealyB
however we can write:
g a b c = (b1,b2,i2) where (i1,b1) = cmealyB clk f 0 (a,b) (i2,b2) = cmealyB clk f 3 (i1,c)