NIOS 2 Zugriff VHDL ohne Avalon ?

[Geldesch B. (Firma: haa) (dravr)]

Hello :D
Kann man (eigene ) Komponenten auch ohne Avalon Bus mit dem Nios 
verbinden ?
Oder wenigstens indirekt indem man Daten an einen PIO schickt.

Danke.
Jetzt mache ich weiter mit Trial and Error und Recherche :D

[Geldesch B. (Firma: haa) (dravr)]

Habe noch mal ein Bild im Anhang.
 Ich werde einfach mal versuchen die Signale zu verknüpfen.
Kenne mich noch nicht so gut mit HDL aus.
Will das gerade erst mal in System Verilog machen ..

[Geldesch B. (Firma: haa) (dravr)]

hier mein erster Test
ich will " test" verwenden um es in meinem hdl adder zu manipulieren und 
das ergebnis im nios zu sehen^^

module p1(
  (* chip_pin = "V11" *) input logic clk,
  (* chip_pin = "AH17"  *) input logic reset_n,
  (* chip_pin = "W15" *) output logic led,
  (* chip_pin = "AA24" *) output logic led2,
  (* chip_pin = "Y24" *) input logic key,
  (* chip_pin = "W24" *) input logic key2
  
  );
  
  logic [7:0] test;
  
      unsaved u0 (   // NIOS
        .clk_clk       (clk),       //   clk.clk
        .reset_reset_n (reset_n),  // reset.reset_n
       .pio_in_export (test)
    );
  
  logic x;
  logic y;
  logic out;
  logic out2;
   


   test1 adder( // eigene komponente 
   .clk_s(clk),
   .x(key),
   .y(key2),
   .sum(led)
   );
  // eigner COde
  always_ff @(posedge clk) begin
  
  led2<=key; // non blocking 
  test <= 2+key;
  end
  
endmodule

[Tja (Gast)]

Das wird so nix. Erarbeite doch besser mal die grundlagen.

[Duke Scarring (Gast)]

Geldesch B. schrieb:
> Kann man (eigene ) Komponenten auch ohne Avalon Bus mit dem Nios
> verbinden ?
An welche Schnittstelle hast Du da gedacht?
Und mit welchen Nios-Befehlen willst Du mit Deiner Komponente 
kommunizieren?

> Oder wenigstens indirekt indem man Daten an einen PIO schickt.
Ja, sowas geht. Ähnlich wie man es beim Mikrocontroller machen würde.
Nutze ich gerne für einzelne Status- bzw. Steuersignale, wo ein 
komplettes Businterface eine Übertreibung wäre.

Duke

[Martin S. (strubi)]

Vorschlag/Stichwort: memory mapped register.
Schritte:
- Register/Adressen definieren
- Adress-Decoder implementieren oder generieren
- Per C Register im entsprechend codierten Memory-Bereich (MMR_Offset) 
ansteuern.

Z.B.

  
#define MMR32_PTR volatile uint32_t *
#define MMR32(x) *((MMR32_PTR) ((x) + MMR_Offset))
...

uint32_t r;
// Register lesen:
r = MMR32(R_CONTROL); // Register-Adresse
// Register setzen:
MMR32(R_CONTROL) = r | ENABLE;

[Geldesch B. (Firma: haa) (dravr)]

>An welche Schnittstelle hast Du da gedacht?
Auf dem FPGA soll ein SPI Slave laufen- er empfängt Daten und legt diese 
ab. Ich möchte genau darauf zugreifen.
Außerdem soll ein HDMI Stream genutzt werden können. ( Einfach nur weiße 
Pixel auf den sonst schwarzen Stream legen)
>Und mit welchen Nios-Befehlen willst Du mit Deiner Komponente
>kommunizieren?
Habe mal unten ein Beispiel wie ich es jetzt versucht habe.. aber gerne 
verwende ich auch andere Befehle.

@Martin S.
Deine Antwort schaue ich mir noch genauer an. Habe gerade erst mal meine 
Idee getestet. War mir wichtig.
Vielen Dank für deinen Tipp - Vielleicht es ja sogar sowas ähnliches ! 
:D


 *Mein testmodul, was einem Signal die Kombination 101 zuweist (also 5)*

 module test1 (
input logic clk_s,
input logic x,
input logic y,
output logic sum,
output  bit [2:0] t1 
);

always @(clk_s)
begin
sum <= x + y;
t1<=3'b101; //6'b10_0011 => 100011
end

endmodule

* Mein Toplvl Modul was mein testmodul instanziiert und das Signal an 
den NIOS weitergibt... *

 
module p1(
  (* chip_pin = "V11" *) input logic clk,
  (* chip_pin = "AH17"  *) input logic reset_n,
  (* chip_pin = "W15" *) output logic led,
  (* chip_pin = "AA24" *) output logic led2,
  (* chip_pin = "Y24" *) input logic key, // y24 erster
  (* chip_pin = "W24" *) input logic key2 // w24 =zweiter
  
  );
  
  //  Signals 
  logic test;
  logic raus;
  logic x;
  logic y;
  logic adder_out;
  logic out2;
  bit  [2:0] adder_out2 ;
  
  
      unsaved u0 (   // NIOS
        .clk_clk       (clk),       //   clk.clk
        .reset_reset_n (reset_n),  // reset.reset_n
      .pio_in_export(adder_out2)  
    );
  
   


   test1 adder( // eigene komponente 
   .clk_s(clk),
   .x(test),
   .y(key2),
   .sum(adder_out),
   .t1(adder_out2)
   );
  // eigner COde
  always_ff @(posedge clk) begin
  
  //led2<=key; // non blocking 
  test <= key;
  end
  
endmodule

Mein NIOS Programm was das Signal erhält--- 

 
#include "sys/alt_stdio.h"
#include "io.h"
#include "alt_types.h"
#include "system.h"
int main() {
  volatile unsigned int * key_ptr = (volatile unsigned int *) 0x80009000;
  alt_putstr("Hello from Nios II!\n");
  int swValue = IORD(0x80009000, 0);
  printf("key: %d", swValue);
  /* Event loop never exits. */
  while (1) {

  }

  return 0;
}

Wenn man den NIOS ausführt ( an dieser stelle stürzt eclipse beim copy 
und pasten einfach ab- aber so in etwas steht das da:) - das ist 101 , 
also das was ich oben im testmodul zugewiesen habe..

Hello from Nios II! key: 5

[Geldesch B. (Firma: haa) (dravr)]

Hi , ich wollte euch mitteilen, dass es so höchstwahrscheinlich klappt.
Auch wenn man es normalerweise so nicht machen würde.
Ein Beispiel hat bei mir funktioniert:

Ich wählte mir in meinem Toplvl vhdl Modul einen Input Slide. 
Anschließend habe ich diesem Eingangssignal einen Eingang eines 
Test-HDL-Moduls zugewiesen, welche in einer Bitkombination ein 
bestimmtes Bit setzen soll, wenn der Slide-Switch gesetzt ist. Dieses 
Modul leitete ich weiter an einen 8 Bit PIO meines Avalon Busses, an dem 
auch der NIOS angeschlossen ist. Ich hatte nun Zugriff auf diese 8 Bit 
und konnte diese zum Beispiel mit alt_putstr ausgeben.
Außerder war an den Avalon Bus noch ein 8 Bit Ausgang angeschlossen. An 
diesen habe ich meine Daten vom PIO-In weitergeleitet. Der PIO Out 
wiederum war an ein weiteres Test-HDL-Modul angeschlossen, welche die 
Bitkombination toggelte und an die 8 LEDs ausgeben sollte.
Es hat geklappt :DDDD
Man konnte beobachten, dass je nach Slide-Switch-Stellung das eine Bit 
aktiv oder eben deaktiviert war, wobei alles noch invertiert war !

Grüße !