git.sesse.net Git - vlc/blob - modules/video_filter/atmo/AtmoSerialConnection.cpp

   1 /*
   2  * AtmoSerialConnection.cpp: Class for communication with the serial hardware of
   3  * Atmo Light, opens and configures the serial port
   4  *
   5  * See the README.txt file for copyright information and how to reach the author(s).
   6  *
   7  * $Id$
   8  */
   9
  10
  11 #include "AtmoDefs.h"
  12 #include "AtmoSerialConnection.h"
  13
  14
  15 #include <stdio.h>
  16 #include <fcntl.h>
  17
  18 #include <sys/stat.h>
  19
  20 #if !defined(WIN32)
  21 #include <termios.h>
  22 #include <unistd.h>
  23 #endif
  24
  25 /*
  26 #include <sys/types.h>
  27 #include <sys/stat.h>
  28 #include <fcntl.h>
  29 #include <string.h>
  30 #include <termios.h>
  31 #include <unistd.h>
  32 #include <vdr/tools.h>
  33 */
  34
  35
  36 CAtmoSerialConnection::CAtmoSerialConnection(CAtmoConfig *cfg) : CAtmoConnection(cfg) {
  37     m_hComport = INVALID_HANDLE_VALUE;
  38 }
  39
  40 CAtmoSerialConnection::~CAtmoSerialConnection() {
  41    CloseConnection();
  42 }
  43
  44 ATMO_BOOL CAtmoSerialConnection::OpenConnection() {
  45 #if defined(_ATMO_VLC_PLUGIN_)
  46      char *serdevice = m_pAtmoConfig->getSerialDevice();
  47      if(!serdevice)
  48         return ATMO_FALSE;
  49 #else
  50      int portNummer = m_pAtmoConfig->getComport();
  51      m_dwLastWin32Error = 0;
  52          if(portNummer < 1) return ATMO_FALSE; // make no real sense;-)
  53 #endif
  54
  55          CloseConnection();
  56
  57 #if !defined(_ATMO_VLC_PLUGIN_)
  58      char comport[16];  // com4294967295
  59      sprintf(comport,"com%d",portNummer);
  60 #endif
  61
  62 #if defined(WIN32)
  63
  64 #  if defined(_ATMO_VLC_PLUGIN_)
  65      m_hComport = CreateFile(serdevice, GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, NULL);
  66 #  else
  67      m_hComport = CreateFile(comport, GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, NULL);
  68 #  endif
  69      if(m_hComport == INVALID_HANDLE_VALUE) {
  70 //      we have a problem here can't open com port... somebody else may use it?
  71 //          m_dwLastWin32Error = GetLastError();
  72             return ATMO_FALSE;
  73      }
  74      /* change serial settings (Speed, stopbits etc.) */
  75      DCB dcb; // für comport-parameter
  76      dcb.DCBlength = sizeof(DCB);
  77      GetCommState (m_hComport, &dcb); // ger current serialport settings
  78      dcb.BaudRate  = 38400;        // set speed
  79      dcb.ByteSize  = 8;            // set databits
  80      dcb.Parity    = NOPARITY;     // set parity
  81      dcb.StopBits  = ONESTOPBIT;   // set one stop bit
  82      SetCommState (m_hComport, &dcb);    // apply settings
  83
  84 #else
  85
  86      int bconst = B38400;
  87 #  if defined(_ATMO_VLC_PLUGIN_)
  88      m_hComport = open(serdevice,O_RDWR |O_NOCTTY);
  89 #  else
  90      m_hComport = open(comport,O_RDWR | O_NOCTTY);
  91 #  endif
  92      if(m_hComport < 0) {
  93             return ATMO_FALSE;
  94      }
  95
  96      struct termios tio;
  97      memset(&tio,0,sizeof(tio));
  98      tio.c_cflag = (CS8 | CREAD | HUPCL | CLOCAL);
  99      tio.c_iflag = (INPCK | BRKINT);
 100      cfsetispeed(&tio, bconst);
 101      cfsetospeed(&tio, bconst);
 102      if(!tcsetattr(m_hComport, TCSANOW, &tio)) {
 103          tcflush(m_hComport, TCIOFLUSH);
 104      } else {
 105          // can't change parms
 106         close(m_hComport);
 107         m_hComport = -1;
 108         return false;
 109      }
 110
 111 #endif
 112
 113      return true;
 114 }
 115
 116 void CAtmoSerialConnection::CloseConnection() {
 117   if(m_hComport!=INVALID_HANDLE_VALUE) {
 118 #if defined(WIN32)
 119      CloseHandle(m_hComport);
 120 #else
 121      close(m_hComport);
 122 #endif
 123          m_hComport = INVALID_HANDLE_VALUE;
 124   }
 125 }
 126
 127 ATMO_BOOL CAtmoSerialConnection::isOpen(void) {
 128          return (m_hComport != INVALID_HANDLE_VALUE);
 129 }
 130
 131 ATMO_BOOL CAtmoSerialConnection::HardwareWhiteAdjust(int global_gamma,
 132                                                      int global_contrast,
 133                                                      int contrast_red,
 134                                                      int contrast_green,
 135                                                      int contrast_blue,
 136                                                      int gamma_red,
 137                                                      int gamma_green,
 138                                                      int gamma_blue,
 139                                                      ATMO_BOOL storeToEeprom) {
 140      if(m_hComport == INVALID_HANDLE_VALUE)
 141             return ATMO_FALSE;
 142
 143      DWORD iBytesWritten;
 144 /*
 145 [0] = 255
 146 [1] = 00
 147 [2] = 00
 148 [3] = 101
 149
 150 [4]  brightness  0..255 ?
 151
 152 [5]  Contrast Red     11 .. 100
 153 [6]  Contrast  Green  11 .. 100
 154 [7]  Contrast  Blue   11 .. 100
 155
 156 [8]   Gamma Red    11 .. 35
 157 [9]   Gamma Red    11 .. 35
 158 [10]  Gamma Red    11 .. 35
 159
 160 [11]  Globale Contrast  11 .. 100
 161
 162 [12]  Store Data: 199 (else 0)
 163
 164 */
 165      unsigned char sendBuffer[16];
 166      sendBuffer[0] = 0xFF;
 167      sendBuffer[1] = 0x00;
 168      sendBuffer[2] = 0x00;
 169      sendBuffer[3] = 101;
 170
 171      sendBuffer[4] = (global_gamma & 255);
 172
 173      sendBuffer[5] = (contrast_red & 255);
 174      sendBuffer[6] = (contrast_green & 255);
 175      sendBuffer[7] = (contrast_blue & 255);
 176
 177      sendBuffer[8]  = (gamma_red & 255);
 178      sendBuffer[9]  = (gamma_green & 255);
 179      sendBuffer[10] = (gamma_blue & 255);
 180
 181      sendBuffer[11] = (global_contrast & 255);
 182
 183      if(storeToEeprom == ATMO_TRUE)
 184         sendBuffer[12] = 199; // store to eeprom!
 185      else
 186         sendBuffer[12] = 0;
 187
 188 #if defined(WIN32)
 189      WriteFile(m_hComport, sendBuffer, 13, &iBytesWritten, NULL); // send to COM-Port
 190 #else
 191      iBytesWritten = write(m_hComport, sendBuffer, 13);
 192      tcdrain(m_hComport);
 193 #endif
 194
 195      return (iBytesWritten == 13) ? ATMO_TRUE : ATMO_FALSE;
 196 }
 197
 198
 199 ATMO_BOOL CAtmoSerialConnection::SendData(tColorPacket data) {
 200    if(m_hComport == INVALID_HANDLE_VALUE)
 201           return ATMO_FALSE;
 202
 203    unsigned char buffer[19];
 204    DWORD iBytesWritten;
 205
 206    buffer[0] = 0xFF;  // Start Byte
 207    buffer[1] = 0x00;  // Start channel 0
 208    buffer[2] = 0x00;  // Start channel 0
 209    buffer[3] = 15; //
 210    int iBuffer = 4;
 211    for(int i=0;i<5;i++) {
 212        if(m_ChannelAssignment[i]>=0) {
 213           buffer[iBuffer++] = data.channel[m_ChannelAssignment[i]].r;
 214           buffer[iBuffer++] = data.channel[m_ChannelAssignment[i]].g;
 215           buffer[iBuffer++] = data.channel[m_ChannelAssignment[i]].b;
 216        } else {
 217           buffer[iBuffer++] = 0;
 218           buffer[iBuffer++] = 0;
 219           buffer[iBuffer++] = 0;
 220        }
 221    }
 222
 223 #if defined(WIN32)
 224    WriteFile(m_hComport, buffer, 19, &iBytesWritten, NULL); // send to COM-Port
 225 #else
 226    iBytesWritten = write(m_hComport, buffer, 19);
 227    tcdrain(m_hComport);
 228 #endif
 229
 230    return (iBytesWritten == 19) ? ATMO_TRUE : ATMO_FALSE;
 231 }
 232
 233 ATMO_BOOL CAtmoSerialConnection::SendData(unsigned char numChannels,
 234                                           int red[],
 235                                           int green[],
 236                                           int blue[])
 237 {
 238    if(m_hComport == INVALID_HANDLE_VALUE)
 239           return ATMO_FALSE;
 240
 241    DWORD bufSize = 4 + numChannels*3;
 242    unsigned char *buffer = new unsigned char[bufSize];
 243    DWORD iBytesWritten;
 244
 245    buffer[0] = 0xFF;  // Start Byte
 246    buffer[1] = 0x00;  // Start Kanal 0
 247    buffer[2] = 0x00;  // Start Kanal 0
 248    buffer[3] = numChannels * 3; //
 249    int iBuffer = 4;
 250    for(int i=0;i<numChannels;i++) {
 251        if(m_ChannelAssignment[i]>=0) {
 252           buffer[iBuffer++] = red[m_ChannelAssignment[i]] & 255;
 253           buffer[iBuffer++] = green[m_ChannelAssignment[i]] & 255;
 254           buffer[iBuffer++] = blue[m_ChannelAssignment[i]] & 255;
 255        } else {
 256           buffer[iBuffer++] = 0;
 257           buffer[iBuffer++] = 0;
 258           buffer[iBuffer++] = 0;
 259        }
 260    }
 261
 262 #if defined(WIN32)
 263    WriteFile(m_hComport, buffer, bufSize, &iBytesWritten, NULL);
 264 #else
 265    iBytesWritten = write(m_hComport, buffer, bufSize);
 266    tcdrain(m_hComport);
 267 #endif
 268
 269    delete buffer;
 270
 271    return (iBytesWritten == bufSize) ? ATMO_TRUE : ATMO_FALSE;
 272 }
 273