File content as of revision 2:11373e09c930:

#include "mbed.h"
#include "TextLCD.h"
#include <string>
#include "MSCFileSystem.h"

#define FSNAME "msc"

MSCFileSystem msc(FSNAME);

LocalFileSystem local("local");    

int saleBicho;
//definimos la bascula para despues obtener el peso 
Serial serialBascula(p9, p10); //Tx,Rx


//Definimos los LED
DigitalOut ledAux1(p15);
DigitalOut ledAux2(p29);
DigitalOut ledAux3(p30);
DigitalOut ledManual(p16);          //Led de estado manual por defecto apagado
DigitalOut ledEntrada(p17);         //Led de puerta de entrada por defecto apagado
DigitalOut ledSalida(p18);          //Led de puerta de salida
DigitalOut ledIzquierda(p19);       //Led de puerta Izquierda
DigitalOut ledDerecha(p20);         //Led de puerta Derecha

//Definimos las entradas
DigitalIn manual(p21);              //Botón Manual
DigitalIn entrada(p5);              //Botón Entrada
DigitalIn salida(p6);               //Botón Salida
DigitalIn izquierda(p7);            //Botón Izquierda
DigitalIn derecha(p8);              //Botón Derecha
DigitalIn masMax(p22);              //Botón Sumar Peso Max
DigitalIn menosMax(p23);            //Botón Restar Peso Max
DigitalIn masMin(p24);              //Botón Sumar Peso Min
DigitalIn menosMin(p25);            //Botón Restar Peso Min

DigitalIn sensorPiston(p26);        //Sensor Piston
DigitalIn presenciaEntrada(p11);    //Sensor Entrada
DigitalIn presenciaSalida(p12);     //Sensor Salida

//Escribimos en el USB
void escribirUSB(int peso)
{
    FILE *fp = fopen( "/" FSNAME "/basculapesos.txt", "a");
    fprintf(fp, "%d \r\n", peso);
    fclose(fp); 
    }

//Iniciamos los led auxiliares.
void iniciaAux()
{
    ledAux1 = 0;
    ledAux2 = 0;
    ledAux3 = 0;
    }
//leemos de memoria flash la variable del peso minimo de clasificacion.
int leeMinMem()
{
    LocalFileSystem local("local");       // Create the local filesystem under the name "local"
    FILE *fp = fopen("/local/MIN", "r");  // Open "out.txt" on the local file system for writing
    char buffer [10];
    int minim;
    fgets(buffer,10,fp);
    fclose(fp);
    minim=atoi(buffer);
    return minim;
    }

//leemos de memoria flash la variable del peso maximo de clasificacion.
int leeMaxMem()
{
    LocalFileSystem local("local");       // Create the local filesystem under the name "local"
    FILE *fp1 = fopen("/local/MAX", "r");  // Open "out.txt" on the local file system for writing
    char buffer1 [10];
    int max;
    fgets(buffer1,10,fp1);
    fclose(fp1);
    max=atoi(buffer1);
    return max;
    }

//Iniciamos pesos Max y Min
int pesoMax = leeMaxMem();
int pesoMin = leeMinMem();


//Iniciamos I2C Communication
I2C i2c_lcd(p28,p27); // SDA, SCL
TextLCD_I2C lcd(&i2c_lcd, 0x4E, TextLCD::LCD16x2, TextLCD::HD44780); // I2C bus, PCF8574 Slaveaddress, LCD Type, Device Type

//Iniciamos el LCD.
void iniciaLCD()
{
    lcd.setMode(TextLCD::DispOn); //DispOff, DispOn
    lcd.setBacklight(TextLCD::LightOff);//LightOff, LightOn
    lcd.setCursor(TextLCD::CurOff_BlkOff);//CurOff_BlkOff, CurOn_BlkOff, CurOff_BlkOn, CurOn_BlkOn
}

//Pintamos en el LCD linea 1.
void pintaLCD1(bool manual){
    if (manual){
        lcd.locate(0,0);
        lcd.printf("     MANUAL     ");
        }
        else{
            lcd.locate(0,0);
            lcd.printf("Salida1  Salida2");
            }
    }
    
//Pintamos en el LCD linea 2.
void pintaLCD2(){
    lcd.locate(0,1);
    lcd.printf("<%dKg. ", pesoMin);
    lcd.locate(7,1);
    lcd.printf("  >%dKg.", pesoMax);
}

int leerPeso(){
    char buffer1[30];
    string pesoss ="";
    int ipesoss =0;
    serialBascula.printf("2005002D:<CR><LF>\n");   //\r\n   2005002D:<CR><LF>\n
        
    pesoss = serialBascula.gets(buffer1,30);
    if (buffer1[0]=='9'){
        pesoss = pesoss.substr(11,3);
        ipesoss = atoi(pesoss.c_str());
    }   
             
    return ipesoss; 
}

void escribeMaxMem(int i)
{
    LocalFileSystem local("local");       // Create the local filesystem under the name "local"
    FILE *fp = fopen("/local/max", "w");  // Open "out.txt" on the local file system for writing
    char buffer [10];
    sprintf (buffer, "%d", i);
    fprintf(fp, buffer);
    fclose(fp);
    }
    
void escribeMinMem(int i)
{
    LocalFileSystem local("local");       // Create the local filesystem under the name "local"
    FILE *fp = fopen("/local/min", "w");  // Open "out.txt" on the local file system for writing
    char buffer [10];
    sprintf (buffer, "%d", i);
    fprintf(fp, buffer);
    fclose(fp);
    }

void cambioManual()
{
    if (ledManual == 1){
        //reescribimos el dato en MAX y MIN al volver de manual por si se ha cambiado
        escribeMaxMem(pesoMax);
        escribeMinMem(pesoMin);
        ledManual = 0;
        pintaLCD1(0);
        wait(0.50);
    }
    else{
        ledManual = 1;
        pintaLCD1(1);
        wait(0.50);
    }
}

    
//Main, aqui ponemos todo el programa.
int main()
{
    Serial pc(USBTX, USBRX);
    iniciaLCD(); //Iniciamos el LCD
    pintaLCD1(0);
    pintaLCD2();
    int pesoreal;
    //int estaPesado; //si esta pesado 1, si no esta pesado 0 

    while(1) {
        //Modo manual: se pueden cambiar pesos y mover las puertas
        while(ledManual == 1)
        {
            if (manual == 1)
            {
                cambioManual();}
            if (entrada == 1)
            {
                if(ledEntrada == 1)
                    {
                        ledEntrada = 0;
                        wait(0.50);
                        }
                    else
                    {
                        ledEntrada = 1;
                        wait(0.50);
                        }
                }
            if (salida == 1)
            {
                if(ledSalida == 1)
                    {
                        ledSalida = 0;
                        wait(0.50);
                        }
                    else
                    {
                        ledSalida = 1;
                        wait(0.50);
                        }
                }
            if (izquierda == 1)
            {
                ledIzquierda = 1;
                wait(0.50);
                ledIzquierda = 0;
                }
            if (derecha == 1)
            {
                if(ledDerecha == 1)
                    {
                        ledDerecha = 0;
                        wait(0.50);
                        }
                    else
                    {
                        ledDerecha = 1;
                        wait(0.50);
                        }
                }
            if (masMax == 1)
            {
                if (pesoMax < 2000)
                    {
                        pesoMax += 1;
                        wait(0.10);
                        pintaLCD2();
                        }
                }
            if (menosMax == 1)
            {
                    if (pesoMax > (pesoMin + 1))
                        {
                            pesoMax -= 1;
                            wait(0.10);
                            pintaLCD2();
                            }
                }
            if (masMin == 1)
            {   
                if(pesoMin < (pesoMax - 1))
                    {
                        pesoMin += 1;
                        wait(0.10);
                        pintaLCD2();
                        }
                }
            if (menosMin == 1)
                {if(pesoMin > 10)
                    {
                        pesoMin -= 1;
                        wait(0.10);
                        pintaLCD2();
                        }
                }
        }
        //empezamos el programa
        ledEntrada = 1;
        ledSalida = 1;
        ledDerecha = 0;
        ledIzquierda = 0;
        pesoreal = 0;
        saleBicho = 0;
        if (manual == 1){
            cambioManual();
        }
        
        //Bucle de entrada a la báscula y funcionamiento real
        wait(0.2);
        int tiempoSinSensorPiston = 0;
        while(presenciaEntrada == 1 && ledManual == 0){
            ledEntrada = 0;
            //Se Comprueba que el bicho no ha salido para no mover la puerta de salida
            if (saleBicho == 0){
                ledSalida = 0;
            }
            //Se comprueba que no se cambia a manual
            if (manual == 1){cambioManual();}
            wait(1);
            if(sensorPiston == 1){
                //Tiempo a esperar para que la bascula calcule el liveWeitgh
                int tiempoLectura = 0;
                //Bucle de espera para obtener el peso (3,5 s)
                while(tiempoLectura < 40 && ledManual == 0 && presenciaEntrada == 1){
                    wait(0.1);
                    if (manual == 1){cambioManual();}
                        tiempoLectura++;
                }
                if (saleBicho == 0){
                    pesoreal = leerPeso();
                    //estaPesado = 1;
                    wait(0.8);
                }
                //Comprobamos el pero obtenido para clasificar o salir
                if (pesoreal < 50000 && ledManual == 0 && presenciaEntrada == 1){
                    if (pesoreal > pesoMin && saleBicho == 0){
                        ledDerecha = 1;
                        //escribimos el peso real en el USB
                        //escribirUSB(pesoreal);
                        if (pesoreal < pesoMax){
                            ledIzquierda = 1;
                            wait(0.5);
                            ledIzquierda = 0;
                        }
                        wait(0.50);
                    }
                    wait(0.1);
                    if(ledManual == 0){
                        ledSalida = 1;
                    }
                    saleBicho = 1;
                }
            }
            //Else del if del sensor del piston
            else{
                tiempoSinSensorPiston = tiempoSinSensorPiston +1;
                wait(0.5);
                if (tiempoSinSensorPiston > 10){
                    ledEntrada = 1;
                    wait(2);
                }
            }
        }  
    }
}