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
import magma as m from magma.testing import check_files_equal m.set_mantle_target('spartan3') def compile_and_regress(name, vendor, main, *largs, **kwargs): build = 'build/' + name gold = 'gold/' + name m.compile(build, main(*largs, **kwargs), vendor=vendor) assert check_files_equal(__file__, build + '.v', gold + '.v') assert check_files_equal(__file__, build + '.pcf', gold + '.pcf') 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()
# they haven't already been defined. This allows implementations to # specialize a common module. For example, mantle40 defines a FullAdder, so # it will not use the generic FullAdder in common. module = importlib.import_module(f"mantle.{module}") if hasattr(module, "__all__"): names = module.__all__ else: names = dir(module) for name in names: try: getattr(mantle, name) except AttributeError: scope.update({name: getattr(module, name)}) if m.mantle_target is None: m.set_mantle_target('coreir') if m.mantle_target in ['coreir', 'ice40', 'spartan3', 'spartan6', 'kintex7', 'cyclone4', ]: #from mantle.primitives import * if m.mantle_target == 'coreir': from mantle.coreir import * elif m.mantle_target in ['ice40']: from mantle.lattice import *
# coding: utf-8 # In[1]: import magma as m m.set_mantle_target("coreir") import mantle class FullAdder(m.Circuit): name = "FullAdderExample" # Note: We use a unique name here # to avoid conflict with the Circuit # called FullAdder that is a part of # the mantle standard library IO = [ "a", m.In(m.Bit), "b", m.In(m.Bit), "cin", m.In(m.Bit), "out", m.Out(m.Bit), "cout", m.Out(m.Bit) ] @classmethod def definition(io): # Generate the sum _sum = io.a ^ io.b ^ io.cin m.wire(_sum, io.out) # Generate the carry carry = (io.a & io.b) | (io.b & io.cin) | (io.a & io.cin)
import magma magma.set_mantle_target('spartan6') from magma.bitutils import clog2 from bit1.asm import assemble, disassemble N = 32 LOGN = clog2(N) NI = 2 LOGNI = clog2(NI) NO = 2 LOGNO = clog2(NO) + 1 def prog(): from bit1.isa import set, clr from bit1.isa import mov, not_, and_, or_, xor from bit1.isa import nop, delay from bit1.isa import jump from bit1.isa import if0, if1, ifelse from bit1.isa import skip, skipif0, skipif1 from bit1.isa import halt set( O0 ) clr( O0 ) mov( I0, O0 ) not_( I0, O0 ) and_( I0, I1, O0 ) or_( I0, I1, O0 ) xor( I0, I1, O0 ) delay(1)
import math import magma as m m.set_mantle_target("ice40") from mantle import Counter, Memory from loam.boards.icestick import IceStick from regex import * from matcher import Matcher def string_to_rom(string): ADDR_BITS = 9 assert (len(string) <= (1 << ADDR_BITS)) counter = Counter(ADDR_BITS) tab = [ord(string[i]) for i in range(len(string))] tab += [0 for _ in range((1 << ADDR_BITS) - len(string))] assert (len(tab) == 1 << ADDR_BITS) rom = Memory(height=(1 << ADDR_BITS), width=8, rom=tab, readonly=True) m.wire(1, rom.RE) return rom(counter.O) def to_fpga(rx): icestick = IceStick() icestick.Clock.on() icestick.D1.on() main = icestick.DefineMain() rom = string_to_rom('x' * 16)
def pytest_configure(config): target = config.getoption('--target') magma.set_mantle_target(target)
import magma as m m.set_mantle_target("ice40") import mantle as mantle import lupa from lupa import LuaRuntime lua = LuaRuntime(unpack_returned_tuples=True) lua.execute("package.path='./?.lua;/home/jhegarty/rigel/?.lua;/home/jhegarty/rigel/src/?.lua;/home/jhegarty/rigel/modules/?.lua;/home/jhegarty/rigel/misc/?.lua;/home/jhegarty/rigel/misc/compare/?.lua;/home/jhegarty/rigel/examples/?.lua'") ############################################## # generate a rigel module like in regular lua... R = lua.require("rigel") G = lua.require("generators") RM = lua.require("modules") types = lua.require("types") C = lua.require("examplescommon") inp = R.input( types.uint(8) ) a = R.apply("a", C.plus100(types.uint(8)), inp) b = R.apply("b", C.plus100(types.uint(8)), a) p200 = RM["lambda"]( "p200", inp, b ) ####################################### def rigelTypeToMagmaType(ty): assert(types.isType(ty)) if ty.isUint(ty): return m.UInt(ty.verilogBits(ty)) else: assert(false)
import magma from magma.bitutils import seq2int from magma.testing.coroutine import check, coroutine from magma.simulator import PythonSimulator from mantle import DefineJohnson magma.set_mantle_target('ice40') def johnson_counter(n): @coroutine def johnson_counter_(): O = [False for _ in range(n)] yield while True: yield O O = [not O[-1]] + O[:-1] return johnson_counter_ def test_lfsr(): n = 8 Johnson8 = DefineJohnson(n=n) check(Johnson8, johnson_counter(n)(), 3 * n)