I am totally new to the RISC-V domain. I am targeting to implement the Rocket Chip core on my FPGA as a module of a bigger project.
As far as I know, SiFive is a supplier for the Rocket Chip. To my knowledge, SiFive makes all its cores implementable only on Xilinx Artix-7 FPGAs. Yet, I am wondering if it is possible to implement it on other FPGAs (Eg. Xilinx Virtex 7 or Zynq)?
If yes, would that require some further modifications of any kind? Or I am fine with the regular flow demonstrated on Github?
Thanks.
LiteX has support for building SoCs around the Rocket core on a range of platforms. It has been tested on both Xilinx FPGAs and Lattice ECP5.
https://www.contrib.andrew.cmu.edu/~somlo/BTCP/ is a description of this flow aimed primarily at the Versa ECP5 development board. But LiteX supports a range of other platforms including some Virtex and Zynq boards.
BTW, Rocket-Chip is not (just) a SiFive project, it was originally developed by Berkeley and is now maintained by Chips Alliance.
Originally, Rocket Chip was supported for Zynq FPGAs: https://github.com/ucb-bar/fpga-zynq
That repo is deprecated and no longer supported, but perhaps something useful can be gleamed from it.
I managed to implement 32-bit single tiny core over Xilinx VC-709 board Virtex-7 fpga for baremetal.
I'm pretty sure you can implement bigger core with linux image.
Modification as per your requirement is not that tough.Just learn chisel and go through with interfaces and architecture.
On hardware side just need knowledge of dpi interface and design flow for fpga.
I am just new on GNURadio and for a project I need to use GNURadio with an FPGA platform different from the ones already supported in the GNURadio project...
Is it feasible to develop design for different platforms?? I must a different FPGA since my board include DA/AD converters with higher BW than the supported platforms.
Thanks in advance for your help
GNURadio is a framework for processing data on a CPU. They added some RFNOC stuff that is supposed to do your processing on Ettus USRP FPGAs, but I'm not sure how well that works. GNURadio does not limit itself to any specific hardware front end, however you will have to write the custom drivers yourself. GNURadio uses UHD as the driver to work with Ettus USRPs, and there are other drivers (such as rtl-sdr) already integrated into GNURadio that work with hardware front-ends other than Ettus USRPs.
So to answer your question, yes you can use GNURadio with other FPGA platforms, but you will need to build the drivers yourself. Is it feasible to develop designs for different platforms? Yes, but there will be a significant amount of work that goes into it, which depends on your specific application and time frame for if it's worth it. You have not given any specifics so it's impossible for me to estimate.
I am trying to port code using boost.asio onto the esp32 (esp-idf) which in turn uses lwip, mbedtls and FreeRTOS using preemptive multitasking.
The esp-idf exposes a Linux/Posix-like interface and most stuff compiles out of the box. Lwip exposes a standard BSD socket interface including select() and blocking and non-blocking sockets etc, but it does not have poll().
So in principle I would think that everything should be there to make boost.asio happy. What I find is that boost.asio (e.g. socket_ops.ipp) contains code variants for many OSes, and it is clear to me that esp32 is not a supported platform.
My question is: What is currently the best alignment of the BOOST_ASIO_* #defines when targeting the esp32?
(I am currently drilling into this and I am modifying both boost.asio and the esp-idf to fit together, but I already made unnecessary changes, thus asking this question.)
I was working as a QA engineer for a proprietary embedded operating system. They built their own ATN stack and stepping though it with a debugger was the most eye opening experience I have had with networking. Watching each layer of the stack build their part of the packet was amazing. Then finally being able to see the built packet on the wire had more meaning.
As an educator I would like share this experience with others. Does anyone know of a straight forward method stepping though a TCP/IP stack? Ideally I would like something easier than debugging a *BSD or Linux kernel, although if this is the only option then some tips and tricks for this process would be nice. A reference stack written in C/C++ that could be run in user mode with Visual Studio or Eclipse would be ideal.
This all depends on what you want to focus on. From your question, the thing you are most interested in is the data flow throughout the different layers (user-space stream -> voltage on the cable).
For this, I propose you use http://www.csse.uwa.edu.au/cnet/, which is a full network simulator. It allows you to step through all levels of the stack.
Real systems will always have a clear distinction between Layer3, Layer2 and Layer1 (Ethernet and CRC-checking firmware on chip, hardware MAC). You will have trouble getting into the OS and some implementation details will be messy and confusing for students. For Linux, you'll have to explain kernel infrastructure to make sense of the TCP/IP stack design.
If you are only interested in the TCP/IP part, I recommend you use an embedded TCP/IP stack like http://www.sics.se/~adam/lwip/ . You can incorporate this into a simple user-space program and fully construct the TCP/IP packet.
Please note that there are a lot of network communication aspects that you cannot address while stepping through the TCP/IP stack. There is still a MAC chip in between which regulates medium access, collisions etc. Below that, there is a PHY chip which translates everything into electric/optical signals, and there is even a protocol which handles communication between MAC and PHY. Also, you are not seeing all aspects related to queueing, concurrency, OS resource allocation ea. A full picture should include all of these aspects, which can only be seen in a network simulator.
I would run Minix in a virtual machine and debug that. It is perfect for this.
Minix is a full OS with TCP/IP stack so you have the code you need. However, unlike Linux/BSD its roots and design goal are to be a teaching tool, so it eschews a certain level of complexity in favor of being clear. In fact, this is the OS Linus Torvalds started hacking on when he started out with Linux :-)
You can run minix in an VM such as VirtualBox or VMware and debug it. There are instruction on the web site: http://www.minix3.org/
I personally learned TCP/IP stack using DOS and SoftICE (oops, leaked that I'm an old guy). Using DOS on a virtual machine and debug through a TCP/IP driver will be much simpler since your goal is to educate how TCP/IP works. Modern OS does a lot of optimization on network I/O and it's not easy to debug through.
http://www.crynwr.com/ has a bunch of open source packet drivers. Debugging with source code shall be a bit easier.
This not exactly what you are looking for but I hope this helps
1995 - TCP/IP Illustrated, Volume 2: The Implementation (with Gary R. Wright) - ISBN 0-201-63354-X
Just walk through the code side by side. Near stepping through experience. Mr Steven's explains key variables too. Just awesome. Note: Code may have changed since the book but still awesome.
Probably lwIP project is what you are looking for because it can be run without an operating system.
As for debugging Linux kernel, there is not very simple, but well-known way to do it. Use KGDB. Install debugging version of Linux kernel on virtual machine or on separate box. And remotely connect GDB to this machine. Probably you would like to use some GDB frontend instead of text-only interface. If you need more details on kernel debugging from more competent people, just add "linux" tag to the question.
I actually wrote a small subset of a TCP/IP stack in a 8051 once, it was a very enlightening experience.
I believe that the best way to learn something is by doing it. Once you finished your task, go and get feedback with other developers and compare your implementation with other existing ones.
My opinion might be biased here, but I think that doing this in a embedded platform is the best way to go. What you are trying to do is very low level, and a PC will just add more complexity into the problem. A embedded chip has no operational system to get in your way. Besides that, it is very satisfying to see a simple 8051 respond to ping requests and telnet calls.
They key is to start small, don't try to create a full TCP/IP stack all at once. Write the code to handle the MAC first, then IP, Ping, UDP and finally TCP.
I don't think that studying an existing implementation is a good ideia. TCP/IP implementations tend to be bloated with code that is unrelated with your goal.
I work in the TCP/IP industry. In BSD and variants, the function tcp_input() is an ideal starting point to explore the innards of TCP. Setting a breakpoint on this function and stepping through it on a live system can give a lot of enlightenment. If that is hard, you can simply browse through the source to get a broad feel of it:
http://fxr.watson.org/fxr/source/netinet/tcp_input.c
It will take time, many weeks at least, to understand the big picture. Quite exhilarating. :-)
You can run the NetBSD IP stack in userspace in Linux or other OS, with gdb or whatever see http://www.netbsd.org/docs/rump/ and https://github.com/anttikantee/buildrump.sh and then eg feed it to a tun/tap device so you can see whats on the wire.
We are building a product, which requires modbus communication (both rs-485 and TCP/IP). The code has to run on an embedded device which has Linux running on it. We have following criteria for the selecting the library that we would be using.
It has to be opensource, since we are opensource geeks.
We would give this product to our users and what their application would be we are not aware, hence it has to complete implementation of the modbus protocol.
Wide user base: What we believe is that greater the users of the code, more the stability of the code.
I came across two such libraries:
http://www.freemodbus.org
and
libmodbus
Are there any more modbus libraries. Please suggest with pros and cons
I'd suggest libmodbus, it works well and is cross platform.
http://www.libmodbus.org
I am just starting to explore these options as well. My priority is on ease of use which has led me to RModBus since it was the only one that I was able to get immediate results with. However, there is also a Python library, Pymodbus, that appears to be quite complete in implementation.
I'm sorry, I just figured out that GCC is a compiler; my answer is way off topic.
Again, I was looking for a scripting language that my noob self could be more comfortable in. It really came down to a question of language rather than the library itself. Oh, I am only using the TCP/IP stack at this time, which somewhat simplifies it as well.