SC_FIFO schreiben: Erste Chance Ausnahme

Question

Ich habe ein einfaches Programm geschrieben, das Daten von einem 2D-Array von einem Modul zu einem anderen Modul sendet, aber es scheint nicht zu funktionieren, und ich bin mir nicht sicher, warum. Hier ist mein Code:

Server.h

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

SC_MODULE(Server){ 
    sc_in <bool> clock; 
    sc_fifo_out <sc_uint<20> > writePath; 

    bool init_flag; 
    int numRobots; 

    void Server_Main(); 

    SC_CTOR(Server){ 
     init_flag = 0; 
     numRobots = 4; 
     SC_METHOD(Server_Main){ sensitive << clock.pos(); } 
    } 
}; 

Server.cpp

#include "stdafx.h" 
#include "Server.h" 

void Server::Server_Main(){ 
    if (init_flag == 0){ 
     int robotPath[4][5] = { 
      { 1, 2, 3, 4, 1 }, 
      { 2, 1, 6, 3, 4 }, 
      { 3, 2, 9, 5, 1 }, 
      { 4, 1, 6, 8, 7 } 
     }; 

     //Write robot path to Sensor 
     for (int i = 0; i < numRobots; i++){ 
      for (int j = 0; j < 5; j++){ 
       cout << "SERVER MODULE: Write Robot Paths " << i << ": " << robotPath[i][j] << endl; 
       writePath.write(robotPath[i][j]); 
      } 
     } 
     init_flag = 1; 
    } 
    else{ sc_stop(); } 
} 

Sensor.h

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

SC_MODULE(Sensor){ 
    //sc_in <bool> clock; 
    sc_fifo_in <sc_uint<20> > readPath; 

    int robotPath[4][5]; 

    void loadPath(); 
    //void Sensor_Main(); 

    SC_CTOR(Sensor){ 
     //SC_METHOD(Sensor_Main){ sensitive << clock.pos(); } 
     SC_THREAD(loadPath){} 
    } 
}; 

Sensor.cpp

#include "stdafx.h" 
#include "Sensor.h" 

void Sensor::loadPath(){ 
    int i = 0; 
    int j = 0; 
    while (1){ 
     robotPath[i][j] = readPath.read(); 
     cout << "SENSOR MODULE: Read Robot " << i << " Path " << j << " : " << robotPath[i][j] << endl; 
     if (j == 4){ 
      j = 0; //Set index to beginning of array 
      i++; //Move to next robot 
     } 
     else{ j++; } //Continue loading path for current robot 
    } 
} 

Main.cpp

#include "stdafx.h" 
#include <iostream> 

#include "Sensor.h" 
#include "Server.h" 

using namespace std; 

int sc_main(int argc, char* argv[]) 
{ 
    sc_clock clock("sysclock", 50, SC_MS, .5); 
    sc_fifo <sc_uint<20> > robotPath; 

    Sensor sensor_mod("Sensor"); 
    sensor_mod.readPath(robotPath); 

    Server server_mod("Server"); 
    server_mod.clock(clock); 
    server_mod.writePath(robotPath); 

    sc_start(); 

    return 0; 
} 

Hier ist, was meine Ausgabe wie folgt aussieht:

Hier ist der Fehler, den ich von VS2013 erhalten:

Das Programm eine Ausnahme zu werfen scheint, wenn Es versucht robotPath[3][1] in den Fifo zu schreiben, aber ich bin mir nicht sicher warum. Ich habe meine Fifo-Größe auf 20 eingestellt, so dass sie 20 Werte gleichzeitig speichern kann, aber ich sende nicht mehr als 20 Werte und diese Ausnahme passiert, wenn ich versuche, den 17. Wert zu schreiben, so dass ich die Verwendung von sc_fifo_out falsch verstehe. Es könnte ein offensichtlicher Fehler sein, den ich übersehe, aber an diesem Punkt bin ich irgendwie ausgebrannt und ich kann nicht herausfinden, was es ist, wenn ich mich versehe.

Jede Hilfe wird geschätzt, danke.

Answer 1

Versuchen Sie, ein Hardware-Design mit SystemC zu modellieren oder SystemC für die Software-Modellierung zu verwenden?
Es scheint, dass Sie die Kontexte durcheinander gebracht haben.

Hier sind eine Liste von Zeigern Sie beachten müssen:

• In Server-Modul Server_Main() als SC_THREAD registriert werden sollen:

  SC_THREAD(Server_Main); 
  sensitive << clk.pos(); 
  

  Da Sie sc_fifo die Schreibmethode verwenden die intern ruft wait() auf, in SystemC ist es unzulässig, wait in einem SC_METHOD zu verwenden.

• die Server.cpp modifizieren, wie unten erwähnt:

  void Server::Server_Main() { 
      int robotPath[4][5] = {{ 1, 2, 3, 4, 1 }, 
           { 2, 1, 6, 3, 4 }, 
           { 3, 2, 9, 5, 1 }, 
           { 4, 1, 6, 8, 7 }}; 
      //Write robot path to Sensor 
      for (int i = 0; i < numRobots; i++){ 
      for (int j = 0; j < 5; j++){ 
       cout << "SERVER MODULE: Write Robot Paths " << i << ": " << robotPath[i][j] << endl; 
       writePath.write(robotPath[i][j]); 
       wait(); //< Notice this wait statement. 
      } 
      } 
  } 
  

• eine wait() Anweisung in der while-Schleife der Sensor.cpp hinzufügen.

• Auch sc_fifo < sc_uint < 20>> ist keine sc_fifo mit Tiefen Instanziieren 20, wie Sie vielleicht denken.
  Es ist tatsächlich ein sc_fifo mit sc_uint < 20> als Datentyp Instanziierung, die zur Modellierung einer 20-Bit-Ganzzahl ohne Vorzeichen, die Standardtiefe fifo als 16 gemäß den SystemC Spezifikationen verwendet wird.

  Sie können ein instanziiert sc_fifo <> mit der Tiefe 20, wie unten erwähnt:

  sc_fifo<sc_uint<20> > robotPath("robotPath", 20); 
  

  Hinweis: Sie brauchen nicht diese von SC_METHOD seit der obigen Änderung zu tun, um zu SC_THREAD und auch die Aktualisierung Das Server_Main wird dieses Verhalten ungültig machen.