Einführung

In diesem Artikel möchte ich ** cReComp ** vorstellen, ein Tool zur Entwicklungsunterstützung für FPGAs, die ich entwickle. Wenn Sie die cReComp-Funktion ausprobieren können, können Sie dies tun, solange auf einem PC ** Ubuntu ** oder ** OSX (MacOS) ** ausgeführt wird.

Was ist cReComp?

cReComp (Ersteller für rekonfigurierbare Komponenten) ist auf programmierbaren SoCs wie Zynq und Cyclone V verfügbar. Es bietet Tools und Frameworks für die ** Softwarekomponalisierung ** von in Verilog geschriebenen Schaltkreisen.

Konkret bedeutet dies, dass durch das Schreiben einer einfachen Einstellung die von Ihnen geschriebene Verilog-Schaltung (im Folgenden als Benutzerlogik bezeichnet) automatisch mit dem Prozessor sowie der Software und dem FPGA verbunden wird Ermöglicht den Datenaustausch zwischen Schaltkreisen. Die Einstellungsbeschreibung in cReComp kann mit ** In-language DSL von Python ** oder meinem DSL für cReComp, ** Scrp (Spezifikation für cReComp) ** erfolgen.

Bitte installieren Sie von der folgenden URL. Sie können auch pip install ausführen, aber ** befindet sich derzeit in der Entwicklung **. Ich denke, Sie können die neueste Version von git clone und dann von python setup.py install erhalten. Github cReComp

Über Xillinux

Xillinux wird von Xillybus veröffentlicht und ist ein Ubuntu-Betriebssystem für programmierbare SoCs, das mit CPUs und FPGAs wie Zynq und Cyclone V ausgestattet ist. In Xillinux stellen FPGA und CPU IP bereit, die die Datenkommunikation über das FIFO über einen Puffer ermöglicht. Die von der Testversion von Xillinux unterstützten FIFO-Pufferbitbreiten betragen 32 Bit und 8 Bit. Die Datenkommunikation zwischen dem FPGA und der CPU kann durch Steuern dieses FIFO-Puffers auf dem FPGA realisiert werden. ** cReComp unterstützt diesen Xillinux-FIFO-Puffer und kann ihn verwenden. ** **. Diesmal ist es eine Voraussetzung, dieses Xillinux zu verwenden. Ich habe bereits einen Artikel über die Einführung von Xillinux geschrieben. Weitere Kommunikationsmechanismen werden in Zukunft implementiert.

Versuchen Sie, mit cReComp zu entwickeln

Wie ich bereits geschrieben habe, gibt es in cReComp zwei Arten der Beschreibung von Einstellungen. Eine Möglichkeit besteht darin, das von cReComp bereitgestellte Framework (DSL in der Sprache) zu verwenden. Informationen zu dieser Methode finden Sie unter Erste Schritte (Japanisch) in der README-Datei des Github-Repositorys.

Daher zeigt Ihnen dieser Artikel, wie Sie Code mit Scrp einrichten und generieren.

Diesmal wurde die Benutzerlogik behandelt

Stellen Sie sicher, dass sich verilog / sonic_sensor.v im geklonten Verzeichnis befindet. Diese Datei ist in Verilog HDL, der Hardwarebeschreibungssprache, geschrieben. Diese Schaltung ist eine Schaltung zum Steuern eines bestimmten Ultraschallsensors, und wenn 1 in "req" eingegeben wird, wird der Sensorwert von "out_data" zurückgegeben. Außerdem steht während der Verarbeitung viel los und nach Abschluss der Verarbeitung steht es voll. Die Kompatibilität von cReComp mit der Schaltung, die einen solchen Handschlag ausführen kann, ist gut. Dieses Mal, wenn der Sensorwert benötigt wird, wird angenommen, dass die Software ein Signal sendet und die Software auf die Daten verweist.

//  verilog/sonic_sensor.v
`timescale 1ns / 1ps
module sonic_sensor(
	input clk,
	input rst,
	input req,
	output [0:0] busy,
	inout sig,
	output finish,
	output [31:0] out_data
);
	parameter STATE_INIT            = 0,
				 STATE_IDLE         = 1,
				 STATE_OUT_SIG      = 2,
				 STATE_OUT_END      = 3,
				 STATE_WAIT750      = 4,
				 STATE_IN_SIG_WAIT  = 5,
				 STATE_IN_SIG       = 6,
				 STATE_IN_SIG_END   = 7,
				 STATE_WAIT200      = 8,
				 STATE_PROCESS_END  = 9;
	reg [3:0] state;
	reg [31:0] echo;
.
.
.

Generierung von Scrp-Dateivorlagen

cReComp kann automatisch eine Scrp-Dateivorlage für die Komponentisierung generieren. Mit dem folgenden Befehl können Sie eine Vorlage erstellen. Geben Sie beim Generieren einer Vorlage außerdem den Namen der Vorlagendatei und den Pfad zur zu komponisierenden Benutzerlogik an.

$ crecomp -u sonic_sensor.v -s sensor_ctl.scrp

Wenn die Vorlagendatei erfolgreich generiert wurde, sollte eine Datei mit dem Namen sensor_ctl.scrp erstellt werden. Der Inhalt der generierten Datei entspricht dem folgenden Code. Wenn Sie beim Generieren der Vorlage die Benutzerlogik angeben, werden die Eingabe- / Ausgabeports der Benutzerlogik wie unten gezeigt gelesen und die erforderliche Beschreibung wird automatisch generiert. Pyverilog und veriloggen werden zur Analyse von Verilog verwendet. # Ist ein Kommentar.

component_name ""

# communication xillybus 1 1 "1" 32
# xillybus32_rcv ""
# xillybus32_snd ""

userlogic_path "sonic_sensor.v" instance_name "uut"
userlogic_assign
	input,1,clk =
	input,1,rst =
	input,1,req =
	output,1,busy =
	inout,1,sig =
	output,1,finish =
	output,32,out_data =
assign_end

end

Komponentenkonfiguration und -generierung

Geben Sie sofort die Einstellungsbeschreibung für die Komponentisierung an.

Projektname (Name der Komponente)

Sie können den Namen der Komponente wie folgt angeben:

component_name "sensor_ctl"

Deklarieren Sie ein Signal, das mit der Benutzerlogik verbunden werden soll

Deklarieren Sie das für die Benutzerlogikverdrahtung erforderliche Signal gemäß dem folgenden Format (Signaltyp Bitbreite "Name").

#Komponententakt und Rücksetzsignal
input 1 "clk"
input 1 "rst"

#Inout-Signal"sig"Signal für die Verkabelung zu
inout 1 "sig_out"

# "finish" and "busy"Signal für die Verkabelung zu
wire 1 "finish_flag"
wire 1 "busy_flag"

Ich habe noch nicht "req" und "out_data" deklariert. Deklarieren Sie es erneut, wenn Sie die Kommunikation zwischen der Benutzerlogik und der Software einstellen. Daher deklarieren wir hier Signale für andere Ports als diejenigen, die Software- und Datenkommunikation erfordern.

Einstellungen der Kommunikationslogik und Signaldeklaration

Kommentieren Sie den Kommentar aus, der bereits in der Vorlage enthalten war, und legen Sie ihn wie folgt fest.

# Xillybus rcv_cycle snd_cycle rs_cond fifo_width
# @param rcv_cycle  :Die Häufigkeit, mit der die Benutzerlogik Daten von der CPU empfängt
# @param snd_cycle  :Häufigkeit, mit der Benutzerlogik Daten an die CPU sendet
# @param rs_cond    :Bedingungen für das Umschalten zwischen Empfangen und Senden von Daten
# @param fifo_width :FIFO-Pufferbitbreite

communication xillybus 1 1 "finish_flag && busy_flag != 0" 32

Als nächstes deklarieren Sie das für die Kommunikation erforderliche Signal. Sie müssen das Signal auch deklarieren und dann dem Xillybus-FIFO-Puffer zuweisen. Bei der Zuweisung muss es sich um ein bereits deklariertes Signal handeln. Zusätzlich wird ** rcv ** verwendet, um Daten in der Richtung Software-> Benutzerlogik zu empfangen, und ** snd ** wird verwendet, um Daten in der Richtung Benutzerlogik-> Software zu senden. Das heißt, es wird bestimmt, in welchem Register die Daten empfangen werden und in welchem Draht die fließenden Daten gesendet werden.

#Registrieren Sie sich für den Empfang von Daten von der CPU
#Da es sich um ein 32-Bit-FIFO handelt, bereiten Sie insgesamt 32 Bit vor.

reg 31 "dummy"
reg 1 "req_reg"

#Interne Leitung zum Senden von Daten an die CPU

wire 32 "sensor_data"

# req_Zuweisen in der Reihenfolge reg und Dummy.
#Sie wird vom LSB des FIFO in der Reihenfolge ihrer Zuordnung zugewiesen.

xillybus32_rcv "req_reg"
xillybus32_rcv "dummy"

#Weisen Sie Signale für die Datenübertragung zu

xillybus32_snd "sensor_data"

Weisen Sie der Benutzerlogik Signale zu

Die Beschreibung zum Zuweisen des Signals zur Benutzerlogik wird automatisch beschrieben, wenn die Vorlagendatei von cReComp generiert wird. Um der Benutzerlogik zuzuweisen, weisen Sie das Signal zu, das Sie beim Einstellen der Komponente deklariert haben. Dieses Mal weisen wir Folgendes zu.

userlogic_path "sonic_sensor.v" instance_name "uut"
userlogic_assign
	input,1,clk = clk
	input,1,rst = rst
	input,1,req = req_reg
	output,1,busy = busy_flag
	inout,1,sig = sig_out
	output,1,finish = finish_flag
	output,32,out_data = sensor_data
assign_end

Vollständige Version der Konfigurationsdatei

Ich denke, dass die Datei, für die die Einstellungsbeschreibung vervollständigt wird, wie folgt ist.

component_name "sensor_ctl"

input 1 "clk"
input 1 "rst"
inout 1 "sig_out"
wire 1 "finish_flag"
wire 1 "busy_flag"

reg 31 "dummy"
reg 1 "req_reg"

wire 32 "sensor_data"

xillybus32_rcv "req_reg"
xillybus32_rcv "dummy"

xillybus32_snd "sensor_data"

userlogic_path "sonic_sensor.v" instance_name "uut"
userlogic_assign
	input,1,clk = clk
	input,1,rst = rst
	input,1,req = req_reg
	output,1,busy = busy_flag
	inout,1,sig = sig_out
	output,1,finish = finish_flag
	output,32,out_data = sensor_data
assign_end

end

Komponentengenerierung

Erstellen wir eine Komponente mit dem folgenden Befehl. Wenn die Generierung erfolgreich ist, wird "Komponente erfolgreich generieren" ausgegeben.

$ crecomp -b sensor_ctl.scrp

Generierte Komponente

Wenn die Generierung erfolgreich ist, wird ein Verzeichnis mit dem Namen der angegebenen Komponente erstellt. Die Hardware enthält die Schaltungsbeschreibung, die auf dem FPGA ausgeführt wird, und die Software enthält die Software, die auf der CPU ausgeführt wird. Mit dieser Software können Sie Daten mit der Benutzerlogik austauschen.

sensor_ctl/
|--hardware/
	|--sensor_ctl.v
	|--sonic_sensor.v
|--software/
	|--sensor_ctl.cpp
	|--lib_cpp.h
	|--Makefile

Die generierte Software hat beispielsweise den folgenden Code.

#include "lib_cpp.h"
#include <iostream>
using namespace std;

class sensor_ctl_32 :public If_module{
	unsigned int sensor_ctl_dout_32;
	unsigned int sensor_ctl_din_32;
public:
	sensor_ctl_32(){}
	~sensor_ctl_32(){}
	unsigned int get_sensor_ctl_32();
	void set_sensor_ctl_32(unsigned int argv);
};
unsigned int sensor_ctl_32::get_sensor_ctl_32(){
	int rc = 0;
	while(1){
		rc = read(fr, &sensor_ctl_dout_32, sizeof(sensor_ctl_dout_32));
		if(rc < 0){
			cout << "fail read from fifo" << endl;
			continue;
			}
		else if(rc == sizeof(sensor_ctl_dout_32)) break;
		}
	return sensor_ctl_dout_32;
}

void sensor_ctl_32::set_sensor_ctl_32(unsigned int argv){
	int rc = 0;
	sensor_ctl_din_32 = argv;
	while(1){
		rc = write(fw, &sensor_ctl_dout_32, sizeof(sensor_ctl_din_32));
		if(rc < 0){
			cout << "fail write to fifo" << endl;
			continue;
		}
		else if (rc == sizeof(sensor_ctl_din_32)) break;
	}
	return;
}


int main(int argc, char const *argv[]){

	sensor_ctl_32 cp_32;
	cp_32.set_devfile_read("/dev/xillybus_read_32");
	cp_32.open_devfile_read();
	cp_32.set_devfile_write("/dev/xillybus_write__32");
	cp_32.open_devfile_write();


	///Please deicribe your code///

	cp_32.close_devfile_read();
	cp_32.close_devfile_write();

	return 0;
}

Bonus FPGA x ROS

Ich selbst recherchiere zum Thema FPGA und Roboter. Tatsächlich verfügt dieser cReComp auch über eine Paketerzeugungsfunktion für ** ROS **, die in letzter Zeit als Roboter-Softwareplattform ein heißes Thema geworden ist. Wenn Sie "generate_ros_package" in scrp schreiben, wird das ROS-Paket automatisch generiert. Bitte versuche.

Weitere Informationen zu FPGA x ROS finden Sie im entsprechenden Artikel.

Das Produkt wird übrigens in ros_package in software / generiert.

sensor_ctl/
|--hardware/
|	|--sensor_ctl.v
|	|--sonic_sensor.v
|--software/
|	|--ros_package/
|		|--sensor_ctl/
|			|--include/
|			|--msg/
|			|--src/
|			|--CMakeLists.txt
|			|--package.xml
|--sensor_ctl.cpp
|--lib_cpp.h
|--Makefile

abschließend

Dieses Mal habe ich das von mir entwickelte Tool cReComp vorgestellt und das Entwicklungsverfahren bei Verwendung von Scrp erläutert. Wie ich schon oft sage, befindet es sich ** in der Entwicklung **. Bitte haben Sie Verständnis dafür, dass die Implementierung immer noch unbefriedigend ist. Ich würde mich sehr freuen, wenn Sie uns Ihre Eindrücke von der Verwendung geben oder einen Fehler melden könnten. Bei Fragen zum Tool können Sie sich gerne an uns wenden.

Kontaktinformationen und meine Website

Email : kazushi_at_virgo.is.utsunomiya-u.ac.jp Twitter : KazushihuzaK Github : kazuyamshi HP : Kazushi Yamashina

Jedes Github-Repository

cReComp pyverilog veriloggen

[PYTHON] Verbinden Sie Xillybus und Benutzerlogik ganz einfach mit cReComp