CodeFese2010#8 โคดโปรแกรม Embed

CodeFese2010#8 โคดโปรแกรม Embed embed.c

#include "stdio.h"
#include "fcntl.h"
#include "getopt.h"
#include "unistd.h"
#include "stdlib.h"
#include "errno.h"
#include "string.h"
#include "sys types.h"
#include "sys stat.h"
#include "24cXX.h"
#include "sys socket.h"
#include "netinet in.h"
#include "netdb.h"
 
#define VERSION     "0.7.6"
#define ENV_DEV        "EEPROG_DEV"
#define ENV_I2C_ADDR    "EEPROG_I2C_ADDR"
 
int g_quiet;
 
#define usage_if(a) do { do_usage_if( a , __LINE__); } while(0);
void do_usage_if(int b, int line)
{
const static char *eeprog_usage =
"eeprog " VERSION ", a 24Cxx EEPROM reader/writer\n"
"Copyright (c) 2003-2004 by Stefano Barbato - All rights reserved.\n"
"Usage: eeprog [-fqxdh] [-16|-8] [ -r addr[:count] | -w addr ]  /dev/i2c-N  i2c-address\n"
"\n"
"  Address modes: \n"
"    -8        Use 8bit address mode for 24c0x...24C16 [default]\n"
"    -16        Use 16bit address mode for 24c32...24C256\n"
"  Actions: \n"
"    -r addr[:count]    Read [count] (1 if omitted) bytes from [addr]\n"
"            and print them to the standard output\n"
"    -w addr        Write input (stdin) at address [addr] of the EEPROM\n"
"    -h        Print this help\n"
"  Options: \n"
"    -x        Set hex output mode\n"
"    -d        Dummy mode, display what *would* have been done\n"
"    -f        Disable warnings and don't ask confirmation\n"
"    -q        Quiet mode\n"
"\n"
"The following environment variables could be set instead of the command\n"
"line arguments:\n"
"    EEPROG_DEV        device name(/dev/i2c-N)\n"
"    EEPROG_I2C_ADDR        i2c-address\n"
"\n"
"    Examples\n"
"    1- read 64 bytes from the EEPROM at address 0x54 on bus 0 starting\n"
"       at address 123 (decimal)\n"
"        eeprog /dev/i2c-0 0x54 -r 123:64\n"
"    2- prints the hex codes of the first 32 bytes read from bus 1 \n"
"       at address 0x22\n"
"        eeprog /dev/i2c-1 0x51 -x -r 0x22:0x20\n"
"    3- write the current timestamp at address 0x200 of the EEPROM on \n"
"       bus 0 at address 0x33 \n"
"        date | eeprog /dev/i2c-0 0x33 -w 0x200\n";
 
    if(!b)
        return;
    fprintf(stderr, "%s\n[line %d]\n", eeprog_usage, line);
    exit(1);
}
 
 
#define die_if(a, msg) do { do_die_if( a , msg, __LINE__); } while(0);
void do_die_if(int b, char* msg, int line)
{
    if(!b)
        return;
    fprintf(stderr, "Error at line %d: %s\n", line, msg);
    //fprintf(stderr, "    sysmsg: %s\n", strerror(errno));
    exit(1);
}
 
#define print_info(args...) do { if(!g_quiet) fprintf(stderr, args); } while(0);
 
void parse_arg(char *arg, int* paddr, int *psize)
{
    char *end;
    *paddr = strtoul(arg, &end, 0);
    if(*end == ':')
        *psize = strtoul(++end, 0, 0);
}
 
int confirm_action()
{
    fprintf(stderr,
    "\n"
    "____________________________WARNING____________________________\n"
    "Erroneously writing to a system EEPROM (like DIMM SPD modules)\n"
    "can break your system.  It will NOT boot anymore so you'll not\n"
    "be able to fix it.\n"
    "\n"
    "Reading from 8bit EEPROMs (like that in your DIMM) without using\n"
    "the -8 switch can also UNEXPECTEDLY write to them, so be sure to\n"
    "use the -8 command param when required.\n"
    "\n"
    "Use -f to disable this warning message\n"
    "\n"
    "Press ENTER to continue or hit CTRL-C to exit\n"
    "\n"
    );
    getchar();
    return 1;
}
 
int read_from_eeprom(struct eeprom *e, int addr, int size, int hex ,int *ar)
{
    int ch, i,arr=0;
    for(i = 0; i < size; ++i, ++addr)
    {
        die_if((ch = eeprom_read_byte(e, addr)) < 0, "read error");
        if(hex)
        {
            if( (i % 16) == 0 )
                printf("\n %.4x|  ", addr);
            else if( (i % 8) == 0 )
                printf("  ");
            
            if(!(i%2==1)){
                ar[arr]= ch;
                arr++;
            }
        } else
            putchar(ch);
    }
    if(hex)
        printf("\n");
    fflush(stdout);
    return 0;
}
 
int write_to_eeprom(struct eeprom *e, int addr)
{
    int c;
    while((c = getchar()) != EOF)
    {
        print_info(".");
        fflush(stdout);
        die_if(eeprom_write_byte(e, addr++, c), "write error");
    }
    print_info("\n");
    return 0;
}
 
int main(int argc, char** argv)
{
    struct eeprom e;
    int ret, op, i2c_addr, memaddr, size, want_hex, dummy, force, sixteen;
    char *device, *arg = 0, *i2c_addr_s;
    struct stat st;
    int eeprom_type = 0;
 
    op = want_hex = dummy = force = sixteen = 0;
    g_quiet = 0;
 
    while((ret = getopt(argc, argv, "1:8fr:qhw:xd")) != -1)
    {
        switch(ret)
        {
        case '1':
            usage_if(*optarg != '6' || strlen(optarg) != 1);
            die_if(eeprom_type, "EEPROM type switch (-8 or -16) used twice");
            eeprom_type = EEPROM_TYPE_16BIT_ADDR;  
            break;
        case 'x':
            want_hex++;
            break;
        case 'd':
            dummy++;
            break;
        case '8':
            die_if(eeprom_type, "EEPROM type switch (-8 or -16) used twice");
            eeprom_type = EEPROM_TYPE_8BIT_ADDR;
            break;
        case 'f':
            force++;
            break;
        case 'q':
            g_quiet++;
            break;
        case 'h':
            usage_if(1);
            break;
        default:
            die_if(op != 0, "Both read and write requested");
            arg = optarg;
            op = ret;
        }
    }
    if(!eeprom_type)
        eeprom_type = EEPROM_TYPE_8BIT_ADDR; // default
 
    usage_if(op == 0); // no switches
    // set device and i2c_addr reading from cmdline or env
    device = i2c_addr_s = 0;
    switch(argc - optind)
    {
    case 0:
        device = getenv(ENV_DEV);
        i2c_addr_s = getenv(ENV_I2C_ADDR);
        break;
    case 1:
        if(stat(argv[optind], &st) != -1)
        {
            device = argv[optind];
            i2c_addr_s = getenv(ENV_I2C_ADDR);
        } else {
            device = getenv(ENV_DEV);
            i2c_addr_s = argv[optind];
        }
        break;
    case 2:
        device = argv[optind++];
        i2c_addr_s = argv[optind];
        break;
    default:
        usage_if(1);
    }
    usage_if(!device || !i2c_addr_s);
    i2c_addr = strtoul(i2c_addr_s, 0, 0);
 
    print_info("eeprog %s, a 24Cxx EEPROM reader/writer\n", VERSION);
    print_info("Copyright (c) 2003-2004 by Stefano Barbato - All rights reserved.\n");
    print_info("  Bus: %s, Address: 0x%x, Mode: %dbit\n",
            device, i2c_addr,
            (eeprom_type == EEPROM_TYPE_8BIT_ADDR ? 8 : 16) );
    if(dummy)
    {
        fprintf(stderr, "Dummy mode selected, nothing done.\n");
        return 0;
    }
    die_if(eeprom_open(device, i2c_addr, eeprom_type, &e) < 0,
            "unable to open eeprom device file "
            "(check that the file exists and that it's readable)");
    switch(op)
    {
    case 'r':
        if(force == 0)
            confirm_action();
        size = 1; // default
        parse_arg(arg, &memaddr, &size);
        print_info("  Reading %d bytes from 0x%x\n", size, memaddr);
        int ar[3],i,j,x[2],y[2],z[2];
        while(1){
            for(i=0;i<2;i++){
                read_from_eeprom(&e, memaddr, size, want_hex,ar);
                    x[i]=ar[0];    y[i]=ar[1];   z[i]=ar[2];
                printf(" P[%d] = %d %d %d",i,x[i],y[i],z[i]);
            }
            printf("\n\n");
            int ac = 15,ac1 = 230;
            if(((abs(z[0]-z[1]) > ac)&&(abs(z[0]-z[1]) < ac 1))||
   ((abs(y[0]-y[1]) > ac)&&(abs(y[0]-y[1]) < ac 1))||
   ((abs(x[0]-x[1])="">ac)&&(abs(x[0]-x[1]) < ac 1))){ 
   if(((z[0]-z[1]="" > ac)&&(z[0]-z[1] < ac 1))){ 
   printf("error="" in="" z="" val="%d" and="" %d="" <-=""> %d.\n",z[0],z[1],abs(z[0]-z[1]));
                SendToServer(z,'Z');
                break;
                }else if (((y[0]-y[1]>ac)&&(y[0]-y[1] < ac 1))){ 
    printf("error="" in="" y="" val="%d" and="" %d="" <-=""> %d.\n",y[0],y[1],abs(y[0]-y[1]));
                  SendToServer(y,'Y');
                }else{
                  printf("Error in X val = %d and %d <-> %d.\n",x[0],x[1],abs(x[0]-x[1]));
                  SendToServer(x,'X');
                break;
                }
             }
        }
 
        break;
    case 'w':
        if(force == 0)
            confirm_action();
        parse_arg(arg, &memaddr, &size);
        print_info("  Writing stdin starting at address 0x%x\n",
            memaddr);
        write_to_eeprom(&e, memaddr);
        break;
    default:
        usage_if(1);
        exit(1);
    }
    eeprom_close(&e);
 
    return 0;
}
 
int SendToServer(int acc[],char ch[]){
    
        int sockfd, portno, n;
            struct sockaddr_in serv_addr;
            struct hostent *server;
 
        char buffer[1024];
        portno = atoi("80");
        sockfd = socket(AF_INET, SOCK_STREAM, 0);
        if (sockfd < 0)
        error("ERROR opening socket");
        server = gethostbyname("192.168.1.9");
        if (server == NULL) {
        fprintf(stderr,"ERROR, no such host\n");
        exit(0);
        }
        bzero((char *) &serv_addr, sizeof(serv_addr));
        serv_addr.sin_family = AF_INET;
        bcopy((char *)server->h_addr,
         (char *)&serv_addr.sin_addr.s_addr,
         server->h_length);
        serv_addr.sin_port = htons(portno);
        if (connect(sockfd,&serv_addr,sizeof(serv_addr)) < 0) {
        error("ERROR connecting");
        }
        bzero(buffer,1024);
           // sprintf(buffer,"GET /g-Box/index.php?act=%c&val=%d HTTP/1.0\n\n",ch,abs(acc[0]-acc[1]));
        sprintf(buffer,"Error in  %c val = %d and %d <-> %d.\n",ch,acc[0],acc[1],abs(acc[0]-acc[1]));
        n = write(sockfd,buffer,strlen(buffer));
        if (n < 0)
         error("ERROR writing to socket");
        bzero(buffer,1024);
        n = read(sockfd,buffer,1024);
        if (n < 0)
         error("ERROR reading from socket");
        printf("%s\n",buffer);
 
return 0;
}
 
int  error(char *msg)
{
    perror(msg);
    exit(0);
return 0;
}