← Back to branch summary

~ubuntu-branches/ubuntu/saucy/nut/saucy

« back to all changes in this revision

Viewing changes to drivers/esupssmart.c

  • Committer: Bazaar Package Importer
  • Author(s): Reinhard Tartler
  • Date: 2005-07-20 19:48:50 UTC
  • mto: (16.1.1 squeeze)
  • mto: This revision was merged to the branch mainline in revision 4.
  • Revision ID: james.westby@ubuntu.com-20050720194850-oo61wjr33rrx2mre
Tags: upstream-2.0.2
Import upstream version 2.0.2

Show diffs side-by-side

added added

removed removed

Lines of Context:
drivers/esupssmart.c
28
28
 
29
29
 
30
30
#include "main.h"
 
31
#include "serial.h"
31
32
 
32
 
#define UPSDELAY 3
33
 
#define MAXTRIES 10
34
 
#define UPSMFR "Energy Sistem"
 
33
#define UPSDELAY        3
 
34
#define MAXTRIES        10
 
35
#define UPSMFR          "Energy Sistem"
 
36
#define SENDDELAY       100             /* 100 usec between chars on send */
 
37
#define SER_WAIT_SEC    3               /* max 3.0 sec window for reads */
 
38
#define SER_WAIT_USEC   0
35
39
 
36
40
#define UPSTYPE "UPS Smart/Advanced"
37
 
char UPSFIRM[20] = " ";
38
 
int UPSFIRMSET = 0;
 
41
 
 
42
static  char UPSFIRM[20] = " ";
 
43
static  int UPSFIRMSET = 0;
39
44
 
40
45
#define Q1  1
41
46
#define F  2
42
47
 
43
 
#define DRIVERVERSION "0.20"
 
48
#define DRIVERVERSION "0.22"
44
49
 
45
 
int     DEBUG;
46
 
int     type;
47
 
char    strwakedelay[5];
48
 
char    strdelayshut[3];
 
50
static  int     DEBUG;
 
51
static  int     type;
 
52
static  char    strwakedelay[5];
 
53
static  char    strdelayshut[3];
49
54
 
50
55
 
51
56
#define MINVOLTGESSFACT12 0.91667
53
58
#define MAXVOLTGESSFACT12 1.16667
54
59
#define MAXVOLTGESSFACT24 1.14167
55
60
 
56
 
float   minbattvolt = -1;
57
 
float   maxbattvolt = -1;
 
61
static  float   minbattvolt = -1;
 
62
static  float   maxbattvolt = -1;
58
63
 
59
64
 
60
65
/**********************************************************************
63
68
* If the number is out of the range 'min-max' the output string goes to defval
64
69
***********************************************************************/
65
70
 
66
 
void parse_str_num(const char *org, char *dest, int prec, int numdec, float min, float max, float defval) {
 
71
static void parse_str_num(const char *org, char *dest, int prec, 
 
72
        int numdec, float min, float max, float defval) {
67
73
      float num;
68
74
      char myfmtstr[7] = "%04.0f";
69
75
           
77
83
      sprintf(dest,myfmtstr,num);
78
84
}
79
85
 
80
 
void get_battpct(char * org, char * dest, float minv, float maxv) {
 
86
static void get_battpct(char * org, char * dest, float minv, float maxv) {
81
87
   float curvolt;
82
88
   curvolt = atof(org);
83
89
   curvolt = (((curvolt < minv ? minv : curvolt) - minv) / (maxv - minv))*100;
95
101
 * Returns NULL on reaching the end of the string.
96
102
 * 
97
103
 ********************************************************************/
98
 
char *StringSplit( char *source, char *word, int maxlen )
 
104
static char *StringSplit( char *source, char *word, int maxlen )
99
105
{
100
106
    int     i;
101
107
    int     len;
125
131
 * "word" has to be exacly the size of "source".
126
132
 * 
127
133
 ********************************************************************/
128
 
void StringStrip( char *source, char *word )
 
134
static void StringStrip( char *source, char *word )
129
135
{
130
136
    int     wc=0;
131
137
    int     i;
153
159
 * command. Sets the INFO_STATUS value ( OL, OB, ... )
154
160
 * 
155
161
 ********************************************************************/
156
 
void parseFlags( char *flags )
 
162
static void parseFlags( char *flags )
157
163
{
158
164
 
159
165
    status_init();
189
195
 * Also sets various values (IPFreq ... )
190
196
 * 
191
197
 ********************************************************************/
192
 
void query1( char *buf )
 
198
static void query1( char *buf )
193
199
{
194
200
    #define WORDMAXLEN 255
195
201
    char    value[WORDMAXLEN];
267
273
 * On this ups seems to be static data from firmware.
268
274
 * 
269
275
 ********************************************************************/
270
 
void queryF( char *buf )
 
276
static void queryF( char *buf )
271
277
{
272
278
    #define WORDMAXLEN 255
273
279
    char    value[WORDMAXLEN];
356
362
 * 
357
363
 ********************************************************************/
358
364
 
359
 
int ups_ident( int displaymsg )
 
365
static int ups_ident( int displaymsg )
360
366
{
361
367
    char    buf[255];
362
368
    int     ret;
366
372
       fflush(stdout);
367
373
          
368
374
    /* Check presence of Q1 */
369
 
    ret = upssend( "Q1\x0D" );
370
 
    ret = upsrecv( buf, 250, '\x0D', "");
 
375
    ret = ser_send_pace(upsfd, SENDDELAY, "Q1\r");
 
376
 
 
377
    ret = ser_get_line(upsfd, buf, sizeof(buf), '\r', "",
 
378
        SER_WAIT_SEC, SER_WAIT_USEC);
 
379
 
371
380
    ret = strlen( buf );
372
381
    if( ret != 46 ) 
373
382
    {
386
395
    }
387
396
 
388
397
    /* COMANDO F */
389
 
    ret = upssend( "F\x0D" );
390
 
    ret = upsrecv( buf, 250, '\x0D', "");
 
398
    ret = ser_send_pace(upsfd, SENDDELAY, "F\r");
 
399
 
 
400
    ret = ser_get_line(upsfd, buf, sizeof(buf), '\r', "",
 
401
        SER_WAIT_SEC, SER_WAIT_USEC);
 
402
 
391
403
    ret = strlen( buf );
392
404
    if( ret == 21 ) 
393
405
    {
402
414
 
403
415
/*************** instcmd *************************/
404
416
 
405
 
/* void instcmd(int auxcmd, int dlen, char *data) { */
406
 
int instcmd(const char *cmdname, const char *extra) { 
407
 
    char aux[50];
408
 
     aux[0] = '\0';
 
417
static int instcmd(const char *cmdname, const char *extra)
 
418
{
 
419
        int     ret;
 
420
        char    aux[50];
409
421
 
410
422
        if (!strcasecmp(cmdname, "shutdown.stop")) {
411
 
             upssend("C\x0D");
412
 
             upslogx(LOG_INFO,"Cancel shutdown sent to UPS.");
413
 
             return STAT_INSTCMD_HANDLED;
 
423
                ret = ser_send_pace(upsfd, SENDDELAY, "C\r");
 
424
                upslogx(LOG_INFO,"Cancel shutdown sent to UPS.");
 
425
                return STAT_INSTCMD_HANDLED;
414
426
        }     
415
427
 
416
428
        if (!strcasecmp(cmdname, "test.battery.start")) {
417
 
             upssend("T\x0D");
418
 
             upslogx(LOG_INFO,"Start 10 Seconds battery test.");
419
 
             return STAT_INSTCMD_HANDLED;
 
429
                ret = ser_send_pace(upsfd, SENDDELAY, "T\r");
 
430
                upslogx(LOG_INFO,"Start 10 Seconds battery test.");
 
431
                return STAT_INSTCMD_HANDLED;
420
432
        }     
421
433
 
422
434
        if (!strcasecmp(cmdname, "shutdown.return")) {
423
 
             sprintf(aux, "S%sR%s\x0D", strdelayshut, strwakedelay);
424
 
             upssend(aux);
425
 
             upslogx(LOG_INFO,"Sending shutdown command '%s' to UPS", aux);
426
 
             return STAT_INSTCMD_HANDLED;
 
435
                snprintf(aux, sizeof(aux), "S%sR%s\r", 
 
436
                        strdelayshut, strwakedelay);
 
437
                ret = ser_send_pace(upsfd, SENDDELAY, "%s", aux);
 
438
             
 
439
                upslogx(LOG_INFO,"Sending shutdown command '%s' to UPS", aux);
 
440
                return STAT_INSTCMD_HANDLED;
427
441
        }     
428
442
 
429
443
        if (!strcasecmp(cmdname, "shutdown.stayoff")) {
430
 
             sprintf(aux, "S%sR0000\x0D", strdelayshut);
431
 
             upssend(aux);
432
 
             upslogx(LOG_INFO,"Sending shutdown command '%s' to UPS", aux);
433
 
             return STAT_INSTCMD_HANDLED;
 
444
                snprintf(aux, sizeof(aux), "S%sR0000\r", strdelayshut);
 
445
                ret = ser_send_pace(upsfd, SENDDELAY, "%s", aux);
 
446
 
 
447
                upslogx(LOG_INFO,"Sending shutdown command '%s' to UPS", aux);
 
448
                return STAT_INSTCMD_HANDLED;
434
449
        }     
435
450
 
436
451
        if (!strcasecmp(cmdname, "load.off")) {
437
 
             upssend("C\x0D");         
438
 
             upssend("S00R0000\x0D");
439
 
             upslogx(LOG_INFO,"Turning off load on UPS.");
440
 
             return STAT_INSTCMD_HANDLED;
 
452
                ret = ser_send_pace(upsfd, SENDDELAY, "C\r");
 
453
                ret = ser_send_pace(upsfd, SENDDELAY, "S00R0000\r");
 
454
                upslogx(LOG_INFO,"Turning off load on UPS.");
 
455
                return STAT_INSTCMD_HANDLED;
441
456
        }     
442
457
 
443
458
        if (!strcasecmp(cmdname, "load.on")) {
444
 
             upssend("C\x0D");
445
 
             upslogx(LOG_INFO,"Turning on load on UPS.");
446
 
             return STAT_INSTCMD_HANDLED;
 
459
                ret = ser_send_pace(upsfd, SENDDELAY, "C\r");
 
460
                upslogx(LOG_INFO,"Turning on load on UPS.");
 
461
                return STAT_INSTCMD_HANDLED;
447
462
        }     
448
 
        upslogx(LOG_INFO,"Unknown command '%s'", cmdname);   
449
 
        return STAT_INSTCMD_UNKNOWN;         
 
463
 
 
464
        upslogx(LOG_INFO,"Unknown command '%s'", cmdname);   
 
465
        return STAT_INSTCMD_UNKNOWN;         
450
466
}
451
467
 
452
468
 
462
478
 
463
479
}
464
480
 
465
 
/* void ups_set_var(int type, int dlen, char *data) { */
466
 
int ups_set_var(const char* varname, const char *val) {
 
481
static int ups_set_var(const char* varname, const char *val) {
467
482
 
468
483
    
469
484
    /* Note Command for instant shutdown with no restart: S00R0000 */
490
505
 ********************************************************************/
491
506
void upsdrv_initinfo(void)
492
507
{
 
508
    dstate_setinfo("driver.version.internal", "%s", DRIVERVERSION);
 
509
 
493
510
  /* Q1 Query */ 
494
 
    dstate_setinfo( "ups.mfr", UPSMFR); /* INFO_MFR*/
495
 
    dstate_setinfo( "ups.model", UPSTYPE); /*INFO_MODEL*/
496
 
    dstate_setinfo( "ups.firmware", UPSFIRM); /* INFO_FIRMREV */
497
 
    dstate_setinfo( "input.voltage", "220");  /*INFO_UTILITY */  /* Q1 VOLTAJE ENTRADA 0 */
498
 
    dstate_setinfo( "output.voltage.target.line", "220" ); /* INFO_NOM_IN_VOLT*/ /* VOLTAJE A ENTRADA 1 */  
499
 
    dstate_setinfo( "battery.voltage", "12");  /* INFO_BATTVOLT */ /* Q1 VOLTAJE BATERIA(S) 5 */
 
511
    dstate_setinfo( "ups.mfr", "%s", UPSMFR); /* INFO_MFR*/
 
512
    dstate_setinfo( "ups.model", "%s", UPSTYPE); /*INFO_MODEL*/
 
513
    dstate_setinfo( "ups.firmware", "%s", UPSFIRM); /* INFO_FIRMREV */
500
514
/*    dstate_setinfo( INFO_STATUS, "");    DUDA  */
501
 
    dstate_setinfo( "input.frequency", "50");  /* INFO_ACFREQ  */  /* Q1 FRECUENCIA ENTRADA 4 */
502
 
    dstate_setinfo( "ups.load", "0" ); /* INFO_LOADPCT */    /* Q1 CARGA UPS 3 */
503
 
    dstate_setinfo( "ups.temperature", "0");  /* INFO_UPSTEMP */  /* Q1 TEMPERATURA 6 */ 
504
 
    dstate_setinfo( "output.voltage", "220");  /* INFO_OUTVOLT */  /* Q1 VOLTAJE SALIDA 2 */
505
515
  
506
516
  /* F query */
507
517
    dstate_setinfo( "output.voltage.target.battery", "220" ); /* INFO_OUTVLTSEL */ /*  F VOLTAJE NOMINAL DE SALIDA 0 */
508
 
    dstate_setinfo( "output.curent", "0" );   /* INFO_CURRENT */  /*  F AMPERIOS SALIDA  1 */
509
518
    dstate_setinfo( "battery.voltage.nominal", "12"); /* INFO_NOMBATVLT */   /*  F VOLTAJE NOMINAL DE BATERIA 2 */
510
519
 
511
520
    dstate_setinfo( "ups.delay.shutdown", "%s", strdelayshut); /* INFO_DELAYSHUT */
515
524
    dstate_setflags("ups.delay.start", ST_FLAG_RW | ST_FLAG_STRING );
516
525
    dstate_setaux  ("ups.delay.start", 4);
517
526
    
518
 
    dstate_setinfo( "battery.charge", "00");      /* INFO_BATTPCT */
519
527
 
520
528
    dstate_addcmd("shutdown.stop"); /* (INFO_INSTCMD, "", 0, CMD_STOPSHUTD);*/
521
529
    dstate_addcmd("test.battery.start"); /* (INFO_INSTCMD, "", 0, CMD_SHUTDOWN);*/
524
532
    dstate_addcmd("load.off"); /* (INFO_INSTCMD, "", 0, CMD_ON);*/
525
533
    dstate_addcmd("load.on"); /* (INFO_INSTCMD, "", 0, CMD_ON);*/
526
534
 
527
 
    upsh.new_instcmd = instcmd; 
528
 
    upsh.new_setvar = ups_set_var;
 
535
    upsh.instcmd = instcmd; 
 
536
    upsh.setvar = ups_set_var;
529
537
 
530
538
 
531
539
}
554
562
     /* F found ? */
555
563
    if( type & F ) 
556
564
    {
557
 
        upssend( "F\x0D" );
 
565
        ser_send_pace(upsfd, SENDDELAY, "%s", "F\x0D" );
558
566
        sleep( UPSDELAY );
559
567
        buf[0] = '\0';
560
 
        upsrecv( buf, 250, '\x0D', "\n");
 
568
        ser_get_line(upsfd, buf, sizeof(buf), '\r', "\n", 3, 0);
561
569
        ret = strlen( buf );
562
570
        if( ret != 21 ) 
563
571
        {
574
582
    /* Q1 found ? */
575
583
    if( type & Q1 )
576
584
    {
577
 
        upssend( "Q1\x0D" );
 
585
        ser_send_pace(upsfd, SENDDELAY, "%s", "Q1\x0D" );
578
586
        sleep( UPSDELAY );
579
587
        buf[0] = '\0';
580
 
        upsrecv( buf, 250, '\x0D', "\n");
 
588
        ser_get_line(upsfd, buf, sizeof(buf), '\r', "\n", 3, 0);
581
589
        ret = strlen( buf );
582
590
        if( ret != 46 ) 
583
591
        {
607
615
void upsdrv_shutdown(void)
608
616
{
609
617
    upslogx( LOG_INFO, "Sending inmediate shutdown to UPS.");
610
 
    upssend( "C\x0D");
611
 
    upssend( "S00R0001\x0D" );
 
618
    ser_send_pace(upsfd, SENDDELAY, "%s", "C\x0D");
 
619
    ser_send_pace(upsfd, SENDDELAY, "%s", "S00R0001\x0D" );
612
620
}
613
621
 
614
622
/********************************************************************
662
670
    
663
671
    DEBUG = 0;
664
672
        /* setup serial port */
665
 
    upssend_delay = 100; 
666
 
        open_serial( device_path, B2400 );
 
673
    upsfd = ser_open(device_path);
 
674
    ser_set_speed(upsfd, device_path, B2400);
667
675
   
668
676
    
669
677
    strcpy(strwakedelay,"0003");
687
695
    if( ! good )
688
696
    {        
689
697
        printf( "No UPS Smart UPS found!\n" );
690
 
        exit( 1 );
 
698
        exit(EXIT_FAILURE);
691
699
    }
692
700
       
693
701
    printf( "Energy Sistem UPS Smart found\n" );
695
703
    /* Cancel Shutdown */
696
704
    if( getval("CS")) 
697
705
    {
698
 
       upssend( "C\x0D" );
699
 
       exit( 1 );
 
706
       ser_send_pace(upsfd, SENDDELAY, "%s", "C\x0D" );
 
707
       exit(EXIT_FAILURE);
700
708
    }
701
709
    if ( getval("DEBUG")) 
702
710
    {
723
731
}
724
732
 
725
733
/********************************************************************
726
 
 *
727
 
 * tell main how many items in the infostructure are needed.
728
 
 * 
729
 
 ********************************************************************/
730
 
int upsdrv_infomax( void )
731
 
{
732
 
    return 24;
733
 
}
734
 
 
735
 
/********************************************************************
736
734
 * From the masterguard.c Author:
737
735
 *   VIM Preferences.
738
736
 *   As you probably know vim is the best editor ever ;-)
745
743
 
746
744
void upsdrv_cleanup(void)
747
745
{
 
746
        ser_close(upsfd, device_path);
748
747
}