Changeset 1246


Ignore:
Timestamp:
01/16/10 10:58:30 (11 years ago)
Author:
alno
Message:

WebIf:

File:
1 edited

Legend:

Unmodified
Added
Removed
  • branches/monitor-improvement/csctapi/io_serial.c

    r1240 r1246  
    160160{
    161161    IO_Serial *io;
    162    
     162
    163163    io = (IO_Serial *) malloc (sizeof (IO_Serial));
    164    
     164
    165165    if (io != NULL)
    166166        IO_Serial_Clear (io);
    167    
     167
    168168    return io;
    169169}
     
    171171bool IO_Serial_Init (IO_Serial * io, int reader_type)
    172172{
    173     if (reader[ridx].typ != R_INTERNAL)
     173    if (reader[ridx].typ != reader_type)
    174174        IO_Serial_InitPnP (io);
    175    
    176     if(reader[ridx].typ!=R_INTERNAL)
     175
     176    if(reader[ridx].typ != reader_type)
    177177        IO_Serial_Flush();
    178        
     178
    179179    return TRUE;
    180180}
     
    193193    if (io->input_bitrate != 0 && io->output_bitrate != 0) //properties are already filled
    194194      return TRUE;
    195    
     195
    196196    if (tcgetattr (reader[ridx].handle, &currtio) != 0)
    197197        return FALSE;
    198198
    199199    o_speed = cfgetospeed (&currtio);
    200    
     200
    201201    switch (o_speed)
    202202    {
     
    302302
    303303    i_speed = cfgetispeed (&currtio);
    304    
     304
    305305    switch (i_speed)
    306306    {
     
    404404            break;
    405405    }
    406    
     406
    407407    switch (currtio.c_cflag & CSIZE)
    408408    {
     
    420420            break;
    421421    }
    422    
     422
    423423    if (((currtio.c_cflag) & PARENB) == PARENB)
    424424    {
     
    432432        io->parity = PARITY_NONE;
    433433    }
    434    
     434
    435435    if (((currtio.c_cflag) & CSTOPB) == CSTOPB)
    436436        io->stopbits = 2;
    437437    else
    438438        io->stopbits = 1;
    439    
     439
    440440    if (ioctl (reader[ridx].handle, TIOCMGET, &mctl) < 0)
    441441        return FALSE;
    442    
     442
    443443    io->dtr = ((mctl & TIOCM_DTR) ? IO_SERIAL_HIGH : IO_SERIAL_LOW);
    444444    io->rts = ((mctl & TIOCM_RTS) ? IO_SERIAL_HIGH : IO_SERIAL_LOW);
    445    
     445
    446446#ifdef DEBUG_IO
    447447    printf("IO: Getting properties: %ld bps; %d bits/byte; %s parity; %d stopbits; dtr=%d; rts=%d\n", io->input_bitrate, io->bits, io->parity == PARITY_EVEN ? "Even" : io->parity == PARITY_ODD ? "Odd" : "None", io->stopbits, io->dtr, io->rts);
    448448#endif
    449    
     449
    450450    return TRUE;
    451451}
     
    454454{
    455455   struct termios newtio;
    456    
     456
    457457#ifdef SCI_DEV
    458458   if(reader[ridx].typ == R_INTERNAL)
    459459      return FALSE;
    460460#endif
    461    
     461
    462462   //   printf("IO: Setting properties: reader_type%d, %ld bps; %d bits/byte; %s parity; %d stopbits; dtr=%d; rts=%d\n", reader[ridx].typ, io->input_bitrate, io->bits, io->parity == PARITY_EVEN ? "Even" : io->parity == PARITY_ODD ? "Odd" : "None", io->stopbits, io->dtr, io->rts);
    463463   memset (&newtio, 0, sizeof (newtio));
     
    480480    int custom_baud = io->output_bitrate * reader[ridx].mhz / reader[ridx].cardmhz;
    481481    nuts.custom_divisor = (nuts.baud_base + (custom_baud/2))/ custom_baud;
    482     cs_debug("custom baudrate: cardmhz=%d mhz=%d custom_baud=%d baud_base=%d divisor=%d -> effective baudrate %d", 
     482    cs_debug("custom baudrate: cardmhz=%d mhz=%d custom_baud=%d baud_base=%d divisor=%d -> effective baudrate %d",
    483483                          reader[ridx].cardmhz, reader[ridx].mhz, custom_baud, nuts.baud_base, nuts.custom_divisor, nuts.baud_base/nuts.custom_divisor);
    484484    nuts.flags &= ~ASYNC_SPD_MASK;
     
    489489   }
    490490#endif
    491        
     491
    492492   /* Set the character size */
    493493   switch (io->bits)
     
    496496            newtio.c_cflag |= CS5;
    497497            break;
    498        
     498
    499499        case 6:
    500500            newtio.c_cflag |= CS6;
    501501            break;
    502        
     502
    503503        case 7:
    504504            newtio.c_cflag |= CS7;
    505505            break;
    506        
     506
    507507        case 8:
    508508            newtio.c_cflag |= CS8;
    509509            break;
    510510    }
    511    
     511
    512512    /* Set the parity */
    513513    switch (io->parity)
     
    517517            newtio.c_cflag |= PARODD;
    518518            break;
    519        
    520         case PARITY_EVEN:   
     519
     520        case PARITY_EVEN:
    521521            newtio.c_cflag |= PARENB;
    522522            newtio.c_cflag &= ~PARODD;
    523523            break;
    524        
     524
    525525        case PARITY_NONE:
    526526            newtio.c_cflag &= ~PARENB;
    527527            break;
    528528    }
    529    
     529
    530530    /* Set the number of stop bits */
    531531    switch (io->stopbits)
     
    538538            break;
    539539    }
    540    
     540
    541541    /* Selects raw (non-canonical) input and output */
    542542    newtio.c_lflag &= ~(ICANON | ECHO | ECHOE | ISIG);
     
    548548    /* Enable receiber, hang on close, ignore control line */
    549549    newtio.c_cflag |= CREAD | HUPCL | CLOCAL;
    550    
     550
    551551    /* Read 1 byte minimun, no timeout specified */
    552552    newtio.c_cc[VMIN] = 1;
     
    564564    IO_Serial_DTR_RTS(1, io->dtr == IO_SERIAL_HIGH);
    565565    IO_Serial_Ioctl_Lock(0);
    566    
     566
    567567#ifdef DEBUG_IO
    568568    printf("IO: Setting properties: reader_type%d, %ld bps; %d bits/byte; %s parity; %d stopbits; dtr=%d; rts=%d\n", reader[ridx].typ, io->input_bitrate, io->bits, io->parity == PARITY_EVEN ? "Even" : io->parity == PARITY_ODD ? "Odd" : "None", io->stopbits, io->dtr, io->rts);
     
    585585    if (ioctl (reader[ridx].handle, TIOCMGET, &mctl) < 0)
    586586        return FALSE;
    587    
     587
    588588    int dtr = ((mctl & TIOCM_DTR) ? IO_SERIAL_HIGH : IO_SERIAL_LOW);
    589589    int rts = ((mctl & TIOCM_RTS) ? IO_SERIAL_HIGH : IO_SERIAL_LOW);
     
    636636    parity == PARITY_EVEN ? "Even" : "Invalid");
    637637#endif
    638    
     638
    639639    if (current_parity != parity)
    640640    {
     
    647647                tio.c_cflag |= PARODD;
    648648                break;
    649            
    650             case PARITY_EVEN:   
     649
     650            case PARITY_EVEN:
    651651                tio.c_cflag |= PARENB;
    652652                tio.c_cflag &= ~PARODD;
    653653                break;
    654            
     654
    655655            case PARITY_NONE:
    656656                tio.c_cflag &= ~PARENB;
     
    685685    struct timeval tv, tv_spent;
    686686#endif
    687    
     687
    688688    if((reader[ridx].typ != R_INTERNAL) && (wr>0))
    689689    {
     
    691691        int n = wr;
    692692        wr = 0;
    693    
     693
    694694        if(!IO_Serial_Read (timeout, n, buf))
    695695        {
     
    697697        }
    698698    }
    699    
     699
    700700#ifdef DEBUG_IO
    701701    printf ("IO: Receiving: ");
     
    718718        }
    719719        if(!readed) return FALSE;
    720        
     720
    721721        data[_in_echo_read ? count/(1+io_serial_need_dummy_char) : count] = c;
    722722#ifdef DEBUG_IO
     
    736736            }
    737737            data[_in_echo_read ? count/(1+io_serial_need_dummy_char) : count] = c;
    738            
     738
    739739#ifdef DEBUG_IO
    740740            printf ("%X ", c);
     
    753753#endif
    754754    }
    755    
     755
    756756    _in_echo_read = 0;
    757757
     
    760760    fflush (stdout);
    761761#endif
    762    
     762
    763763    return TRUE;
    764764}
     
    773773#ifdef DEBUG_IO
    774774    unsigned i;
    775    
     775
    776776    printf ("IO: Sending: ");
    777777    fflush (stdout);
     
    779779    /* Discard input data from previous commands */
    780780//  tcflush (reader[ridx].handle, TCIFLUSH);
    781    
     781
    782782    for (count = 0; count < size; count += to_send)
    783783    {
     
    786786//      else
    787787            to_send = (delay? 1: size);
    788        
     788
    789789        if (IO_Serial_WaitToWrite (delay, 1000))
    790790        {
     
    807807                return FALSE;
    808808            }
    809            
     809
    810810            if(reader[ridx].typ != R_INTERNAL)
    811811                wr += to_send;
    812            
     812
    813813#ifdef DEBUG_IO
    814814            for (i=0; i<(1+io_serial_need_dummy_char)*to_send; i++)
     
    827827        }
    828828    }
    829    
     829
    830830#ifdef DEBUG_IO
    831831    printf ("\n");
    832832    fflush (stdout);
    833833#endif
    834    
     834
    835835    return TRUE;
    836836}
     
    838838bool IO_Serial_Close (IO_Serial * io)
    839839{
    840    
     840
    841841#ifdef DEBUG_IO
    842842    printf ("IO: Clossing serial port %s\n", reader[ridx].device);
    843843#endif
    844    
     844
    845845#if defined(TUXBOX) && defined(PPC)
    846846    close(fdmc);
     
    848848    if (close (reader[ridx].handle) != 0)
    849849        return FALSE;
    850    
     850
    851851    IO_Serial_Clear (io);
    852    
     852
    853853    return TRUE;
    854854}
     
    927927   int select_ret;
    928928   int in_fd;
    929    
     929
    930930   if (delay_ms > 0)
    931931   {
    932932#ifdef HAVE_NANOSLEEP
    933933      struct timespec req_ts;
    934      
     934
    935935      req_ts.tv_sec = delay_ms / 1000;
    936936      req_ts.tv_nsec = (delay_ms % 1000) * 1000000L;
     
    940940#endif
    941941   }
    942    
     942
    943943   in_fd=reader[ridx].handle;
    944    
     944
    945945   FD_ZERO(&rfds);
    946946   FD_SET(in_fd, &rfds);
    947    
     947
    948948   FD_ZERO(&erfds);
    949949   FD_SET(in_fd, &erfds);
    950    
     950
    951951   tv.tv_sec = timeout_ms/1000;
    952952   tv.tv_usec = (timeout_ms % 1000) * 1000L;
     
    978978   int select_ret;
    979979   int out_fd;
    980    
     980
    981981#ifdef SCI_DEV
    982982   if(reader[ridx].typ == R_INTERNAL)
    983983      return TRUE;
    984984#endif
    985        
     985
    986986   if (delay_ms > 0)
    987987    {
    988988#ifdef HAVE_NANOSLEEP
    989989      struct timespec req_ts;
    990      
     990
    991991      req_ts.tv_sec = delay_ms / 1000;
    992992      req_ts.tv_nsec = (delay_ms % 1000) * 1000000L;
     
    998998
    999999   out_fd=reader[ridx].handle;
    1000    
     1000
    10011001   FD_ZERO(&wfds);
    10021002   FD_SET(out_fd, &wfds);
    1003    
     1003
    10041004   FD_ZERO(&ewfds);
    10051005   FD_SET(out_fd, &ewfds);
    1006    
     1006
    10071007   tv.tv_sec = timeout_ms/1000L;
    10081008   tv.tv_usec = (timeout_ms % 1000) * 1000L;
     
    10271027
    10281028   return(FD_ISSET(out_fd,&wfds));
    1029    
     1029
    10301030}
    10311031
     
    10571057    io->dtr = IO_SERIAL_HIGH;
    10581058    io->rts = IO_SERIAL_LOW;
    1059    
     1059
    10601060    if (!IO_Serial_SetPropertiesOld (io))
    10611061        return FALSE;
     
    10671067        return TRUE;
    10681068}
    1069  
     1069
Note: See TracChangeset for help on using the changeset viewer.