Esempio n. 1
0
def main(ninputs,
         noutputs,
         input_isbits=True,
         output_isbits=True,
         has_clock=False):
    assert 0 <= ninputs <= 8
    assert 0 <= noutputs <= 8

    print(m.mantle_target)

    if m.mantle_target == 'ice40':
        from loam.boards.icestick import IceStick

        icestick = IceStick()

        if has_clock:
            icestick.Clock.on()

        for i in range(ninputs):
            icestick.J1[i].input().on()

        for i in range(noutputs):
            icestick.J3[i].output().on()

        top = icestick.main()

        if ninputs:
            top.I = top.J1
        if noutputs:
            top.O = top.J3

    elif m.mantle_target == 'spartan3' or m.mantle_target == 'spartan6':
        from loam.boards.papilioone import PapilioOne
        from loam.boards.papiliopro import PapilioPro
        from loam.shields.megawing import MegaWing

        Papilio = PapilioOne if m.mantle_target == 'spartan3' else PapilioPro
        megawing = MegaWing(Papilio)

        if has_clock:
            megawing.Clock.on()
        megawing.Switch.on(ninputs)
        megawing.LED.on(noutputs)

        top = megawing.main()

        if ninputs:
            top.I = top.SWITCH
        if noutputs:
            top.O = top.LED

    else:
        raise ValueError(m.mantle_target)

    if ninputs == 1 and input_isbits:
        top.I = m.bits([top.I])
    if noutputs == 1 and output_isbits:
        top.O = m.bits([top.O])

    return top
Esempio n. 2
0
def main(n):
    import magma as m
    m.set_mantle_target('spartan3')
    from loam.boards.papilioone import PapilioOne
    from loam.shields.megawing import MegaWing
    from mantle import LUTN

    megawing = MegaWing(PapilioOne)
    megawing.Switch.on(n)
    megawing.LED.on(1)

    top = megawing.main()
    pown = 1 << n
    lut = LUTN(pown // 2 * [0, 1], pown)
    I = [top.SWITCH[i] for i in range(n)] if n != 1 else [top.SWITCH]
    m.wire(lut(*I), top.LED)
    m.EndCircuit()

    return top
Esempio n. 3
0
import sys
from magma import *
from mantle import *
from loam.shields.megawing import MegaWing

megawing = MegaWing()
megawing.Switch.on(2)
megawing.LED.on(1)

main = megawing.main()
A = main.SWITCH[0]
B = main.SWITCH[1]
O = main.LED[0]

xor2 = Xor2()

xor2(A, B)
wire(xor2.O, O)

compile(sys.argv[1], main)


Esempio n. 4
0
import magma as m
from mantle.xilinx.spartan3.RAMB import ROMB16
from loam.boards.papilioone import PapilioOne
from loam.shields.megawing import MegaWing


megawing = MegaWing(PapilioOne)
megawing.Clock.on()
megawing.Switch.on(8)
megawing.LED.on(8)

main = megawing.main()

rom = 2048*[0]
for i in range(2048):
    byte = i & 0xff
    rom[i] = byte

romb = ROMB16( rom, 8 )

I = m.bits([main.SWITCH[0], main.SWITCH[1], main.SWITCH[2], main.SWITCH[3],
            main.SWITCH[4], main.SWITCH[5], main.SWITCH[6], main.SWITCH[7],
            0, 0, 0])

O = main.LED

m.wire( I, romb.A )
m.wire( romb.O, O )

Esempio n. 5
0
from loam.boards.papiliopro import PapilioPro
from loam.shields.megawing import MegaWing
from bit1 import Bit1

N = 32
NI = 2
NO = 2


def prog():
    from bit1.isa import clr, set, O0
    clr(O0)
    set(O0, jump=0)


megawing = MegaWing(PapilioPro)
megawing.Clock.on()
megawing.Joystick.on()
megawing.LED.on(NO)

main = megawing.main()
if NO == 1:
    main.LED = m.bits([main.LED])

slow = mantle.Counter(16)
select = debounce(main.SELECT, slow.COUT)
step = falling(select)

bit1 = Bit1(prog, N, NI, NO, has_ce=True)

m.wire(bit1(m.bits([1, 1]), ce=step), main.LED)