Esempio n. 1
0
File: ecran.c Progetto: Keynub/psys
void traite_car(char c)
{
    if(c < 32) {
        switch(c) {
            case 8:
	      if(cursor_col!=0){
		place_curseur(cursor_lig, cursor_col-1);
	      }
              break;
            case 9:
	      place_curseur(cursor_lig, (cursor_col!=NB_COL-1)?((cursor_col/8)*8+8):NB_COL-1 );               
	      break;
            case 10:
	      if(cursor_lig+1==NB_LINE){
		defilement();
		place_curseur(NB_LINE-1, 0);
	      }
	      else 
		place_curseur(cursor_lig+1, 0);
              break;
            case 12:
	        efface_ecran();
                break;
            case 13:
	      place_curseur(cursor_lig, 0);
                break;
            default:
                break;
}
    } else {
        ecrit_car(cursor_lig, cursor_col, c);
        step_cursor();
    }
}
Esempio n. 2
0
void kernel_start(void){

	/* Initialisation de l'écran et du curseur */
	efface_ecran();
	place_curseur(0,0);

	/* Initialisation des interruptions */
	masque_IRQ(0, false);
	init_traitant_IT(32, traitant_IT_32);

	/* Initialisation de l'horloge */
	set_clock();

	/* Initialisation des processus */
	
	cree_processus("idle", NULL, ELU);
	cree_processus("proc_proc1", proc1, ACTIVABLE);
	cree_processus("proc_proc2", proc2, ACTIVABLE);
	cree_processus("proc_proc3", proc3, ACTIVABLE);

	processus_elu = tab_processus[0];

	
	/* Démarrage du processus par defaut */
	idle();

 	while(1) {
		hlt();
	}
}
Esempio n. 3
0
File: ecran.c Progetto: Keynub/psys
void efface_ecran()
{
    for(uint8_t i = 0; i < NB_LINE; i++) {
        for(uint8_t j = 0; j < NB_COL; j++) {
            ecrit_car(i, j, ' ');
        }
    }
    place_curseur(0,0);
}
Esempio n. 4
0
File: ecran.c Progetto: Keynub/psys
void step_cursor() {
    cursor_col ++;
    if(cursor_col == 80) {
        cursor_col = 0;
        cursor_lig ++;
        if (cursor_lig == 25) {
            defilement();
            cursor_lig = 24;
        }
    }
    place_curseur(cursor_lig, cursor_col);
}
// afficher l'uptime
void affiche_heure(char *chaine, int32_t taille) {
    // sauvegarde la position du curseur actuel
    uint32_t xligne = ligne;
    uint32_t xcolonne = colonne;
    // l'heure est en haut a droite
    ligne = 0;
    colonne = 80 - strlen(chaine);
    // affiche une chaine qui represente l'uptime
    console_putbytes(chaine, taille);
    // remet le curseur au bon endroit
    ligne = xligne;
    colonne = xcolonne;
    place_curseur(ligne, colonne);
}
Esempio n. 6
0
//affiche les états des processus
void affiche_etats(void)
{
    int i = 0;
    int l = 2;
    uint32_t col = 0;
    uint32_t lig = 0 ;
    get_cursor(&lig, &col);

    while ( i < l )
    {
            place_curseur(i, 60);
            printf("                   ");
            i++;
    }
    afficher_l0_c72(heure);
    i = 0;
    while (i < NB_PROCESSES)
    {
        place_curseur(l, 60);
        if( proc_table[i].state == ENDORMI )
        {
            printf("                   ");
            place_curseur(l, 60);
            printf("%s : ENDORMI", proc_table[i].name);
        }
        else if ( proc_table[i].state == ELU )
        {
            printf("                   ");
            place_curseur(l, 60);
            printf("%s : ELU", proc_table[i].name);
        }
        else if ( proc_table[i].state == MORT )
        {
            printf("                   ");
            place_curseur(l, 60);
            printf("%s : MORT", proc_table[i].name);
        }
        else if ( proc_table[i].state == ACTIVABLE )
        {
            printf("                   ");
            place_curseur(l, 60);
            printf("%s : ACTIVABLE", proc_table[i].name);
        }
        i++;
        l++;
    }
    place_curseur(lig, col);
}
Esempio n. 7
0
void traite_car(char c)
{
	if((int)c < 127)
	{
		int tab_suivante;
		switch((int)c)
		{
			case 8 : 
				if( col_ != 0)
				{
					col_ = col_ - 1 ;
					place_curseur(lig_, col_);
				}
			
				break ;
			case 9 :
				tab_suivante = (int) (col_ / LARGEUR_TAB) + 1 ;
				col_=tab_suivante*LARGEUR_TAB;
				if (col_ >= 80){
					col_=0;
					lig_++;
					if (lig_>=HAUTEUR_ECRAN-1){
						lig_--;
						defilement();
					}
				}
				place_curseur(lig_, col_);
				break ;
			case 10 :
				col_ = 0 ;
				lig_ = lig_ + 1 ;
				if(lig_ >= HAUTEUR_ECRAN-1)
				{
					lig_--;
					defilement();
				}
				place_curseur(lig_, col_);
				break ;
			case 12 : 
				efface_ecran();
				place_curseur(lig_, col_);
				break ;
			case 13 : 
				col_ = 0 ;
				place_curseur(lig_, col_);
				break ;
			default :
				ecrit_car(lig_, col_, c, _color, NOIR, 0);
				col_ ++;
				if(col_ >= 80)
				{
					col_ = 0;
					lig_ ++;
					if(lig_ >= HAUTEUR_ECRAN - 1)
					{
						lig_ -- ;
						defilement();
					}
				}
				place_curseur(lig_, col_);
		}
	}
}
// traiter un caractère donné (c'est à dire qui l'affiche si c'est un caractère normal ou qui implante l'effet voulu si c'est un caractère de contrôle)
void traite_car(char c) {
    // c doit être positif; on ignore tous les caractères >127; on ignore le caractère 127
    c = (int)c;
    if(c < 0 || c > 126) {
        return;
    }
    // get les coordonnées (ligne -> ligne, colonne -> colonne)
    // selon les commandes on change la position du curseur
    if(c < 32) {
        switch(c) {
        case 8: // '\b'
            if(colonne) {
                place_curseur(ligne, --colonne);
            }
            break;
        case 9: // '\t'
            if(colonne < 72) {
                //avance à la prochaine valeur de la chaine 8
                colonne = colonne + (8 - (colonne % 8));
            } else {
                colonne = 79;
            }
            place_curseur(ligne, colonne);
            break;
        case 10: // '\n'
	    colonne = 0;
	    if(ligne + 1 < 25) {
                place_curseur(++ligne, colonne);
	    } else {
	        defilement();
		place_curseur(ligne, colonne);
	    }
	    break;
        case 12: // '\f'
            efface_ecran();
	    ligne = 0;
	    colonne = 0;
            place_curseur(ligne, colonne);
            break;
        case 13: // '\r'
   	    colonne = 0;
            place_curseur(ligne, colonne);
            break;
        default:
            // ignore tous les autres caractères
            break;
        }
    } else {
      // cas standard: ecrit normal d'un caractere (en faisant attention aux contraintes)
      ecrit_car(ligne, colonne, c, VERT);
        if(colonne + 1 < 80) {
	    place_curseur(ligne, ++colonne);
	} else {
	    colonne = 0;
	  if(ligne + 1 < 25) {
	      place_curseur(++ligne, colonne);
	  } else {
	      defilement();
	      place_curseur(ligne, colonne);
	  }
	}
    }
    return;
}