dimecres, 15 de setembre del 2021

Bases de dades orientades a documents

 



"En el model de base de dades orientat a documents, les dades es guarden en documents individuals i no en taules com en el model relacional."

En els últims anys, i gràcies a l'èxit de NoSQL, les bases de dades documentals han experimentat un gran auge, sobretot, per la seva bona escalabilitat. Un exemple per a aquest tipus de sistema de base de dades és MongoDB.

En aquest model, els documents són la unitat bàsica per a l'emmagatzematge de dades. Aquestes unitats són les que estructuren les dades i no s'han de confondre amb els documents dels programes de processament de text. Aquí, les dades es guarden en els anomenats parells clau-valor, comprenent així, una "clau" i un "valor". Com que no estan definits ni l'estructura ni el nombre de parells, els documents que integren una base de dades orientada a documents poden resultar molt dispars entre si. Cada document és una unitat tancada en si mateixa i establir relacions entre documents no resulta fàcil, però en aquest model no és necessari.

Tecnlogies que treballen amb Bases de dades orientades a documents:

Més informació --> Base de dades

Bases de dades orientades a objectes

 


"El model de base de dades orientat a objectes preveu l'emmagatzematge de les dades juntament amb els seus mètodes d'accés."


En el model orientat a objectes, les dades es guarden en un objecte juntament amb les seves funcions (mètodes) i els atributs que els descriuen més en profunditat. En un sistema de gestió de bases de dades d'objectes, són els mètodes, dipositats en l'objecte juntament amb les dades, els que defineixen com s'accedeix a l'objecte.

Els objectes poden ser complexos i estar compostos per múltiples tipus de dades, són únics dins el sistema de base de dades i s'identifiquen amb un identificador d'objecte (OID en anglès) únic. Com es pot veure a la figura de dalt, els objectes s'agrupen en classes (object category), donant com a resultat una jerarquia de classes. Malgrat l'aparent similitud amb el model jeràrquic, aquí predomina el paradigma orientat a objectes i no existeix cap relació pare-fill fixa. Tot i així, a través de la classe pot definir-se el mètode per a l'accés.

Els avantatges de les bases de dades orientades a objectes destaquen, sobretot, en problemes amb tipus de dades complexos. Aquestes bases de dades treballen, en la seva major part, de forma autònoma sense recórrer a la normalització ia la correspondència d'ID, permetent així emmagatzemar els objectes nous de forma relativament simple i fluïda. No obstant això, les consultes són molt més àgils en un sistema de base de dades relacional. L'escassa popularitat dels sistemes orientats a objectes resulta en una insuficient compatibilitat amb moltes de les aplicacions de base de dades que es fan servir habitualment

Tecnlogies que treballen amb Bases de dades en objectes:



Més informació --> Base de dades

Bases de dades en xarxa

 

"En el model de base de dades en xarxa no governa cap jerarquia fixa i, per tant, són diversos els camins que porten a un mateix destí."


El model en xarxa es va desenvolupar gairebé de forma simultània al relacional, encara que amb el temps seria superat per la competència. A diferència d'el model jeràrquic, aquí els registres o rècords no revelen relacions pare-fill estrictes , sinó que cada registre pot tenir múltiples precedents, el que li dóna la estructura en xarxa del seu nom. Per accedir a un registre tampoc hi ha, per això mateix, un camí únic i invariable.

Avui el model de base de dades en xarxa s'utilitza, sobretot, en els grans ordinadors . En altres camps se segueix confiant en el model jeràrquic (clients d'IBM, sobretot) o s'ha fet el pas cap al model relacional, molt més flexible i fàcil d'utilitzar. Alguns models coneguts de base de dades en xarxa són el UDS de Siemens i el DMS de Sperry Univac. Amb el temps, tots dos fabricants han desenvolupat també interessants formes mixtes entre el model en xarxa i el relacional encara que sense aconseguir arrencar de el tot. Amb tot, encara avui poden trobar aspectes d'aquests intents en el SQL de Siemens. La base de dades orientada a grafs, per la seva estructura reticular, és considerada l'evolució moderna de el model en xarxa.

Tecnlogies que treballen amb Bases de dades en xarxa:
  • UDS (Siemens)
  • DMS (Sperry Univac)



Més informació --> Base de dades

Bases de dades Jeràrquiques

 


"En el model jeràrquic de base de dades les dependències són estrictes."


En les bases de dades jeràrquiques les dependències són inequívoques. Cada registre té només un precedent (Parent-Child Relationships, PCR) a excepció de l'arrel (root), constituint un esquema en arbre com el de dalt. Mentre que cada node "fill", només pot tenir un node "pare", els "pares" poden tenir tants "fills" com vulguin. Atès l'estricte ordenament jeràrquic, els nivells sense relació directa, no interactuen entre si i connectar dos arbres diferents tampoc és fàcil. Per tot això, les estructures de base de dades jeràrquiques són extremadament inflexibles, però molt clares .

Els registres amb fills es diuen records i els que no tenen s'anomenen fulles i són els que solen contenir els documents. Els records serveixen per classificar les fulles . Les consultes a una base de dades jeràrquica arriben als fulls partint des de l'arrel i passant pels diferents records.


Tecnlogies que treballen amb Bases de dades jeràrquiques:



Més informació --> Base de dades

dimarts, 14 de setembre del 2021

Bases de dades relacionals


"El model relacional de base de dades es basa en taules i avui s'ha consolidat com
estàndard per a les bases de dades."

El model relacional treballa amb taules independents que determinen la localització de les dades i les seves connexions. Aquestes dades conformen un registre (a la imatge, una fila o "tupla") i es guarden en columnes com a atributs. La relació és el que resulta dels atributs interrelacionats. Per identificar inequívocament un registre és elemental la clau primària , que normalment es defineix com el primer atribut (A1) i que no pot canviar-se. Dit d'una altra manera, aquesta clau primària o ID, defineix la posició exacta de l'registre amb tots els atributs.

Tecnlogies que treballen amb Bases de dades relacionals:

Més informació --> Base de dades

dissabte, 24 d’abril del 2021

Encoders absoluts, quins son i com funcionen?

 



Els encoders de valor absolut subministren un codi binari que es correspon amb la posició en què es troba l'eix.

És a dir, llegeix la posició del disc, no la transició d'una posició a la següent (com passa amb els encoders incrementals). Per tant, aquests encoders no perden la posició en què es troben encara es moguin quan no hi ha tensió d'alimentació.

Aquest fet suposa un gran avantatge ja que no cal posicionar la màquina en l'origen després d'una falta de tensió d'alimentació.


Principi de funcionament:

Un emissor de llum infraroja emet un feix que travessa una màscara i el disc on està serigrafiat el codi binari en pistes circulars concèntriques a l'eix.
Quan el disc (que està fixat a l'eix de l'encoder) gira, una matriu de foto-transistors rep llums i ombres produïdes quan les pistes serigrafiades en el disc interrompen el feix de llum emès pel díode emissor.





En el croquis anterior podem veure el principi de funcionament de l'encoder absolut. Com es pot apreciar, la llum de l'díode emissor d'infrarojos, travessa el disc i la màscara i incideix sobre els foto-transistors (n'hi ha tants, com bits té el codi binari que fa servir l'encoder).


Representacio de un disc:




Com es pot observar, el disc està dividit en pistes circulars concèntriques. Cada pista (començant per la més perifèrica i cap al centre del disc) correspon a un bit d'el codi binari que s'estigui fent servir.

Els sectors en negre produeixen ombra en el Foto-Transistor corresponent i el circuit electrònic subministra un "1" lògic en el bit en qüestió.

Els sectors en blanc deixen passar la llum a l'Foto-Transistor i l'electrònica subministra un "0" lògic per al bit a què correspon.

Encoders absoluts mono-volta i multi-voltes

Fins ara hem estat veient que el encoder absolut té un disc que gira solidari amb l'eix. Però què passa quan l'Eix arriba a la fi de la volta de 360º ?.

Per contestar aquesta pregunta cal tenir en compte que, pel que fa a aquest punt, hi ha dos tipus d'encoders:
  • Encoders mono-volta
L'encoder subministra, a cada volta, el nombre de lectures (passos) que tingui el disc que porta al seu interior. Quan nafra a la fi de la volta, torna a començar la lectura pel principi. Per exemple, suposem que el encoder porta un disc de 360 passos, llavors la seqüència que subministra és la següent:


És a dir, el receptor del senyal de l'encoder sap quina és la posició del disc en cada volta, però no sap en què tornada està l'eix o quantes voltes ha donat.

Aquest tipus d'encoders s'usa quan l'eix de l'encoder no va a donar més d'una volta o quan es vol controlar l'angle de gir d'una peça (per exemple una antena orientable 360º). 

 

  • Encoders multi-voltes
Aquest tipus d'encoders permet saber, no només en quina posició està l'eix sinó també quantes voltes ha donat.
Per aconseguir això, l'encoder porta en el seu interior, a més de el disc que indica el nombre de passos per volta, altres discos (amb diferent relació mecànica) que són els que comptabilitzen el nombre de voltes de l'eix.

Aquests discos auxiliars poden ser un, dos o tres i també van codificats amb el mateix codi binari que el disc general.

Vegem un croquis il·lustratiu:


Quan un encoder multi-volta sigui de 16 voltes portarà només un disc auxiliar. Aquest disc donarà una volta completa cada 16 voltes del disc principal (16 voltes de l'eix).

Quan un encoder multi-volta de 256 voltes portarà dos discos auxiliars. Cada 16 voltes del disc principal (16 voltes de l'eix), el primer disc auxiliar donarà una volta i cada 16 voltes del primer disc auxiliar donarà una volta el segon disc auxiliar. (16x16 = 256) 

Quan un encoder multi-volta sigui de 4.096 voltes portarà tres discos auxiliars. Cada 16 voltes d'un disc, el següent dóna una volta. (16 x 16 x 16 = 4.096)

Per tant, sabent el nombre de passos per volta del disc principal, podem saber el nombre màxim de passos en tot el recorregut.

Exemple 1 :

Tenim un disc de 1.024 passos / tornada muntat en un encoder multi-volta de 4.096 voltes. Quin és el nombre de lectures (passos) total que donarà el encoder?

1.024 x 4.096 = 4.194.304 passos


Exemple 2:

Tenim un disc de 8.192 passos / tornada muntat en un encoder multi-volta de 4.096 voltes. Quin és el nombre de lectures (passos) total que donarà el encoder?

8.192 x 4.096 = 33.554.432 passos

 

Així doncs, sabent les necessitats de resolució que necessitem en una aplicació determinada es pot triar l'encoder amb els passos per volta i el nombre de voltes adequats per obtenir la solució òptima.


Exemple:  
Suposem que anem a controlar la posició d'un eix amb un recorregut útil màxim de 1.000 mm, i volem una resolució i precisió de 0,001 mm (mil·lèsima de mm.).

D'altra banda la relació mecànica entre la rotació de l'eix de l'encoder i el desplaçament lineal de la peça és de 10 voltes de l'eix de l'encoder per cada 2 mil·límetres de desplaçament lineal de la peça mòbil (10 voltes = 2.000 mil·lèsimes)



Així doncs, es dedueix que necessitem un encoder multi-voltes de 4.096 passos / tornada i de més de 5.000 voltes (8.192 voltes) ja que el encoder dóna 5.000 voltes perquè la peça mòbil recorri els 1.000 mm (1m) i com té una resolució de 4.096 lectures per volta, donarà a la fi de l'recorregut:

5.000 voltes x 4.096 passos = 20.480.000 lectures

Per tant, per llegir la posició correcta (1.000.000 mil·lèsimes de mm.) S'ha de realitzar la següent operació:

Si 20.480.000 lectures són  1.000.000 mil·lèsimes de mm
1 lectura serà  X  
 
Així doncs X = 0,0488281

 

Per tant la posició real (PR) de la peça mòbil es calcula:

 PR = Lectura * 0,0488281 mil·lèsimes mm


Aquesta és l'operació que ha de fer l'equip que llegeixi el senyal de l'encoder (autòmat programable, CNC, etc.).

Comprovem, amb un exemple d'una cota, que la resolució que surt és de mil·lèsima de mm:

En un moment determinat, el controlador ha llegit la xifra 12.700.827. Llavors si realitzem la fórmula per calcular la posició real de la Peça Mòbil, tenim:

 
PR = 12.700.827 * 0,0488281 = 620.157,25 mil·lèsimes de mm.


Si menyspreem els decimals (0,25) tindrem, tan sols, un error en la posició de 25  mil·lèsimes de mm.

Encoders, què són i com funciona?




Què és un encoder?

En poques paraules, un encoder és un dispositiu de detecció que proporciona una resposta. Els Encoders converteixen el moviment en un senyal elèctric que pot ser llegida per algun tipus de dispositiu de control en un sistema de control de moviment, com ara un taulell o PLC.


Com funciona un encoder?

Els Encoders utilitzen diferents tipus de tecnologies per crear un senyal, incloent: mecànica, magnètic, òptic i de resistència òptica és la més comuna. En detecció òptica, l'encoder proporciona informació basada en la interrupció de la llum.


Diferencies entre encoders absolut i els encoders incrementals:

Els encoders poden produir senyal ja sigui incrementals o absolutes. Les senyals incrementals no indiquen la posició específica, només que s'ha mogut. Els Encoders absoluts, d'altra banda, utilitzen una "paraula" diferent per a cada posició, el que significa que un encoder absolut proporciona tant la indicació que s'ha mogut i una indicació de la posició absoluta de l'encoder.


Diferents tipus de encoders:

 --> Encoder lineal absolut magnetic






Més informacio:





Encoder rotatiu incremental amb tecnologia òptica.

 



Per controlar el posicionament d'un mòbil en ocasions, a causa de grans velocitats o necessitats de precisió, no n'hi ha prou amb els detectors convencionals, per solucionar aquest problema utilitzarem els Codificadors òptics rotatius.

Un codificador òptic rotatiu, és un captador angular de posició. El seu eix unit mecànicament a un arbre que l'acciona, fa girar a un disc que consta d'una sèrie de zones opaques i transparents. La llum emesa pels díodes electro-luminiscents arriba als foto-diodes cada vegada que travessen una zona transparent de el disc. Els foto-diodes generen un senyal elèctric que s'amplifica i converteix en senyal quadrat abans de transmetre al senyal de tractament.


                         *Representació gir en sentit horari






Més informació:



Activació windows per cmd





Obrir una terminal com administrador i escriure les seguents 3 linies.
Els asteriscos han de ser substituits per la clau depenent del producte que vulguem activar.


slmgr /ipk *****-*****-*****-*****-*****
slmgr /skms kms.digiboy.ir    si no funciona usar ->    kms.msguides.com
slmgr /ato

 
Windows 10 Home: TX9XD-98N7V-6WMQ6-BX7FG-H8Q99
Windows 10 Home N: 3KHY7-WNT83-DGQKR-F7HPR-844BM
Windows 10 Home Single Language: 7HNRX-D7KGG-3K4RQ-4WPJ4-YTDFH
Windows 10 Home Country Specific: PVMJN-6DFY6-9CCP6-7BKTT-D3WVR
Windows 10 Professional: W269N-WFGWX-YVC9B-4J6C9-T83GX
Windows 10 Professional N: MH37W-N47XK-V7XM9-C7227-GCQG9
Windows 10 Enterprise: NPPR9-FWDCX-D2C8J-H872K-2YT43
Windows 10 Enterprise N: DPH2V-TTNVB-4X9Q3-TJR4H-KHJW4
Windows 10 Education: NW6C2-QMPVW-D7KKK-3GKT6-VCFB2
Windows 10 Education N: 2WH4N-8QGBV-H22JP-CT43Q-MDWWJ
Windows 10 Enterprise 2015 LTSB: WNMTR-4C88C-JK8YV-HQ7T2-76DF9
Windows 10 Enterprise 2015 LTSB N: 2F77B-TNFGY-69QQF-B8YKP-D69TJ

dijous, 1 d’abril del 2021

Com trobar el serial key de windows




Utilitzant el powershell de Windows podem escriure la seguent ordre:

powershell "(Get-WmiObject -query ‘select *from SoftwareLicensingService').OA3xOriginalProductKey"


Aquesta mostrara en pantalla el serial d'activacio utilitzat a la maquina.

dimecres, 10 de març del 2021

Cronos




Aquest programa en C ens permet diferents utilitats com a cronometre.
Entre les seves funcions disposa la programacio de un compte enrere per tal de apagar el ordinador a una hora programada.

 
/*

        Cronos es un programa simple que compleix com a conometre d'anar per casa.
        Permet fer un compte atras i tancar el ordinador en el moment programat.
*/

#include <stdio.h>
#include <stdlib.h>
#include <windows.h>
#include <ctype.h>
HANDLE wHnd;


void menu();
int temporitzador(char a);
void cronometro(int thoraint tminuts,int tsegons);
void compenrera(int thoraint tminuts,int tsegons);
void bomba(int thoraint tminuts,int tsegons);
void alarma();
void credits();


int main (){
    credits
    SetConsoleTitle("Cronos V1.3");
    wHnd = GetStdHandle(STD_OUTPUT_HANDLE);
    SMALL_RECT windowSize = {003015};
    SetConsoleWindowInfo(wHnd, 1, &windowSize);
    
    system("color 0A");
    menu();
    atexit(credits);    // Avans de tancar el programa pasarem per la funcio credits.
    return 0;
}

void menu(){

    char a,i;
    
    system("cls");
    printf("##############################\n");
    printf("#       Seleccioneu mode:    #\n");
    printf("##############################\n");
    printf("#                            #\n");
    printf("#    [1] Cronometre          #\n");
    printf("#    [2] Compte enrera       #\n");
    printf("#    [3] Mode bomba          #\n");
    printf("#                            #\n"); 
    printf("#    [0] sortir              #\n");
    printf("#                            #\n");
    printf("##############################\n");
        
    fflush(stdin);
     i = getch();
    
    switch(i){
        case '1': a = 'A';temporitzador(a);break;
        case '2': a = 'B';temporitzador(a);break
        case '3': a = 'C';temporitzador(a);break;
        case '0'break;
        default: menu(); break;
        
    }   
}

int temporitzador(char a){  
    int thora, tminuts, tsegons, maux;
    int x,i;
    char c; 
        
    thora = 0;                                  
    tminuts = 0;                            
    tsegons = 0;
    
    HANDLE hOut;                                    //Controlarem els colors de la consola.
    hOut = GetStdHandle(STD_OUTPUT_HANDLE);
    
    do
        system("cls");
        printf("Cronos V.1 \n\n");
        for (x=1; x<=5;x++){
            for (i=1; i<=30;i++){               
                if((x == 1)||(x ==3)||(x ==5)||(i == 1)||(i == 7)||(x == 12)){
                    printf("#");
                }else if (x ==2 && i == 2){
                    SetConsoleTextAttribute(hOut, FOREGROUND_GREEN | FOREGROUND_BLUE | FOREGROUND_INTENSITY);
                    printf(" [H] [M] [S]");
                    SetConsoleTextAttribute(hOut, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE | FOREGROUND_INTENSITY);
                    printf(" [R]");
                    SetConsoleTextAttribute(hOut, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_INTENSITY);
                    printf("   [i]");
                    SetConsoleTextAttribute(hOut, FOREGROUND_RED | FOREGROUND_INTENSITY);
                    printf(" (P)  ");
                    SetConsoleTextAttribute(hOut, FOREGROUND_GREEN | FOREGROUND_INTENSITY);
                }else if ((x == 4)&&(i == 3)){
                    SetConsoleTextAttribute(hOut, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE | FOREGROUND_INTENSITY);
                    printf(" Temporitzador:  %.2i:%.2i:%.2i   ", thora,tminuts,tsegons);
                    SetConsoleTextAttribute(hOut, FOREGROUND_GREEN | FOREGROUND_INTENSITY);
                }   
            }
        printf("\n");
        }
        
        c = toupper(getch());       // capturem un valor char i el pasem a majuscula. per seguir amb el codic.  
        
        if (c == 'I'){
            SetConsoleTextAttribute(hOut, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_INTENSITY);
            printf("Informacio: \n  - Pulsa H para hores \n  - Pulsa M para min. \n  - Pulsa S para seg.");  
printf("\n  - Pulsa R para reset. \n  - Pulsa P para iniciar \n  - Pulsa ESC para sortir \n"); 
            SetConsoleTextAttribute(hOut, FOREGROUND_GREEN | FOREGROUND_INTENSITY);
            c = toupper(getch());
        }

        switch (c){ 
            case 'H':   printf("Hores  :  ");fflush(stdin);scanf("%i", & maux);thora += maux;break;
            case 'M':   printf("Minuts :  ");fflush(stdin);scanf("%i", & maux);tminuts += maux;break;
            case 'S':   printf("Segons :  ");fflush(stdin);scanf("%i", & maux);tsegons += maux;break;                      
            case 'R':   thora = 0; tminuts = 0; tsegons =  0;break;                                    
            case 'P':   if ( a == 'A'){cronometro(thora,tminuts,tsegons);}  
                        else if( a == 'B'){compenrera(thora,tminuts,tsegons);}
                        else if( a == 'C'){bomba(thora,tminuts,tsegons);}                       
                        break;          
            case 27 :   return 0;break;          
            default :   break;                             
        }
        
        if (tsegons >= 60){
            tminuts += tsegons / 60;
            tsegons = tsegons % 60;
        }
        if (tminuts >= 60){
            thora += tminuts / 60;
            tminuts = tminuts % 60;
        }

    }while(1);   
}

void cronometro(int thoraint tminuts,int tsegons){
    int hora,minuts,segons,x,i;
    
    HANDLE hOut;                                    //Controlarem els colors de la consola.
    hOut = GetStdHandle(STD_OUTPUT_HANDLE);
    
    for( hora = 0; hora < 24; hora++){      
        for( minuts = 0; minuts < 60; minuts++){            
            for ( segons = 0; segons < 60; segons++){
                
                Sleep(1000);
                system("cls");
                printf("##############################\n#");
                
                SetConsoleTextAttribute(hOut, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_INTENSITY);
                    printf("    Alarma:   %.2i:%.2i:%.2i      ", thora,tminuts,tsegons);
                                
                SetConsoleTextAttribute(hOut, FOREGROUND_GREEN | FOREGROUND_INTENSITY);
                    printf("#\n##############################\n#");
                                
                SetConsoleTextAttribute(hOut, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE | FOREGROUND_INTENSITY);
                    printf("    Temps:    %.2i:%.2i:%.2i      ", hora,minuts,segons);
                                                    
                SetConsoleTextAttribute(hOut, FOREGROUND_GREEN | FOREGROUND_INTENSITY);
                    printf("#\n##############################\n");      
            
                if((thora == hora)&&(tminuts == minuts)&&(tsegons == segons))   {alarma();break;}               
                }                           
            if((thora == hora)&&(tminuts == minuts)&&(tsegons == segons))   {alarma();break;}
            }           
        if((thora == hora)&&(tminuts == minuts)&&(tsegons == segons))   {alarma();break;}   
        }
}

void compenrera(int thoraint tminuts,int tsegons){
    
    int hora,minuts,segons,x,i;

    HANDLE hOut;                                    //Controlarem els colors de la consola.
    hOut = GetStdHandle(STD_OUTPUT_HANDLE);

    
    for( hora = thora; hora >= 0; hora--){      
        for( minuts = tminuts; minuts >= 0; minuts--){          
            for ( segons = tsegons; segons >= 0; segons--){
                Sleep(1000);
                
                
                Sleep(1000);
                system("cls");
                printf("CronosV1 \n\n##############################\n#");
                
                    SetConsoleTextAttribute(hOut, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_INTENSITY);
                    printf("    Alarma:   %.2i:%.2i:%.2i      ", hora,minuts,segons);
                    SetConsoleTextAttribute(hOut, FOREGROUND_GREEN | FOREGROUND_INTENSITY);
                
                printf("#\n##############################\n");
                
                if((hora == 0)&&(minuts == 0)&&(segons == 0))   {alarma();break;}               
                }                           
            }               
        }       
}


void bomba(int thoraint tminuts,int tsegons){
//  SHUTDOWN /S /T 10                       en 10 segons windows s'apaga.

int hora,minuts,segons,x,i,pass;

    HANDLE hOut;                                    //Controlarem els colors de la consola.
    hOut = GetStdHandle(STD_OUTPUT_HANDLE);

    system("color 40");
    system("cls");
    printf("CronosV1             DEATH PC\n\n##############################\n#");
    printf("   INTRODUEIX CLAU SEGURETAT:  \n   *:\r pass ");
    scanf("%d",&pass);
    printf("\n");   
        
while( !kbhit(pass) )   {   
    for( hora = thora; hora >= 0; hora--){      
        for( minuts = tminuts; minuts >= 0; minuts--){          
            for ( segons = tsegons; segons >= 0; segons--){
                Sleep(1000);
                
                system("cls");
                printf("CronosV1 \n\n##############################\n#");
                
                    SetConsoleTextAttribute(hOut, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_INTENSITY);
                    printf("    Alarma:   %.2i:%.2i:%.2i      ", hora,minuts,segons);
                    SetConsoleTextAttribute(hOut, FOREGROUND_GREEN | FOREGROUND_INTENSITY);
                
                printf("#\n##############################\n");
                
                if((hora == 0)&&(minuts == 0)&&(segons == 0))   {;break;}               
                }                           
            }               
        }   
    }
}


void alarma(){  
    printf("ALARMA!\n");
    
    /*
    while ( !kbhit() )  {printf("\r\a"); Sleep(1000);}      // ALARMA sonora, pitara cada segon fins que pulsem un boto.
    */

    system("C:\\WINDOWS\\System32\\shutdown /s");       //Apagarem l'ordenador
}

void credits(){
    int i,j;
    
    printf("Emakt 2020 \n");    
    for(i=1;i<=15;i++){
        for (j=1;j<=15;j++){
        
            if          (i==1  && (j==6||j==7||j==8||j==9||j==10))                                          {printf("##");}                     
            else if     (i==2  && (j==4||j==5||j==8||j==11||j==12))                                         {printf("##");}     
            else if     (i==3  && (j==3||j==7||j==9||j==13))                                                {printf("##");}
            else if     (i==4  && (j==2||j==6||j==7||j==9||j==10||j==14))                                   {printf("##");} 
            else if     (i==5  && (j==1||j==2||j==6||j==10||j==14||j==15))                                  {printf("##");} 
            else if     (i==6  && (j==1||j==5||j==11||j==15))                                               {printf("##");} 
            else if     (i==7  && (j==1||j==5||j==11||j==15))                                               {printf("##");} 
            else if     (i==8  && (j==1||j==4||j==5||j==6||j==7||j==8||j==9||j==10||j==11||j==12||j==15))   {printf("##");} 
            else if     (i==9  && (j==1||j==4||j==12||j==15))                                               {printf("##");} 
            else if     (i==10 && (j==1||j==3||j==13||j==15))                                               {printf("##");}
            else if     (i==11 && (j==1||j==2||j==3||j==13||j==14||j==15))                                  {printf("##");} 
            else if     (i==12 && (j==2||j==14))                                                            {printf("##");} 
            else if     (i==13 && (j==3||j==13))                                                            {printf("##");} 
            else if     (i==14 && (j==4||j==5||j==11||j==12))                                               {printf("##");} 
            else if     (i==15 && (j==6||j==7||j==8||j==9||j==10))                                          {printf("##");} 
            else                                                                                            {printf("  ");}             
        }   
        printf("\n");
    }
    printf("                  No copy raid! \n"); 
    Sleep(1000);
}