PANEL DE CELULAS FOTOVOLTAICAS

Autor: Diego Espinosa Menca.

Desarrollo del trabajo.1.-Dimensin y constantes del panel de clulas fotovoltaicas.
He planteado una matriz de 6 Filas y 10 Columnas para representar dicho panel.
Estas 6 Filas y 10 Columnas las he declarado como constantes en todo el programa, as como el
Umbral (T) que lo he declarado constante con un valor de 14 y a partir del cual la clula estar
activa o sea produciendo electricidad.
#include <stdio.h>
#include <stdlib.h>
#include <time.h> //para generar nmeros aleatorios
#define F 6

//El panel sera conbstante y tendr 6 filas de clulas

#define C 10 //El panel ser constante y tendr 10 columnas de clulas

#define UMBRAL 14 //valor a partir del cual la clula estar activa

2.-Rellenar matrices con sus valores.

Lo primero que he hecho es inicializar los valores aleatorios con los que voy a rellenar las
matrices con srand(time(NULL) dentro del main.
2.1. He rellenado una primera matriz con valores aleatorios comprendidos entre 3 y 10 que
representan los coeficientes (E) de cada clula fotovoltaica.
void rellenacoeficientes(int m[F][C]){
int i,j;
for(i=0;i<F;i++){
for (j=0;j<C;j++){
m[i][j] = rand() % 8 + 3;
}
}

}
//Muestra la matriz de coeficientes
void matrizcoeficientes(int m[F][C]){
int i,j;
for(i=0;i<F;i++){
for (j=0;j<C;j++){
printf("%d\t",m[i][j]);
}
printf("\n\n");
}
}
2.2. He rellenado as mismo otra matriz con un solo valor aleatorio comprendido entre 1 y 16
para representar la intensidad del Sol (Q) en determinado momento del da.
void rellenamatrizintensidad (int m[F][C]){
int i,j;
int numero;
for(i=0;i<1;i++) {
numero=rand()% 16 + 1;
printf("El valor de la intensidad del Sol es: %d\n",numero);
}
for(i=0;i<F;i++){
for (j=0;j<C;j++){
m[i][j] = numero;
}
}
}
void muestramatrizintensidad (int m[F][C]){
int i,j;

for(i=0;i<F;i++){
for (j=0;j<C;j++){
printf("%d\t",m[i][j]);
}
printf("\n\n");
}

}
2.3. Para obtener una matriz que represente el nivel de activacin de cada clula fotovoltaica
dentro del panel S= (Q+E), he creado una tercera matriz, sumando las dos anteriores y que va a
ser la base con la que se va a desarrollar el programa. En esta matriz se cumplir que siempre
que el nivel de activacin (S) de cada clula sea superior al UMBRAL, la clula producir
electricidad.
void sumar(int a[F][C], int b[F][C], int s[F][C]) {
int i,j;
for(i=0;i<F;i++){
for (j=0;j<C;j++){
s[i][j] = a[i][j] + b[i][j];
}
}
}
void mostrarsuma(int m[F][C]){
int i,j;
printf("Esta es la matriz suma\n\n");
for(i=0;i<F;i++){
for (j=0;j<C;j++){
printf("%d\t",m[i][j]);
}
printf("\n\n");

3.-Solucin del Trabajo.

Este nos plantea 4 posibles alternativas, en las que hay que determinar las clulas que estarn
activas en cada uno de los casos.
3.1.CASO GENERAL.
Que es la solucin de lo anterior o sea ver el nmero de clulas que superan el UMBRAL y que
sern las que estn produciendo electricidad. Este caso general nos servir de base para el
resto de alternativas.
int contarceldas(int m[F][C]){
int resultado=0;
int i,j;
for(i=0;i<F;i++){
for (j=0;j<C;j++){
if (m[i][j]>UMBRAL){
resultado++;
}
}
}
return resultado;
}
3.2.ALTERNATIVA1.
Hacemos una funcin en que si en el panel hay al menos un 50% de clulas fotovoltaicas
produciendo electricidad, todas las clulas del panel se pondrn a producir electricidad.
int alternativa1 (int m[F][C]){
int resultado=0;
int i,j;
for(i=0;i<F;i++){

for (j=0;j<C;j++){
if (m[i][j]>UMBRAL){
resultado++;
}
}
}
if (resultado>=30){
printf("Todas las casillas estaran activas en LA ALTERNATIVA 1");
}
else {
printf("el numero de celdas activas rn la ALTERNATIVA 1 es %d", resultado++);
}
}
3.3.ALTERNATIVA2.
A las clulas que ya estn produciendo electricidad porque su nivel de activacin sea superior
al UMBRAL habr que sumarlas aquellas que no estn activas, pero que estn rodeadas de al
menos 4 clulas activas, escojo un radio 1 alrededor de cada clula y fijo las posiciones de cada
clula vecina como si fuesen los posibles movimientos del Rey en un tablero de ajedrez. Si una
clula no activa no est rodeada de al menos 4 clulas activas, no se activar.
Esta alternativa 3 an la estoy desarrollando.
int alternativa2 (int m[F][C]){
int i,j;
for (i = 0; i < F; i++) {
for (j = 0; j < C; j++) {
//si se encuentra con 1 celda activada al noroeste:
if (m[i][j] <UMBRAL &&(m[i - 1][j- 1] >= UMBRAL)) {

m[i][j] = 0;
m[i - 1][j- 1] = 1;

}
//si se encuentra con 1 celda activada noreste:

if (m[i][j] <UMBRAL && (m[i - 1][j + 1] >= UMBRAL)) {

m[i][j] = 0;
m[i - 1][j + 1] = 1;
}
//si se encuentra con 1 celda activada al suroeste:
if (m[i][j] <UMBRAL && (m[i + 1][j - 1] >= UMBRAL)) {
m[i][j] = 0;
m[i + 1][j - 1] = 1;
}
//si se encuentra con 1 celda activada al sureste:
if (m[i][j] <UMBRAL && (m[i + 1][j + 1] >= UMBRAL)) {
m[i][j] = 0;
m[i + 1][j + 1] = 1;
}
//si se encuentra con 1 celda activada arriba:
if (m[i][j]<UMBRAL && (m[i - 1][j] >= UMBRAL)) {
m[i][j] = 0;
m[i - 1][j] = 1;
}
//si se encuentra con 1 celda activada abajo:
if (m[i][j] <UMBRAL && (m[i + 1][j] >= UMBRAL)) {
m[i][j] = 0;
m[i + 1][j] = 1;
}

//si se encuentra con 1 celda activada a la izquierda:

if (m[i][j]<UMBRAL && (m[i][j - 1] >= UMBRAL)) {
m[i][j] = 0;
m[i][j - 1] = 1;
}
//si se encuentra con 1 celda activada a la derecha:
if (m[i][j]<UMBRAL && (m[i][j + 1] >= UMBRAL)) {
m[i][j] = 0;
m[i][j + 1] = 1;
}
}
}
}
3.4.ALTERNATIVA3.
La intentar desarrollar de modo similar a la alternativa 2, o sea a las clulas que estn
activadas les sumar aquellas que no lo estn, si al menos el 50% de las clulas que se
encuentran situadas en sus diagonales inferiores estn activadas, las posiciones de las clulas
de estas diagonales las fijar como si se tratase del movimiento de un alfil en el tablero de
ajedrez.
Estas funciones han sido declaradas dentro del main.
int main () {
//declaracin de variables

int matriz[F][C];
int matrizintensidad[F][C];
int matrizsuma[F][C];
int numerodeceldas;
int hora = time(NULL);//Inicializa el sistema de nmeros aleatorios
srand(hora);

//rellena la matriz con valores aleatorios de los coeficientes(E)

//Estos valores estarn comprendidos entre 3 y 10.
rellenacoeficientes(matriz);
//muestra la matriz de coeficientes(E)
matrizcoeficientes(matriz);
system("pause");

//Genera un valor aleatorio comprendido entre 1 y 16

//que correspone a la Intensidad del Sol en un momento determinado.

rellenamatrizintensidad(matrizintensidad);
muestramatrizintensidad(matrizintensidad);

system("pause");
sumar(matriz, matrizintensidad, matrizsuma);
mostrarsuma(matrizsuma);
system("pause");
numerodeceldas=contarceldas(matrizsuma);
printf("Hay %d celdas activas en el caso general\n",numerodeceldas);
alternativa1(matrizsuma);
alternativa2(matrizsuma);
}

Dificultades encontradas.He tenido que dedicar muchas horas para completar algunas funciones, estudiando teora y
viendo casos prcticos pues a veces la teora por s sola no me permita implementar
correctamente la funcin como en el caso de generacin de nmeros aleatorios.
Estas dificultades se han visto incrementadas al no poder recibir ayuda de ningn conocido
que tuviese conocimientos de programacin