703 lines
16 KiB
C
Executable File
703 lines
16 KiB
C
Executable File
/*****************************************************************/
|
|
/* */
|
|
/* CASIO fx-9860G SDK Library */
|
|
/* */
|
|
/* File name : [ProjectName].c */
|
|
/* */
|
|
/* Copyright (c) 2006 CASIO COMPUTER CO., LTD. */
|
|
/* */
|
|
/*****************************************************************/
|
|
#include "periodiq.h"
|
|
|
|
#include "display.h"
|
|
#include "stdlib.h"
|
|
#include "stdio.h"
|
|
#include "ctype.h"
|
|
#include "keyboard.h"
|
|
#include "tales.h"
|
|
|
|
|
|
//#include <stdlib.h>
|
|
//#include <ctype.h>
|
|
|
|
int atoi(const char *str)
|
|
{
|
|
// Variables declaration.
|
|
int n=0, sign=1;
|
|
|
|
// Parsing string until the first glyph.
|
|
while(isspace(*str)) str++;
|
|
|
|
// Checking sign.
|
|
if(*str=='-') sign=-1, str++;
|
|
else if(*str=='+') sign=+1, str++;
|
|
|
|
// Reading digits.
|
|
while(isdigit(*str))
|
|
{
|
|
n += *str - '0';
|
|
if(*++str) n *= 10;
|
|
}
|
|
|
|
// Returning the final value.
|
|
return n*sign;
|
|
}
|
|
|
|
// element family
|
|
static const char *family[25] ={
|
|
"non metaux", // 0
|
|
"halogene", // 1
|
|
"gaz rare", // 2
|
|
"metalloide", // 3
|
|
"metal alcalin", // 4
|
|
"metal alcalino terreux", // 5
|
|
"lanthanide", // 6
|
|
"actinide", // 7
|
|
"metal de transition", // 8
|
|
"post transition metal"// 9
|
|
};
|
|
|
|
// state element
|
|
static const char *etat[9]={
|
|
"solide", // 0
|
|
"gaz", // 1
|
|
"liquide", // 2
|
|
"inconnu", // 3
|
|
};
|
|
|
|
extern font_t modern;
|
|
extern image_t tableauMini;
|
|
|
|
#define floor(x) ((int)(x))
|
|
|
|
|
|
/* returns element number (1-118) or 0 if there is nothing at the given cell */
|
|
/* x and y can hold any value, even if it's outside the table */
|
|
|
|
|
|
int element_at(int x, int y)
|
|
{
|
|
static const int counts[] = { 2, 8, 8, 18, 18, 32, 32 };
|
|
static const int firsts[] = { 1, 2, 2, 3, 3, 18, 18 };
|
|
|
|
int result = 0;
|
|
|
|
if(x < 0 || x > 17 || y < 0 || y > 8 ) return 0;
|
|
|
|
if(y >= 7)
|
|
{
|
|
if(x < 3 || x > 17) return 0;
|
|
return ( y == 7 ? 57 : 89 ) + x - 3;
|
|
}
|
|
else if(y >= 5)
|
|
{
|
|
if(x >= 3) result += 14;
|
|
}
|
|
|
|
if(x >= firsts[y])
|
|
{
|
|
if(x + (counts[y] - firsts[y]) < 18) return 0;
|
|
else x -= (18 - counts[y]);
|
|
}
|
|
|
|
while(y--)
|
|
{
|
|
result += counts[y];
|
|
}
|
|
|
|
return result + x + 1 ;
|
|
}
|
|
|
|
/* updates x and y if there is an element if the requested direction */
|
|
/* in this case, returns the element's number; otherwise returns 0 */
|
|
int move(int *x, int *y, enum { up = 0, right, down, left } dir)
|
|
{
|
|
int dx[] = { 0, 1, 0, -1 };
|
|
int dy[] = { -1, 0, 1, 0 };
|
|
|
|
int elt = element_at(*x + dx[dir], *y + dy[dir]);
|
|
if(elt) *x += dx[dir], *y += dy[dir];
|
|
return elt;
|
|
}
|
|
|
|
int main()
|
|
{
|
|
tableauElement(0);
|
|
return 1;
|
|
}
|
|
|
|
void Mini(char* chaine, int n ) // fonc defini le numero de la fonction
|
|
{
|
|
|
|
short j;
|
|
dtext(n*21+strlen(chaine), 58, chaine);
|
|
|
|
drect(n*21+2, 56, n*21+20, 63, color_invert);
|
|
|
|
//ML_display_vram();
|
|
}
|
|
|
|
int tableauElement(int chang)
|
|
{
|
|
|
|
|
|
short decalx = 0, decaly = 0;
|
|
int test;
|
|
char x = 1, y = 1;
|
|
unsigned char i;
|
|
|
|
|
|
text_configure(&modern, color_black);
|
|
|
|
while(1)
|
|
{
|
|
dclear();
|
|
|
|
for(i = 0; i < 118; i++)
|
|
{
|
|
dtext(13*(elements[i].groupe-1)+decalx+1, 8*( elements[i].famille == 6 || elements[i].famille == 7 ? elements[i].periode + 3 : elements[i].periode) +decaly-6, elements[i].symbol);
|
|
|
|
}
|
|
|
|
// x = elements[chang].groupe;
|
|
// y = ( elements[chang].famille == 6 || elements[chang].famille == 7 ? elements[chang].periode + 3 : elements[chang].periode);
|
|
/* test = element_at(x, y);
|
|
/* dprint(1,1, "(%d,%d) => %d et %s", x,y, test, elements[test-1].symbol);*/
|
|
chang = element_at(x, y);
|
|
|
|
dprint(1,1, "(%d,%d) = %d", x, y, chang);
|
|
|
|
drect(13*x,8*y,13*x+12,8*y+8, color_invert);
|
|
|
|
dupdate();
|
|
|
|
//drect()
|
|
key=getkey();
|
|
|
|
|
|
switch(key)
|
|
{
|
|
case KEY_UP : y--; break;
|
|
case KEY_DOWN : y++; break;
|
|
case KEY_LEFT : x--; break;
|
|
case KEY_RIGHT : x++; break;
|
|
//case KEY_F4 : chang=tableauEleMini(chang); break;
|
|
case KEY_F2 : chang=find(chang); break;
|
|
// case KEY_F3 : calcul_mole(); break;
|
|
|
|
case KEY_F6 : case KEY_EXE : chang=detailsElement(chang - 1); break;
|
|
|
|
case KEY_EXIT : return 1;
|
|
}
|
|
}
|
|
}
|
|
|
|
int tableauEleMini(int chang)
|
|
{
|
|
char buffer[50];
|
|
char y;
|
|
char menu=0;
|
|
char choix=-1;
|
|
|
|
dclear();
|
|
|
|
dimage(0, 0, &tableauMini);
|
|
dupdate();
|
|
getkey();
|
|
/*
|
|
chang=(chang>=118 ? 0 : chang<=-1 ? 117 : chang);
|
|
|
|
y=(chang>55 && chang<71 ? 9 : chang>87 && chang<103 ? 10 : elements[chang].periode);
|
|
|
|
if (chang>55 && chang<71 || chang>87 && chang<103)
|
|
{
|
|
drect(5*elements[chang].groupe-4, 5*y-7, 5*elements[chang].groupe-1, 5*y-4, color_black);
|
|
}
|
|
else
|
|
{
|
|
drect(5*elements[chang].groupe-4, 5*y-4, 5*elements[chang].groupe-1, 5*y-1, color_black);
|
|
}
|
|
|
|
|
|
dtext(110-3*strlen(elements[chang].symbol), 13, elements[chang].symbol);
|
|
|
|
sprintf(buffer, "%d", chang+1); // détail des éléments sur la droite
|
|
dtext(110-2*strlen(buffer), 5, buffer);
|
|
|
|
sprintf(buffer, "%.3f", elements[chang].masse_mol);
|
|
dtext(110-2*strlen(buffer), 23, buffer);
|
|
|
|
|
|
|
|
if(menu==0)
|
|
{
|
|
|
|
Mini("maxi", 0);
|
|
Mini("find", 1);
|
|
Mini("mol", 2);
|
|
|
|
Mini("fami", 4);
|
|
Mini("det", 5);
|
|
|
|
key=getkey();
|
|
|
|
switch(key)
|
|
{
|
|
case KEY_F1 : case KEY_EXIT : return chang;
|
|
case KEY_F2 : chang=find(chang); break;
|
|
case KEY_F3 : calcul_mole(); break;
|
|
|
|
case KEY_F5 : menu=1; break;
|
|
case KEY_F6 : chang=detailsElement(chang); break;
|
|
}
|
|
}
|
|
else if (menu==1)
|
|
{
|
|
Mini("n-me", 0);
|
|
Mini("halo", 1);
|
|
Mini("g-ra", 2);
|
|
Mini("m-ti", 3);
|
|
Mini("m-al", 4);
|
|
Mini(" -->", 5);
|
|
|
|
key=getkey();
|
|
|
|
switch(key)
|
|
{
|
|
case KEY_EXIT : menu=0; choix=-1; break;
|
|
|
|
case KEY_F1 : choix=0; break;
|
|
case KEY_F2 : choix=1; break;
|
|
case KEY_F3 : choix=2; break;
|
|
case KEY_F4 : choix=3; break;
|
|
case KEY_F5 : choix=4; break;
|
|
case KEY_F6 : menu=2; break; // on change dans les 2 menus
|
|
}
|
|
}
|
|
else if (menu==2)
|
|
{
|
|
Mini("m-at", 0);
|
|
Mini("lant", 1);
|
|
Mini("acta", 2);
|
|
Mini("m-tr", 3);
|
|
Mini("p-tr", 4);
|
|
Mini(" -->", 5);
|
|
|
|
key=getkey();
|
|
|
|
switch(key)
|
|
{
|
|
case KEY_EXIT : menu=0; choix=-1;break;
|
|
|
|
case KEY_F1 : choix=5; break;
|
|
case KEY_F2 : choix=6; break;
|
|
case KEY_F3 : choix=7; break;
|
|
case KEY_F4 : choix=8; break;
|
|
case KEY_F5 : choix=9; break;
|
|
case KEY_F6 : menu=1; break; // on change dans les 2 menus
|
|
|
|
}
|
|
}
|
|
|
|
switch(key) // pour les touches principales à chaque fois
|
|
{
|
|
case KEY_LEFT : chang+=1; break;
|
|
case KEY_RIGHT : chang-=1; break;
|
|
case KEY_DOWN : chang=elements[chang].dessous; break;
|
|
case KEY_UP : chang=elements[chang].dessus; break;
|
|
|
|
case KEY_EXE : chang=detailsElement(chang); break;
|
|
|
|
}
|
|
}*/
|
|
}
|
|
|
|
void choix_famille(int choix)
|
|
{
|
|
/*
|
|
char i=0, y;
|
|
|
|
for(i;i<118;++i)
|
|
{
|
|
if (choix==ajout[i].famille)
|
|
{
|
|
y=(i>55 && i<71 ? 9 : i>87 && i<103 ? 10 : elements[i].periode);
|
|
|
|
(i>55 && i<71 || i>87 && i<103 ? ML_bmp_or(select, 5*elements[i].groupe-4, 5*y-7, 4, 4) : ML_bmp_or(select, 5*elements[i].groupe-4, 5*y-4, 4, 4));
|
|
|
|
ML_bmp_or(select, 20, 50, 4, 4);
|
|
dtext(30, 50, family[choix]);
|
|
}
|
|
}*/
|
|
}
|
|
|
|
int detailsElement(int a)
|
|
{
|
|
unsigned char buffer[50];
|
|
unsigned char page = 0;
|
|
unsigned char i, j = 0;
|
|
|
|
|
|
text_configure(&modern, color_black);
|
|
|
|
while (1)
|
|
{
|
|
dclear();
|
|
|
|
dprint(20, 2, "%s", elements[a].symbol);
|
|
dprint(40, 2, "%s", elements[a].nom);
|
|
dprint((10-a/25), 4, "%d", a+1);
|
|
dline(0, 10, 128, 10, color_black);
|
|
|
|
dline(127, 22*page + 12, 127, 22*page + 42, color_black);
|
|
|
|
switch(page)
|
|
{
|
|
case 0 :
|
|
{
|
|
dprint(1, 12, "masse molaire %d.%03d g/mol", elements[a].masse_mol/1000, elements[a].masse_mol % 1000);
|
|
|
|
dprint(20, 22, "propriete de base");
|
|
|
|
sprintf(buffer, "groupe : %d ", elements[a].groupe);
|
|
|
|
if(elements[a].famille==6 || elements[a].famille==7)
|
|
{
|
|
sprintf(buffer, "groupe inconnu");
|
|
}
|
|
|
|
dtext(1, 32, buffer);
|
|
|
|
sprintf(buffer, "periode : %d ", elements[a].periode);
|
|
dtext(1, 42, buffer);
|
|
|
|
j=0;
|
|
|
|
for(i = 0; i < strlen(elements[a].config_electro); i++)
|
|
{
|
|
if(elements[a].config_electro[i]>=10)
|
|
{
|
|
buffer[j++] = (int)elements[a].config_electro[i]/10 + '0';
|
|
buffer[j++] = elements[a].config_electro[i]%10 + '0';
|
|
}
|
|
else
|
|
{
|
|
buffer[j++] = elements[a].config_electro[i] + '0';
|
|
}
|
|
|
|
buffer[j++] = '-';
|
|
}
|
|
|
|
j--;
|
|
|
|
buffer[j]=0;
|
|
|
|
sprintf(buffer, "couch electro %s", buffer);
|
|
dtext(1, 52, buffer);
|
|
|
|
break;
|
|
}
|
|
|
|
case 1 :
|
|
{
|
|
dprint(1, 12, "famille %s", family[elements[a].famille]);
|
|
|
|
dprint(1, 22, "etat a 293.15 K : %s", etat[elements[a].etat]);
|
|
|
|
dtext(20, 32, "reactivite :");
|
|
|
|
if (elements[a].electro_neg == -1)
|
|
{
|
|
sprintf(buffer, "electro neg inconnue");
|
|
}
|
|
else
|
|
{
|
|
sprintf(buffer, "electro neg : %d.%02d ", elements[a].electro_neg/100, elements[a].electro_neg%100);
|
|
}
|
|
|
|
dtext(1, 42, buffer);
|
|
|
|
if (elements[a].valence == -1)
|
|
{
|
|
sprintf(buffer, "valence inconnue ");
|
|
}
|
|
else
|
|
{
|
|
sprintf(buffer, "valence : %d", elements[a].valence);
|
|
}
|
|
dtext(1, 52, buffer);
|
|
|
|
break;
|
|
}
|
|
}
|
|
|
|
Mini("ret", 5);
|
|
|
|
dupdate();
|
|
|
|
key=getkey();
|
|
|
|
switch (key)
|
|
{
|
|
case KEY_LEFT : a-=1; break;
|
|
case KEY_RIGHT : a+=1; break;
|
|
case KEY_DOWN : page = (page <= 1 ? 1 : page + 1); break;
|
|
case KEY_UP : page = (page >=0 ? 0 : page - 1); break;
|
|
case KEY_F6 : case KEY_EXE : case KEY_EXIT : return a;
|
|
}
|
|
|
|
a=(a<0 ? 117 : a>117 ? 0 : a);
|
|
}
|
|
}
|
|
|
|
unsigned char* input(unsigned char* ask, unsigned char size, unsigned char* char_allowed)
|
|
{
|
|
unsigned char buffer[50];
|
|
unsigned char j,i;
|
|
|
|
j=0;
|
|
|
|
while(1)
|
|
{
|
|
dclear();
|
|
|
|
dtext(1, 1, ask);
|
|
dtext(1, 20, buffer);
|
|
|
|
dupdate();
|
|
|
|
key=getkey();
|
|
|
|
for(i = 0; i < strlen(char_allowed); i++)
|
|
{
|
|
if(char_allowed[i] == key_char(key) && j < size)
|
|
{
|
|
buffer[j++] = key_char(key);
|
|
buffer[j] = 0;
|
|
}
|
|
}
|
|
|
|
switch(key)
|
|
{
|
|
case KEY_DEL :
|
|
{
|
|
j--;
|
|
buffer[j] = 0;
|
|
break;
|
|
}
|
|
case KEY_EXE :
|
|
{
|
|
return buffer;
|
|
}
|
|
case KEY_EXIT :
|
|
{
|
|
return NULL;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
int find(chang)
|
|
{
|
|
|
|
char *numero=NULL;
|
|
|
|
char i=0, j=0;
|
|
|
|
unsigned char buffer[50];
|
|
|
|
text_configure(&modern, color_black);
|
|
|
|
dclear();
|
|
dtext(10, 1, "Vous cherchez :");
|
|
dtext(10, 15, "1. numero de l'element");
|
|
dtext(10, 25, "2. masse molaire");
|
|
dtext(10, 35, "3. Symbole de l'element");
|
|
dtext(10, 45, "4. Nom de l'element");
|
|
dupdate();
|
|
|
|
/*while (1)
|
|
{
|
|
|
|
key=getkey();
|
|
|
|
switch(key)
|
|
{
|
|
case KEY_1 :
|
|
{
|
|
numero=input("Element num :", 3, "0123456789");
|
|
|
|
if (atoi(numero)>0 && atoi(numero)<119)
|
|
{
|
|
return atoi(numero)-1;
|
|
}
|
|
break;
|
|
}
|
|
|
|
case KEY_2 :
|
|
{
|
|
while(1)
|
|
{
|
|
numero=input("Masse molaire de :", 3, "0123456789");
|
|
|
|
for (i=0;i<118;i++)
|
|
{
|
|
if (atoi(numero)==floor(elements[i].masse_mol/1000+0.5))
|
|
{
|
|
return i;
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
/*
|
|
case KEY_3 :
|
|
{
|
|
while(1)
|
|
{
|
|
Bdisp_AllClr_DDVRAM();
|
|
dtext(1, 1, "Vous cherchez le symbole ?", 0);
|
|
|
|
EI_manage_config(EI_SET_START_MODE, EI_ALPHA_LOCKED);
|
|
|
|
numero=EI_input_string(3, (const char*)"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz");
|
|
numero[0]=toupper (numero[0]); // on met le 1er caractère en majuscule
|
|
for (i=0;i<118;i++)
|
|
{
|
|
for (j = 1 ; numero[j] != '\0' ; j++)
|
|
{
|
|
numero[j] = tolower(numero[j]); // on met certains caractères en minuscule pour la recherche
|
|
}
|
|
|
|
if (!strcmp(numero, elements[i].symbol))
|
|
{
|
|
return i;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
case KEY_4 :
|
|
{
|
|
while(1)
|
|
{
|
|
Bdisp_AllClr_DDVRAM();
|
|
dtext(1, 1, "Vous cherchez le nom ?", 0);
|
|
|
|
EI_manage_config(EI_SET_START_MODE, EI_ALPHA_LOCKED);
|
|
|
|
numero=EI_input_string(13, (const char*)"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz");
|
|
numero[0]=toupper(numero[0]); // on met le 1er caractère en majuscule
|
|
for (i=0;i<118;i++)
|
|
{
|
|
for (j = 1 ; numero[j] != '\0' ; j++)
|
|
{
|
|
numero[j] = tolower(numero[j]);// on met certains caractères en minuscule pour la recherche
|
|
}
|
|
|
|
if (!strcmp(numero, elements[i].nom))
|
|
{
|
|
return i;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
case KEY_EXIT : return chang;
|
|
|
|
}
|
|
}*/
|
|
}
|
|
|
|
void calcul_mole()
|
|
{/*
|
|
char *str = NULL, *p=str;
|
|
char characts[20]={'\0'};
|
|
char i=0;
|
|
float result=0, masse;
|
|
const char buffer[50]={0};
|
|
char cap;
|
|
|
|
while(1)
|
|
{
|
|
Bdisp_AllClr_DDVRAM();
|
|
|
|
dtext(1, 1, "Entrez votre formule : ");
|
|
|
|
Mini("A a", 0);
|
|
|
|
EI_init();
|
|
|
|
EI_manage_config(EI_SET_COLUMN, 1);
|
|
EI_manage_config(EI_SET_ROW, 2);
|
|
EI_manage_config(EI_SET_START_MODE, EI_NORMAL);
|
|
|
|
str=EI_input_string(25, (const char*)"0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz");
|
|
|
|
Bdisp_AllClr_DDVRAM();
|
|
|
|
sprintf(buffer, "%s", str);
|
|
PrintXY(64-3*strlen(str), 10, buffer, 36);
|
|
|
|
while(*str) // on va jusqu'a la fin de la chaine
|
|
{
|
|
i=0;
|
|
|
|
while(isalpha(*str)) // on prends seulement les lettres
|
|
{
|
|
characts[i]=tolower(*str); // on copie la lettre en minuscule directement dans characts
|
|
++i;
|
|
++str;
|
|
}
|
|
|
|
characts[0]=toupper(characts[0]); // on met le 1er caractère en majuscule
|
|
|
|
for(i=0;i<118;i++) // on se déplace dans les éléments de la structure
|
|
{
|
|
if(!strcmp(characts, elements[i].symbol))
|
|
{
|
|
masse=elements[i].masse_mol; // on a la masse molaire
|
|
break;
|
|
}
|
|
}
|
|
|
|
for(i=0;i<20;++i) // on remet tout à zéro : évite les erreurs
|
|
characts[i]='\0';
|
|
|
|
i=0;
|
|
|
|
while(isdigit(*str)) // on prends seulement les chiffres
|
|
{
|
|
characts[i]=*str; // on copie la lettre dans characts
|
|
++i;
|
|
++str;
|
|
}
|
|
|
|
result += atoi(characts)*masse;
|
|
|
|
for(i=0;i<4;++i) // on remet tout à zéro : évite les erreurs
|
|
characts[i]='\0';
|
|
}
|
|
|
|
free(p);
|
|
|
|
dtext(1, 30, "la masse molaire est de");
|
|
|
|
sprintf(buffer, "%.3f g/mol", result);
|
|
dtext(1, 40, buffer);
|
|
|
|
Mini("calc", 0);
|
|
Mini("ret", 5);
|
|
|
|
result=0;
|
|
|
|
GetKey(&key);
|
|
|
|
switch(key)
|
|
{
|
|
case 29 : return;
|
|
}
|
|
|
|
}*/
|
|
}
|