Update printf Wert in derselben Zeile statt neue

Ich würde gerne wissen, ob es eine Möglichkeit gibt in C überschreiben den Wert, der bereits gedruckt wurde, statt dem erstellen einer neuen Zeile jedes mal, oder nur Bewegung in einem Raum. Ich muss, erhalten Sie in Echtzeit Daten von einem sensor und möchte, dass es gerade dort zu sitzen und halten die Aktualisierung der existierenden Werte ohne scrollen. Ist das möglich?

UPDATE: CODE HINZUGEFÜGT

#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <unistd.h>
#include <stdlib.h>
#include <stdint.h>
#include <time.h>

#include <wiringPi.h>
#include <wiringPiI2C.h>

#define CTRL_REG1 0x20
#define CTRL_REG2 0x21
#define CTRL_REG3 0x22
#define CTRL_REG4 0x23


int fd;
short x = 0;
short y = 0;
short z = 0;
int main (){



    fd = wiringPiI2CSetup(0x69); //I2C address of gyro
    wiringPiI2CWriteReg8(fd, CTRL_REG1, 0x1F); //Turn on all axes, disable power down
    wiringPiI2CWriteReg8(fd, CTRL_REG3, 0x08); //Enable control ready signal
    wiringPiI2CWriteReg8(fd, CTRL_REG4, 0x80); //Set scale (500 deg/sec)
    delay(200);                    //Wait to synchronize

void getGyroValues (){
    int MSB, LSB;

    LSB = wiringPiI2CReadReg8(fd, 0x28);
    MSB = wiringPiI2CReadReg8(fd, 0x29);
    x = ((MSB << 8) | LSB);

    MSB = wiringPiI2CReadReg8(fd, 0x2B);
    LSB = wiringPiI2CReadReg8(fd, 0x2A);
    y = ((MSB << 8) | LSB);

    MSB = wiringPiI2CReadReg8(fd, 0x2D);
    LSB = wiringPiI2CReadReg8(fd, 0x2C);
    z = ((MSB << 8) | LSB);
}
    for (int i=0;i<10;i++){
    getGyroValues();
    //In following Divinding by 114 reduces noise
    printf("Value of X is: %d\r", x/114);
// printf("Value of Y is: %d", y/114);
// printf("Value of Z is: %d\r", z/114);
    int t = wiringPiI2CReadReg8(fd, 0x26);
    t = (t*1.8)+32;//convert Celcius to Fareinheit
    int a = wiringPiI2CReadReg8(fd,0x2B);
    int b = wiringPiI2CReadReg8(fd,0x2A);
// printf("Y_L equals: %d\r", a);
// printf("Y_H equals: %d\r", b);
    int c = wiringPiI2CReadReg8(fd,0x28);
    int d = wiringPiI2CReadReg8(fd,0x29);
// printf("X_L equals: %d\r", c);
// printf("X_H equals: %d\r", d);
    int e = wiringPiI2CReadReg8(fd,0x2C);
    int f = wiringPiI2CReadReg8(fd,0x2D);
// printf("Z_L equals: %d\r", e);
// printf("Z_H equals: %d\r", f); 

// printf("The temperature is: %d\r", t); 
    delay(2000);
}
};
InformationsquelleAutor Yamaha32088 | 2013-03-03
  1. 19

    Sollten Sie \r zu Ihrem printf wie schon andere gesagt haben.
    Auch, stellen Sie sicher, Spülen Sie stdout als Standardausgabe-stream gepuffert ist & wird nur angezeigt, was in die Puffer nach dem es reicht ein Zeilenumbruch.

    In Ihrem Fall: 

    for (int i=0;i<10;i++){
    //...
    printf("\rValue of X is: %d", x/114);
    fflush(stdout);
    //...
}
    • Die fflush ist ein wichtiger Hinweis, wie auf den meisten Plattformen funktioniert es nicht ohne diese.
    • Auch dieses Beispiel nicht arbeiten, wenn Sie versuchen zu verwenden, für die Sie die Protokollierung in der Konsole von Xcode 9 (und vielleicht OS X im Allgemeinen).
    InformationsquelleAutor Zaxter
  2. 23

    Du suchst einen Wagenrücklauf. In C, das ist \r. Dies bringt den cursor wieder an den Anfang der aktuellen Zeile, ohne eine neue Zeile (Zeilenvorschub)

    • Ein Interessantes problem wäre, wenn die neue Zeile, die gedruckt wird, ist kürzer als die zuvor gedruckten Linie. In diesem Fall wird ein Teil der vorherigen Zeile, die auch auf dem Bildschirm sichtbar.
    • Dann drucken Sie einfach ein zusätzliches Leerzeichen für jeden char.
    • Ja, dass ist eine Lösung.Das Programm würde haben zu wissen, die Länge des Strings und anschließend etwas Mathe tun, um Leerzeichen einfügen, um es so Aussehen ordnungsgemäße. Die Herausforderung ist, wenn es irgendeinen anderen Weg, um effektiv zu flush die Linie.
    • Ich aktualisiert meine Frage und zusätzlichen code, ich bin nicht immer jede Art von output bei Verwendung der \r ich kommentiert habe alle anderen Zeilen mit Ausnahme eines im inneren des for Schleife, aber alles, was ich bekommen ist der blinkende cursor
    • versuchen Sie, die \r am Anfang der printf string anstatt am Ende. Es ist möglich, dass der Wagen zurück ist, wischen Sie die Linie auf dem terminal.
    • Funktioniert immer noch nicht ich denke ich werde gehen mit der \n Methode
    • Sie müssen auch eine fflush wie bereits von Zaxter unten.

    InformationsquelleAutor Yaniv
  3. 5

    Können Sie es mit "\r" anstelle von "\n".

    InformationsquelleAutor Gorbag
  4. 2

    Gedruckt wo?

    Wenn Ihr sind die Ausgabe-Daten an die standard-Ausgabe, Sie können nicht in der Regel kommen Sie zurück und ändern alles, was bereits geschrieben wurde. Wenn Ihr standard-Ausgabe richtet sich an terminal, können Sie versuchen, die Ausgabe \r Zeichen, wird der cursor an den Anfang der Zeile, an einige Klemmen (der Effekt ist Plattform-abhängig), so dass die nachfolgende Ausgabe-Zeile überschrieben wird, was gedruckt wurde, in der Zeile zuvor. Dieses produziert einen visuellen Effekt von alten Daten durch neue Daten. Allerdings bedeutet dies nicht wirklich "ersetzen" der alten Daten in den stream, was bedeutet, dass, wenn Sie die Umleitung der standard-Ausgabe in Datei speichern alles, was gedruckt wurde. Beachten Sie wieder, dass \r zwingen wird, überschreiben Sie die gesamte Zeile auf dem terminal.

    Wenn Sie bei der Ausgabe Ihrer Daten in einer Datei, dann können Sie fseek Funktion zurück zu gehen, um einige zuvor besuchte Stelle und "start over" von dort, dem überschreiben der Daten in den Prozess.

    InformationsquelleAutor AnT
  5. 1

    Haben Sie getestet, das '\b' Zeichen (backspace)? Vielleicht funktioniert je nach Konsole.

    InformationsquelleAutor Josh Petitt
  6. 0

    Drucken Sie sich so viele Zeilenumbrüche wie die Konsole hat. Dies wird effektiv löscht den Bildschirm.

    Dies ist eine große link über clearing-Bildschirm in verschiedenen Arten.

    InformationsquelleAutor
  7. -1

    Finden Sie in der Beispielcode zu verstehen:

    #include <stdio.h>
#include <pthread.h>

void myThread(void* ptr) {
    printf("Hello in thread\n");
    int i=0;    
    for(;i<10;i++)
    {
        sleep(1);
        printf(". ");
        fflush(stdout);  //comment this, to see the difference in O/P
    }
    printf("sleep over now\n");
}

int main(void) {
    pthread_t tid;
    printf("creating a new thread\n");
    pthread_create(&tid, NULL, (void*)myThread, 0);
    printf("going to join with child thread..\n");
    pthread_join(tid, NULL);
    printf("joined..!!\n");
    return 0;
}

    Referenz Blog

    InformationsquelleAutor parasrish
  8. -2

    Zusätzlich zu den oben genannten Antworten, \r ist eigentlich ein code für das terminal.
    c scheint nicht ein Weg, um zu ändern, was auch immer Programm hat bereits in den Standardausgabe-stream. 

    #include<stdio.h>
int main(){
    freopen("output.txt", "w", stdout);
    printf("somthing");
    printf("\r other thing");
}

    in output.txt etwas nicht ändern, weil \r bedeutet nicht, dass alles, was für eine txt-Datei.
    Aber für das terminal, \r sinnvoll ist. Es behandelt das format und zeigt Sie gut.

    Verwendung von terminal-codes tun könnte einige lustige Dinge. wie unten

    #include<iostream>
#include<bits/stdc++.h>
#include<unistd.h>

int main(){
std::string processBar[] {
    "00%: [                     ]",
    "05%: [#                    ]",
    "10%: [##                   ]",
    "15%: [###                  ]",
    "20%: [####                 ]",
    "25%: [#####                ]",
    "30%: [######               ]",
    "35%: [#######              ]",
    "40%: [########             ]",
    "45%: [#########            ]",
    "50%: [##########           ]",
    "55%: [###########          ]",
    "60%: [############         ]",
    "65%: [#############        ]",
    "70%: [##############       ]",
    "75%: [###############      ]",
    "80%: [################     ]",
    "85%: [#################    ]",
    "90%: [###################  ]",
    "95%: [#################### ]",
    "100%:[#####################]",
};

int n = sizeof(processBar)/ sizeof(*processBar);
//pretty fanny
for(int i{0}; i<n; ++i){
    fprintf(stdout, "\e[%d;1H \e[2K \r \a%s", i, processBar[i].c_str());
    fflush(stdout);
    sleep(1);
}

}
    InformationsquelleAutor Richard Lee
Schreibe einen Kommentar