FPGA LCD MicroBlaze

User schrieb:
> https://source.ece.iastate.edu/scm/viewvc.php/*che...
>
> Problem: Z.B XGpio_WriteReg(LCD_BASEADDR, ... gibt es nicht.

Ich glaube das heißt nun XGpio_mWriteReg oder so ähnlich.

> Nun habe
> ich nach Include-Dateien gesucht. Jedoch keinen Erfolg.

Also wenn du das Xilinx SDK nutzt, dann finden sich die einfach in dem 
von dir eingerichteten BSP.

> Ich habe mir
> gedacht, dass die Funktion "XGpio_WriteReg()" ja scheinbar lediglich
> Register beschreibt. Also habe ich statt XGpio_WriteReg() die Funktion
> XIOModule_DiscreteWrite() aus der Bibilothek "xiomodule.h" hergenommen.

Naja, bleib doch einfach lieber bei XGpio, und schau mal nach wie man 
das richtig nutzt.

> Das Argument "LCD_BASEADDR" habe ich durch "&gpo" ersetzt (Pointer gibt
> Register des Ports an). Als zweites Argument habe ich den Kanal GPIO 2
> genommen (dort hängt das LCD dran). Z.B. in dieser Zeile aus dem
> geposteten Quellcode:
>
> void LCDInit()
> {
>     // Sets CHAR LCD Reg to Write Mode
>     XGpio_WriteReg(LCD_BASEADDR, 0x4, 0x00000000);
>
> steht ja scheinbar nicht an zweiter Stelle der Kanal (sondern 0x4). Hatb
> hier jemand für mich vielleicht eine Lösung/Ansatz/ Quelle ?
>

Der erste Parameter ist hier die Basisasdresse, der zweite das Offset 
und der dritte der Wert, der geschrieben werden soll. Diese Funktion 
schreibt also Nullen in die Adresse LCD_BASEADDR+4. Was das bedeutet, 
kannst du unter

http://www.xilinx.com/support/documentation/ip_documentation/axi_gpio/v1_01_b/ds744_axi_gpio.pdf#page=8

nachlesen.

Danke. Die C_BASEADDR wo finde ich die?

Ein Hinweis noch. Ich habe im Virtex 6 lediglich den Microblaze IPCore 
eingebunden. (nicht den hier aufgezeigten LogiCORE IP AXI GPIO). Ich 
möchte (zum Test der genannten Funktion) LEDs anschalten. Diese sind mit 
dem Port "GPO1" vom Microblaze verbunden.

User schrieb:
> Danke. Die C_BASEADDR wo finde ich die?

Die Adressen der Hardware finden sich in der Hardwarekonfiguration des 
BSP (siehe xparameters.h).

User schrieb:
> Ein Hinweis noch. Ich habe im Virtex 6 lediglich den Microblaze
> IPCore
> eingebunden. (nicht den hier aufgezeigten LogiCORE IP AXI GPIO). Ich
> möchte (zum Test der genannten Funktion) LEDs anschalten. Diese sind mit
> dem Port "GPO1" vom Microblaze verbunden.

Der normale MicroBlaze hat gar keine I/O-Ports. Hast du das Microblaze 
MCS verwendet? Das kenn ich überhaupt nicht, kann dazu also nichts 
sagen. Aber Xilinx hat eigentlich (fast) alles ganz gut dokumentiert.

Habe den Cor MicroBlaze mcs verwendet. Hierbei habe ich den GPO mit 7 
Bit herausgeführt. Soweit ich es sehe brauche ich um auf das Display zu 
schreiben lediglich Ausgänge.

Ich habe einmal in die xparameters.h geschaut (hatte ich auch 
eingebunden). Da steht u.a.

// mit diesem Ausgang sind die sieben Display-Pins verbunden
#define XPAR_IOMODULE_0_USE_GPO2 1
#define XPAR_IOMODULE_0_GPO2_SIZE 7
...

#define XPAR_IOMODULE_INTC_MAX_INTR_SIZE 0
#define XPAR_IOMODULE_SINGLE_BASEADDR 0x80000000
#define XPAR_IOMODULE_SINGLE_HIGHADDR 0x8000007F
#define XPAR_IOMODULE_INTC_SINGLE_DEVICE_ID XPAR_IOMODULE_0_DEVICE_ID

Daraus leite ich ab, dass die Addresse die ich suche die 0x80000000 ist, 
korrekt?

Also schreibe ich:

XGpio_mWriteReg(0x80000000, 0x4, 0x00000000);

Damit spreche ich Register 0x80000000 + 0x4 = 0x80000004 und schreibe 
den Wert 0x00000000 in dieses. Korrekt?

Hör bitte auf damit zu raten und lies die Dokumentation!

Vielen Dank. Bin weitergekommen. Hab die Dokumentation zu den Registern 
gefunden. Die Initialisierung klappt (fast). Ich sehe statt des Strings 
einen blinkenden Curser sowie undefinierte Zeichen (Ich denke, dass das 
nun ein Problem mit der von mir verwendeten Delay-Funktion ist..auf 
"nop" Basis). Die ist noch ziemlich ungenau. In dem Beispiel (Post von 
Holger Harten) verwendet der Autor die "delay_us(Xuint32 time)".

Ich habe mein "Test-Projekt" zur Timer-Funktion wie folgt aufgebaut:

#include <stdio.h>
#include "gpio_l.h"
#include "xiomodule.h"
#include "xparameters.h"
#include "xtmrctr.h"
#include "xstatus.h"


void delay_us(Xuint32 time);

XTmrCtr DelayTimer;

int main()
{
  while(1){
    XGpio_mWriteReg( 0x80000010, 0x00000000, 0x00000001); // LED 1 "on"
    delay_us(500000);                                     //Warte 0.5 s
    XGpio_mWriteReg( 0x80000010, 0x00000000, 0x0000000);  // LED 1 "off"
    delay_us(500000);}                                    //Warte 0.5 s

    return 0;
}


void delay_us(Xuint32 time)
{
  XTmrCtr_SetResetValue(&DelayTimer, 1, time * 125);
  XTmrCtr_Start(&DelayTimer, 1);
  while(!(XTmrCtr_IsExpired(&DelayTimer, 1))){}
  XTmrCtr_Stop(&DelayTimer, 1);
}

Ich habe neben der "xtmrctr.h" folgende Dateien ins Projekt eingebunden:

- "xtmrctr.c"
- "xtmrctr_l.h"
- "xtmrctr_l.c"
- "xtmrctr_i.h"

In "xtmrctr.c" ist XPAR_XTMRCTR_NUM_INSTANCES noch undefiniert.

Mir ist noch nicht ganz klar, welchen Timer diese Funktion nutzt? Habe 
im MicroBlaze ja mehrere FIT und PIT zur Verfügung (Habe nicht gesehen 
wo die Registeraddresse angegeben wird). Zudem weiß ich nicht, wie der 
XPAR_XTMRCTR_NUM_INSTANCES zu belegen ist, bzw. was dieser aussagt.

Sorry habe gerad entdeckt, dass es sich bei dem Parameter 
XPAR_XTMRCTR_NUM_INSTANCES  bei dem Auto um einen im File xparameters.h 
definierten Namen handelt. Dieser ist bei mir nicht vorhanden. Heißt 
wohl jetzt anders.

Eine einfachere Variante:


void delay_us_(long int time) // clk = 200 MHz
{
XGpio_mWriteReg(0x80000040,0,time*200);//PIT1 Preload Register
XGpio_mWriteReg(0x80000048,0,0x00000003);//PIT1 Control Register: 
Counter Starten ( EN = 1, PRELOAD = 1)
while(!(XGpio_mReadReg(0x80000044,0x00000000))){
  //PIT1 Counter Register: Ausgabe des Zählerstandes
}
XGpio_mWriteReg(0x80000010,0,0x00000024);//Counter angehalten

}
Würde so auch gehen,oder seht ihr Nachteile?

Danke. Wie meinst du das, dass du den Systemtakt nicht einbeziehst 
Holger? Ich habe momentan auch eine Funktion "ohne" den Systemtakt 
direkt zu berücksichtigen.

void usleep(unsigned int useconds)
{ int i,j;
  for (j=0;j<useconds;j++)
    for (i=0;i<6;i++) asm("nop");}

Ist aber sehr unsauber. Habe mir versucht die Funktion mittels Oszi 
abzugleichen. Funktioniert aber nicht besonders. Wenn deine Funktion den 
Takt auch nicht einbezieht, wie unterscheiden sich dann beide 
Funktionen?

Benötige eine Funktion, welche sich am Takt orientiert. Deswegen mein 
vorheriger Versuch. Ich kann ihn nochmal erläutern (über bessere 
Vorschläge freue ich mich).

Der Eingangstakt ist z.B. 200 MHz (steht ja in der #include 
"xparameters.h"). Die Registernamen habe ich aus folgender Beschreibung: 
http://www.xilinx.com/support/documentation/sw_manuals/xilinx14_1/ds865_microblaze_mcs.pdf. 
(Seite 30, Seite 31)


void delay_us_(long int time)
{
XGpio_mWriteReg(0x80000040,0,time*200);//Hier lade ich einen Wert in das 
Register. Z.B. 200 (time = 1us bei 200 MHz (1 Takt 5 ns).

XGpio_mWriteReg(0x80000048,0,0x00000003);//PIT1 Control Register:
Counter Starten ( EN = 1, PRELOAD = 1). Hier Starte ich den Counter. Im 
nächsten Schritt frage ich den Zählerstand ab. Sind 200 Takte um, dann 
halte ich den Zähler an und springe aus der delay_us_-Funktion. Das war 
mein Gedanke. Funktioniert aber nicht. Leider.
while(!(XGpio_mReadReg(0x80000044,0x00000000))){
  //PIT1 Counter Register: Ausgabe des Zählerstandes
}
XGpio_mWriteReg(0x80000010,0,0x00000024);//Counter angehalten

}

Ich teste gerade mal für das Beispiel oben nur die

XGpio_mReadReg()-Funktion. In der Dokumentation 
(http://www.cs.indiana.edu/hmg/le/project-home/xilinx/ise_13.2/ISE_DS/EDK/sw/XilinxProcessorIPLib/drivers/gpio_v2_13_a/doc/html/api/xgpio__l_8h.html#a17) 
steht:

"Read a value from a GPIO register. A 32 bit read is performed. If the 
GPIO component is implemented in a smaller width, only the least 
significant data is read from the register. The most significant data 
will be read as 0."

Als Rückgabewert wird der Registerinhalt angegeben:

"Returns:    Data read from the register."

Folgendes habe ich umgesetzt:

#include "gpio_l.h"

...

data = XGpio_mReadReg(GPI1, 0x00);
xil_printf("Data(%x):    %x\n\r", GPI1, data);

Am GPI1-Port hängen Dip-Schalter. Ich bekomme jedoch keinen 
Rückgabewert. Im xgpio_l.h-File 
(http://users.ece.gatech.edu/~hamblen/4006/xup/embedded/labs/lab4mb/microblaze_0/include/xgpio_l.h) 
steht als Kommentar:


* Set the input/output direction of the signals of the specified GPIO 
channel.
*
* @param    BaseAddress contains the base address of the GPIO device.
* @param    Channel contains the channel (1 or 2) to operate on.
* @param    DirectionMask is a bitmask specifying which discretes are 
input and
*           which are output. Bits set to 0 are output and bits set to 1 
are
*           input.
*
* @return   None.
*
* @note     None.

Nutze ich die Funktion falsch,oder habe ich das falsche Header-File 
erwischt? (Registeraddresse stimmt! Gebe ich die Schalterstellungen 
direkt auf LEDs funktioniert es)

Ziehe die Frage zurück. Der Offset muss bei GPI1 auf den Wert 1 gestellt 
werden.

Soweit bin ich beim Timer gekommen:

#include <stdio.h>
#include "platform.h"
#include "gpio_l.h"
#include "xiomodule.h"
#include "xparameters.h"
#include <stdlib.h>

// GPO4: 0x8000001C

int main()
{
    init_platform();

    unsigned long data = 0x0;
    unsigned long null = 0x3E8; //Grenze, sollte eigentlich 0 sein

    //200000000 => 1 s bei 200 MHz
    XGpio_mWriteReg(0x80000040, 0x01, 0x0BEBC200);
    XGpio_mWriteReg(0x80000048, 0x01, 0x03);
    data = XGpio_mReadReg(0x80000044, 1);

    while(data >= null){
      data = XGpio_mReadReg(0x80000044, 1);}
    XGpio_mWriteReg(0x80000048, 0x01, 0x00); //Timer EN = 0
    cleanup_platform();
    return 0;
}

Ich sehe am Oszi einen Takt. Jedoch etwa 6,6 MHz. Ist mein Ansatz 
brauchbar, oder ist es sinnvoller den Ansatz zu verwerfen? Danke

Danke dir Holger. Ich habe hier einmal die xparameters.h kopiert. Die 
meinst du doch wahrscheinlich. (Ein wenig lang, tut mir leid). 
Vielleicht kannst du mir zeigen, wo ich da die richtigen defines 
herauslese. Danke nochmals.

#define STDIN_BASEADDRESS 0x80000000
#define STDOUT_BASEADDRESS 0x80000000

/* Definitions for driver BRAM */
#define XPAR_XBRAM_NUM_INSTANCES 2

/* Definitions for peripheral DLMB_CNTLR */
#define XPAR_DLMB_CNTLR_DEVICE_ID 0
#define XPAR_DLMB_CNTLR_DATA_WIDTH 32
#define XPAR_DLMB_CNTLR_ECC 0
#define XPAR_DLMB_CNTLR_FAULT_INJECT 0
#define XPAR_DLMB_CNTLR_CE_FAILING_REGISTERS 0
#define XPAR_DLMB_CNTLR_UE_FAILING_REGISTERS 0
#define XPAR_DLMB_CNTLR_ECC_STATUS_REGISTERS 0
#define XPAR_DLMB_CNTLR_CE_COUNTER_WIDTH 0
#define XPAR_DLMB_CNTLR_ECC_ONOFF_REGISTER 0
#define XPAR_DLMB_CNTLR_ECC_ONOFF_RESET_VALUE 1
#define XPAR_DLMB_CNTLR_WRITE_ACCESS 2
#define XPAR_DLMB_CNTLR_BASEADDR 0x00000000
#define XPAR_DLMB_CNTLR_HIGHADDR 0x00003FFF
#define XPAR_DLMB_CNTLR_S_AXI_CTRL_BASEADDR 0xFFFFFFFF
#define XPAR_DLMB_CNTLR_S_AXI_CTRL_HIGHADDR 0xFFFFFFFF


/* Definitions for peripheral ILMB_CNTLR */
#define XPAR_ILMB_CNTLR_DEVICE_ID 1
#define XPAR_ILMB_CNTLR_DATA_WIDTH 32
#define XPAR_ILMB_CNTLR_ECC 0
#define XPAR_ILMB_CNTLR_FAULT_INJECT 0
#define XPAR_ILMB_CNTLR_CE_FAILING_REGISTERS 0
#define XPAR_ILMB_CNTLR_UE_FAILING_REGISTERS 0
#define XPAR_ILMB_CNTLR_ECC_STATUS_REGISTERS 0
#define XPAR_ILMB_CNTLR_CE_COUNTER_WIDTH 0
#define XPAR_ILMB_CNTLR_ECC_ONOFF_REGISTER 0
#define XPAR_ILMB_CNTLR_ECC_ONOFF_RESET_VALUE 1
#define XPAR_ILMB_CNTLR_WRITE_ACCESS 2
#define XPAR_ILMB_CNTLR_BASEADDR 0x00000000
#define XPAR_ILMB_CNTLR_HIGHADDR 0x00003FFF
#define XPAR_ILMB_CNTLR_S_AXI_CTRL_BASEADDR 0xFFFFFFFF
#define XPAR_ILMB_CNTLR_S_AXI_CTRL_HIGHADDR 0xFFFFFFFF

/* Canonical definitions for peripheral DLMB_CNTLR */
#define XPAR_BRAM_0_DEVICE_ID XPAR_DLMB_CNTLR_DEVICE_ID
#define XPAR_BRAM_0_DATA_WIDTH 32
#define XPAR_BRAM_0_ECC 0
#define XPAR_BRAM_0_FAULT_INJECT 0
#define XPAR_BRAM_0_CE_FAILING_REGISTERS 0
#define XPAR_BRAM_0_UE_FAILING_REGISTERS 0
#define XPAR_BRAM_0_ECC_STATUS_REGISTERS 0
#define XPAR_BRAM_0_CE_COUNTER_WIDTH 0
#define XPAR_BRAM_0_ECC_ONOFF_REGISTER 0
#define XPAR_BRAM_0_ECC_ONOFF_RESET_VALUE 1
#define XPAR_BRAM_0_WRITE_ACCESS 2
#define XPAR_BRAM_0_BASEADDR 0x00000000
#define XPAR_BRAM_0_HIGHADDR 0x00003FFF

/* Canonical definitions for peripheral ILMB_CNTLR */
#define XPAR_BRAM_1_DEVICE_ID XPAR_ILMB_CNTLR_DEVICE_ID
#define XPAR_BRAM_1_DATA_WIDTH 32
#define XPAR_BRAM_1_ECC 0
#define XPAR_BRAM_1_FAULT_INJECT 0
#define XPAR_BRAM_1_CE_FAILING_REGISTERS 0
#define XPAR_BRAM_1_UE_FAILING_REGISTERS 0
#define XPAR_BRAM_1_ECC_STATUS_REGISTERS 0
#define XPAR_BRAM_1_CE_COUNTER_WIDTH 0
#define XPAR_BRAM_1_ECC_ONOFF_REGISTER 0
#define XPAR_BRAM_1_ECC_ONOFF_RESET_VALUE 1
#define XPAR_BRAM_1_WRITE_ACCESS 2
#define XPAR_BRAM_1_BASEADDR 0x00000000
#define XPAR_BRAM_1_HIGHADDR 0x00003FFF

/* Definitions for driver IOMODULE */
#define XPAR_XIOMODULE_NUM_INSTANCES 1

/* Definitions for peripheral IOMODULE_0 */
#define XPAR_IOMODULE_0_DEVICE_ID 0
#define XPAR_IOMODULE_0_BASEADDR 0x80000000
#define XPAR_IOMODULE_0_HIGHADDR 0x8000007F
#define XPAR_IOMODULE_0_MASK 0xC0000000
#define XPAR_IOMODULE_0_FREQ 20000000
#define XPAR_IOMODULE_0_USE_UART_RX 1
#define XPAR_IOMODULE_0_USE_UART_TX 1
#define XPAR_IOMODULE_0_UART_BAUDRATE 921600
#define XPAR_IOMODULE_0_UART_PROG_BAUDRATE 0
#define XPAR_IOMODULE_0_UART_DATA_BITS 8
#define XPAR_IOMODULE_0_UART_USE_PARITY 0
#define XPAR_IOMODULE_0_UART_ODD_PARITY 0
#define XPAR_IOMODULE_0_UART_RX_INTERRUPT 0
#define XPAR_IOMODULE_0_UART_TX_INTERRUPT 0
#define XPAR_IOMODULE_0_UART_ERROR_INTERRUPT 0
#define XPAR_IOMODULE_0_USE_FIT1 1
#define XPAR_IOMODULE_0_FIT1_NO_CLOCKS 200
#define XPAR_IOMODULE_0_FIT1_INTERRUPT 1
#define XPAR_IOMODULE_0_USE_FIT2 0
#define XPAR_IOMODULE_0_FIT2_NO_CLOCKS 6216
#define XPAR_IOMODULE_0_FIT2_INTERRUPT 0
#define XPAR_IOMODULE_0_USE_FIT3 0
#define XPAR_IOMODULE_0_FIT3_NO_CLOCKS 6216
#define XPAR_IOMODULE_0_FIT3_INTERRUPT 0
#define XPAR_IOMODULE_0_USE_FIT4 0
#define XPAR_IOMODULE_0_FIT4_NO_CLOCKS 6216
#define XPAR_IOMODULE_0_FIT4_INTERRUPT 0
#define XPAR_IOMODULE_0_USE_PIT1 1
#define XPAR_IOMODULE_0_PIT1_SIZE 32
#define XPAR_IOMODULE_0_PIT1_READABLE 1
#define XPAR_IOMODULE_0_PIT1_PRESCALER 0
#define XPAR_IOMODULE_0_PIT1_INTERRUPT 1
#define XPAR_IOMODULE_0_USE_PIT2 0
#define XPAR_IOMODULE_0_PIT2_SIZE 32
#define XPAR_IOMODULE_0_PIT2_READABLE 1
#define XPAR_IOMODULE_0_PIT2_PRESCALER 0
#define XPAR_IOMODULE_0_PIT2_INTERRUPT 0
#define XPAR_IOMODULE_0_USE_PIT3 0
#define XPAR_IOMODULE_0_PIT3_SIZE 32
#define XPAR_IOMODULE_0_PIT3_READABLE 1
#define XPAR_IOMODULE_0_PIT3_PRESCALER 0
#define XPAR_IOMODULE_0_PIT3_INTERRUPT 0
#define XPAR_IOMODULE_0_USE_PIT4 0
#define XPAR_IOMODULE_0_PIT4_SIZE 32
#define XPAR_IOMODULE_0_PIT4_READABLE 1
#define XPAR_IOMODULE_0_PIT4_PRESCALER 0
#define XPAR_IOMODULE_0_PIT4_INTERRUPT 0
#define XPAR_IOMODULE_0_USE_GPO1 1
#define XPAR_IOMODULE_0_GPO1_SIZE 8
#define XPAR_IOMODULE_0_USE_GPO2 1
#define XPAR_IOMODULE_0_GPO2_SIZE 7
#define XPAR_IOMODULE_0_USE_GPO3 0
#define XPAR_IOMODULE_0_GPO3_SIZE 32
#define XPAR_IOMODULE_0_USE_GPO4 0
#define XPAR_IOMODULE_0_GPO4_SIZE 32
#define XPAR_IOMODULE_0_USE_GPI1 1
#define XPAR_IOMODULE_0_GPI1_SIZE 8
#define XPAR_IOMODULE_0_GPI1_INTERRUPT 0
#define XPAR_IOMODULE_0_USE_GPI2 0
#define XPAR_IOMODULE_0_GPI2_SIZE 32
#define XPAR_IOMODULE_0_GPI2_INTERRUPT 0
#define XPAR_IOMODULE_0_USE_GPI3 0
#define XPAR_IOMODULE_0_GPI3_SIZE 32
#define XPAR_IOMODULE_0_GPI3_INTERRUPT 0
#define XPAR_IOMODULE_0_USE_GPI4 0
#define XPAR_IOMODULE_0_GPI4_SIZE 32
#define XPAR_IOMODULE_0_GPI4_INTERRUPT 0
#define XPAR_IOMODULE_0_INTC_USE_EXT_INTR 0
#define XPAR_IOMODULE_0_INTC_INTR_SIZE 1
#define XPAR_IOMODULE_0_INTC_HAS_FAST 1
#define XPAR_IOMODULE_0_INTC_BASE_VECTORS 0
#define XPAR_IOMODULE_0_USE_IO_BUS 0
#define XPAR_IOMODULE_0_IO_BASEADDR 0xC0000000
#define XPAR_IOMODULE_0_IO_HIGHADDR 0xFFFFFFFF
#define XPAR_IOMODULE_0_IO_MASK 0xC0000000

/* Additional definitions for peripheral IOMODULE_0 */
#define XPAR_IOMODULE_0_GPO1_INIT 0x00000000
#define XPAR_IOMODULE_0_GPO2_INIT 0x00000000
#define XPAR_IOMODULE_0_GPO3_INIT 0x00000000
#define XPAR_IOMODULE_0_GPO4_INIT 0x00000000
#define XPAR_IOMODULE_0_INTC_LEVEL_EDGE 0x0000
#define XPAR_IOMODULE_0_INTC_POSITIVE 0xFFFF

#define XPAR_IOMODULE_INTC_MAX_INTR_SIZE 0
#define XPAR_IOMODULE_SINGLE_BASEADDR 0x80000000
#define XPAR_IOMODULE_SINGLE_HIGHADDR 0x8000007F
#define XPAR_IOMODULE_INTC_SINGLE_DEVICE_ID XPAR_IOMODULE_0_DEVICE_ID

/******************************************************************/



/******************************************************************/

/* Definitions for bus frequencies */
/******************************************************************/

/* Canonical definitions for bus frequencies */
/******************************************************************/

#define XPAR_CPU_CORE_CLOCK_FREQ_HZ 20000000
#define XPAR_MICROBLAZE_CORE_CLOCK_FREQ_HZ 20000000

/******************************************************************/


/* Definitions for peripheral MICROBLAZE_MCS */
#define XPAR_MICROBLAZE_MCS_SCO 0
#define XPAR_MICROBLAZE_MCS_FREQ 20000000
#define XPAR_MICROBLAZE_MCS_DATA_SIZE 32
#define XPAR_MICROBLAZE_MCS_DYNAMIC_BUS_SIZING 1
#define XPAR_MICROBLAZE_MCS_AVOID_PRIMITIVES 0
#define XPAR_MICROBLAZE_MCS_FAULT_TOLERANT 0
#define XPAR_MICROBLAZE_MCS_ECC_USE_CE_EXCEPTION 0
#define XPAR_MICROBLAZE_MCS_LOCKSTEP_SLAVE 0
#define XPAR_MICROBLAZE_MCS_ENDIANNESS 1
#define XPAR_MICROBLAZE_MCS_AREA_OPTIMIZED 1
#define XPAR_MICROBLAZE_MCS_OPTIMIZATION 0
#define XPAR_MICROBLAZE_MCS_INTERCONNECT 2
#define XPAR_MICROBLAZE_MCS_STREAM_INTERCONNECT 0
#define XPAR_MICROBLAZE_MCS_DPLB_DWIDTH 32
#define XPAR_MICROBLAZE_MCS_DPLB_NATIVE_DWIDTH 32
#define XPAR_MICROBLAZE_MCS_DPLB_BURST_EN 0
#define XPAR_MICROBLAZE_MCS_DPLB_P2P 0
#define XPAR_MICROBLAZE_MCS_IPLB_DWIDTH 32
#define XPAR_MICROBLAZE_MCS_IPLB_NATIVE_DWIDTH 32
#define XPAR_MICROBLAZE_MCS_IPLB_BURST_EN 0
#define XPAR_MICROBLAZE_MCS_IPLB_P2P 0
#define XPAR_MICROBLAZE_MCS_M_AXI_DP_SUPPORTS_THREADS 0
#define XPAR_MICROBLAZE_MCS_M_AXI_DP_THREAD_ID_WIDTH 1
#define XPAR_MICROBLAZE_MCS_M_AXI_DP_SUPPORTS_READ 1
#define XPAR_MICROBLAZE_MCS_M_AXI_DP_SUPPORTS_WRITE 1
#define XPAR_MICROBLAZE_MCS_M_AXI_DP_SUPPORTS_NARROW_BURST 0
#define XPAR_MICROBLAZE_MCS_M_AXI_DP_DATA_WIDTH 32
#define XPAR_MICROBLAZE_MCS_M_AXI_DP_ADDR_WIDTH 32
#define XPAR_MICROBLAZE_MCS_M_AXI_DP_PROTOCOL AXI4LITE
#define XPAR_MICROBLAZE_MCS_M_AXI_DP_EXCLUSIVE_ACCESS 0
#define XPAR_MICROBLAZE_MCS_INTERCONNECT_M_AXI_DP_READ_ISSUING 1
#define XPAR_MICROBLAZE_MCS_INTERCONNECT_M_AXI_DP_WRITE_ISSUING 1
#define XPAR_MICROBLAZE_MCS_M_AXI_IP_SUPPORTS_THREADS 0
#define XPAR_MICROBLAZE_MCS_M_AXI_IP_THREAD_ID_WIDTH 1
#define XPAR_MICROBLAZE_MCS_M_AXI_IP_SUPPORTS_READ 1
#define XPAR_MICROBLAZE_MCS_M_AXI_IP_SUPPORTS_WRITE 0
#define XPAR_MICROBLAZE_MCS_M_AXI_IP_SUPPORTS_NARROW_BURST 0
#define XPAR_MICROBLAZE_MCS_M_AXI_IP_DATA_WIDTH 32
#define XPAR_MICROBLAZE_MCS_M_AXI_IP_ADDR_WIDTH 32
#define XPAR_MICROBLAZE_MCS_M_AXI_IP_PROTOCOL AXI4LITE
#define XPAR_MICROBLAZE_MCS_INTERCONNECT_M_AXI_IP_READ_ISSUING 1
#define XPAR_MICROBLAZE_MCS_D_AXI 0
#define XPAR_MICROBLAZE_MCS_D_PLB 0
#define XPAR_MICROBLAZE_MCS_D_LMB 1
#define XPAR_MICROBLAZE_MCS_I_AXI 0
#define XPAR_MICROBLAZE_MCS_I_PLB 0
#define XPAR_MICROBLAZE_MCS_I_LMB 1
#define XPAR_MICROBLAZE_MCS_USE_MSR_INSTR 0
#define XPAR_MICROBLAZE_MCS_USE_PCMP_INSTR 0
#define XPAR_MICROBLAZE_MCS_USE_BARREL 0
#define XPAR_MICROBLAZE_MCS_USE_DIV 0
#define XPAR_MICROBLAZE_MCS_USE_HW_MUL 0
#define XPAR_MICROBLAZE_MCS_USE_FPU 0
#define XPAR_MICROBLAZE_MCS_USE_REORDER_INSTR 0
#define XPAR_MICROBLAZE_MCS_UNALIGNED_EXCEPTIONS 0
#define XPAR_MICROBLAZE_MCS_ILL_OPCODE_EXCEPTION 0
#define XPAR_MICROBLAZE_MCS_M_AXI_I_BUS_EXCEPTION 0
#define XPAR_MICROBLAZE_MCS_M_AXI_D_BUS_EXCEPTION 0
#define XPAR_MICROBLAZE_MCS_IPLB_BUS_EXCEPTION 0
#define XPAR_MICROBLAZE_MCS_DPLB_BUS_EXCEPTION 0
#define XPAR_MICROBLAZE_MCS_DIV_ZERO_EXCEPTION 0
#define XPAR_MICROBLAZE_MCS_FPU_EXCEPTION 0
#define XPAR_MICROBLAZE_MCS_FSL_EXCEPTION 0
#define XPAR_MICROBLAZE_MCS_USE_STACK_PROTECTION 0
#define XPAR_MICROBLAZE_MCS_PVR 0
#define XPAR_MICROBLAZE_MCS_PVR_USER1 0x00
#define XPAR_MICROBLAZE_MCS_PVR_USER2 0x00000000
#define XPAR_MICROBLAZE_MCS_DEBUG_ENABLED 0
#define XPAR_MICROBLAZE_MCS_NUMBER_OF_PC_BRK 1
#define XPAR_MICROBLAZE_MCS_NUMBER_OF_RD_ADDR_BRK 0
#define XPAR_MICROBLAZE_MCS_NUMBER_OF_WR_ADDR_BRK 0
#define XPAR_MICROBLAZE_MCS_INTERRUPT_IS_EDGE 0
#define XPAR_MICROBLAZE_MCS_EDGE_IS_POSITIVE 1
#define XPAR_MICROBLAZE_MCS_RESET_MSR 0x00000000
#define XPAR_MICROBLAZE_MCS_OPCODE_0X0_ILLEGAL 0
#define XPAR_MICROBLAZE_MCS_FSL_LINKS 0
#define XPAR_MICROBLAZE_MCS_FSL_DATA_SIZE 32
#define XPAR_MICROBLAZE_MCS_USE_EXTENDED_FSL_INSTR 0
#define XPAR_MICROBLAZE_MCS_M0_AXIS_PROTOCOL GENERIC
#define XPAR_MICROBLAZE_MCS_S0_AXIS_PROTOCOL GENERIC
#define XPAR_MICROBLAZE_MCS_M1_AXIS_PROTOCOL GENERIC
#define XPAR_MICROBLAZE_MCS_S1_AXIS_PROTOCOL GENERIC
#define XPAR_MICROBLAZE_MCS_M2_AXIS_PROTOCOL GENERIC
#define XPAR_MICROBLAZE_MCS_S2_AXIS_PROTOCOL GENERIC
#define XPAR_MICROBLAZE_MCS_M3_AXIS_PROTOCOL GENERIC
#define XPAR_MICROBLAZE_MCS_S3_AXIS_PROTOCOL GENERIC
#define XPAR_MICROBLAZE_MCS_M4_AXIS_PROTOCOL GENERIC
#define XPAR_MICROBLAZE_MCS_S4_AXIS_PROTOCOL GENERIC
#define XPAR_MICROBLAZE_MCS_M5_AXIS_PROTOCOL GENERIC
#define XPAR_MICROBLAZE_MCS_S5_AXIS_PROTOCOL GENERIC
#define XPAR_MICROBLAZE_MCS_M6_AXIS_PROTOCOL GENERIC
#define XPAR_MICROBLAZE_MCS_S6_AXIS_PROTOCOL GENERIC
#define XPAR_MICROBLAZE_MCS_M7_AXIS_PROTOCOL GENERIC
#define XPAR_MICROBLAZE_MCS_S7_AXIS_PROTOCOL GENERIC
#define XPAR_MICROBLAZE_MCS_M8_AXIS_PROTOCOL GENERIC
#define XPAR_MICROBLAZE_MCS_S8_AXIS_PROTOCOL GENERIC
#define XPAR_MICROBLAZE_MCS_M9_AXIS_PROTOCOL GENERIC
#define XPAR_MICROBLAZE_MCS_S9_AXIS_PROTOCOL GENERIC
#define XPAR_MICROBLAZE_MCS_M10_AXIS_PROTOCOL GENERIC
#define XPAR_MICROBLAZE_MCS_S10_AXIS_PROTOCOL GENERIC
#define XPAR_MICROBLAZE_MCS_M11_AXIS_PROTOCOL GENERIC
#define XPAR_MICROBLAZE_MCS_S11_AXIS_PROTOCOL GENERIC
#define XPAR_MICROBLAZE_MCS_M12_AXIS_PROTOCOL GENERIC
#define XPAR_MICROBLAZE_MCS_S12_AXIS_PROTOCOL GENERIC
#define XPAR_MICROBLAZE_MCS_M13_AXIS_PROTOCOL GENERIC
#define XPAR_MICROBLAZE_MCS_S13_AXIS_PROTOCOL GENERIC
#define XPAR_MICROBLAZE_MCS_M14_AXIS_PROTOCOL GENERIC
#define XPAR_MICROBLAZE_MCS_S14_AXIS_PROTOCOL GENERIC
#define XPAR_MICROBLAZE_MCS_M15_AXIS_PROTOCOL GENERIC
#define XPAR_MICROBLAZE_MCS_S15_AXIS_PROTOCOL GENERIC
#define XPAR_MICROBLAZE_MCS_M0_AXIS_DATA_WIDTH 32
#define XPAR_MICROBLAZE_MCS_S0_AXIS_DATA_WIDTH 32
#define XPAR_MICROBLAZE_MCS_M1_AXIS_DATA_WIDTH 32
#define XPAR_MICROBLAZE_MCS_S1_AXIS_DATA_WIDTH 32
#define XPAR_MICROBLAZE_MCS_M2_AXIS_DATA_WIDTH 32
#define XPAR_MICROBLAZE_MCS_S2_AXIS_DATA_WIDTH 32
#define XPAR_MICROBLAZE_MCS_M3_AXIS_DATA_WIDTH 32
#define XPAR_MICROBLAZE_MCS_S3_AXIS_DATA_WIDTH 32
#define XPAR_MICROBLAZE_MCS_M4_AXIS_DATA_WIDTH 32
#define XPAR_MICROBLAZE_MCS_S4_AXIS_DATA_WIDTH 32
#define XPAR_MICROBLAZE_MCS_M5_AXIS_DATA_WIDTH 32
#define XPAR_MICROBLAZE_MCS_S5_AXIS_DATA_WIDTH 32
#define XPAR_MICROBLAZE_MCS_M6_AXIS_DATA_WIDTH 32
#define XPAR_MICROBLAZE_MCS_S6_AXIS_DATA_WIDTH 32
#define XPAR_MICROBLAZE_MCS_M7_AXIS_DATA_WIDTH 32
#define XPAR_MICROBLAZE_MCS_S7_AXIS_DATA_WIDTH 32
#define XPAR_MICROBLAZE_MCS_M8_AXIS_DATA_WIDTH 32
#define XPAR_MICROBLAZE_MCS_S8_AXIS_DATA_WIDTH 32
#define XPAR_MICROBLAZE_MCS_M9_AXIS_DATA_WIDTH 32
#define XPAR_MICROBLAZE_MCS_S9_AXIS_DATA_WIDTH 32
#define XPAR_MICROBLAZE_MCS_M10_AXIS_DATA_WIDTH 32
#define XPAR_MICROBLAZE_MCS_S10_AXIS_DATA_WIDTH 32
#define XPAR_MICROBLAZE_MCS_M11_AXIS_DATA_WIDTH 32
#define XPAR_MICROBLAZE_MCS_S11_AXIS_DATA_WIDTH 32
#define XPAR_MICROBLAZE_MCS_M12_AXIS_DATA_WIDTH 32
#define XPAR_MICROBLAZE_MCS_S12_AXIS_DATA_WIDTH 32
#define XPAR_MICROBLAZE_MCS_M13_AXIS_DATA_WIDTH 32
#define XPAR_MICROBLAZE_MCS_S13_AXIS_DATA_WIDTH 32
#define XPAR_MICROBLAZE_MCS_M14_AXIS_DATA_WIDTH 32
#define XPAR_MICROBLAZE_MCS_S14_AXIS_DATA_WIDTH 32
#define XPAR_MICROBLAZE_MCS_M15_AXIS_DATA_WIDTH 32
#define XPAR_MICROBLAZE_MCS_S15_AXIS_DATA_WIDTH 32
#define XPAR_MICROBLAZE_MCS_ICACHE_BASEADDR 0x00000000
#define XPAR_MICROBLAZE_MCS_ICACHE_HIGHADDR 0x3FFFFFFF
#define XPAR_MICROBLAZE_MCS_USE_ICACHE 0
#define XPAR_MICROBLAZE_MCS_ALLOW_ICACHE_WR 1
#define XPAR_MICROBLAZE_MCS_ADDR_TAG_BITS 0
#define XPAR_MICROBLAZE_MCS_CACHE_BYTE_SIZE 16384
#define XPAR_MICROBLAZE_MCS_ICACHE_USE_FSL 0
#define XPAR_MICROBLAZE_MCS_ICACHE_LINE_LEN 4
#define XPAR_MICROBLAZE_MCS_ICACHE_ALWAYS_USED 0
#define XPAR_MICROBLAZE_MCS_ICACHE_INTERFACE 0
#define XPAR_MICROBLAZE_MCS_ICACHE_VICTIMS 0
#define XPAR_MICROBLAZE_MCS_ICACHE_STREAMS 0
#define XPAR_MICROBLAZE_MCS_ICACHE_FORCE_TAG_LUTRAM 0
#define XPAR_MICROBLAZE_MCS_ICACHE_DATA_WIDTH 0
#define XPAR_MICROBLAZE_MCS_M_AXI_IC_SUPPORTS_THREADS 0
#define XPAR_MICROBLAZE_MCS_M_AXI_IC_THREAD_ID_WIDTH 1
#define XPAR_MICROBLAZE_MCS_M_AXI_IC_SUPPORTS_READ 1
#define XPAR_MICROBLAZE_MCS_M_AXI_IC_SUPPORTS_WRITE 0
#define XPAR_MICROBLAZE_MCS_M_AXI_IC_SUPPORTS_NARROW_BURST 0
#define XPAR_MICROBLAZE_MCS_M_AXI_IC_DATA_WIDTH 32
#define XPAR_MICROBLAZE_MCS_M_AXI_IC_ADDR_WIDTH 32
#define XPAR_MICROBLAZE_MCS_M_AXI_IC_PROTOCOL AXI4
#define XPAR_MICROBLAZE_MCS_M_AXI_IC_USER_VALUE 0b11111
#define XPAR_MICROBLAZE_MCS_M_AXI_IC_SUPPORTS_USER_SIGNALS 1
#define XPAR_MICROBLAZE_MCS_M_AXI_IC_AWUSER_WIDTH 5
#define XPAR_MICROBLAZE_MCS_M_AXI_IC_ARUSER_WIDTH 5
#define XPAR_MICROBLAZE_MCS_M_AXI_IC_WUSER_WIDTH 1
#define XPAR_MICROBLAZE_MCS_M_AXI_IC_RUSER_WIDTH 1
#define XPAR_MICROBLAZE_MCS_M_AXI_IC_BUSER_WIDTH 1
#define XPAR_MICROBLAZE_MCS_INTERCONNECT_M_AXI_IC_READ_ISSUING 2
#define XPAR_MICROBLAZE_MCS_DCACHE_BASEADDR 0x00000000
#define XPAR_MICROBLAZE_MCS_DCACHE_HIGHADDR 0x3FFFFFFF
#define XPAR_MICROBLAZE_MCS_USE_DCACHE 0
#define XPAR_MICROBLAZE_MCS_ALLOW_DCACHE_WR 1
#define XPAR_MICROBLAZE_MCS_DCACHE_ADDR_TAG 0
#define XPAR_MICROBLAZE_MCS_DCACHE_BYTE_SIZE 16384
#define XPAR_MICROBLAZE_MCS_DCACHE_USE_FSL 0
#define XPAR_MICROBLAZE_MCS_DCACHE_LINE_LEN 4
#define XPAR_MICROBLAZE_MCS_DCACHE_ALWAYS_USED 0
#define XPAR_MICROBLAZE_MCS_DCACHE_INTERFACE 0
#define XPAR_MICROBLAZE_MCS_DCACHE_USE_WRITEBACK 0
#define XPAR_MICROBLAZE_MCS_DCACHE_VICTIMS 0
#define XPAR_MICROBLAZE_MCS_DCACHE_FORCE_TAG_LUTRAM 0
#define XPAR_MICROBLAZE_MCS_DCACHE_DATA_WIDTH 0
#define XPAR_MICROBLAZE_MCS_M_AXI_DC_SUPPORTS_THREADS 0
#define XPAR_MICROBLAZE_MCS_M_AXI_DC_THREAD_ID_WIDTH 1
#define XPAR_MICROBLAZE_MCS_M_AXI_DC_SUPPORTS_READ 1
#define XPAR_MICROBLAZE_MCS_M_AXI_DC_SUPPORTS_WRITE 1
#define XPAR_MICROBLAZE_MCS_M_AXI_DC_SUPPORTS_NARROW_BURST 0
#define XPAR_MICROBLAZE_MCS_M_AXI_DC_DATA_WIDTH 32
#define XPAR_MICROBLAZE_MCS_M_AXI_DC_ADDR_WIDTH 32
#define XPAR_MICROBLAZE_MCS_M_AXI_DC_PROTOCOL AXI4
#define XPAR_MICROBLAZE_MCS_M_AXI_DC_EXCLUSIVE_ACCESS 0
#define XPAR_MICROBLAZE_MCS_M_AXI_DC_USER_VALUE 0b11111
#define XPAR_MICROBLAZE_MCS_M_AXI_DC_SUPPORTS_USER_SIGNALS 1
#define XPAR_MICROBLAZE_MCS_M_AXI_DC_AWUSER_WIDTH 5
#define XPAR_MICROBLAZE_MCS_M_AXI_DC_ARUSER_WIDTH 5
#define XPAR_MICROBLAZE_MCS_M_AXI_DC_WUSER_WIDTH 1
#define XPAR_MICROBLAZE_MCS_M_AXI_DC_RUSER_WIDTH 1
#define XPAR_MICROBLAZE_MCS_M_AXI_DC_BUSER_WIDTH 1
#define XPAR_MICROBLAZE_MCS_INTERCONNECT_M_AXI_DC_READ_ISSUING 2
#define XPAR_MICROBLAZE_MCS_INTERCONNECT_M_AXI_DC_WRITE_ISSUING 32
#define XPAR_MICROBLAZE_MCS_USE_MMU 0
#define XPAR_MICROBLAZE_MCS_MMU_DTLB_SIZE 4
#define XPAR_MICROBLAZE_MCS_MMU_ITLB_SIZE 2
#define XPAR_MICROBLAZE_MCS_MMU_TLB_ACCESS 3
#define XPAR_MICROBLAZE_MCS_MMU_ZONES 16
#define XPAR_MICROBLAZE_MCS_MMU_PRIVILEGED_INSTR 0
#define XPAR_MICROBLAZE_MCS_USE_INTERRUPT 2
#define XPAR_MICROBLAZE_MCS_USE_EXT_BRK 0
#define XPAR_MICROBLAZE_MCS_USE_EXT_NM_BRK 0
#define XPAR_MICROBLAZE_MCS_USE_BRANCH_TARGET_CACHE 0
#define XPAR_MICROBLAZE_MCS_BRANCH_TARGET_CACHE_SIZE 0
#define XPAR_MICROBLAZE_MCS_PC_WIDTH 32

/******************************************************************/

#define XPAR_CPU_ID 0
#define XPAR_MICROBLAZE_ID 0
#define XPAR_MICROBLAZE_SCO 0
#define XPAR_MICROBLAZE_FREQ 20000000
#define XPAR_MICROBLAZE_DATA_SIZE 32
#define XPAR_MICROBLAZE_DYNAMIC_BUS_SIZING 1
#define XPAR_MICROBLAZE_AVOID_PRIMITIVES 0
#define XPAR_MICROBLAZE_FAULT_TOLERANT 0
#define XPAR_MICROBLAZE_ECC_USE_CE_EXCEPTION 0
#define XPAR_MICROBLAZE_LOCKSTEP_SLAVE 0
#define XPAR_MICROBLAZE_ENDIANNESS 1
#define XPAR_MICROBLAZE_AREA_OPTIMIZED 1
#define XPAR_MICROBLAZE_OPTIMIZATION 0
#define XPAR_MICROBLAZE_INTERCONNECT 2
#define XPAR_MICROBLAZE_STREAM_INTERCONNECT 0
#define XPAR_MICROBLAZE_DPLB_DWIDTH 32
#define XPAR_MICROBLAZE_DPLB_NATIVE_DWIDTH 32
#define XPAR_MICROBLAZE_DPLB_BURST_EN 0
#define XPAR_MICROBLAZE_DPLB_P2P 0
#define XPAR_MICROBLAZE_IPLB_DWIDTH 32
#define XPAR_MICROBLAZE_IPLB_NATIVE_DWIDTH 32
#define XPAR_MICROBLAZE_IPLB_BURST_EN 0
#define XPAR_MICROBLAZE_IPLB_P2P 0
#define XPAR_MICROBLAZE_M_AXI_DP_SUPPORTS_THREADS 0
#define XPAR_MICROBLAZE_M_AXI_DP_THREAD_ID_WIDTH 1
#define XPAR_MICROBLAZE_M_AXI_DP_SUPPORTS_READ 1
#define XPAR_MICROBLAZE_M_AXI_DP_SUPPORTS_WRITE 1
#define XPAR_MICROBLAZE_M_AXI_DP_SUPPORTS_NARROW_BURST 0
#define XPAR_MICROBLAZE_M_AXI_DP_DATA_WIDTH 32
#define XPAR_MICROBLAZE_M_AXI_DP_ADDR_WIDTH 32
#define XPAR_MICROBLAZE_M_AXI_DP_PROTOCOL AXI4LITE
#define XPAR_MICROBLAZE_M_AXI_DP_EXCLUSIVE_ACCESS 0
#define XPAR_MICROBLAZE_INTERCONNECT_M_AXI_DP_READ_ISSUING 1
#define XPAR_MICROBLAZE_INTERCONNECT_M_AXI_DP_WRITE_ISSUING 1
#define XPAR_MICROBLAZE_M_AXI_IP_SUPPORTS_THREADS 0
#define XPAR_MICROBLAZE_M_AXI_IP_THREAD_ID_WIDTH 1
#define XPAR_MICROBLAZE_M_AXI_IP_SUPPORTS_READ 1
#define XPAR_MICROBLAZE_M_AXI_IP_SUPPORTS_WRITE 0
#define XPAR_MICROBLAZE_M_AXI_IP_SUPPORTS_NARROW_BURST 0
#define XPAR_MICROBLAZE_M_AXI_IP_DATA_WIDTH 32
#define XPAR_MICROBLAZE_M_AXI_IP_ADDR_WIDTH 32
#define XPAR_MICROBLAZE_M_AXI_IP_PROTOCOL AXI4LITE
#define XPAR_MICROBLAZE_INTERCONNECT_M_AXI_IP_READ_ISSUING 1
#define XPAR_MICROBLAZE_D_AXI 0
#define XPAR_MICROBLAZE_D_PLB 0
#define XPAR_MICROBLAZE_D_LMB 1
#define XPAR_MICROBLAZE_I_AXI 0
#define XPAR_MICROBLAZE_I_PLB 0
#define XPAR_MICROBLAZE_I_LMB 1
#define XPAR_MICROBLAZE_USE_MSR_INSTR 0
#define XPAR_MICROBLAZE_USE_PCMP_INSTR 0
#define XPAR_MICROBLAZE_USE_BARREL 0
#define XPAR_MICROBLAZE_USE_DIV 0
#define XPAR_MICROBLAZE_USE_HW_MUL 0
#define XPAR_MICROBLAZE_USE_FPU 0
#define XPAR_MICROBLAZE_USE_REORDER_INSTR 0
#define XPAR_MICROBLAZE_UNALIGNED_EXCEPTIONS 0
#define XPAR_MICROBLAZE_ILL_OPCODE_EXCEPTION 0
#define XPAR_MICROBLAZE_M_AXI_I_BUS_EXCEPTION 0
#define XPAR_MICROBLAZE_M_AXI_D_BUS_EXCEPTION 0
#define XPAR_MICROBLAZE_IPLB_BUS_EXCEPTION 0
#define XPAR_MICROBLAZE_DPLB_BUS_EXCEPTION 0
#define XPAR_MICROBLAZE_DIV_ZERO_EXCEPTION 0
#define XPAR_MICROBLAZE_FPU_EXCEPTION 0
#define XPAR_MICROBLAZE_FSL_EXCEPTION 0
#define XPAR_MICROBLAZE_USE_STACK_PROTECTION 0
#define XPAR_MICROBLAZE_PVR 0
#define XPAR_MICROBLAZE_PVR_USER1 0x00
#define XPAR_MICROBLAZE_PVR_USER2 0x00000000
#define XPAR_MICROBLAZE_DEBUG_ENABLED 0
#define XPAR_MICROBLAZE_NUMBER_OF_PC_BRK 1
#define XPAR_MICROBLAZE_NUMBER_OF_RD_ADDR_BRK 0
#define XPAR_MICROBLAZE_NUMBER_OF_WR_ADDR_BRK 0
#define XPAR_MICROBLAZE_INTERRUPT_IS_EDGE 0
#define XPAR_MICROBLAZE_EDGE_IS_POSITIVE 1
#define XPAR_MICROBLAZE_RESET_MSR 0x00000000
#define XPAR_MICROBLAZE_OPCODE_0X0_ILLEGAL 0
#define XPAR_MICROBLAZE_FSL_LINKS 0
#define XPAR_MICROBLAZE_FSL_DATA_SIZE 32
#define XPAR_MICROBLAZE_USE_EXTENDED_FSL_INSTR 0
#define XPAR_MICROBLAZE_M0_AXIS_PROTOCOL GENERIC
#define XPAR_MICROBLAZE_S0_AXIS_PROTOCOL GENERIC
#define XPAR_MICROBLAZE_M1_AXIS_PROTOCOL GENERIC
#define XPAR_MICROBLAZE_S1_AXIS_PROTOCOL GENERIC
#define XPAR_MICROBLAZE_M2_AXIS_PROTOCOL GENERIC
#define XPAR_MICROBLAZE_S2_AXIS_PROTOCOL GENERIC
#define XPAR_MICROBLAZE_M3_AXIS_PROTOCOL GENERIC
#define XPAR_MICROBLAZE_S3_AXIS_PROTOCOL GENERIC
#define XPAR_MICROBLAZE_M4_AXIS_PROTOCOL GENERIC
#define XPAR_MICROBLAZE_S4_AXIS_PROTOCOL GENERIC
#define XPAR_MICROBLAZE_M5_AXIS_PROTOCOL GENERIC
#define XPAR_MICROBLAZE_S5_AXIS_PROTOCOL GENERIC
#define XPAR_MICROBLAZE_M6_AXIS_PROTOCOL GENERIC
#define XPAR_MICROBLAZE_S6_AXIS_PROTOCOL GENERIC
#define XPAR_MICROBLAZE_M7_AXIS_PROTOCOL GENERIC
#define XPAR_MICROBLAZE_S7_AXIS_PROTOCOL GENERIC
#define XPAR_MICROBLAZE_M8_AXIS_PROTOCOL GENERIC
#define XPAR_MICROBLAZE_S8_AXIS_PROTOCOL GENERIC
#define XPAR_MICROBLAZE_M9_AXIS_PROTOCOL GENERIC
#define XPAR_MICROBLAZE_S9_AXIS_PROTOCOL GENERIC
#define XPAR_MICROBLAZE_M10_AXIS_PROTOCOL GENERIC
#define XPAR_MICROBLAZE_S10_AXIS_PROTOCOL GENERIC
#define XPAR_MICROBLAZE_M11_AXIS_PROTOCOL GENERIC
#define XPAR_MICROBLAZE_S11_AXIS_PROTOCOL GENERIC
#define XPAR_MICROBLAZE_M12_AXIS_PROTOCOL GENERIC
#define XPAR_MICROBLAZE_S12_AXIS_PROTOCOL GENERIC
#define XPAR_MICROBLAZE_M13_AXIS_PROTOCOL GENERIC
#define XPAR_MICROBLAZE_S13_AXIS_PROTOCOL GENERIC
#define XPAR_MICROBLAZE_M14_AXIS_PROTOCOL GENERIC
#define XPAR_MICROBLAZE_S14_AXIS_PROTOCOL GENERIC
#define XPAR_MICROBLAZE_M15_AXIS_PROTOCOL GENERIC
#define XPAR_MICROBLAZE_S15_AXIS_PROTOCOL GENERIC
#define XPAR_MICROBLAZE_M0_AXIS_DATA_WIDTH 32
#define XPAR_MICROBLAZE_S0_AXIS_DATA_WIDTH 32
#define XPAR_MICROBLAZE_M1_AXIS_DATA_WIDTH 32
#define XPAR_MICROBLAZE_S1_AXIS_DATA_WIDTH 32
#define XPAR_MICROBLAZE_M2_AXIS_DATA_WIDTH 32
#define XPAR_MICROBLAZE_S2_AXIS_DATA_WIDTH 32
#define XPAR_MICROBLAZE_M3_AXIS_DATA_WIDTH 32
#define XPAR_MICROBLAZE_S3_AXIS_DATA_WIDTH 32
#define XPAR_MICROBLAZE_M4_AXIS_DATA_WIDTH 32
#define XPAR_MICROBLAZE_S4_AXIS_DATA_WIDTH 32
#define XPAR_MICROBLAZE_M5_AXIS_DATA_WIDTH 32
#define XPAR_MICROBLAZE_S5_AXIS_DATA_WIDTH 32
#define XPAR_MICROBLAZE_M6_AXIS_DATA_WIDTH 32
#define XPAR_MICROBLAZE_S6_AXIS_DATA_WIDTH 32
#define XPAR_MICROBLAZE_M7_AXIS_DATA_WIDTH 32
#define XPAR_MICROBLAZE_S7_AXIS_DATA_WIDTH 32
#define XPAR_MICROBLAZE_M8_AXIS_DATA_WIDTH 32
#define XPAR_MICROBLAZE_S8_AXIS_DATA_WIDTH 32
#define XPAR_MICROBLAZE_M9_AXIS_DATA_WIDTH 32
#define XPAR_MICROBLAZE_S9_AXIS_DATA_WIDTH 32
#define XPAR_MICROBLAZE_M10_AXIS_DATA_WIDTH 32
#define XPAR_MICROBLAZE_S10_AXIS_DATA_WIDTH 32
#define XPAR_MICROBLAZE_M11_AXIS_DATA_WIDTH 32
#define XPAR_MICROBLAZE_S11_AXIS_DATA_WIDTH 32
#define XPAR_MICROBLAZE_M12_AXIS_DATA_WIDTH 32
#define XPAR_MICROBLAZE_S12_AXIS_DATA_WIDTH 32
#define XPAR_MICROBLAZE_M13_AXIS_DATA_WIDTH 32
#define XPAR_MICROBLAZE_S13_AXIS_DATA_WIDTH 32
#define XPAR_MICROBLAZE_M14_AXIS_DATA_WIDTH 32
#define XPAR_MICROBLAZE_S14_AXIS_DATA_WIDTH 32
#define XPAR_MICROBLAZE_M15_AXIS_DATA_WIDTH 32
#define XPAR_MICROBLAZE_S15_AXIS_DATA_WIDTH 32
#define XPAR_MICROBLAZE_ICACHE_BASEADDR 0x00000000
#define XPAR_MICROBLAZE_ICACHE_HIGHADDR 0x3FFFFFFF
#define XPAR_MICROBLAZE_USE_ICACHE 0
#define XPAR_MICROBLAZE_ALLOW_ICACHE_WR 1
#define XPAR_MICROBLAZE_ADDR_TAG_BITS 0
#define XPAR_MICROBLAZE_CACHE_BYTE_SIZE 16384
#define XPAR_MICROBLAZE_ICACHE_USE_FSL 0
#define XPAR_MICROBLAZE_ICACHE_LINE_LEN 4
#define XPAR_MICROBLAZE_ICACHE_ALWAYS_USED 0
#define XPAR_MICROBLAZE_ICACHE_INTERFACE 0
#define XPAR_MICROBLAZE_ICACHE_VICTIMS 0
#define XPAR_MICROBLAZE_ICACHE_STREAMS 0
#define XPAR_MICROBLAZE_ICACHE_FORCE_TAG_LUTRAM 0
#define XPAR_MICROBLAZE_ICACHE_DATA_WIDTH 0
#define XPAR_MICROBLAZE_M_AXI_IC_SUPPORTS_THREADS 0
#define XPAR_MICROBLAZE_M_AXI_IC_THREAD_ID_WIDTH 1
#define XPAR_MICROBLAZE_M_AXI_IC_SUPPORTS_READ 1
#define XPAR_MICROBLAZE_M_AXI_IC_SUPPORTS_WRITE 0
#define XPAR_MICROBLAZE_M_AXI_IC_SUPPORTS_NARROW_BURST 0
#define XPAR_MICROBLAZE_M_AXI_IC_DATA_WIDTH 32
#define XPAR_MICROBLAZE_M_AXI_IC_ADDR_WIDTH 32
#define XPAR_MICROBLAZE_M_AXI_IC_PROTOCOL AXI4
#define XPAR_MICROBLAZE_M_AXI_IC_USER_VALUE 0b11111
#define XPAR_MICROBLAZE_M_AXI_IC_SUPPORTS_USER_SIGNALS 1
#define XPAR_MICROBLAZE_M_AXI_IC_AWUSER_WIDTH 5
#define XPAR_MICROBLAZE_M_AXI_IC_ARUSER_WIDTH 5
#define XPAR_MICROBLAZE_M_AXI_IC_WUSER_WIDTH 1
#define XPAR_MICROBLAZE_M_AXI_IC_RUSER_WIDTH 1
#define XPAR_MICROBLAZE_M_AXI_IC_BUSER_WIDTH 1
#define XPAR_MICROBLAZE_INTERCONNECT_M_AXI_IC_READ_ISSUING 2
#define XPAR_MICROBLAZE_DCACHE_BASEADDR 0x00000000
#define XPAR_MICROBLAZE_DCACHE_HIGHADDR 0x3FFFFFFF
#define XPAR_MICROBLAZE_USE_DCACHE 0
#define XPAR_MICROBLAZE_ALLOW_DCACHE_WR 1
#define XPAR_MICROBLAZE_DCACHE_ADDR_TAG 0
#define XPAR_MICROBLAZE_DCACHE_BYTE_SIZE 16384
#define XPAR_MICROBLAZE_DCACHE_USE_FSL 0
#define XPAR_MICROBLAZE_DCACHE_LINE_LEN 4
#define XPAR_MICROBLAZE_DCACHE_ALWAYS_USED 0
#define XPAR_MICROBLAZE_DCACHE_INTERFACE 0
#define XPAR_MICROBLAZE_DCACHE_USE_WRITEBACK 0
#define XPAR_MICROBLAZE_DCACHE_VICTIMS 0
#define XPAR_MICROBLAZE_DCACHE_FORCE_TAG_LUTRAM 0
#define XPAR_MICROBLAZE_DCACHE_DATA_WIDTH 0
#define XPAR_MICROBLAZE_M_AXI_DC_SUPPORTS_THREADS 0
#define XPAR_MICROBLAZE_M_AXI_DC_THREAD_ID_WIDTH 1
#define XPAR_MICROBLAZE_M_AXI_DC_SUPPORTS_READ 1
#define XPAR_MICROBLAZE_M_AXI_DC_SUPPORTS_WRITE 1
#define XPAR_MICROBLAZE_M_AXI_DC_SUPPORTS_NARROW_BURST 0
#define XPAR_MICROBLAZE_M_AXI_DC_DATA_WIDTH 32
#define XPAR_MICROBLAZE_M_AXI_DC_ADDR_WIDTH 32
#define XPAR_MICROBLAZE_M_AXI_DC_PROTOCOL AXI4
#define XPAR_MICROBLAZE_M_AXI_DC_EXCLUSIVE_ACCESS 0
#define XPAR_MICROBLAZE_M_AXI_DC_USER_VALUE 0b11111
#define XPAR_MICROBLAZE_M_AXI_DC_SUPPORTS_USER_SIGNALS 1
#define XPAR_MICROBLAZE_M_AXI_DC_AWUSER_WIDTH 5
#define XPAR_MICROBLAZE_M_AXI_DC_ARUSER_WIDTH 5
#define XPAR_MICROBLAZE_M_AXI_DC_WUSER_WIDTH 1
#define XPAR_MICROBLAZE_M_AXI_DC_RUSER_WIDTH 1
#define XPAR_MICROBLAZE_M_AXI_DC_BUSER_WIDTH 1
#define XPAR_MICROBLAZE_INTERCONNECT_M_AXI_DC_READ_ISSUING 2
#define XPAR_MICROBLAZE_INTERCONNECT_M_AXI_DC_WRITE_ISSUING 32
#define XPAR_MICROBLAZE_USE_MMU 0
#define XPAR_MICROBLAZE_MMU_DTLB_SIZE 4
#define XPAR_MICROBLAZE_MMU_ITLB_SIZE 2
#define XPAR_MICROBLAZE_MMU_TLB_ACCESS 3
#define XPAR_MICROBLAZE_MMU_ZONES 16
#define XPAR_MICROBLAZE_MMU_PRIVILEGED_INSTR 0
#define XPAR_MICROBLAZE_USE_INTERRUPT 2
#define XPAR_MICROBLAZE_USE_EXT_BRK 0
#define XPAR_MICROBLAZE_USE_EXT_NM_BRK 0
#define XPAR_MICROBLAZE_USE_BRANCH_TARGET_CACHE 0
#define XPAR_MICROBLAZE_BRANCH_TARGET_CACHE_SIZE 0
#define XPAR_MICROBLAZE_PC_WIDTH 32
#define XPAR_MICROBLAZE_HW_VER "8.40.a"

Hier finde ich z.b. die #defines nicht: "XPAR_XPS_TIMER_0_DEVICE_ID"

status = XTmrCtr_Initialize(&DelayTimer,XPAR_XPS_TIMER_0_DEVICE_ID);

Hier wird zb. gesagt, dass der virtex 6 über den Timer verfügt:

http://www.xilinx.com/products/intellectual-property/xps_timer.htm.

Hat jemand eine Idee, wieso er nicht in den xparameters.h aufgelistet 
ist? Aus Beispielen vom Vitex 5 kenne ich diese defines nämlich.

Danke dir. Ich probiere es morgen gleich aus. Ich schau morgen nach, wie 
genau der Name der Entwicklungsumgebung ist. Auf alle Fälle von xilinx. 
Ich kann die  xtmrctr.h anklicken. Die habe ich aus dem Internet geladen 
und in den projektordner kopiert. Ich schaue morgen, ob ich dadrin eine 
Timer Adresse finde. Ich gebe auf alle Fälle Rückmeldung. Danke

Ich habe ein Projekt in xilix Ise angelegt. In dem Projekt habe ich 
ml605 als Grundeinstellung gewählt. Als IPCore habe Ich den microblaze 
eingebunden. Um diesen zu programmieren bin ich nach dem Tutorial 
vorgegangen 
http://ece.wpi.edu/~xhuang/index_files/courses/ECE3829-Lab4.pdf. Ich 
weiß nun nicht, ob ich mit den Programmen arbeite, die du verwendest um 
diese Ansicht mit den Adressen zu bekommen. Bzw. Wie komme ich von 
meinem Standpunkt zu deiner Ansicht (sie Foto aus deinem Beitrag vom 
23.12.2013 16:27 Uhr )?

Guten Morgen Holger,

meine xtmrctr.h sieht wie folgt aus:

http://users.ece.gatech.edu/~hamblen/4006/xup/embedded/labs/lab4mb/microblaze_0/include/xtmrctr.h.

Von dieser Seite habe ich diese geladen und zum Projekt hinzugefügt. 
Wenn du sagst, dass eigentlich in der Datei die Address-Konstanten 
stehen, dann kann es bei mir ja nicht funktionieren (ist ja scheinbar 
keine von meiner Platform generierte Datei, richtig?). Lösche ich die 
extra von mir eingefügte Header-Datei, dann fehlt diese nach dem 
Einbinden. Dass heißt ja, dass sie von SDK nicht wirklich bereitgestellt 
wird. Hast du eine Idee, oder drehe ich mich im Kreis? Danke dir.

Ich denke mal, dass meine Probleme daher kommen, dass ich mit dem Virtex 
6 auf dem ML605 arbeite. Die Hilfen, die ich mir anschaue stammen jedoch 
von älteren Versionen.

Ich habe einmal ein neues Projekt mit dem von dir angesprochenen System 
Builder erstellt. Anbei befindet sich ein JPG mit den Konstanten. Dort 
habe ich nun die Timer BaseAddress entnommen.

(Ich habe die Dateien alle hinzugefügt 
http://users.ece.gatech.edu/~hamblen/4006/xup/embedded/labs/lab4mb/microblaze_0/libsrc/tmrctr_v1_00_b/src/)

#include "xstatus.h"
#include "xparameters.h"
#include "xtmrctr.h" /* axi_timer_0 */

#define BaseAddress 0x41C00000 // axi_timer_0
XTmrCtr DelayTimer;

int main(){
  Xuint32 status;
  status = XTmrCtr_Initialize(&DelayTimer,BaseAddress);
  if (status != XST_SUCCESS){
    xil_printf("Timer failed to initialize\r\n");
    return XST_FAILURE;}
  XTmrCtr_SetOptions(&DelayTimer, 1, XTC_DOWN_COUNT_OPTION);

  delay_ms(1); //Test

  return 0;
}

void delay_ms(Xuint32 time)
{
  XTmrCtr_SetResetValue(&DelayTimer, 1, time * 125000);
  XTmrCtr_Start(&DelayTimer, 1);
  while(!(XTmrCtr_IsExpired(&DelayTimer, 1))){}
  XTmrCtr_Stop(&DelayTimer, 1);
}

Dann bekomme ich die Fehlermeldung:

error: 'XPAR_XTMRCTR_NUM_INSTANCES' undeclared (first use in this 
function).

Diese soll angeblich auch in der xparameters.h definiert sein... Setze 
ich einmal zum TEST "#define XPAR_XTMRCTR_NUM_INSTANCES 2", dann fehlen 
als nächstes XPAR_DELAY_DEVICE_ID und XPAR_DELAY_BASEADDR aus dem header 
"xtmrctr_g.c". Diese sollen angeblich wieder aus der Datei xparameters.h 
entnommen werden.

Demnach zweifel ich gerade daran, ob der Virtex6 diesen Timer in der Art 
wie die Vorgänger besitzt. Ich habe wie gesagt scheinbar immernoch das 
Problem die defines zu finden.

Warum muß man eigentlich als Anfänger mit dem komplexesten Szenario, das 
es auf einem FPGA gibt anfangen?
Frei konfigurierbare Logik + parametrierbare CPU + variable Peripherie + 
Software?!?
Hast Du schon mal eine blinkende LED realisiert (ohne Softcore)?
Lauflicht? State-Machine?
Wenn nein, warum fängst Du dann mit einem LCD+Softcore an?

Was für eine Version Deiner Entwicklungsumgebung hast Du (Webpack, Eval 
oder Full)?
Hast Du Dir Deinen Microblaze selber konfiguriert oder wurde er 
vorgegeben?
Normalerweise wird beim Parametrieren der CPU (und der Peripherie) 
ausgewählt, ob und wieviele GPIO, Timer, RAM etc. pp. man haben möchte 
(bzw. im FPGA unterbringen kann).
Genau dort fällt auch ein Parameterfile raus, welches man hinterher in 
der Software einbindet.
Wenn Du dieses File aus einem anderen Projekt nimmst, ist die 
Wahrscheinlichkeit hoch, das es bei Dir nicht passt.

Machst Du das Projekt für Dich, für die Uni oder für Deinen Arbeitgeber?

Duke

User schrieb:
> Ich habe wie gesagt scheinbar immernoch das
> Problem die defines zu finden.
Du hast das Problem, daß Du noch nicht geblickt hast, wie die Tools 
aufeinander aufbauen (-> Toolflow).
Hast Du schon mal die Tutorials vom Hersteller durchgearbeitet?

Duke

Danke für die Antwort Duke.

Ich habe mit einem FPGA schon ein Lauflicht, blinkende LEDs (mit der 
einfachen delay-Fkt - Stichwort "nop") usw. realisiert. VHDL Kenntnisse 
sind soweit vorhanden.

Nun möchte ich mit dem MicroBlaze experimentieren. LCD läuft, LED- 
Ausgaben, DIP-Schalter-Eingaben, USB etc läuft. Ich habe früher auf AVRs 
in C programmiert.

Tutorials habe ich einige durchgearbeitet. Aber du hast sicherlich 
recht, dass ich den "Toolflow" noch nicht verinnerlicht habe.

Zum Verständnis noch ein letztes mal.

1. Die Adressen des GPI, GPO, Timers usw. eines FPGAs (Virtex 5, Virtex 
6, ...) sind vom Hersteller fest vorgegeben, richtig?
2. Die festen Register-Adressen muss ich im Datenblatt des jeweiligen 
FPGAs nachschauen, korrekt?
3. Die Adressen sollten damit unabhängig von der verwendeten ISE-Version 
usw. sein, richtig?


Ich frage aus folgendem Grund:

Ich habe euren Rat befolgt und einmal den Flow versucht 
nachzuvollziehen. Ich habe dieses Mal wie in Holgers obigen Beispiel 
erläutert ein neues Projekt gemäß Tutorial angelegt.
Dazu habe ich
(a) in „Xilinx Platform Studio“ ein neues Projekt angelegt. Ich kann da 
wählen zwischen einem AIX- und einem PLB-System. Ich habe das PLB-System 
wie im Beispiel erstellt. Der Timer „xps_timer_0“ (wie in Holgers 
Darstellung) ist vorhanden. Die Basis-Adresse habe ich mir notiert 
(0x83C00000). Ebenso die Adresse des GPO1-Registers, an dem die LEDs 
"angelegt" sind (0x81400000).
(b) anschließend habe ich SDK geladen und ein Projekt angelegt. Binde 
ich nun "xparameters.h" ein, dann erscheint der Timer als 
Peripherie-Komponente. (Bis dahin stimmt scheinbar alles)
(c) ein erster Test: "Hello world" über UART ausgeben funktioniert!
(d) ein zweiter Test: LEDs einschalten. In dem funktionsfähigen Projekt 
von mir ging das über:
#define XPAR_LEDS_8BIT_BASEADDR 0x81400000;
XGpio_mWriteReg(XPAR_LEDS_8BIT_BASEADDR, 0x01, 0xFF);
=> LEDs leuchten nicht!
Ich habe mein altes Projekt geladen. Hier funktioniert es. Mir ist 
aufgefallen, dass die Basis-Adresse für den GPO1 0x80000010 ist. (eine 
andere Adresse ?!)
Aus diesem Grund meine oben gestellten Verständnisfragen, ob die 
Adressen fest sind. Die Adresse 0x80000010 hatte ich damals aus dem 
Dokument
http://www.xilinx.com/support/documentation/sw_manuals/xilinx14_1/ds865_microblaze_mcs.pdf 
(Seite 24)

Das Dokument beschreibt den MicroBlaze. Das Dokument ist ja gültig für 
"Virtex 5, Virtex 6 ...

=> Adresse doch lediglich abhängig von der Konfigurierung (Automatische 
Festlegung, wenn ich das Projekt erstelle?!) ?

Ich versuche momentan ein wenig dahinterzukommen, wie das Ganze 
funktioniert. Es ist jedoch bei den vielen Dokumenten von Xilinx schwer 
die richtigen (ist ja auch abhängig von der ISE-Version) 
herauszufiltern.

Danke

Danke dir. Also bis eben dachte ich, dass ich nur den IPCore "MicoBlaze" 
in mein VHDL-Projekt als "Blackbox" einbinden muss. Das habe ich auch im 
ISE-Projekt getan (bis die (bisher noch ungelöste) Frage nach einem 
Timer/ einer genauen Delay-Funktion auftauchte). Die Vorstellung fand 
ich eigentlich für meine Bastelzwecke gut.

Mit den Adressen ist es klar geworden, danke. Also ist es schwierig nach 
ein paar Monaten z.B. zu einem bestehenden Projekt (im "Mikrocontroller" 
eine neue Komponente hinzuzufügen..da das xparameters.h sich ja nicht 
automatisch anzupassen scheint)

C programmieren ist bei mir eigentlich nicht wirklich das Problem. VHDL 
ebenso wenig.


Bemerkung/Überlegung:
Später wollte ich eine Ethernet-Schnittstelle oder PCI nutzen, um mit 
dem PC Daten auszutauschen. Auch deswegen wollte ich mit dem 
Mikrocontroller experimentieren. (ich weiß, dass das viel viel 
anspruchsvoller ist, ein Ziel muss jedoch sein ;) )

Also baue Ich quasi mit dem System builder den mikrocontroller nach 
meinem Bedürfnissen selbst zusammen. Somit wäre dieses ja 
unausweichlich, wenn Ich in die Zukunft gesehen pci umsetzen mag.

Danke. Ich habe meine ich das Problem gefunden (weswegen ich nie defines 
gefunden habe und der Timer nicht funktionierte). Bei meiner ISE-Version 
funktioniert es scheinbar nicht richtig, wenn man ein "PLB System" 
auswählt. Mit dem neueren AXI-System funktioniert alles super: LEDs, 
DIPs, LCD, UART ... der Timer funktioniert auch!
Folgende Zeilen habe ich dafür umgesetzt:

#include "platform.h"
#include "xparameters.h"
#include "xstatus.h"
#include "xtmrctr.h"

void delay_us(Xuint32 us);
XTmrCtr TmrCtrInstancePtr;

int main()
{
    init_platform();

    // AXI_Timer-Test --------------------------------------------------
    Xuint32 status;
    status = XTmrCtr_Initialize(&TmrCtrInstancePtr, 
XPAR_AXI_TIMER_0_DEVICE_ID);

    if (status != XST_SUCCESS)
    {
        xil_printf("Timer failed to initialize\r\n");
        return XST_FAILURE;
    }
    XTmrCtr_SetOptions(&TmrCtrInstancePtr, 1, XTC_DOWN_COUNT_OPTION);

    while(1) //Test, zur Überprüfung auf Oszi.
    {
      XGpio_mWriteReg(XPAR_GPIO_1_BASEADDR, 0, 0b00000000);
      delay_us(time);
      XGpio_mWriteReg(XPAR_GPIO_1_BASEADDR, 0, 0b00000001);
      delay_us(time);
    }
    return 0;
}

void delay_us(Xuint32 us)
{
  XTmrCtr_SetResetValue(&TmrCtrInstancePtr, 1, us * 
XPAR_AXI_TIMER_0_CLOCK_FREQ_HZ/1000000);
  XTmrCtr_Start(&TmrCtrInstancePtr, 1);
  while(!(XTmrCtr_IsExpired(&TmrCtrInstancePtr, 1))){}
  XTmrCtr_Stop(&TmrCtrInstancePtr, 1);
}

Ich muss jetzt nur noch einen Korrekturwert von "us * 
XPAR_AXI_TIMER_0_CLOCK_FREQ_HZ/1000000" abziehen, um an Genauigkeit zu 
gewinnen. Die Ungenauigkeit kommt meiner Meinung nach aus der 
delay-us-Funktion selbst. Die Operationen XTmrCtr_SetResetValue() usw. 
benötigen ja auch ein paar Takte. Auf 1 us genau kann ich somit bei 50 
MHz Takt (20 ns) nicht kommen. (Übergebe ich den Wert 1 an die Funktion 
delay_us(), dann messe ich am Oszi. eine Pulsbreite von 13,2 us. Damit 
suche ich einen konstanten Korrekturwert, richtig?
Um auf 1 us und niedriger zu kommen, muss ich demnach entweder die 
Taktfrequenz erhöhen, oder doch die alte delay-Funktion mit „nop“ 
nehmen.
Danke für die wertvollen Tipps.

Tobis du schriebst:

"
> Mit den Adressen ist es klar geworden, danke. Also ist es schwierig nach
> ein paar Monaten z.B. zu einem bestehenden Projekt (im "Mikrocontroller"
> eine neue Komponente hinzuzufügen..da das xparameters.h sich ja nicht
> automatisch anzupassen scheint)

Nein. Eigentlich kein Problem. Du fügst die Komponente im XPS hinzu und
machst ein Export to SDK. Dann aktualisiert er dein Bitfile und
automatisch deine Hardwareplatform und dann auch dein BSP wo die
xparameters.h drin steckt. Aber immer vorher ne Sicherung machen!"

Ich habe nun den Takt, mit welchem der virtuelle MicroBlaze arbeitet, in 
EDK geändert. Wie schaffe ich es, dass diese Änderung in die Konstante 
XPAR_AXI_TIMER_0_CLOCK_FREQ_HZ im xparameters.h File automatisch 
übernommen wird? Finde keinen Knopf zum erneuern des sdk-projektes.

Kann es natürlich per Hand nachtragen, wenns automatisch ginge fände ich 
es schöner.

Danke Tobias. CLK Einstellung wird im xparameters.h übernommen. Hatte 
mich nur verklickt.

Ich habe über den System Builder einmal ein Projekt wie beschrieben 
erstellt. Funktioniert auch super.

Habe die LEDs auf dem Entwicklungsboard angesteuert. Die hängen ja an 
einem AIX GPIO. Nun wollte ich z.B. ein paar Pins ansteuern. Die möchte 
ich an einen anderen GPIO betreiben. Also führe ich "Schritt 1" aus.
Der GPIO_1 und GPIO_2 usw. sind nun hinzugefügt. Ich habe nun die Pins 
(die ich ins ucf-File eingetragen habe zugewiesen) (Schritt 3).

Ich verstehe nicht, wieso ich einmal GPIO_IO_O und einmal GPIO_IO habe. 
(rot umrandet). Setze ich die beiden auf GPIO_IO_O erscheint folgende 
Fehlermeldung:

EDK:4074 - INSTANCE: GPIO_2, PORT: GPIO_IO, CONNECTOR: GPIO_2_GPIO_IO - 
No
   driver found ...
ERROR:EDK:440 - platgen failed with errors!

Wenn ich sie alle unterschiedlich setze, dann funktioniert es mit der 
Ansteuerung. Kann mich jemand aufklären?

Ich habe wahrscheinlich das Konzept falsch verstanden ?!

Danke dir. Das scheint mir alles sehr kompliziert. Ich meine um ein LCD, 
acht LEDs und vielleicht noch weitere acht LEDs an den mikrocontroller 
anzuschließen. Mit kompliziert meine ich, dass irgendwie viel Vhdl Code 
erzeugt wird. Das Projekt wird sehr groß und unübersichtlich in meiner 
Augen. Damals, als ich nur den microblaze ip Core eingebunden habe (LCD, 
LED, switches ...) war die Main.vhd übersichtlich. Ich hatte im UCI file 
meine Peripherie, die in an den mikrocontroller über Signal 
angeschlossen habe.

Beim Konzept mit dem systembuilder erscheint mir alles unklar. Wieso 
soll ich mir einen neuen Custom Pi erstellen und darf nicht einfach 
einen Gpio hinzufügen (ich meine der vom Programm selbst erstellte LED 
Bus war auch von der Sorte)? Kannst du mich vielleicht aufklären ;)

Danke