File content as of revision 0:2f48b11b154f:

#include "mbed.h"
#include "extern.h"

#ifdef SD_CARD
void Sd_System(void){
    
    char buf[BUFSIZE];
    uint16_t FileData[FDATA_NUM]={0}, num, data;
    uint8_t spi_num, h_byte, l_byte;
    uint16_t spi_data;
    int i;
    FILE *fp;
    pc.printf("Hello World!\n");

    mkdir("/sd/mydir", 0777);
    
    while(1){
        
        val = nucleo.receive();
        if(!val) return;
        
        spi_num = device.read();
        h_byte = device.read();
        l_byte = device.read();
        
        if((spi_num&0x80)>>7 == 1){
            
        }
        else{
            
        }
        if(val) {
            
            packet = (front_dis&0x00FF);
            nucleo.reply(packet);
            packet = (front_dis&0xFF00)>>8;
            nucleo.reply(packet);
            packet = (rear_dis&0x00FF);
            nucleo.reply(packet);
            packet = (rear_dis&0xFF00)>>8;
            nucleo.reply(packet);
        }
        // example writing to SD card, sford
        
        fp = fopen("/sd/mydir/sdtest.txt", "r");
        if(fp == NULL) {
            error("Could not open file for read\n");
        }
        while(fgets(buf, sizeof(buf), fp) != NULL){
            if(buf[0] == '#') continue;
            
            num = atol(strtok(buf, ","));
            data = atol(strtok(NULL, "\r\n\0"));
            
            if((num>=0)&&(num<FDATA_NUM)){
                FileData[num] = data;
                pc.printf("%d, %ld\n", num, FileData[num]);
            }
            else{
                continue;
            }
        }
        fclose(fp);
        
        FileData[0] = 1;
        FileData[1] = 2;
        FileData[2] = 5;
        FileData[3] = 10;
        FileData[4] = 20;
        FileData[5] = 50;
        FileData[6] = 10;
        FileData[7] = 20;
        FileData[8] = 50;
        FileData[9] = 100;
        
        fp = fopen("/sd/mydir/sdtest.txt", "w");
        for(i=0; i<FDATA_NUM; i++) fprintf(fp, "%d, %ld\n", i, FileData[i]);
        fclose(fp);
    
        //pc.printf("Goodbye World!\n");
    }
}
#endif /*SD_CARD*/

#ifdef ULTRA_SONIC
void Usw_System(void){
    uint8_t paket, val, order;
    uint16_t front_dis=0, rear_dis=0;
    
    while(1){
        front.Send();
        wait_ms(30);
        front_dis = front.Read_cm();
        
        rear.Send();
        wait_ms(30);
        rear_dis = rear.Read_cm();
        
        while(1){
            val = nucleo.receive();
            if(val){
                order = nucleo.read();
                switch(order){
                    case 0x01:
                        packet = (front_dis&0x00FF);break;
                    case 0x02:
                        packet = (front_dis&0xFF00)>>8;break;
                    case 0x03:
                        packet = (rear_dis&0x00FF);break;
                    case 0x04:
                        packet = (rear_dis&0xFF00)>>8;break;
                    default:
                        packet = 0x00;break;
                }
                nucleo.reply(packet);
            }
            else{
                break;
            }
        }
    }
}
#endif /*ULTRA_SONIC*/

#ifdef COLOR_SENSOR
void Color_System(void){
    
    while(1){
        
        ColorSensor[0]
    }
}
#endif /*COLOR_SENSOR*/

#ifdef IR_SENSOR
void Ir_System(void){
    
    static uint8_t const START_BIT      = 0x04;
    static uint8_t const MODE_SINGLE    = 0x02;    // Single-ended mode
    //static uint8_t const MODE_DIFF      = 0x00;    // Differential mode
    
    static uint8_t const IR_NUM[IC_NUM] = {6, 6, 8};
    
    uint8_t ic, ch;
    unsigned int command_high, command_low;
    unsigned int high_byte, low_byte;
    
    uint8_t packet, val, order;
    
    uint16_t ir_data[IC_NUM][CH_NUM];
    
    ir.frequency(1000000);
    
    for(ic=0; ic<IC_NUM; ic++) cs[ic]=1;
    while(1) {
        for(ic=0; ic<IC_NUM; ic++){//IC
            for(ch=0; ch<IR_NUM[ic]; ch++){//Ch
                command_high = START_BIT | MODE_SINGLE | ((ch & 0x04) >> 2);
                command_low = (ch & 0x03) << 6;
                
                cs[ic] = 0;
                
                ir.write(command_high);
                high_byte = ir.write(command_low) & 0x0F;
                low_byte = ir.write(0);
                
                cs[ic] = 1;
                wait_us(1);
                
                //ir_data[ic][ch] = (high_byte << 8) | low_byte;
               ir_data[ic][ch] = ((high_byte << 4) | (low_byte >> 4))&0xFF;
            }
        }
        while(1){
            val = nucleo.receive();
            if(val){
                order = nucleo.read();
                packet = ir_data[order/10][order%10] & 0x00FF;
                nucleo.reply(packet);
                //for(ic=0; ic<IC_NUM; ic++){//IC
                //    for(ch=0; ch<IR_NUM[ic]; ch++){//Ch
                //        packet = ir_data[ic][ch] & 0x00FF;
                //        nucleo.reply(packet);
                //    }
                //}
            }
            else{
                break;
            }
        }
        
    }
}
#endif /*IR_SENSOR*/