#include <stdio.h>
#include <stdlib.h>
#include <p24FJ64GB002.h>
typedef struct estructura_planta{
char nom[10];
int duracio_etapes[4];
float Kcb[3];
float altura;
float arrels[2];
} cultiu;
struct cultiu cultius[5];
float calcul_kcb_diari(unsigned char dia_any, unsigned char x)
{
int Lprev, Letapa;
float Kcprev, Kcprox;
if (dia_any<= (cultius[1].duracio_etapes[0]))
return(cultius[x].Kcb[0]);
else
if (dia_any<=(cultius[x].duracio_etapes[0]+cultius[x].duracio_etapes[1]))
{
Kcprev=cultius[x].Kcb[0];
Kcprox=cultius[x].Kcb[1];
Lprev=cultius[x].duracio_etapes[0];
Letapa=cultius[x].duracio_etapes[1];
return(Kcprev+((dia_any-Lprev)/Letapa)*(Kcprox-Kcprev));
}
else
if (dia_any<=(cultius[x].duracio_etapes[0]+cultius[x].duracio_etapes[1]+cultius[x].duracio_etapes[2]))
return(cultius[x].Kcb[1]);
else
{
Kcprev=cultius[x].Kcb[1];
Kcprox=cultius[x].Kcb[2];
Lprev=cultius[x].duracio_etapes[0]+cultius[x].duracio_etapes[1]+cultius[x].duracio_etapes[2];
Letapa=cultius[x].duracio_etapes[3];
return(Kcprev+((dia_any-Lprev)/Letapa)*(Kcprox-Kcprev));
}
}
float calcul_etc (float eto)
{
float Kcb, Ke;
Kcb = calcul_kcb_diari();
Ke = calcul_ke_diari();
return(eto*(Kcb+Ke));
}
/*
*
*/
int main(void) {
}
Aún no hace nada pero, como hace mucho tiempo que no programo en C (lo tengo todo muy olvidado) he querido compilar esta parte a ver si daba errores y me da el siguiente:struct cultiu cultius[5];
const cultiu cultius[15] = {
{"Broquil", {35,45,40,15,0,0,0,0}, {0.15,0.95,0.85}, 0.3, {0.2,0.4}},
{"Col", {40,60,50,15,0,0,0,0}, {0.15,0.95,0.85}, 0.4, {0.2,0.5}},
{"Coliflor", {35,50,40,15,0,0,0,0}, {0.15,0.95,0.85}, 0.4, {0.2,0.4}},
{"Enciam", {25,35,30,10,20,30,15,10}, {0.15,0.90,0.90}, 0.3, {0.2,0.3}},
{"Ceba", {20,35,110,45,15,25,70,40}, {0.15,0.95,0.65}, 0.4, {0.2,0.3}},
{"Espinacs", {20,20,25,5,20,20,15,5}, {0.15,0.95,0.85}, 0.3, {0.2,0.3}},
{"Ceba tendre", {0,0,0,0,25,30,10,5}, {0.15,0.90,0.90}, 0.3, {0.2,0.3}},
{"Alberginia", {0,0,0,0,30,40,40,20}, {0.15,1.1,0.7}, 0.8, {0.2,0.7}},
{"Pebrot", {0,0,0,0,25,35,40,20}, {0.15,1.0,0.8}, 0.7, {0.2,0.5}},
{"Tomaquet", {0,0,0,0,30,40,45,30}, {0.15,1.1,0.7}, 0.6, {0.2,0.7}},
{"Carbasso", {0,0,0,0,25,35,25,15}, {0.15,0.9,0.7}, 0.3, {0.2,0.6}},
{"Carabassa", {0,0,0,0,20,30,30,20}, {0.15,0.95,0.70}, 0.4, {0.2,1.0}},
{"Bajoca", {0,0,0,0,20,30,30,10}, {0.15,1.0,0.8}, 0.4, {0.2,0.5}},
{"Fabes", {0,0,0,0,20,30,35,15}, {0.15,1.1,1.05}, 0.8, {0.2,0.5}},
{"Pesols", {0,0,0,0,20,30,35,15}, {0.15,1.1,1.05}, 0.5, {0.2,0.6}}
};Mi duda es si es mejor crear tres arrays de 15 posiciones para guardar estos datos variantes o ponerlos en campos de la estructura principal y no declararla como constante.
No lo tengo muy claro. Las variables const se guardan en la ROM (en mi caso seria en la Fash de programa? O no?
float intro_var_float(float num_max, float num_min, char text[8], float increment)
{
unsigned char buf[5];
float var=0;
escriure_cmd (0x01); //Borrar LCD
escriure_cmd(0x02); //Cursor a l'inici
escriure_txt(text);
sprintf (buf, "%.2f", var);
escriure_txt (buf);
while ((_RB4 == 0)||(var == num_min))
{
if (_RA4 == 1)
{
if (var == num_max)
var = 0;
else
var= var+increment;
escriure_cmd (0x01); //Borrar LCD
escriure_cmd(0x02); //Cursor a l'inici
escriure_txt(text);
sprintf (buf, "%.2f", var);
escriure_txt (buf);
__delay_ms(300);
}
}
__delay_ms(500); //Elimina rebots pulsador
return(var);
}
caudal = calcul_caudal_reg();
float calcul_caudal_reg ()
{
float dist_a=0, dist_b=0, c_goter=0;
escriure_cmd(0x01); //Borrar LCD
escriure_cmd(0x02); //Cursor a l'inici
escriure_txt("Intro caudal goter");
while(_RB4 == 0);
__delay_ms(500);
c_goter = intro_var_float(5, 0, "Cau goter: ", 0.5);
dist_a = intro_var_float(1, 0, "Dist a: ", 0.05);
dist_b = intro_var_float(2, 0, "Dist b: ", 0.05)
return((1/(dist_a*dist_b)*c_goter));
}
En esta parte:
if (_RA4 == 1)
{
if (var == num_max)
var = 0;
else
var= var+increment;
Cambiá if (var == num_max) por if (var >= num_max) y contanos si funciona.
Slds.
En esta parte:
if (_RA4 == 1)
{
if (var == num_max)
var = 0;
else
var= var+increment;
Cambiá if (var == num_max) por if (var >= num_max) y contanos si funciona.
Slds.
Pues así si que funciona más o menos. Me deja subir hasta 2.05 y después vuelve a 0. Es como si no reconociera el valor de var cuando es 2... :shock:
Alguna idea porque pasa eso? No entiendo la diferencia en un float de incrementarlo 0.5 o 0.05 para este caso
Saludos y muchas gracias
typedef struct estructura_planta
{
char nom[12];
int duracio_etapes[8];
float Kcb[3];
float altura;
float arrels[2];
} cultiu;
typedef struct dades_diaries
{
float kcb;
float ke;
float kc;
float Zr;
float AFA;
float ks;
float altura;
}valors_diaris;
typedef struct estructura_terra
{
char nom[17];
float CC;
float PMP;
float AFE;
} terra;
const cultiu cultius[15] = {
{"Broquil", {35,45,40,15,0,0,0,0}, {0.15,0.95,0.85}, 0.3, {0.2,0.4}},
{"Col", {40,60,50,15,0,0,0,0}, {0.15,0.95,0.85}, 0.4, {0.2,0.5}},
{"Coliflor", {35,50,40,15,0,0,0,0}, {0.15,0.95,0.85}, 0.4, {0.2,0.4}},
{"Enciam", {25,35,30,10,20,30,15,10}, {0.15,0.90,0.90}, 0.3, {0.2,0.3}},
{"Ceba", {20,35,110,45,15,25,70,40}, {0.15,0.95,0.65}, 0.4, {0.2,0.3}},
{"Espinacs", {20,20,25,5,20,20,15,5}, {0.15,0.95,0.85}, 0.3, {0.2,0.3}},
{"Ceba tendre", {0,0,0,0,25,30,10,5}, {0.15,0.90,0.90}, 0.3, {0.2,0.3}},
{"Alberginia", {0,0,0,0,30,40,40,20}, {0.15,1.1,0.7}, 0.8, {0.2,0.7}},
{"Pebrot", {0,0,0,0,25,35,40,20}, {0.15,1.0,0.8}, 0.7, {0.2,0.5}},
{"Tomaquet", {0,0,0,0,30,40,45,30}, {0.15,1.1,0.7}, 0.6, {0.2,0.7}},
{"Carbasso", {0,0,0,0,25,35,25,15}, {0.15,0.9,0.7}, 0.3, {0.2,0.6}},
{"Carabassa", {0,0,0,0,20,30,30,20}, {0.15,0.95,0.70}, 0.4, {0.2,1.0}},
{"Bajoca", {0,0,0,0,20,30,30,10}, {0.15,1.0,0.8}, 0.4, {0.2,0.5}},
{"Fabes", {0,0,0,0,20,30,35,15}, {0.15,1.1,1.05}, 0.8, {0.2,0.5}},
{"Pesols", {0,0,0,0,20,30,35,15}, {0.15,1.1,1.05}, 0.5, {0.2,0.6}}
};
const terra terres[9] = {
{"Arenos", 0.12, 0.045, 4.5},
{"Arenofranca", 0.15, 0.065, 6},
{"Franca-Arenosa", 0.23, 0.11, 8},
{"Franca", 0.25, 0.12, 9},
{"Franca llimosa", 0.29, 0.15, 9.5},
{"Llimosa", 0.32, 0.17, 9.5},
{"F-Argil-Llimosa", 0.33, 0.20, 9.5},
{"Argilosa-Llimosa",0.36, 0.23, 10},
{"Argilosa", 0.36, 0.22, 10},
};
const float PI=3.1415392653;
unsigned char tipus_terra[12], cultivat[15], superficie[15];
valors_diaris diari[15];
Proba lo siguiente:
Prototipá las variables globales dentro de los archivos .c que las utilizan, así:
extern const cultiu cultius[15];
extern const terra terres[9];
extern const float PI=3.1415392653;
etcétera, etcétera... Así no hará falta declararlas antes de las directivas #include en el .c principal. Eso sí, van después.
Igual lo que estás haciendo de usar variables globales es bastante feíto. No está prohibido, pero no es recomendable.
De hecho lo que hacés de dividir el código en varios .c es correcto; pero la principal razón de esto es la reusabilidad del código. Pero cuando quieras reutilizar ese archivo .c en el futuro, a modo de librería, no te va a servir porque usa variables globales que no están declaradas en el mismo, y te vas a tener que poner a trabajar de nuevo.
Lo correcto es pasar todo como parámetro (esos parámetros normalemente van declarados en un propotitpo de la función llamada en un archivo .h que acompaña al .c; lo que se llama interfaz de la librería). Si los structs pasados son grandes (por ejemplo tablas de datos), conviene pasarlos mediante un puntero, para no cargar tanto la pila. Y si la función llamada no los tiene que modificar el puntero para pasarlos tiene que ser "a constante".
Te dejo para leer:
https://es.wikipedia.org/wiki/Variable_externa (modificador extern)
http://stackoverflow.com/a/13555817 (paso de structs por valor y referencia)
http://stackoverflow.com/a/8728992 (compilar múltiples .c, usando cabeceras .h)
http://www.learncpp.com/cpp-tutorial/610-pointers-and-const/ (punteros a constantes)
Espero sirva. Slds.
PD: Supongo que esos nombres están en catalán. Mi mamá y mis tías todavía lo hablan, y me enseñaron algunos versitos de chico.