#include "ComPort.h"
#include "Fl/Fl.h"
#include "Fl/Fl_Double_Window.h"
#include "Fl/Fl_Box.h"
#include "Fl/Fl_Input.h"
#include "Fl/Fl_Output.h"
#include "Fl/Fl_Check_Button.h"
#include "Fl/Fl_Chart.h"

#pragma comment(lib,"fltk.lib")

Fl_Input * tx;
Fl_Output * rx;
Fl_Box * rx_bit[8];
Fl_Check_Button * tx_bit[8];
Fl_Chart * chart;
ComPort * port;

void Input_cb(Fl_Widget * w, void *p){
int b = strtol(tx->value(),NULL, 16);
for (int i = 0; i < 8; i++){
tx_bit[i]->value(b & 0x01);
b>>=1;
}
}

void InputBit_cb(Fl_Widget * w, void *p){
int b = 0;
for (int i = 0; i < 8; i++){
b>>=1;
if (tx_bit[i]->value()) b |= 0x80;
}
char str[8];
sprintf_s(str,8,"%02X",;
tx->value(str);
}

void Send_cb(Fl_Widget * w, void *p){
port->Write(0xCA);
int byte = strtol(tx->value(),NULL,16);
port->Write(byte);
}

void Clear_cb(Fl_Widget * w, void *p){
for (int i = 0; i < 8; i++) tx_bit[i]->value(0);
tx->value("");
}

void Timer_cb(void * p){
static char rxBuff [8];
static int rxNum = 0;
static int num = 0;
while (port->Read(&rxBuff[rxNum],1)){
rxNum += 1;
if (rxBuff[0] != 0xCA) rxNum = 0;
if (rxNum >= 3){
int b = rxBuff[3];
for (int i = 0; i < 8; i++){
rx_bit[i]->color((b & 0x01) ? FL_RED : FL_DARK_RED);
b>>=1;
}
chart->replace(num++, ;
if (num >= 256){
for (int i = 0; i < 256; i++) chart->replace(i,0);
num = 0;
}
}
}
Fl::repeat_timeout(0.01, Timer_cb);

// chart test:
static double tmp = 10;
static int n = 0;
chart->replace(n,tmp);
tmp+=tmp*0.01;
n++;
if (n >= 256){
for (int i = 0; i < 256; i++) chart->replace(i,0);
n = 0;
tmp = 10;
}
//
}

int main(){
ComPort p("COM1", 9600);
port = &p;
Fl_Double_Window w(800,600,"test");
rx = new Fl_Output(100,0,200,50,"Rx");
rx->textsize(50);
rx->labelsize(50);

for (int i = 0; i < 8; i++){
rx_bit[i] = new Fl_Box(250 - i*20,100,20,20);
rx_bit[i]->align(FL_ALIGN_TOP);
char str[2] = {i+'0',0};
rx_bit[i]->copy_label(str);
rx_bit[i]->color(FL_RED);
rx_bit[i]->box(FL_BORDER_BOX);
}

tx = new Fl_Input(100,200,200,50,"Tx");
tx->textsize(50);
tx->labelsize(50);
tx->callback(Input_cb);
tx->when(FL_WHEN_CHANGED);
tx->align();
for (int i = 0; i < 8; i++){
tx_bit[i] = new Fl_Check_Button(250 - i*20,300,20,20);
tx_bit[i]->align(FL_ALIGN_TOP);
char str[2] = {i+'0',0};
tx_bit[i]->copy_label(str);
tx_bit[i]->callback(InputBit_cb);
}

Fl_Button * b_send = new Fl_Button(100,400,100,50,"Send");
b_send->callback(Send_cb);
Fl_Button * b_clear = new Fl_Button(200,400,100,50,"Clear");
b_clear->callback(Clear_cb);

chart = new Fl_Chart(350,0,400,400);
chart->type(FL_LINE_CHART);
chart->maxsize(256);
for (int i = 0; i < 256; i++) chart->add(0);
chart->bounds(0,256);

w.end();
w.show();
Fl::add_timeout(0.01, Timer_cb);
return Fl::run();
}

#ifndef __COMPORT_H_
#define __COMPORT_H_

#include <windows.h>

class ComPort{
private:
HANDLE hCom;
int opened;
char * luaBuff;
int lastReadNum;
public:
~ComPort();
ComPort();
ComPort(const char * comPortStr,int speed, int byteSize = 8, int parity = 0, int stopBit = 0);
int Init(const char * comPortStr,int speed, int byteSize = 8, int parity = 0, int stopBit = 0);
int SetBaudRate(int speed);
void Close ();
int Read(char * c,int num);
const char * Read(int num = 1024);
int LastReadNum();
int Status();
int Writef(char * str, ...);
int Write(char *c, int num);
int Write(char *c);
int Write(char c);
int Rts(int level);
int Dtr(int level);
int Cts();
int Dsr();
int Ri();
int Dcd();
void ClearTxBuff();
void ClearRxBuff();
int RxBuffNum();
};

#endif

#include "comPort.h"
#include <stdarg.h>
#include <stdio.h>

void ComPort::ClearTxBuff(){
PurgeComm(hCom,PURGE_TXCLEAR);
}

void ComPort::ClearRxBuff(){
PurgeComm(hCom,PURGE_RXCLEAR);
}

int ComPort::SetBaudRate(int speed){
DCB dcb;
GetCommState( hCom, &dcb );
dcb.BaudRate = speed ;
if ( !SetCommState( hCom, &dcb ) ){
// CloseHandle(hCom);
return 1; //SetCommState error
}
return 0;
}

int ComPort::Status(){
unsigned int stat;
GetCommModemStatus(hCom, (LPDWORD)&stat);
return stat;
}

int ComPort::Cts(){
return Status() & MS_CTS_ON ? 1 : 0;
}

int ComPort::Dsr(){
return Status() & MS_DSR_ON ? 1 : 0;
}

int ComPort::Ri(){
return Status() & MS_RING_ON ? 1 : 0;
}

int ComPort::Dcd(){
return Status() & MS_RLSD_ON ? 1 : 0;
}


int ComPort::Rts(int level){
DCB dcb;
GetCommState( hCom, &dcb );
dcb.fRtsControl = level ? RTS_CONTROL_ENABLE : RTS_CONTROL_DISABLE;
if ( !SetCommState( hCom, &dcb ) ){
// CloseHandle(hCom);
return 1; //SetCommState error
}
return 0;
}

int ComPort::Dtr(int level){
DCB dcb;
GetCommState( hCom, &dcb );
dcb.fDtrControl = level ? DTR_CONTROL_ENABLE : DTR_CONTROL_DISABLE;
if ( !SetCommState( hCom, &dcb ) ){
// CloseHandle(hCom);
return 1; //SetCommState error
}
return 0;
}

ComPort::~ComPort(){
Close();
delete[] luaBuff;
}

ComPort::ComPort(){
lastReadNum = 0;
opened = 0;
luaBuff = new char[2]; luaBuff[0]=0; luaBuff[1]=0;
}

ComPort::ComPort(const char * comPortStr,int speed, int byteSize, int parity, int stopBit){
lastReadNum = 0;
opened = 0;
luaBuff = new char[2]; luaBuff[0]=0; luaBuff[1]=0;
Init(comPortStr,speed,byteSize,parity,stopBit);
}

/* Initialize Communication port */
int ComPort::Init(const char * comPortStr,int speed, int byteSize, int parity, int stopBit){
DCB dcb;

COMMTIMEOUTS CommTimeOuts ;
if ( ( hCom = CreateFile (comPortStr, GENERIC_READ | GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, NULL ) )
== INVALID_HANDLE_VALUE ) {
return 1; // error
}
CommTimeOuts.ReadIntervalTimeout = MAXDWORD;
CommTimeOuts.ReadTotalTimeoutMultiplier = 0;
CommTimeOuts.ReadTotalTimeoutConstant = 0;
CommTimeOuts.WriteTotalTimeoutMultiplier = 0;
CommTimeOuts.WriteTotalTimeoutConstant = 0;

if ( !SetCommTimeouts( hCom, &CommTimeOuts )){
CloseHandle(hCom);
return 2; // SetCommTimeouts error
}

dcb.DCBlength = sizeof ( DCB ) ;
dcb.BaudRate = speed ;
dcb.fBinary = TRUE ;
dcb.fParity = 0;
dcb.fOutxCtsFlow = 0; // CTS output flow control
dcb.fOutxDsrFlow = 0; // DSR output flow control
dcb.fDtrControl = 0;//DTR_CONTROL_ENABLE; // DTR flow control type

dcb.fDsrSensitivity = 0; // DSR sensitivity
dcb.fTXContinueOnXoff = 0; // XOFF continues Tx
dcb.fOutX = 0; // XON/XOFF output flow control
dcb.fInX = 0; // XON/XOFF input flow control

dcb.fErrorChar = 0; // enable error replacement
dcb.fNull = 0; // enable null stripping
dcb.fRtsControl = 0;//RTS_CONTROL_ENABLE; // RTS flow control

dcb.fAbortOnError = 0; // abort reads/writes on error
dcb.XonLim = 0; // transmit XON threshold
dcb.XoffLim = 0; // transmit XOFF threshold
dcb.ByteSize = byteSize; // number of bits/byte, 4-8
dcb.Parity = parity; // 0-4=no,odd,even,mark,space
dcb.StopBits = stopBit; // 0,1,2 = 1, 1.5, 2
dcb.XonChar = 0; // Tx and Rx XON character
dcb.XoffChar = 0; // Tx and Rx XOFF character
dcb.ErrorChar = 0; // error replacement character
dcb.EofChar = 0; // end of input character
dcb.EvtChar = 0; // received event character
if ( !SetCommState( hCom, &dcb ) ){
CloseHandle(hCom);
return 3; //SetCommState error
}
opened = 1;
return(0);
}

/* Close Communication port */
void ComPort::Close (){
if (opened!=1) return;
opened = 0;
CloseHandle( hCom );
}

int ComPort::RxBuffNum(){
COMSTAT stat;
unsigned long err;
ClearCommError(hCom, &err, &stat);
return stat.cbInQue;
}

int ComPort::Read(char * c,int num){
DWORD length = 0;
if( !ReadFile(hCom, c, num, &length, NULL) ) return 0;
return length;
}

const char * ComPort::Read(int num){
delete luaBuff;
luaBuff = new char[num];
memset(luaBuff, 0, num);
lastReadNum = Read(luaBuff, num);
return luaBuff;
}

int ComPort::LastReadNum(){
return lastReadNum;
}

/*
Send a character
*/

int ComPort::Write(char *c, int num){
DWORD length = 0;
WriteFile(hCom, c, num, &length, NULL);
return length;
}

int ComPort::Write(char c){
DWORD length;
return WriteFile(hCom, &c, 1, &length, NULL);
}

int ComPort::Write(char * c){
DWORD length;
int num = 0;
while (c[num]) num += 1;
return WriteFile(hCom, c, num, &length, NULL);
}

int ComPort::Writef(char * str, ...){
char tmpStr[1024];
va_list args;
va_start (args, str);
vsprintf_s (tmpStr, 1024, str, args);
va_end (args);
return Write(tmpStr);
}

void CPultsNamesDlg::fromDatabase()
{
    VERIFY(m_lstPults.DeleteAllItems());

    CAbonentsBriefVo vo(lConnection.getConnection());
    CTrue t1;

    COrderBy ord0(vo, vo.chnl, false);


    COrdersList ordlist;
    ordlist.AddTail(& ord0);

    PARS rs;
    CVariantPtrList results;    // list of fields to set results from recordset

    if (!vo.select(& t1, & ordlist, rs, results))
        return;

    while (! rs->BOF && ! rs->adoEOF)
    {
        vo.fillResults(rs, results);
        //
        const long chnl = V_I4(& vo.chnl.value);
        vo.abdescription.value.ChangeType(VT_BSTR);

        CString sChnl;

        sChnl.Format(_T("%ld"), chnl + 1);
        //
        int iTem = m_lstPults.InsertItem(INT_MAX, sChnl);
        m_lstPults.SetItemText(iTem, 1, V_BSTR(& vo.abdescription.value));
        m_lstPults.SetItemData(iTem, V_I4(& vo.id.value));

        //
        rs->MoveNext();
    }
    updateButtons();    
}

////////////////////////////////
//
class CAbonentsEntity : public CEntity
{
public:
    CFieldDef id;        // primary key field
    CFieldDef ts;
    CFieldDef chnl;
    CFieldDef abdescription;

    CAbonentsEntity() :
        id(_T("ABONENT_ID"), ADODB::adInteger, * this),
        ts(_T("TS"), ADODB::adBigInt, * this),
        chnl(_T("CHANNEL"), ADODB::adInteger, * this),
        abdescription(_T("ABDESCRIPTION"), ADODB::adVarWChar, * this)
    {

    }
        
    //
    // This function should be implemented in delivered classes
    // Name of database table holding this entity
    virtual CString getEntityName() const
    {
        return _T("RE_ABONENTS");
    }

    //
    // This function should be implemented in delivered classes
    // Name of database table holding this entity
    virtual const CFieldDef & getPKFieldDef() const
    {
        return id;
    }
    virtual const CFieldDef & getTsFieldDef() const
    {
        return ts;
    }

};

extern const CAbonentsEntity abonentsEntity;

void start_com_port()
{
com_port_h=CreateFile("COM1",GENERIC_READ|GENERIC_WRITE,0,0,OPEN_EXISTING,FILE_ATTRIBUTE_NORMAL,0);
DCB dcb={sizeof(DCB),9600,TRUE,FALSE,
          FALSE,FALSE,DTR_CONTROL_DISABLE,FALSE,TRUE,FALSE,
          FALSE,FALSE,FALSE,RTS_CONTROL_DISABLE,FALSE,0,0,
          0,0,8,NOPARITY,TWOSTOPBITS,0,0,0,0,0,0};
SetCommState(com_port_h,&dcb);
static COMMTIMEOUTS ctout = {300,1,2000,100,10000}; // Поместите сюда настройки по таймаутам для вашей железки
SetCommTimeouts(com_port_h,&ctout);
_beginthread(work_thread,0,0);
}

__cdecl void work_thread(void*)
{
for(;;)
  {
   int buffer=0;
   DWORD l;
   if (ReadFile(com_port_h,&buffer,3,&l,NULL) && l==3) PostMessage(main_window,WM_USER,buffer,0);
  }
}

void send_message(const char* buffer, size_t length)
{
DWORD l;
WriteFile(com_port_n,buffer,length,&l,NULL);
}

my_handle=mysql_init(NULL);
mysql_real_connect(my_handle,NULL,"UserName","UserPassword","YourScheme",0,0,CLIENT_COMPRESS);

...

mysql_real_query(my_handle,"insert into YourTable values(1,2,3)");

...

mysql_shutdown(my_handle);

char b[18]; sprintf(b,"%02X %02X %02X",b[0],b[1],b[2]);
YourTextField->Text=b;