clash-prelude-1.8.4: Clash: a functional hardware description language - Prelude library

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.Moore

Contents

- Moore machine

Description

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.

Synopsis

- moore :: forall (dom :: Domain) s i o. (HiddenClockResetEnable dom, NFDataX s) => (s -> i -> s) -> (s -> o) -> s -> Signal dom i -> Signal dom o
- mooreB :: forall (dom :: Domain) s i o. (HiddenClockResetEnable dom, NFDataX s, Bundle i, Bundle o) => (s -> i -> s) -> (s -> o) -> s -> Unbundled dom i -> Unbundled dom o
- medvedev :: forall (dom :: Domain) s i. (HiddenClockResetEnable dom, NFDataX s) => (s -> i -> s) -> s -> Signal dom i -> Signal dom s
- medvedevB :: forall (dom :: Domain) s i. (HiddenClockResetEnable dom, NFDataX s, Bundle i, Bundle s) => (s -> i -> s) -> s -> Unbundled dom i -> Unbundled dom s

# Moore machine

moore Source #

Arguments

:: forall (dom :: Domain) s i o. (HiddenClockResetEnable dom, NFDataX s) |
=> (s -> i -> s) | Transfer function in moore machine form: `state -> input -> newstate`
-> (s -> o) | Output function in moore machine form: `state -> output`
-> s | Initial state
-> Signal dom i | Synchronous sequential function with input and output matching that of the moore machine
-> Signal dom o |

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 Source #

Arguments

:: forall (dom :: Domain) s i o. (HiddenClockResetEnable dom, NFDataX s, Bundle i, Bundle o) |
=> (s -> i -> s) | Transfer function in moore machine form: `state -> input -> newstate`
-> (s -> o) | Output function in moore machine form: `state -> output`
-> s | Initial state
-> Unbundled dom i | Synchronous sequential function with input and output matching that of the moore machine
-> Unbundled dom o |

A version of `moore` that does automatic `Bundle`ing

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)

medvedev :: forall (dom :: Domain) s i. (HiddenClockResetEnable dom, NFDataX s) => (s -> i -> s) -> s -> Signal dom i -> Signal dom s Source #

Create a synchronous function from a combinational function describing a moore machine without any output logic

medvedevB :: forall (dom :: Domain) s i. (HiddenClockResetEnable dom, NFDataX s, Bundle i, Bundle s) => (s -> i -> s) -> s -> Unbundled dom i -> Unbundled dom s Source #

A version of `medvedev` that does automatic `Bundle`ing