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