Actualice el valor de printf en la misma línea en lugar de uno nuevo

Me gustaría saber si hay una forma en C de sobrescribir un valor existente que ya se ha impreso en lugar de crear una nueva línea cada vez o simplemente moverse sobre un espacio. Necesito obtener datos en tiempo real de un sensor y me gustaría que simplemente se sentara allí y siguiera actualizando los valores existentes sin ningún desplazamiento. es posible?

ACTUALIZACIÓN: CÓDIGO AÑADIDO

 #include  #include  #include  #include  #include  #include  #include  #include  #include  #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); } }; 

Usted debe agregar a su printf como han dicho otros. Además, asegúrese de vaciar la salida estándar, ya que la secuencia de salida de la base de datos está almacenada en el búfer y solo mostrará lo que hay en el búfer después de que llegue a una nueva línea.

En tu caso:

 for (int i=0;i<10;i++){ //... printf("\rValue of X is: %d", x/114); fflush(stdout); //... } 

Estás buscando un retorno de carro. En C, eso es \r . Esto hará que el cursor regrese al inicio de la línea actual sin iniciar una nueva línea (avance de línea)

Puede hacerlo usando “\ r” en lugar de “\ n”.

Impreso donde?

Si está enviando datos a la salida estándar, generalmente no puede regresar y cambiar cualquier cosa que ya haya sido escrita. Si su salida estándar se dirige a la terminal, puede probar la salida del carácter que moverá el cursor al principio de la línea en algunas terminales (el efecto depende de la plataforma), de modo que la línea de salida subsiguiente sobrescriba lo que se imprimió en esa línea anteriormente. Esto producirá un efecto visual de los datos antiguos que serán reemplazados con datos nuevos. Sin embargo, esto realmente no “reemplaza” los datos antiguos en el flujo, lo que significa que si redirige la salida estándar al archivo, el archivo almacenará todo lo que se imprimió. Tenga en cuenta una vez más, que lo forzará a sobrescribir toda la línea en el terminal.

Si fseek sus datos a un archivo, puede usar la función fseek para volver a algún punto visitado previamente y “comenzar de nuevo” desde allí, sobrescribiendo los datos en el proceso.

Puede imprimir tantas líneas nuevas como la pantalla de la consola. Esto borrará efectivamente la pantalla.

Este es un gran enlace sobre la limpieza de la pantalla de diferentes maneras.

¿Has probado el carácter ‘\ b’ (retroceso)? Tal vez funcione dependiendo de tu consola.

Consulte el código de muestra para entender:

 #include  #include  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; } 

Blog de referencia

Además de las respuestas anteriores, \ r es en realidad un código del terminal. Parece que c no proporciona una manera de cambiar cualquier progtwig que ya se haya puesto en la secuencia de salida estándar.

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

en output.txt, algo no cambia, porque no significa nada para un archivo txt. Pero para el terminal, es significativo. Se maneja el formato y se muestra bien.

Usar códigos de terminal podría hacer algunas cosas divertidas. como abajo

 #include #include #include 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