Copyright	(C) 2013-2016 University of Twente 2017 Google Inc. 2019 Myrtle Software Ltd
License	BSD2 (see the file LICENSE)
Maintainer	Christiaan Baaij <christiaan.baaij@gmail.com>
Safe Haskell	Safe
Language	Haskell2010

Clash.Prelude.Mealy

Contents

Mealy machine synchronized to the system clock

Description

Whereas the output of a Moore machine depends on the previous state, the output of a Mealy machine depends on current transition.

Mealy machines are strictly more expressive, but may impose stricter timing requirements.

Synopsis

mealy :: (HiddenClockResetEnable dom, Undefined s) => (s -> i -> (s, o)) -> s -> Signal dom i -> Signal dom o
mealyB :: (HiddenClockResetEnable dom, Undefined s, Bundle i, Bundle o) => (s -> i -> (s, o)) -> s -> Unbundled dom i -> Unbundled dom o
(<^>) :: (HiddenClockResetEnable dom, Undefined s, Bundle i, Bundle o) => (s -> i -> (s, o)) -> s -> Unbundled dom i -> Unbundled dom o

Mealy machine synchronized to the system clock

mealy Source #

Arguments

:: (HiddenClockResetEnable dom, Undefined s)
=> (s -> i -> (s, o))	Transfer function in mealy machine form: `state -> input -> (newstate,output)`
-> s	Initial state
-> Signal dom i -> Signal dom 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

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

mac :: HiddenClockResetEnable dom  => Signal dom (Int, Int) -> Signal dom Int
mac = mealy macT 0

>>> simulate @System mac [(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
  :: 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 = mealy mac 0 (bundle (a,x))
    s2 = mealy mac 0 (bundle (b,y))

mealyB Source #

Arguments

:: (HiddenClockResetEnable dom, Undefined s, Bundle i, Bundle o)
=> (s -> i -> (s, o))	Transfer function in mealy machine form: `state -> input -> (newstate,output)`
-> s	Initial state
-> Unbundled dom i -> Unbundled dom o	Synchronous sequential function with input and output matching that of the mealy machine

A version of mealy that does automatic Bundleing

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 (c,i1)))

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 (c,i1)

(<^>) Source #

Arguments

:: (HiddenClockResetEnable dom, Undefined s, Bundle i, Bundle o)
=> (s -> i -> (s, o))	Transfer function in mealy machine form: `state -> input -> (newstate,output)`
-> s	Initial state
-> Unbundled dom i -> Unbundled dom o	Synchronous sequential function with input and output matching that of the mealy machine

Infix version of mealyB