CLaSH.Signal.Delayed

Delay-annotated synchronous signals

data DSignal delay a

A synchronized signal with samples of type a, synchronized to "system" clock (period 1000), that has accumulated delay amount of samples delay along its path.

Instances

Functor (DSignal delay)

Applicative (DSignal delay)

Foldable (DSignal delay)

Traversable (DSignal delay)

Bounded a => Bounded (DSignal delay a)

Enum a => Enum (DSignal delay a)

Eq (DSignal delay a)

Fractional a => Fractional (DSignal delay a)

Integral a => Integral (DSignal delay a)

Num a => Num (DSignal delay a)

Ord a => Ord (DSignal delay a)

(Num a, Ord a) => Real (DSignal delay a)

Show a => Show (DSignal delay a)

Arbitrary a => Arbitrary (DSignal delay a)

CoArbitrary a => CoArbitrary (DSignal delay a)

Bits a => Bits (DSignal delay a)

FiniteBits a => FiniteBits (DSignal delay a)

Default a => Default (DSignal delay a)

Lift a => Lift (DSignal delay a)

SaturatingNum a => SaturatingNum (DSignal delay a)

ExtendingNum a b => ExtendingNum (DSignal n a) (DSignal n b)

type AResult (DSignal n a) (DSignal n b) = DSignal n (AResult a b)

type MResult (DSignal n a) (DSignal n b) = DSignal n (MResult a b)

delay :: forall a n d. KnownNat d => Vec d a -> DSignal n a -> DSignal (n + d) a

Delay a DSignal for d periods.

delay3 :: DSignal n Int -> DSignal (n + 3) Int
delay3 = delay (0 :> 0 :> 0 :> Nil)

>>> sampleN 6 (delay3 (dfromList [1..]))
[0,0,0,1,2,3]

delayI :: (Default a, KnownNat d) => DSignal n a -> DSignal (n + d) a

Delay a DSignal for m periods, where m is derived from the context.

delay2 :: DSignal n Int -> DSignal (n + 2) Int
delay2 = delayI

>>> sampleN 6 (delay2 (dfromList [1..]))
[0,0,1,2,3,4]

feedback :: (DSignal n a -> (DSignal n a, DSignal ((n + m) + 1) a)) -> DSignal n a

Feed the delayed result of a function back to its input:

mac :: DSignal 0 Int -> DSignal 0 Int -> DSignal 0 Int
mac x y = feedback (mac' x y)
  where
    mac' :: DSignal 0 Int -> DSignal 0 Int -> DSignal 0 Int
         -> (DSignal 0 Int, DSignal 1 Int)
    mac' a b acc = let acc' = a * b + acc
                   in  (acc, delay (singleton 0) acc')

>>> sampleN 6 (mac (dfromList [1..]) (dfromList [1..]))
[0,1,5,14,30,55]

Signal <-> DSignal conversion

fromSignal :: Signal a -> DSignal 0 a

Signals are not delayed

sample s == dsample (fromSignal s)

toSignal :: DSignal delay a -> Signal a

Strip a DSignal from its delay information.

List <-> DSignal conversion (not synthesisable)

dfromList :: [a] -> DSignal 0 a

Create a DSignal from a list

Every element in the list will correspond to a value of the signal for one clock cycle.

>>> sampleN 2 (dfromList [1,2,3,4,5])
[1,2]

NB: This function is not synthesisable

Experimental

unsafeFromSignal :: Signal a -> DSignal n a

EXPERIMENTAL

Unsafely convert a Signal to any DSignal.

NB: Should only be used to interface with functions specified in terms of Signal.

antiDelay :: SNat d -> DSignal (n + d) a -> DSignal n a

EXPERIMENTAL

Access a delayed signal in the present.

mac :: DSignal 0 Int -> DSignal 0 Int -> DSignal 0 Int
mac x y = acc'
  where
    acc' = (x * y) + antiDelay d1 acc
    acc  = delay (singleton 0) acc'