Hallo, hallo ein code aufgebrummt bekommen den ich an einigen stellen nicht nicht richtig enziffern kann :(. Dieser code soll den DMA tranfer FPGA -> PCI-> DMA->..... regeln. Diese ganze hardware/Stecker ist auf einer karte (Ics554). Da irgendetwas am tranfer der daten nicht stimmt soll der code angeguckt werden. Unteraderen funktionen gibt es eine fkt: savefile. Zu der ich einige fragen habe. hier ein kleiner ausschnitt. void saveFile (ULONGLONG** rbuf, int quantity, int capture_mode){ . . div = (capture_mode == ICS554_CAPTURE)?1:4; // was bedeutet in dieser Zuweisung ?1:4 ???? hab ein PDF von dieser funktion erstellt die gelb markierten abschnitte verstehe ichnoch nicht richtig. Wäre echt super wenn mir einer helfen könnte danke.
> div = (capture_mode == ICS554_CAPTURE)?1:4; > // was bedeutet in dieser Zuweisung ?1:4 ???? Das ist eine Kurzschreibweise von if (capture_mode == ICS554_CAPTURE) div = 1; else div = 4;
Schwammkopf schrieb: > div = (capture_mode == ICS554_CAPTURE)?1:4; > // was bedeutet in dieser Zuweisung ?1:4 ???? Das ist die C-Kurzform für
1 | if( capture_mode == ICS554_CAPTURE ) |
2 | div = 1; |
3 | else
|
4 | div = 4; |
Den ?: Operator findest du in jedem grindigen C-Buch
Das ging aber flott. Zwei Moderatoren nach einander was für ein luxus ;-). danke. Das mit dem c-buch weis ich ja auch nur man muß ja auch wissen nach was man sucht. ;-)
Hi, das ist der Fragezeichenoperator und ersetzt eine if-Abfrage. Die von Dir gepostete Zeile würde mit if-Abfrage so aussehen:
1 | if (capture_mode == ICS554_CAPTURE) |
2 | {
|
3 | div = 1; |
4 | }
|
5 | else
|
6 | {
|
7 | div = 4; |
8 | }
|
Was verstehst Du an den fprintf-Aufrufen nicht? Ein Shift um 16 nach rechts (>> 16) ist gleichbedeutend mit einer Division duruch 65536, ein Rechtsshift um 32 mit einer Divisin durch 2^32 und ein Rechtsshift um 48 mit einer Division durch 2^48. Gruß
So ist es! Das ist die Kurzform einer If-Abfrage! Ist nicht allzu sehr verbreitet, aber ich finde sie recht praktisch.
Hallo ich bins wieder. Hänge wieder an einem Problem. Es geht darum einen kontinuierlichen DMA Datentransfer zwischen der bereits genannten Hardwareanordnung um genauer zu sein den Transfer der Daten zwischen: FPGA -> PCI-> DMA(Buffer)-> festplatte zu gewerleisten. Der FPGA(ICS554) erzeugt mit hilfe eines Zählers, zahlen die anschließend auf der Platte abgespeichert werden sollen. Momentan funtioniert das so: (kurze Zusammenfassung) //////////////////////////////////////////////////////////////////////// /// HANDLE hDevice = INVALID_HANDLE_VALUE; ULONGLONG* rbuffer12[100]; ULONGLONG* rbuffer34[100]; main() { hDevice = open("/dev/ics554-1", O_RDWR); . . . BytesToRead = bufferLength12 * sizeof (ULONGLONG); // BytesToRead = (int(4Byte) * 8Byte) = 32Byte . . while(i!=lauf){ rbuffer12[i] = (ULONGLONG *) ics554AllocateDmaBuffer (hDevice,BytesToRead); i++; } i =0; . while(!kbhit && i!=lauf) // solange taste nicht gedrückt { temp = ICS554_FIFO1_SPACE; . . if (0 > read (hDevice, rbuffer12[i], BytesToRead)) {perror("read12[i]");} . . temp = ICS554_FIFO2_SPACE; . . if (0 > read (hDevice, rbuffer34[i], BytesToRead)) {perror("read34[i]");} } // saveFile speichert von DMAbuffer auf festplatte// saveFile ((ULONGLONG**) rbuffer12, bufferLength12, BoardControl1.mode); saveFile ((ULONGLONG**) rbuffer34, bufferLength34, BoardControl1.mode); } //////////////////////////////////////////////////////////////////////// /// wobei ich Schwierigkeiten habe ist, daten wie oben beschrieben ohne jegliche Verzögerung vom hDevice auf die Platte zu bringen. Hab da was von Memory Mapping gelesen?? Dadurch kann man ja einen Bestimmten RAM Bereich reservieren um dann auf die Platte zu speichern. Kennt einer das verfahren oder gibt es eventuell was anderes?? bin für jeden tipp dankbar.
Schwammkopf schrieb: > wobei ich Schwierigkeiten habe ist, daten wie oben beschrieben ohne > jegliche Verzögerung vom hDevice auf die Platte zu bringen. Dann wirst du nicht umhin kommen, das Schreiben auf die Platte mit in die Leseschleife zu packen. > Hab da was von Memory Mapping gelesen?? Dadurch kann man ja einen > Bestimmten RAM Bereich reservieren um dann auf die Platte zu speichern. Die Grundsatzfrage lautet: Worin bestehen deine 'Schwierigkeiten'. Denn eines muss klar sein. Das Schreiben auf die Platte dauert seine Zeit. Und es ist ziemlich unerheblich, wie und wann du das machst. Der Zeitbedarf für das eigentliche Schreiben von 1Mb auf die Platte zu schreiben ist immer gleich groß. Man kann natürlich diese Zeit zb in mehrere Abschnitte aufteilen und mit dem DMA-Lesen ineinander verweben. Aber grundsätzlich ist meistens die Devise: soviele Daten wie möglich in einem Rutsch schreiben, damit der Verwaltungsoverhead möglichst klein wird.
ja hab ich mir auch so vorgestellt, dass man während dem lesen
gleichzeitig schreiben(platte) muß. Nur wie das anstellen muß ka.
So wie ich den Code verstehe, werden immer eine liste bzw. file mit in
diesem fall:( 2048(ULONGLONG) x i(files) ) Werten auf einmal gelesen:
if (0 > read (hDevice, rbuffer34[i], BytesToRead))
{perror("read34[i]");}
und nach i durchläufen auf die platte geschrieben.
Was ich nicht weiß ist, wie kann man das lesen und schreiben
aufeinander synchronisieren?? ohne Datenverluste bzw. ohne das der
lese-pointer den schreib-pointer überholt weil ja auf den RAM schneller
geschrieben werden kann als auf??
Schwammkopf schrieb: > ja hab ich mir auch so vorgestellt, dass man während dem lesen > gleichzeitig schreiben(platte) muß. Nur wie das anstellen muß ka. Da gehe ich doch davon aus, dass die read Funktionen zwischenspeichern werden, was du nicht abholst. Wo liegt dann das Problem, ausser dass dein ursprüngliches Programm schon eine Fehlkonstruktion war, denn wie du mit nur einem i darüber buchführen willst, wiviele Bytes aus 2 unterschiedlichen Kanälen ankommen, ist mir nicht ganz klar.
1 | while(!kbhit && |
2 | i != lauf ) // solange taste nicht gedrückt |
3 | {
|
4 | temp = ICS554_FIFO1_SPACE; |
5 | .
|
6 | .
|
7 | readBytes = read( hDevice, rbuffer12, BytesToRead ); |
8 | if( readBytes < 0 ) |
9 | perror("read12[i]"); |
10 | else
|
11 | saveFile ((ULONGLONG**) rbuffer12, readBytes, BoardControl1.mode ); |
12 | |
13 | .
|
14 | .
|
15 | temp = ICS554_FIFO2_SPACE; |
16 | |
17 | readBytes = read( hDevice, rbuffer34, BytesToRead ); |
18 | if( readBytes < 0 ) |
19 | perror("read34[i]"); |
20 | else
|
21 | saveFile ((ULONGLONG**) rbuffer34, readBytes, BoardControl1.mode ); |
22 | |
23 | }
|
Die schleife war eigentlich so gedacht, dass nach einer vordef. Anzahl
von cycles, die Werte die aus dem File "hDevice" gelesen wurden, erst
dann gespeichert werden sollen.
while(i < cycles && !kbhit)
{
temp = ICS554_FIFO1_SPACE;
.
.
if (0 > read (hDevice, rbuffer12[i], BytesToRead))
{perror("read12[i]");}
.
.
.i++;
}
// dann speichern auf platte.
saveFile(..,..,..); //
Mit i wähle ich nur den Speicherort(DMA-Buffer), wo die Werte vom
hDevice hin müssen. // da ULONGLONG* rbuffer12[100];
Mein Problem ist dabei dieses: Es wurde ein Timer gestartet der eine
Zahl Inkrementiert und diese mit hilfe des hDevice bzw, DMA auf die
Platte gelangen sollen. Da die Werte inkrementiert werden soll ja
eigentlich auch eine Folge von Zahlen im ,gespeicherten-file, auf der
Platte wieder zufinden sein. Wenn ich allerdings. Die Speicherstelle
wechsele, dann kriege ich einenen sprung in der Zahlenfollge.
z.B.
//rbuffer[i]
1
2
3
4 <- *
//rbuffer[i+1]
10 <- hier der sprung
11
12
14
warum passiert das?? Liegt das an dem saveFile(..,..,..);? also an der
Art des speicherns // der code ist oben als PDF angehangen.
oder dauert der Schleifendurchlauf zu lange.
Angestrebt ist auf jedenfall ein kontinuirlicher Zahlenstrang also ein
durchgehender Datentransfer von perepherie->DMA->RAM->Platte
RAM weil man so einen Puffer schaffen kann zwischen DMA->Platte.
ich hoffe diesmal war ich etwas genauer mit meinem Problem
Thread beobachten
Seitenaufteilung abschaltenBitte melde dich an um einen Beitrag zu schreiben. Anmeldung ist kostenlos und dauert nur eine Minute.
Bestehender Account
Schon ein Account bei Google/GoogleMail? Keine Anmeldung erforderlich!
Mit Google-Account einloggen
Mit Google-Account einloggen
Noch kein Account? Hier anmelden.