• Ver online .
• Repositorio en github

• Gente que sabe de hardware pero no sabe Python (mis cumpas)

• Gente que sabe de Python (mucho!) pero no de hardware

• Yo, que sólo sé que no sé nada

• En una charla de 30 minutos

  

• programar HW != diseñar HW

  • Hw con Funcionamiento y prestaciones predefinidas.
  • Ejemplo: Arduino se programa sobre un uC que tiene un firmware.
  • Desde el diseño el ASM es un lenguaje de "alto nivel"!

• Pero... ¿cómo se diseña un micro?

  • Con ustedes los HDL (Hardware Description Language)
  • Electrónica digital a través software
  • VHDL y Verilog son los más típicos

• FPGAs : Field Programmable Gates Array

  • Hardware "metaprogramable",

  El camaleón mamá, el camaleón, cambia de colores según la ocasión

  —Chico Novarro

• Originalmente sólo para prototipar.

  • Ahora son baratos, se usan en producción!

• >> escala, se fabrican chips ASIC (Application-specific integrated circuit)

  • con (casi) el mismo HDL!

• Es un framework HDL en Python
• Incluye tipos de datos, helpers, conversores y un simulador
• Permite unificar algoritmo, RTL y verificación en un mismo entorno!
• Convierte (con ciertas restricciones) a VHDL o Verilog (sintetizable)
• Permite cosimular Verilog
• Gratis
• Libre (LGPL)

library ieee ;
use ieee . std logic 1164 . all ;

entity mux is
    port (
    a, b : in std logic vector (3 downto 0);
    s : in std logic ;
    o : out std logic vector (3 downto 0));
end mux;
architecture behavior of mux is
begin  behavior
    o <= a when s = '0' else b;
end behavior

• Requiere declarar la "entidad" (entradas y salidas)
• Tipado estático: requiere declarar tipo de entradas
• Verbósico y no muy ortogonal

def mux(s, o, a, b):
 """2-channels N-bits multiplexor

 a, b: generic bits input channels
 o: output vector
 s: channel selector"""

 @always_comb
 def logic():
     if s == 0:
         o.next = a
     else:
         o.next = b
 return logic

• La entidad se determina por introspección (cuando se instancia)
• Python es dinámico ;-)
• Simple is better than complex!

• "módulo" (bloque) de HW => función Python: mux
• En una función interna se define el comportamiento: logic
• Se decora con magia (@always_comb) y se vuelve un generador
  • Los generadores guardan un estado interno
  • Esto permite la simulación
  • El decorador determina el tipo de sensibilidad. Predefinidos:
    • @always_comb cuando cambie cualquier señal de entrada
    • @always: cuando cambie las que le indiquemos
    • @instance: generador adhoc (se usa en testbench)

• Y cómo echufamos? Signal (a.k.a "cablecitos")

  >>> bus = Signal(0)
  >>> bus.val
  0
  >>> bus.next = 1
  >>>
  

• Pero el HW tiene límites físicos ¿cuántos bits tiene ese bus?

>>> val = intbv(1, min=0, max=15)
>>> len(val)
4
>>> bus = Signal(val)

• Hagamos un testbench

def testBench():

I0, I1 = [Signal(intbv(random.randint(0, 255))[32:]) for i in range(2)]
O = Signal(intbv(0)[32:])
S = Signal(intbv(0, min=0, max=2))

mux_inst = mux (S, O, I0, I1)

@instance
def stimulus():
    header =  "%-6s|%-6s|%-6s|%-6s|%-6s" % ('time', 'I0', 'I1', 'S', 'O')
    print header + '\n' + '-' * len(header)
    while True:
        S.next = intbv(random.randint(0, 1))[1:]
        I0.next, I1.next = [intbv(random.randint(0, 255))[32:] for i in range(2)]
        print "%-6s|%-6s|%-6s|%-6s|%-6s" % (now(), I0, I1, S, O)
        yield delay(5)

return mux_inst, stimulus

sim = Simulation(testBench())
sim.run(20)

• Simulation recibe como parámetros los "módulos"
• con el método run se ejecuta, indicando cuantos ciclos (timesteps) se correrá
• El resultado es:

time  |I0    |I1    |S     |O
----------------------------------
0     |35    |96    |0     |0
5     |164   |254   |1     |254
10    |132   |60    |0     |132
15    |32    |138   |0     |32
20    |15    |112   |1     |112
<class 'myhdl._SuspendSimulation'>: Simulated 20 timesteps

• Un print sofisticado: generar formas de onda (.vcd)

tb_4_sim = traceSignals(testBench)
sim = Simulation(tb_4_sim)
sim.run(20)

• Se pueden leer con GTKWave

  

• unittest querido, el pueblo está contigo

class MuxTest(unittest.TestCase):

    def setUp(self):
        self.channels = [Signal(intbv(random.randint(0, 255))[32:]) for i in range(2)]
        self.O = Signal(intbv(0)[32:])
        self.S = Signal(intbv(0, min=0, max=2))
        self.mux_inst = mux(self.S, self.O, self.channels[0], self.channels[1])

    def test_starts_in_channel_0(self):
        yield delay(1)
        Simulation( self.mux_inst )
        self.assertEqual(self.channels[0].val, self.O.val)

    def test_channel_1_when_select_is_1(self):
        self.S.next = intbv(1)
        yield delay(1)
        Simulation( self.mux_inst )
        self.assertEqual(self.channels[1].val, self.O.val)

• A VHDL

mux_inst = toVHDL(mux, S, O, I0, I1)

• A Verilog

mux_inst = toVerilog(mux, S, O, I0, I1)

• MyHDL es una opción seria

  • ... aunque su nombre no ayude a transmitirlo

• Algoritmia, RTL, simulación y tests: Python FTW!

• La inferencia de patrones para conversion es pura magia

• Unittests (y TDD) => diseño de hardware ágil y bien

• Le debo mi última materia: hice un procesador MIPS en 3 semanas

  https://github.com/nqnwebs/pymips

• Gracias, y vamo'a comer