OROLOGIO INDIPENDENTE DA WINDOWS......

[8rda3+]

Ciao a tutti.........

Chiedo il vostro aiuto per un mio problema............

Sto cercando, invano fino ad ora, un semplice orologio che possa essere indipendente dall'orologio di windows(bios)

Insomma, io setto un orario, e lui inperterrito contianua ad andare avanti......

Basterebbe un semplicissimo file exe, o bat.........o anche qualcosa con C++......

o anche con java......

Qualcuno mi può aiutare?

[71104]

non capisco che intendi con "indipendente da Windows"; e poi che c'entra il BIOS? cioè, tu vorresti ottenere un programma che potenzialmente possa sfasarsi dopo un certo tempo rispetto a quello di Windows a causa della diversa precisione, ho capito bene? è una domanda assurda lo so, ma è per sapere se ho capito quello che intendi; e siccome è una domanda assurda dovresti anche immaginare la risposta al tuo post... :D

[andbin]

Sto cercando, invano fino ad ora, un semplice orologio che possa essere indipendente dall'orologio di windows(bios)Cosa intendi per "indipendente"???

A) Che il "tuo" orologio sia semplicemente "sfasato" rispetto a quello di Windows. Questo comporta che: 1) Una modifica all'orologio di Windows, causa una modifica (sfasata) al "tuo" orologio. 2) Il tuo orologio gira in sincrono con quello di Windows.

B) Che il "tuo" orologio sia temporizzato e funzioni in maniera completamente indipendente dall'orologio di Windows. Questo comporta che: 1) Devi gestire tu un contatore da incrementare in modo opportuno e preciso. 2) Il "tuo" orologio non può "vivere" a pc spento (ovvio, l'unico che continua a girare è il RTC hardware sulla scheda madre!).

[8rda3+]

Cosa intendi per "indipendente"???

A) Che il "tuo" orologio sia semplicemente "sfasato" rispetto a quello di Windows. Questo comporta che: 1) Una modifica all'orologio di Windows, causa una modifica (sfasata) al "tuo" orologio. 2) Il tuo orologio gira in sincrono con quello di Windows.

B) Che il "tuo" orologio sia temporizzato e funzioni in maniera completamente indipendente dall'orologio di Windows. Questo comporta che: 1) Devi gestire tu un contatore da incrementare in modo opportuno e preciso. 2) Il "tuo" orologio non può "vivere" a pc spento (ovvio, l'unico che continua a girare è il RTC hardware sulla scheda madre!).


Innanzi tutto grazie delle risposte.........

Allora preciso..............
Il mio orologio deve funzionare in maniera completamente indipendente da windows............
Magari, per agirare lo spegnimento del pc, questo orologio, potrebbe calcolare l'ora corrente aggiungendo un certo valore di ore, secondi, e minuti all'orologio di windows..........

non so se sono stato chiaro...........

magari possiamo sentirci con msn???

:D :D :D

thanks

[andbin]

Allora preciso..............
Il mio orologio deve funzionare in maniera completamente indipendente da windows............
Magari, per agirare lo spegnimento del pc, questo orologio, potrebbe calcolare l'ora corrente aggiungendo un certo valore di ore, secondi, e minuti all'orologio di windows..........Non è banalissimo ma credo che si possa fare.
I problemi da risolvere sono quindi:

1) Gestire un contatore del tempo da incrementare in modo preciso ogni secondo. (ad esempio tramite un timer e magari per essere preciso usando il valore ritornato dalla funzione Win32 GetTickCount).

2) Settare/Leggere il tuo orologio come data/ora. (basta usare ad esempio le funzioni Win32 FileTimeToSystemTime e SystemTimeToFileTime).

3) Rendere "persistente" l'orologio anche se viene spento il PC.

[8rda3+]

Non è banalissimo ma credo che si possa fare.
I problemi da risolvere sono quindi:

1) Gestire un contatore del tempo da incrementare in modo preciso ogni secondo. (ad esempio tramite un timer e magari per essere preciso usando il valore ritornato dalla funzione Win32 GetTickCount).

2) Settare/Leggere il tuo orologio come data/ora. (basta usare ad esempio le funzioni Win32 FileTimeToSystemTime e SystemTimeToFileTime).

3) Rendere "persistente" l'orologio anche se viene spento il PC.


Esattamente.............

Io clicco sul file .exe (suppongo) e visualizzo un orario che differisca dal nosto di 8 ore in più............

[andbin]

Io clicco sul file .exe (suppongo) e visualizzo un orario che differisca dal nosto di 8 ore in più............Ma allora, scusa, non ti basta semplicemente "sfasare" l'orologio di Windows??? Vorrei capire bene ...

Per ottenere un semplice "sfasamento" si può fare:
1) Si ottiene l'ora locale di Windows con la funzione GetLocalTime (che riempie una struttura SYSTEMTIME).
2) Si converte la struttura SYSTEMTIME in una struttura FILETIME con la funzione SystemTimeToFileTime.
3) Si somma un certo valore es. 28800 per avere 8 ore in più al valore FILETIME (questo va fatto usando un ULARGE_INTEGER).
4) Si converte il nuovo FILETIME in un SYSTEMTIME con la funzione FileTimeToSystemTime e si ottengono i dati ora/min/sec. ecc... sfasati.

[8rda3+]

Ma allora, scusa, non ti basta semplicemente "sfasare" l'orologio di Windows??? Vorrei capire bene ...

Per ottenere un semplice "sfasamento" si può fare:
1) Si ottiene l'ora locale di Windows con la funzione GetLocalTime (che riempie una struttura SYSTEMTIME).
2) Si converte la struttura SYSTEMTIME in una struttura FILETIME con la funzione SystemTimeToFileTime.
3) Si somma un certo valore es. 28800 per avere 8 ore in più al valore FILETIME (questo va fatto usando un ULARGE_INTEGER).
4) Si converte il nuovo FILETIME in un SYSTEMTIME con la funzione FileTimeToSystemTime e si ottengono i dati ora/min/sec. ecc... sfasati.

Così era troppo semplice.......... :D :D
Non voglio toccare l'orologio di windows.........
Ma creare un altro con questo sfasamento di ore......... :D

[andbin]

Così era troppo semplice.......... :D :D
Non voglio toccare l'orologio di windows.........
Ma creare un altro con questo sfasamento di ore......... :DE va beh ... allora vuoi proprio le cose complicate! :p ;)

Comunque faccio alcune precisazioni. Nel mio post precedente dicevo di sommare 28800 al FILETIME per avere 8 ore in più. Correzione: mi sono ricordato appena adesso che FILETIME non ha la granularità di 1 secondo ma di 100 nanosecondi! ;)
Inoltre con il metodo che ho detto io NON tocchi/alteri assolutamente l'orologio di Windows. Prendi solo il suo valore, lo sfasi e basta.

E giusto per darti un esempio del metodo che ho detto io, ho buttato giù questo codice:
#define STRICT
#include <stdio.h>
#include <windows.h>

BOOL GetShiftedLocalTime (LPSYSTEMTIME lpstShifted, INT iSecondsShift)
{
SYSTEMTIME stLocal;
FILETIME ftLocal;
ULARGE_INTEGER ulInt;

GetLocalTime (&stLocal);

if (!SystemTimeToFileTime (&stLocal, &ftLocal))
return FALSE;

CopyMemory (&ulInt, &ftLocal, sizeof (ULARGE_INTEGER));

ulInt.QuadPart += ((LONGLONG) iSecondsShift) * 10000000;

CopyMemory (&ftLocal, &ulInt, sizeof (ULARGE_INTEGER));

if (!FileTimeToSystemTime (&ftLocal, lpstShifted))
return FALSE;

return TRUE;
}

int main (void)
{
SYSTEMTIME st;
CHAR szDate[64], szTime[64];

if (GetShiftedLocalTime (&st, 28800)) /* 8 ore di sfasamento */
{
/* Formatta e stampa data/ora */
GetDateFormat (LOCALE_USER_DEFAULT, DATE_SHORTDATE, &st,
NULL, szDate, sizeof (szDate));
GetTimeFormat (LOCALE_USER_DEFAULT, 0, &st,
NULL, szTime, sizeof (szTime));

printf ("%s %s\n", szDate, szTime);
}

return 0;
}È per una applicazione Win32 console. Se lo compili e lo esegui, ti stampa l'ora sfasata di 8 ore in avanti.

[8rda3+]

E va beh ... allora vuoi proprio le cose complicate! :p ;)

Comunque faccio alcune precisazioni. Nel mio post precedente dicevo di sommare 28800 al FILETIME per avere 8 ore in più. Correzione: mi sono ricordato appena adesso che FILETIME non ha la granularità di 1 secondo ma di 100 nanosecondi! ;)
Inoltre con il metodo che ho detto io NON tocchi/alteri assolutamente l'orologio di Windows. Prendi solo il suo valore, lo sfasi e basta.

E giusto per darti un esempio del metodo che ho detto io, ho buttato giù questo codice:
#define STRICT
#include <stdio.h>
#include <windows.h>

BOOL GetShiftedLocalTime (LPSYSTEMTIME lpstShifted, INT iSecondsShift)
{
SYSTEMTIME stLocal;
FILETIME ftLocal;
ULARGE_INTEGER ulInt;

GetLocalTime (&stLocal);

if (!SystemTimeToFileTime (&stLocal, &ftLocal))
return FALSE;

CopyMemory (&ulInt, &ftLocal, sizeof (ULARGE_INTEGER));

ulInt.QuadPart += ((LONGLONG) iSecondsShift) * 10000000;

CopyMemory (&ftLocal, &ulInt, sizeof (ULARGE_INTEGER));

if (!FileTimeToSystemTime (&ftLocal, lpstShifted))
return FALSE;

return TRUE;
}

int main (void)
{
SYSTEMTIME st;
CHAR szDate[64], szTime[64];

if (GetShiftedLocalTime (&st, 28800)) /* 8 ore di sfasamento */
{
/* Formatta e stampa data/ora */
GetDateFormat (LOCALE_USER_DEFAULT, DATE_SHORTDATE, &st,
NULL, szDate, sizeof (szDate));
GetTimeFormat (LOCALE_USER_DEFAULT, 0, &st,
NULL, szTime, sizeof (szTime));

printf ("%s %s\n", szDate, szTime);
}

return 0;
}È per una applicazione Win32 console. Se lo compili e lo esegui, ti stampa l'ora sfasata di 8 ore in avanti.


Ho provato, compilato ed eseguito, ma non funziona........... :muro: :muro: :muro:

[andbin]

Ho provato, compilato ed eseguito, ma non funziona........... :muro: :muro: :muro:Innanzitutto quale compilatore/ambiente stai usando?? Quale è il problema esatto?

[andbin]

Prova questo sorgente. È un po' più lungo (ho aggiunto la gestione della console) ma ti consente di modificare in modo interattivo lo sfasamento dell'ora.
#define STRICT
#include <windows.h>

/*---- Funzioni per gestione console ----*/
#define CONSOLE_FG_BLACK 0
#define CONSOLE_FG_BLUE FOREGROUND_BLUE
#define CONSOLE_FG_GREEN FOREGROUND_GREEN
#define CONSOLE_FG_CYAN (FOREGROUND_BLUE | FOREGROUND_GREEN)
#define CONSOLE_FG_RED FOREGROUND_RED
#define CONSOLE_FG_MAGENTA (FOREGROUND_RED | FOREGROUND_BLUE)
#define CONSOLE_FG_YELLOW (FOREGROUND_RED | FOREGROUND_GREEN)
#define CONSOLE_FG_WHITE (FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE)

#define CONSOLE_BG_BLACK 0
#define CONSOLE_BG_BLUE BACKGROUND_BLUE
#define CONSOLE_BG_GREEN BACKGROUND_GREEN
#define CONSOLE_BG_CYAN (BACKGROUND_BLUE | BACKGROUND_GREEN)
#define CONSOLE_BG_RED BACKGROUND_RED
#define CONSOLE_BG_MAGENTA (BACKGROUND_RED | BACKGROUND_BLUE)
#define CONSOLE_BG_YELLOW (BACKGROUND_RED | BACKGROUND_GREEN)
#define CONSOLE_BG_WHITE (BACKGROUND_RED | BACKGROUND_GREEN | BACKGROUND_BLUE)

BOOL WINAPI Console_Clear (HANDLE hStdOut, WORD wAttributes)
{
COORD coord = { 0, 0 };
DWORD dwScreenSize, dwWritten;
CONSOLE_SCREEN_BUFFER_INFO csbi;

if (GetConsoleScreenBufferInfo (hStdOut, &csbi) == FALSE)
return FALSE;

dwScreenSize = csbi.dwSize.X * csbi.dwSize.Y;

if (FillConsoleOutputCharacter (hStdOut, (TCHAR) ' ', dwScreenSize, coord, &dwWritten) == FALSE)
return FALSE;
if (FillConsoleOutputAttribute (hStdOut, wAttributes, dwScreenSize, coord, &dwWritten) == FALSE)
return FALSE;
if (SetConsoleCursorPosition (hStdOut, coord) == FALSE)
return FALSE;
if (SetConsoleTextAttribute (hStdOut, wAttributes) == FALSE)
return FALSE;

return TRUE;
}

BOOL WINAPI Console_SetCursorPos (HANDLE hStdOut, SHORT sX, SHORT sY)
{
COORD coord;

coord.X = sX;
coord.Y = sY;

return SetConsoleCursorPosition (hStdOut, coord);
}

BOOL WINAPI Console_SetCursorVisibility (HANDLE hStdOut, BOOL bVisible)
{
CONSOLE_CURSOR_INFO cci;

if (GetConsoleCursorInfo (hStdOut, &cci) == FALSE)
return FALSE;

cci.bVisible = bVisible;

return SetConsoleCursorInfo (hStdOut, &cci);
}

BOOL WINAPI Console_Write (HANDLE hStdOut, LPTSTR lpszText)
{
DWORD dwWritten;

if (WriteConsole (hStdOut, lpszText, (DWORD) lstrlen (lpszText), &dwWritten, NULL) == FALSE)
return FALSE;

return TRUE;
}

BOOL WINAPI Console_Read (HANDLE hStdIn, PINPUT_RECORD pir, LPDWORD lpdwRead, BOOL bBlocking)
{
INPUT_RECORD ir;
DWORD dwRead;

if (!bBlocking)
{
if (!PeekConsoleInput (hStdIn, &ir, 1, &dwRead))
return FALSE;

if (dwRead == 0)
{
*lpdwRead = 0;
return TRUE;
}
}

if (!ReadConsoleInput (hStdIn, pir, 1, lpdwRead))
return FALSE;

return TRUE;
}

/*---------------------------------------*/


BOOL GetShiftedLocalTime (LPSYSTEMTIME lpstShifted, INT iSecondsShift)
{
SYSTEMTIME stLocal;
FILETIME ftLocal;
ULARGE_INTEGER ulInt;

GetLocalTime (&stLocal);

if (!SystemTimeToFileTime (&stLocal, &ftLocal))
return FALSE;

CopyMemory (&ulInt, &ftLocal, sizeof (ULARGE_INTEGER));

ulInt.QuadPart += ((LONGLONG) iSecondsShift) * 10000000;

CopyMemory (&ftLocal, &ulInt, sizeof (ULARGE_INTEGER));

if (!FileTimeToSystemTime (&ftLocal, lpstShifted))
return FALSE;

return TRUE;
}


int main (void)
{
HANDLE hStdIn, hStdOut;
SYSTEMTIME st;
INT iHoursShift = 8;
WORD wSecondOld = 0xFFFF;
CHAR szDate[64], szTime[64], szBuffer[128];
INPUT_RECORD ir;
DWORD dwRead;
BOOL bExit = FALSE;

hStdIn = GetStdHandle (STD_INPUT_HANDLE);
hStdOut = GetStdHandle (STD_OUTPUT_HANDLE);

Console_Clear (hStdOut, CONSOLE_BG_BLUE | CONSOLE_FG_YELLOW | FOREGROUND_INTENSITY);
Console_SetCursorVisibility (hStdOut, FALSE);

Console_SetCursorPos (hStdOut, 0, 0);
Console_Write (hStdOut, "Premi: ESC per uscire ; freccia su/giu' per aumentare/diminuire lo sfasamento");

do {
if (GetShiftedLocalTime (&st, iHoursShift * 3600))
{
if (st.wSecond != wSecondOld)
{
wsprintf (szBuffer, "Ore sfasamento: %d ", iHoursShift);

Console_SetCursorPos (hStdOut, 30, 10);
Console_Write (hStdOut, szBuffer);

GetDateFormat (LOCALE_USER_DEFAULT, DATE_SHORTDATE, &st,
NULL, szDate, sizeof (szDate));
GetTimeFormat (LOCALE_USER_DEFAULT, 0, &st,
NULL, szTime, sizeof (szTime));

wsprintf (szBuffer, "%s %s ", szDate, szTime);

Console_SetCursorPos (hStdOut, 30, 13);
Console_Write (hStdOut, szBuffer);

wSecondOld = st.wSecond;
}
}

Sleep (50);

if (Console_Read (hStdIn, &ir, &dwRead, FALSE))
{
if (dwRead == 1 && ir.EventType == KEY_EVENT && ir.Event.KeyEvent.bKeyDown == TRUE)
{
if (ir.Event.KeyEvent.wVirtualKeyCode == VK_ESCAPE)
bExit = TRUE;
else if (ir.Event.KeyEvent.wVirtualKeyCode == VK_UP)
{
iHoursShift++;
wSecondOld = 0xFFFF;
}
else if (ir.Event.KeyEvent.wVirtualKeyCode == VK_DOWN)
{
iHoursShift--;
wSecondOld = 0xFFFF;
}
}
}
} while (!bExit);

Console_Clear (hStdOut, CONSOLE_BG_BLACK | CONSOLE_FG_WHITE);
Console_SetCursorVisibility (hStdOut, TRUE);

return 0;
}

[8rda3+]

Innanzitutto quale compilatore/ambiente stai usando?? Quale è il problema esatto?


Ho usato DEV, per conpilarlo..........

Appena eseguo il file compilato, la finestra esce per una frazione di secondo, e poi si chiude subito...... :confused: :confused: :confused: :confused:

[8rda3+]

Ho provato, anche il secondo codice che mi hai dato, e devo dire che mi và più che bene.....

Solo che la data dovrebbe essere di un giorno in avanti..........

Se mi dici cosa modificare lo posso fare io.........


Thanks!!!!!!!!!!!!!!!!!!!

[andbin]

Ho usato DEV, per conpilarlo..........

Appena eseguo il file compilato, la finestra esce per una frazione di secondo, e poi si chiude subito...... :confused: :confused: :confused: :confused:Beh, certo! Il primo sorgente stampa l'ora e termina immediatamente. Se lo lanci dal tuo ambiente di sviluppo, non vedi niente! ;) Dovresti invece aprire una nuova finestra del prompt dei comandi e lanciarlo a mano.

Non ho inserito alcuna getch, scanf, system("pause") o roba simile per attendere un tasto proprio perché dovrebbe essere facilmente comprensibile che esce immediatamente! E quindi poi ognuno si regola come meglio crede.

[andbin]

Ho provato, anche il secondo codice che mi hai dato, e devo dire che mi và più che bene.....Certo, perché il programma non termina subito. C'è un loop all'interno del main da cui si esce solo premendo ESC. Altrimenti l'orologio avanza secondo per secondo ed è anche possibile modificare in modo interattivo lo sfasamento con le frecce su/giù.

Solo che la data dovrebbe essere di un giorno in avanti..........

Se mi dici cosa modificare lo posso fare io.........Dipende da cosa ti serve. Io ho aggiunto un po' di "folklore" usando dei colori e dando la possibilità di modificare lo sfasamento. Se a te non serve, puoi togliere diversa roba. Non so nemmeno se ti va bene una applicazione "console". Si potrebbe anche fare una applicazione "gui" con una piccola dialog-box con un campo "static" che mostra l'orologio mentre avanza. Ma questo richiede altre cose (l'utilizzo di un file di risorse .rc nel progetto e la gestione della dialog-box).

La funzione fondamentale che consente di ottenere lo sfasamento dell'ora è quella che ho chiamato GetShiftedLocalTime. Per avere l'ora di un giorno in avanti basta passargli come secondo parametro 24*3600.

Poi vedi tu ... se hai qualche dubbio comunque chiedi pure.