Search the Community

Showing results for tags 'wishbone'.

  • Search By Tags

    Type tags separated by commas.
  • Search By Author

Content Type


  • Community
    • Gadget Factory Reboot 2022
    • Gadget Factory
    • Documentation
    • FPGA Discussions
    • Community Projects
  • Soft Processors
    • Migen/LiteX/Risc-V
    • ZPUino
    • J1 Forth
    • AVR8 Soft Processor
  • Electronics
    • Modules
  • Papilio Platform (Retired)
    • Papilio General Discussion
    • Papilio Pro
    • Papilio One
    • Papilio DUO
    • Papilio Wings
    • DesignLab IDE
    • DesignLab Libraries
    • RetroCade Synth
    • Papilio Arcade
    • Papilio Loader Application
    • Papilio Logic Sniffer
    • Pipistrello
    • Retired
  • Open Bench (Retired)
    • Open Bench Logic Sniffer at Dangerous Prototypes
    • OpenBench Logic Sniffer at Gadget Factory
  • GadgetBox Universal IoT Hardware (Retired)
    • GadgetBox General Discussion
  • Gadget Factory Internal Category


  • Papilio Platform
    • Papilio One
    • Papilio Plus
    • Papilio Wings
    • LogicStart MegaWing
    • ZPUino
    • Papilio Pro
  • Papilio Arcade
  • RetroCade Synth
  • Logic Sniffer
  • FPGAs
  • DesignLab
    • Example Projects
    • Libraries


  • Papilio FPGA
    • Papilio UCF (User Constraint) Files
    • Papilio Bit Files
  • Papilio Arcade
  • RetroCade Synth
  • General
  • Beta (Test) Releases
  • Books

Find results in...

Find results that contain...

Date Created

  • Start


Last Updated

  • Start


Filter by number of...


  • Start





Website URL







Found 5 results

  1. Dear Altruists, I'm new to Papilio Pro FPGA. I designed my circuit with VHDL and also synthesized it, and it is ready to be loaded in the papilio pro fpga. My circuits interface has an input of 64 bits and output of 1 bit. I need only to send this 64 bit data from my pc to FPGA and receive the output of 1 bit ( please check the uploaded circuit interface). I already watched most of the learning videos. I have already contacted Mr. Alvie and thanks to him he reply with an answer, but it was a little difficult for me to understand as I am new to FPGA. His answer was that I should connect my circuits to one of wishbone ZPUino slots, and use ZPUino to interface with the USB/serial using software moving data to and form my circuits. However, the things that I don't understand are that: 1. Should i connect my circuits to wishbone bridge and then connect my circuits to the wishbone slots as you did here ( If the answer yes, should I connect the the both input and output to the wishbone bridge. If answer no, then should I interface my circuits directly to the ZPUino wishbone slots. 2. If I connect my circuits to ZPUino wishbone slots. The input 64 bits and the output 1 bit should be connected to what to the slots or Paplilio Pro Pins. 3. Mr. Jack illustrate in the learning site videos that ZPUino should be loaded to the SPI not to the FPGA Spartan6. So, If I am going to interface my design to ZPUino how can I load the circuits to the FPGA. 4. If I am going to make an interface of the UART I think I just need to follow as same as Mr. Jack did in this video( ) Please forgive my shortcomings. I am new to these things. Any help will be highly appreciated. Thanks
  2. hi, i'm using designlab 1.0.8 with ise 14.7 on ubuntu 17.04 amd64, targeting a papilio pro/spartan 6 with the zpuino soft processor. i've got a working proof-of-concept design which combines a few bits and pieces, namely the whirlyfly (whirlygig) random number generator (, a couple wishbone uart's (COMM_zpuino_wb_UART.vhd), and a wishbone watchdog peripheral written in verilog that i've been trying to integrate ( the rng and uart components appear to be working fine, giving me up to 280KB/s or so of random data when polling both wishbone uart's sequentially at 3mbit/s. i'm then using the reference blake2s hash implementation ( to further "whiten" the output of the rng's. this slows down the output to about 30KB/s which is fine considering it's a complex operation. that's not the issue. anyhow, the wishbone peripherals included in designlab, as well as the schematic representation of the zpuino 2.0 soft processor bundle the input and output wires into the wishbone_in/wishbone_out connections, which i assume is for simplicity when placing components using the schematic editor in ise. the watchdog.v implementation linked previously is designed with all of the wishbone wires broken out like: module watchdog(wb_clk_i, wb_rst_i, wb_dat_i, wb_dat_o, wb_we_i, wb_stb_i, wb_cyc_i, wb_ack_o, wb_int_o); i've been trying unsuccessfully now for a while to modify the watchdog.v to present the same interface, so i can easily attach it to the zpuino using the schematic editor gui (i.e. Papilio_Pro.sch) in ise. without knowing how to modify the schematic symbol after generating it, i just took the one from the wishbone uart included in designlab, replaced the relevant variables and removed the tx/rx, and overwrote the existing watchdog.sym in the project directory. that seemed to work fine and let me drag & drop the watchdog onto an open wishbone port on the zpuino. the issue i'm having is that i can't seem to get the pre-synthesis rtl schematic viewer in planahead to "alias" the slices of wishbone_in/wishbone_out to the friendly-named wires representative of their function within the wishbone bus (e.g. wire [31:0] wb_dat_i; assign wb_dat_i [31:0] = wishbone_in [59:28];). the design does synthesize fine, but i haven't bothered trying to write C code for the zpuino to interface/write with the watchdog peripheral because of the apparent brokenness being shown in planahead. here's a simplification of what i've been doing unsuccessfully to create the "friendly" aliases of wishbone_in/wishbone_out: // original, simplified module watchdog(wb_clk_i, wb_rst_i, wb_dat_i, ...); parameter Tp = 1; input wb_clk_i; input wb_rst_i; input [`WDT_WIDTH - 1:0] wb_dat_i; ... // new, simplified module watchdog(wishbone_in, wishbone_out); parameter Tp = 1; input [100:0] wishbone_in; output [100:0] wishbone_out; wire wb_clk_i = wishbone_in [61]; wire wb_rst_i = wishbone_in [60]; wire [31:0] wb_dat_i; assign wb_dat_i [31:0] = wishbone_in [59:28]; ... // mutual code between original & new ... always @(posedge wb_rst_i or posedge wb_clk_i) if (wb_rst_i) begin stb <= #Tp 1'b0; we <= #Tp 1'b0; dat_ir <= #Tp `WDT_WIDTH'h0; end else begin stb <= #Tp wb_stb_i && wb_cyc_i; we <= #Tp wb_we_i; dat_ir <= #Tp wb_dat_i; end ... attached are abridged screenshots of what planahead shows for the unmodified verilog code straight from the aforementioned github repo (top image), and the seemingly broken output from my modified version where i try to bundle up the wires into wishbone_in/wishbone_out. the dat_ir is where wb_dat_i is showing a single wire instead of [31:0]. also attached is the work-in-progress modified watchdog.v. please keep in mind that these are the first lines of vhdl/verilog i've ever written so my knowledge of syntax/terminology is very limited. thanks! watchdog.v
  3. Hi, I wonder how the access to the on-board RAM can be implemented and organized. So far I know that a ZPUino uses the on-board RAM to store programs and data. If I understand it correctly, the ZPUino implementation uses the sram_ctl8.vhd source to access the RAM chip via a Wishbone bus interface. I want to use the Papilio DUO to simulate an expansion board for an old 6502-based computer (Ohio Scientific Challenger 1P). On the one hand I want to use a part of the Papilio DUO RAM chip as a memory expansion for the 6502 board. On the other hand a floppy controller with attached floppy disks shall be simulated with storage on an SD card. So for the RAM expansion alone I only need to translate the 6502 bus to something that can communicate with the Papilio DUO's RAM chip. I either could create a Wishbone bus wrapper around the 6502 bus, and use the sram_ctl8.vhd as-is, or I could directly build a bridge from the 6502 bus to the RAM chip based on the internals of the sram_ctl8.vhd source. But when the floppy controller comes into the picture it gets more complicated. I need to simulate some of the chips for the floppy controller (6850 ACIA and 6820 PIA) and map them into the address space of the 6502. For access to an SD card I will either need to use a ZPUino or the real ATmega32U4 processor. With a ZPuino I would need to divide the RAM between the memory expansion and the ZPUino. So lots of questions arise: How can I divide the RAM between the ZPUino and other parts of my design? Could that be managed with compile and link time options when building the sketch for the ZPUino, or would I need to build something in VHDL? Is it even possible at all to influence the ZPUino's use of the RAM chip without modifying its implementation? Would it be better to use the ATmega32U4 for implementing the access to the SD card? I'm obviously at the very beginner level regarding designing and implementing such a project, so I would be very grateful about any tips and experiences in this area. Thanks Stephan
  4. Hello, Im having a problem with the wishbone interface on the ZPUino soft processor. I am trying to output a signal to a design I have made, in this instance its outputting a reset signal but the same problem occurs on all the other outputs too. The signal and corresponding pin I have the oscilloscope connected to is highlighted in red in fig 1. This goes to a custom block that builds individual signals into a bus that is outputted using the Papilio block set provided, this can be seen in fig 2. Im using the standard ZPUino programing IDE, when I program it to output 0xff to wishbone Register 2 the output pin on the FPGA becomes high, this is shown in figure 3. This is exactly what you would expect to happen. Again in fig 4 the when Register 2 is set to be 0x00 then the output on the pin connected to the oscilloscope is set to logic 0, as expected. However in figure 5 Wishbone register 2 is set to be 0x00 for 100ms then set to 0xff for 200ms, this should produce a waveform that shows a signal that is high twice as long as low. Though this is the comes out as the opposite, it seems that the signal is being inverted. I can’t for the life of me work out why this is. Similarly in fig 6 I set it to be the opposite 0xff for 200ms and 0x00 for 100ms and it does the same, inverting the signals again. I have checked for sources of error in other places, the oscilloscope is working fine Ive tried connecting the Wishbone output directly to a pin to see if the Papilio output block was the cause this had no effect, I’ve double checked my Wishbone interface code its fine no reason to invert the output. This also happens when the delay is increased to 20secconds and 10secconds to see if it was a timing issue and needed a steeling time, keeps inverting the signals still. The weird thing is that it works fine when the is no periodic signal applied and its just a DC output, if it was an inverter causing the problem that’s fine all I need to do is change my code around a bit but this is not that simple and I couldn’t work with an unpredictable output. Does anyone have any suggestion as to what the problem is? Many thanks Joe
  5. Hi All, I've been getting back into some Papilio development again lately and have been very happy to see all the improvements to the SoC ecosystem. I've been able to reproduce the pwn tutorial (very helpful!) and now want to add a toy 'adder' (add two registers and store the result in a third) component. I'm struggling to understand the behavior of async vs sync from the perspective of software running on zpuino. With an async result do you poll for a ready bit, vs having the cpu block on sync? Are there software examples of the two, or best practices to follow? The default template is async, and the vhdl code makes sense, I'm just wondering… for the adder component described above, should I be using sync? (I've seen the examples of that in another thread). Thanks in advance, -Greg