def definition(io): edge_r = rising(io.SCK) edge_f = falling(io.SCK) # pixels come 16 bits (high and low byte) at a time bit_counter = mantle.Counter(4, has_ce=True, has_reset=True) m.wire(edge_r, bit_counter.CE) # find when the high and low byte are valid low = mantle.Decode(15, 4)(bit_counter.O) high = mantle.Decode(7, 4)(bit_counter.O) # shift registers to store high and low byte low_byte = mantle.PIPO(8, has_ce=True) high_byte = mantle.PIPO(8, has_ce=True) low_byte(0, io.DATA, low) high_byte(0, io.DATA, high) m.wire(low, low_byte.CE) m.wire(high, high_byte.CE) # assemble the 16-bit RGB565 value px_bits = (m.uint(mantle.LSL(16)((m.uint(m.concat(high_byte.O, zeros))), m.bits(8, 4))) + m.uint(m.concat(low_byte.O, zeros))) # extract the values for each color r_val = m.uint(mantle.LSR(16)((px_bits & RMASK), m.bits(11, 4))) g_val = m.uint(mantle.LSR(16)((px_bits & GMASK), m.bits(5, 4))) b_val = m.uint(px_bits & BMASK) # sum them to get grayscale (0 to 125) px_val = (r_val + g_val + b_val) # --------------------------UART OUTPUT---------------------------- # # run 16-bit UART at 2x speed baud = edge_r | edge_f # reset at start of pixel transfer ff1 = mantle.FF(has_ce=True) m.wire(baud, ff1.CE) u_reset = mantle.LUT2(I0 & ~I1)(io.VALID, ff1(io.VALID)) m.wire(u_reset, bit_counter.RESET) # generate load signal ff2 = mantle.FF(has_ce=True) m.wire(baud, ff2.CE) load = mantle.LUT3(I0 & I1 & ~I2)(io.VALID, high, ff2(high)) uart = UART(16) uart(CLK=io.CLK, BAUD=baud, DATA=px_val, LOAD=load) m.wire(px_val, io.PXV) m.wire(uart, io.UART) m.wire(load, io.LOAD)
def definition(io): load = io.LOAD baud = rising(io.SCK) | falling(io.SCK) valid_counter = mantle.CounterModM(buf_size, 12, has_ce=True) m.wire(load & baud, valid_counter.CE) valid_list = [wi * (b - 1) + i * a - 1 for i in range(1, wo + 1)] # len = 32 valid = m.GND for i in valid_list: valid = valid | mantle.Decode(i, 12)(valid_counter.O) # register on input st_in = mantle.Register(width, has_ce=True) st_in(io.DATA) m.wire(load, st_in.CE) # --------------------------DOWNSCALING----------------------------- # # downscale the image from 352x288 to 32x32 Downscale = m.DeclareCircuit( 'Downscale', "I_0_0", m.In(m.Array(1, m.Array(1, m.Array(width, m.Bit)))), "WE", m.In(m.Bit), "CLK", m.In(m.Clock), "O", m.Out(m.Array(width, m.Bit)), "V", m.Out(m.Bit)) dscale = Downscale() m.wire(st_in.O, dscale.I_0_0[0][0]) m.wire(1, dscale.WE) m.wire(load, dscale.CLK) add16 = mantle.Add(width) # needed for Add16 definition # threshold the downscale output px_bit = mantle.ULE(16)(dscale.O, m.uint(THRESH, 16)) & valid # ---------------------------UART OUTPUT----------------------------- # m.wire(px_bit, io.O) m.wire(valid, io.VALID)
def definition(io): load = io.LOAD baud = rising(io.SCK) | falling(io.SCK) valid_counter = mantle.CounterModM(buf_size, 12, has_ce=True) m.wire(load & baud, valid_counter.CE) valid_list = [wi * (b - 1) + i * a - 1 for i in range(1, wo + 1)] # len = 32 valid = m.GND for i in valid_list: valid = valid | mantle.Decode(i, 12)(valid_counter.O) # register on input st_in = mantle.Register(width, has_ce=True) st_in(io.DATA) m.wire(load, st_in.CE) # --------------------------DOWNSCALING----------------------------- # # downscale the image from 352x288 to 32x32 Downscale = m.DeclareCircuit( 'Downscale', "I_0_0", m.In(m.Array(1, m.Array(1, m.Array(width, m.Bit)))), "WE", m.In(m.Bit), "CLK", m.In(m.Clock), "O", m.Out(m.Array(width, m.Bit)), "V", m.Out(m.Bit)) dscale = Downscale() m.wire(st_in.O, dscale.I_0_0[0][0]) m.wire(1, dscale.WE) m.wire(load, dscale.CLK) add16 = mantle.Add(width) # needed for Add16 definition # --------------------------FILL IMG RAM--------------------------- # # each valid output of dscale represents an entry of 32x32 binary image # accumulate each group of 32 entries into a 32-bit value representing a row col = mantle.CounterModM(32, 6, has_ce=True) col_ce = rising(valid) m.wire(col_ce, col.CE) # shift each bit in one at a time until we get an entire row px_bit = mantle.ULE(16)(dscale.O, m.uint(THRESH, 16)) & valid row_reg = mantle.SIPO(32, has_ce=True) row_reg(px_bit) m.wire(col_ce, row_reg.CE) # reverse the row bits since the image is flipped row = reverse(row_reg.O) rowaddr = mantle.Counter(6, has_ce=True) img_full = mantle.SRFF(has_ce=True) img_full(mantle.EQ(6)(rowaddr.O, m.bits(32, 6)), 0) m.wire(falling(col.COUT), img_full.CE) row_ce = rising(col.COUT) & ~img_full.O m.wire(row_ce, rowaddr.CE) waddr = rowaddr.O[:5] rdy = col.COUT & ~img_full.O pulse_count = mantle.Counter(2, has_ce=True) we = mantle.UGE(2)(pulse_count.O, m.uint(1, 2)) pulse_count(CE=(we|rdy)) # ---------------------------UART OUTPUT----------------------------- # row_load = row_ce row_baud = mantle.FF()(baud) uart_row = UART(32) uart_row(CLK=io.CLK, BAUD=row_baud, DATA=row, LOAD=row_load) uart_addr = UART(5) uart_addr(CLK=io.CLK, BAUD=row_baud, DATA=waddr, LOAD=row_load) m.wire(waddr, io.WADDR) m.wire(img_full, io.DONE) #img_full m.wire(uart_row, io.UART) #uart_st m.wire(row, io.O) m.wire(we, io.VALID) m.wire(valid, io.T0) m.wire(uart_addr, io.T1)
# hx8kboard.J2[16].output().on() # hx8kboard.J2[17].output().on() # hx8kboard.J2[18].output().on() # hx8kboard.J2[19].output().on() main = hx8kboard.main() # "test" data init = [m.uint(i, 16) for i in range(16)] printf = mantle.Counter(4, has_ce=True) rom = ROM16(4, init, printf.O) clk_counter = mantle.Counter(5) sclk = clk_counter.O[4] edge_r = rising(sclk) edge_f = falling(sclk) baud = edge_r | edge_f bit_counter = mantle.Counter(4, has_ce=True, has_reset=True) m.wire(edge_r, bit_counter.CE) high = mantle.Decode(7, 4)(bit_counter.O) ff2 = mantle.FF(has_ce=True) m.wire(baud, ff2.CE) load = high & ~ff2(high) m.wire(load & baud, printf.CE) rescale = Rescale()
def definition(cam): edge_f = falling(cam.SCK) edge_r = rising(cam.SCK) # ROM to store commands rom_index = mantle.Counter(4, has_ce=True) rom = ROM16(4, init, rom_index.O) # Message length is 16 bits, setup counter to generate done signal # after EOM done_counter = mantle.Counter(5, has_ce=True, has_reset=True) count = done_counter.O done = mantle.Decode(16, 5)(count) # State machine to generate run signal (enable) run = mantle.DFF(has_ce=True) run_n = mantle.LUT3([0, 0, 1, 0, 1, 0, 1, 0]) run_n(done, trigger, run) run(run_n) m.wire(edge_f, run.CE) # Reset the message length counter after done run_reset = mantle.LUT2(I0 | ~I1)(done, run) done_counter(CE=edge_r, RESET=run_reset) # State variables for high-level state machine ready = mantle.LUT2(~I0 & I1)(run, edge_f) start = mantle.ULE(4)(rom_index.O, m.uint(3, 4)) burst = mantle.UGE(4)(rom_index.O, m.uint(9, 4)) # Shift register to store 16-bit command|data to send mosi = mantle.PISO(16, has_ce=True) # SPI enable is negative of load-don't load and shift out data at the # same time enable = mantle.LUT3(I0 & ~I1 & ~I2)(trigger, run, burst) mosi(~burst, rom.O, enable) m.wire(edge_f, mosi.CE) # Shit register to read in 8-bit data miso = mantle.SIPO(8, has_ce=True) miso(cam.MISO) valid = mantle.LUT2(~I0 & I1)(enable, edge_r) m.wire(valid, miso.CE) # Capture done state variable cap_done = mantle.SRFF(has_ce=True) cap_done(mantle.EQ(8)(miso.O, m.bits(0x08, 8)), 0) m.wire(enable & edge_r, cap_done.CE) # Use state variables to determine what commands are sent (how) increment = mantle.LUT4(I0 & (I1 | I2) & ~I3)( ready, start, cap_done, burst) m.wire(increment, rom_index.CE) # wire outputs m.wire(enable, cam.EN) m.wire(mosi.O, cam.MOSI) m.wire(miso.O, cam.DATA) m.wire(burst, cam.VALID) # --------------------------UART OUTPUT---------------------------- # # run UART at 2x SPI rate to allow it to keep up baud = edge_r | edge_f # reset when SPI burst read (image transfer) begins ff = mantle.FF(has_ce=True) m.wire(edge_r, ff.CE) u_reset = mantle.LUT2(I0 & ~I1)(burst, ff(burst)) # UART data out every 8 bits u_counter = mantle.CounterModM(8, 3, has_ce=True, has_reset=True) u_counter(CE=edge_r, RESET=u_reset) load = burst & rising(u_counter.COUT) uart = UART(8) uart(CLK=cam.CLK, BAUD=baud, DATA=miso, LOAD=load) # wire output m.wire(uart, cam.UART) # generate signal for when transfer is done data_count = mantle.Counter(18, has_ce=True) tx_done = mantle.SRFF(has_ce=True) # transfer has size 153600 bytes, first 2 bytes are ignored tx_done(mantle.EQ(18)(data_count.O, m.bits(153602, 18)), 0) m.wire(load, tx_done.CE) m.wire(load, data_count.CE) # wire output m.wire(tx_done, cam.DONE)
def definition(io): load = io.LOAD baud = io.BAUD valid_counter = mantle.CounterModM(buf_size, 13, has_ce=True) m.wire(load & baud, valid_counter.CE) valid_list = [wi * (b - 1) + i * a - 1 for i in range(1, wo + 1)] valid = m.GND for i in valid_list: valid = valid | mantle.Decode(i, 13)(valid_counter.O) # register on input st_in = mantle.Register(16, has_ce=True) st_in(io.DATA) m.wire(load, st_in.CE) # --------------------------DOWNSCALING----------------------------- # # downscale the image from 320x240 to 16x16 Downscale = m.DeclareCircuit( 'Downscale', "I_0_0", m.In(m.Array(1, m.Array(1, m.Array(16, m.Bit)))), "WE", m.In(m.Bit), "CLK", m.In(m.Clock), "O", m.Out(m.Array(16, m.Bit)), "V", m.Out(m.Bit)) dscale = Downscale() m.wire(st_in.O, dscale.I_0_0[0][0]) m.wire(1, dscale.WE) m.wire(load, dscale.CLK) add16 = mantle.Add(16) # needed for Add16 definition # --------------------------FILL IMG RAM--------------------------- # # each valid output of dscale represents an entry of 16x16 binary image # accumulate each group of 16 entries into a 16-bit value representing # a row of the image col = mantle.Counter(4, has_ce=True) row_full = mantle.SRFF(has_ce=True) row_full(mantle.EQ(4)(col.O, m.bits(15, 4)), 0) m.wire(falling(dscale.V), row_full.CE) col_ce = rising(dscale.V) & ~row_full.O m.wire(col_ce, col.CE) row = mantle.Counter(4, has_ce=True) img_full = mantle.SRFF(has_ce=True) img_full(mantle.EQ(4)(row.O, m.bits(15, 4)), 0) m.wire(falling(col.COUT), img_full.CE) row_ce = rising(col.COUT) & ~img_full.O m.wire(row_ce, row.CE) # ---------------------------UART OUTPUT----------------------------- # uart_st = UART(16) uart_st(CLK=io.CLK, BAUD=baud, DATA=dscale.O, LOAD=load) m.wire(row.O, io.ROW) m.wire(img_full.O, io.DONE) m.wire(uart_st.O, io.UART)
def definition(io): load = io.LOAD baud = rising(io.SCK) | falling(io.SCK) valid_counter = mantle.CounterModM(buf_size, 13, has_ce=True) m.wire(load & baud, valid_counter.CE) valid_list = [wi * (b - 1) + i * a - 1 for i in range(1, wo + 1)] valid = m.GND for i in valid_list: valid = valid | mantle.Decode(i, 13)(valid_counter.O) # register on input st_in = mantle.Register(16, has_ce=True) st_in(io.DATA) m.wire(load, st_in.CE) # --------------------------DOWNSCALING----------------------------- # # downscale the image from 320x240 to 16x16 Downscale = m.DeclareCircuit( 'Downscale', "I_0_0", m.In(m.Array(1, m.Array(1, m.Array(16, m.Bit)))), "WE", m.In(m.Bit), "CLK", m.In(m.Clock), "O", m.Out(m.Array(16, m.Bit)), "V", m.Out(m.Bit)) dscale = Downscale() m.wire(st_in.O, dscale.I_0_0[0][0]) m.wire(1, dscale.WE) m.wire(load, dscale.CLK) add16 = mantle.Add(16) # needed for Add16 definition # --------------------------FILL IMG RAM--------------------------- # # each valid output of dscale represents a pixel in 16x16 binary image # accumulate each group of 16 pixels into a 16-bit value representing # a row in the image col = mantle.CounterModM(16, 5, has_ce=True) col_ce = rising(valid) m.wire(col_ce, col.CE) # shift each bit in one at a time until we get an entire row px_bit = mantle.ULE(16)(dscale.O, m.uint(THRESH, 16)) & valid row_reg = mantle.SIPO(16, has_ce=True) row_reg(px_bit) m.wire(col_ce, row_reg.CE) # reverse the row bits since the image is flipped row = reverse(row_reg.O) rowaddr = mantle.Counter(5, has_ce=True) img_full = mantle.SRFF(has_ce=True) img_full(mantle.EQ(5)(rowaddr.O, m.bits(16, 5)), 0) m.wire(falling(col.COUT), img_full.CE) row_ce = rising(col.COUT) & ~img_full.O m.wire(row_ce, rowaddr.CE) waddr = rowaddr.O[:4] # we_counter = mantle.CounterModM(16, 5, has_ce=True) # m.wire(rising(valid), we_counter.CE) rdy = col.COUT & ~img_full.O pulse_count = mantle.Counter(5, has_ce=True) we = mantle.UGE(5)(pulse_count.O, m.uint(1, 5)) pulse_count(CE=(we | rdy)) # ---------------------------UART OUTPUT----------------------------- # row_load = row_ce row_baud = mantle.FF()(baud) uart_row = UART(16) uart_row(CLK=io.CLK, BAUD=row_baud, DATA=row, LOAD=row_load) uart_addr = UART(4) uart_addr(CLK=io.CLK, BAUD=row_baud, DATA=waddr, LOAD=row_load) # split 16-bit row data into 8-bit packets so it can be parsed low_byte = row & LOW_MASK high_byte = row & HIGH_MASK uart_counter = mantle.CounterModM(8, 4, has_ce=True) m.wire(rising(valid), uart_counter.CE) m.wire(waddr, io.WADDR) m.wire(img_full, io.DONE) m.wire(uart_row, io.UART) m.wire(row, io.O) m.wire(we, io.VALID)
img_list = [ 0, 0, 0, 0, 960, 4064, 48, 32, 96, 192, 192, 384, 768, 512, 1536, 0 ] # from arducam #img_list = [0, 0, 0, 0, 64, 57440, 50720, 50976, 50592, 64576, 28672, 0, 0, 0, 0, 32768] # 3, last col->first col #img_list = [0, 0, 192, 480, 816, 528, 528, 528, 528, 1552, 1552, 560, 880, 992, 448, 0] # 0 # [1536, 3840, 8064, 6528, 4224, 4224, 6400, 3840, 3840, 8064, 14720, 14720, 14784, 14784, 16256, 7936] # [0, 1, 256, 1920, 3136, 2112, 64, 128, 128, 256, 768, 1536, 4080, 8176, 6144, 0] num_data = [m.uint(img_list[i], 16) for i in range(16)] # decrease the frequency to avoid timing violation counter = mantle.Counter(5) sclk = counter.O[4] baud = mantle.FF()(rising(sclk) | falling(sclk)) rom_idx = mantle.Counter(5, has_ce=True) addr = rom_idx.O[:4] bit_counter = mantle.Counter(5, has_ce=True) m.wire(rising(sclk), bit_counter.CE) we = mantle.Decode(0, 5)(bit_counter.O) load = rising(we) full = mantle.SRFF(has_ce=True) check = mantle.EQ(5)(rom_idx.O, m.bits(16, 5)) full(check, 0) m.wire(falling(sclk), full.CE) rom_ce = load & ~full.O
# print(arr) # plt.imshow(arr, cmap=cm.gray) # plt.show() num_data = [uint(img_list[i], 16) for i in range(16)] # decrease the frequency to avoid timing violation counter = Counter(4) sclk = counter.O[-1] rom_idx = Counter(4, has_ce=True) full = SRFF(has_ce=True) check = EQ(4)(rom_idx.O, bits(15, 4)) full(check, 0) wire(falling(sclk), full.CE) rom_ce = rising(sclk) & ~full.O wire(rom_ce, rom_idx.CE) rom = ROM16(4, num_data, rom_idx.O) pipeline = Pipeline() wire(sclk, pipeline.CLK) wire(rom.O, pipeline.DATA) wire(rom_idx.O, pipeline.WADDR) wire(full.O, pipeline.RUN) wire(pipeline.O[:4], bits([main.D1, main.D2, main.D3, main.D4])) # light 5 indicates the end of prediction wire(pipeline.D, main.D5) # mem = MEM()
main = hx8kboard.main() # baud for uart output clock = mantle.CounterModM(100, 8) baud = clock.COUT bit_counter = mantle.Counter(5, has_ce=True) m.wire(baud, bit_counter.CE) load = mantle.Decode(0, 5)(bit_counter.O) valid_counter = mantle.CounterModM(4800, 13, has_ce=True) m.wire(load & baud, valid_counter.CE) valid_list = [10 * i for i in range(16)] # len = 16 valid = m.GND for i in valid_list: valid = valid | mantle.Decode(i, 13)(valid_counter.O) col = mantle.CounterModM(16, 4, has_ce=True) col_ce = rising(valid) #& ~row_full.O m.wire(col_ce, col.CE) m.wire(baud, main.J2_3) m.wire(load, main.J2_4) m.wire(valid, main.J2_5) m.wire(col_ce, main.J2_8) m.wire(col.COUT, main.J2_9)