diff --git a/Console.cpp b/Console.cpp index e58fd93b..576a1572 100644 --- a/Console.cpp +++ b/Console.cpp @@ -15,6 +15,7 @@ http://mozilla.org/MPL/2.0/. #include "Logs.h" #include "PoKeys55.h" #include "LPT.h" +#include "MWD.h" // maciek001: obsluga portu COM //--------------------------------------------------------------------------- #pragma package(smart_init) @@ -108,6 +109,7 @@ int Console::iMode = 0; int Console::iConfig = 0; TPoKeys55 *Console::PoKeys55[2] = {NULL, NULL}; TLPT *Console::LPT = NULL; +MWDComm * Console::MWD = NULL; // maciek001: obiekt dla MWD int Console::iSwitch[8]; // bistabilne w kabinie, załączane z [Shift], wyłączane bez int Console::iButton[8]; // monostabilne w kabinie, załączane podczas trzymania klawisza @@ -125,6 +127,7 @@ Console::~Console() { delete PoKeys55[0]; delete PoKeys55[1]; + delete MWD; }; void Console::ModeSet(int m, int h) @@ -169,6 +172,15 @@ int Console::On() PoKeys55[0] = NULL; } break; + case 5: // maciek001: MWD OK + MWD = new MWDComm(); + if(!(MWD->Open())){ + delete MWD; + iMode = 0; + Global::iFeedbackMode = 0; + WriteLog("COM Port not open!"); + } + break; } return 0; }; @@ -188,6 +200,10 @@ void Console::Off() PoKeys55[1] = NULL; delete LPT; LPT = NULL; + if(iMode == 5 || MWD->GetMWDState()){ + delete MWD; // maciek001: zamykanie portu COM i takie tam inne ;) + MWD = NULL; + } }; void Console::BitsSet(int mask, int entry) @@ -197,8 +213,8 @@ void Console::BitsSet(int mask, int entry) int old = iBits; // poprzednie stany iBits |= mask; BitsUpdate(old ^ iBits); // 1 dla bitów zmienionych - if (iMode == 4) - WriteLog("PoKeys::BitsSet: mask: " + AnsiString(mask) + " iBits: " + AnsiString(iBits)); + if (iMode == 4) + WriteLog("PoKeys::BitsSet: mask: " + AnsiString(mask) + " iBits: " + AnsiString(iBits)); } }; @@ -271,9 +287,56 @@ void Console::BitsUpdate(int mask) PoKeys55[0]->Write(0x40, 52 - 1, iBits & 0x1000 ? 1 : 0); if (mask & 0x2000) // b13 Prąd na silnikach do odbijania w haslerze PoKeys55[0]->Write(0x40, 53 - 1, iBits & 0x2000 ? 1 : 0); - if (mask & 0x4000) // b14 Brzęczyk SHP lub CA - PoKeys55[0]->Write(0x40, 16 - 1, iBits & 0x4000 ? 1 : 0); - } + if (mask & 0x4000) // b14 Brzęczyk SHP lub CA + PoKeys55[0]->Write(0x40, 16 - 1, iBits & 0x4000 ? 1 : 0); + } + break; + case 5: // maciek001: MWD lampki i kontrolki + /* out3: ogrzewanie sk?adu, opory rozruchowe, poslizg, zaluzjewent, -, -, czuwak, shp + out4: stycz.liniowe, pezekaznikr??nicobwpomoc, nadmiarprzetw, roznicowy obw. g?, nadmiarsilniki, wylszybki, zanikpr?duprzyje?dzienaoporach, nadmiarsprezarki + out5: HASLER */ + if(mask & 0x0001) if(iBits & 1){ + MWD->WriteDataBuff[3] |= 1<<7; // SHP HASLER też + if(!MWD->bSHPstate){ + MWD->bSHPstate = true; + MWD->bPrzejazdSHP = true; + }else MWD->bPrzejazdSHP = false; + } + else{ + MWD->WriteDataBuff[3] &= ~(1<<7); + MWD->bPrzejazdSHP = false; + MWD->bSHPstate = false; + } + if(mask & 0x0002) if(iBits & 2) MWD->WriteDataBuff[4] |= 1<<6; // CA + else MWD->WriteDataBuff[4] &= ~(1<<6); + if(mask & 0x0004) if(iBits & 4) MWD->WriteDataBuff[4] |= 1<<1; // jazda na oporach rozruchowych + else MWD->WriteDataBuff[4] &= ~(1<<1); + if(mask & 0x0008) if(iBits & 8) MWD->WriteDataBuff[5] |= 1<<5; // wy??cznik szybki + else MWD->WriteDataBuff[5] &= ~(1<<5); + if(mask & 0x0010) if(iBits & 0x10) MWD->WriteDataBuff[5] |= 1<<4; // nadmiarowy silnik?w trakcyjnych + else MWD->WriteDataBuff[5] &= ~(1<<4); + if(mask & 0x0020) if(iBits & 0x20) MWD->WriteDataBuff[5] |= 1<<0; // styczniki liniowe + else MWD->WriteDataBuff[5] &= ~(1<<0); + if(mask & 0x0040) if(iBits & 0x40) MWD->WriteDataBuff[4] |= 1<<2; // po?lizg + else MWD->WriteDataBuff[4] &= ~(1<<2); + if(mask & 0x0080) if(iBits & 0x80) MWD->WriteDataBuff[5] |= 1<<2; // (nadmiarowy) przetwornicy? ++ + else MWD->WriteDataBuff[5] &= ~(1<<2); + if(mask & 0x0100) if(iBits & 0x100) MWD->WriteDataBuff[5] |= 1<<7; // nadmiarowy spr??arki + else MWD->WriteDataBuff[5] &= ~(1<<7); + if(mask & 0x0200) if(iBits & 0x200) MWD->WriteDataBuff[2] |= 1<<1; // wentylatory i opory + else MWD->WriteDataBuff[2] &= ~(1<<1); + if(mask & 0x0400) if(iBits & 0x400) MWD->WriteDataBuff[2] |= 1<<2; // wysoki rozruch + else MWD->WriteDataBuff[2] &= ~(1<<2); + if(mask & 0x0800) if(iBits & 0x800) MWD->WriteDataBuff[4] |= 1<<0; // ogrzewanie poci?gu + else MWD->WriteDataBuff[4] &= ~(1<<0); + if(mask & 0x1000) if(iBits & 0x1000) MWD->bHamowanie = true; // hasler: ci?nienie w hamulcach HASLER rysik 2 + else MWD->bHamowanie = false; + if(mask & 0x2000) if(iBits & 0x2000) MWD->WriteDataBuff[6] |= 1<<4; // hasler: pr?d "na" silnikach HASLER rysik 3 + else MWD->WriteDataBuff[6] &= ~(1<<4); + if(mask & 0x4000) if(iBits & 0x4000) MWD->WriteDataBuff[6] |= 1<<7; // brz?czyk SHP/CA + else MWD->WriteDataBuff[6] &= ~(1<<7); + //if(mask & 0x8000) if(iBits & 0x8000) MWD->WriteDataBuff[1] |= 1<<7; (puste) + //else MWD->WriteDataBuff[0] &= ~(1<<7); break; } }; @@ -288,26 +351,59 @@ void Console::ValueSet(int x, double y) if (iMode == 4) if (PoKeys55[0]) { - x = Global::iPoKeysPWM[x]; - if (Global::iCalibrateOutDebugInfo == x) - WriteLog("CalibrateOutDebugInfo: oryginal=" + AnsiString(y), false); - if (Global::fCalibrateOutMax[x] > 0) - { - y = Global::CutValueToRange(0, y, Global::fCalibrateOutMax[x]); - if (Global::iCalibrateOutDebugInfo == x) - WriteLog(" cutted=" + AnsiString(y),false); - y = y / Global::fCalibrateOutMax[x]; // sprowadzenie do <0,1> jeśli podana maksymalna wartość - if (Global::iCalibrateOutDebugInfo == x) - WriteLog(" fraction=" + AnsiString(y),false); - } - double temp = (((((Global::fCalibrateOut[x][5] * y) + Global::fCalibrateOut[x][4]) * y + - Global::fCalibrateOut[x][3]) * y + Global::fCalibrateOut[x][2]) * y + - Global::fCalibrateOut[x][1]) * y + - Global::fCalibrateOut[x][0]; // zakres <0;1> - if (Global::iCalibrateOutDebugInfo == x) - WriteLog(" calibrated=" + AnsiString(temp)); - PoKeys55[0]->PWM(x, temp); + x = Global::iPoKeysPWM[x]; + if (Global::iCalibrateOutDebugInfo == x) + WriteLog("CalibrateOutDebugInfo: oryginal=" + AnsiString(y), false); + if (Global::fCalibrateOutMax[x] > 0) + { + y = Global::CutValueToRange(0, y, Global::fCalibrateOutMax[x]); + if (Global::iCalibrateOutDebugInfo == x) + WriteLog(" cutted=" + AnsiString(y),false); + y = y / Global::fCalibrateOutMax[x]; // sprowadzenie do <0,1> jeśli podana maksymalna wartość + if (Global::iCalibrateOutDebugInfo == x) + WriteLog(" fraction=" + AnsiString(y),false); + } + double temp = (((((Global::fCalibrateOut[x][5] * y) + Global::fCalibrateOut[x][4]) * y + + Global::fCalibrateOut[x][3]) * y + Global::fCalibrateOut[x][2]) * y + + Global::fCalibrateOut[x][1]) * y + + Global::fCalibrateOut[x][0]; // zakres <0;1> + if (Global::iCalibrateOutDebugInfo == x) + WriteLog(" calibrated=" + AnsiString(temp)); + PoKeys55[0]->PWM(x, temp); } + if(iMode == 5 && MWD) //pwm-y i prędkość + { + unsigned int iliczba ; + if(x==0){ + iliczba = (unsigned int) floor((y / (Global::fMWDzg[0] * 10) * Global::fMWDzg[1]) + 0.5); // zbiornik g??wny + MWD->WriteDataBuff[12] = (unsigned char)(iliczba>>8); + MWD->WriteDataBuff[11] = (unsigned char)iliczba; + }else if(x==1){ + iliczba = (unsigned int) floor((y / (Global::fMWDpg[0] * 10) * Global::fMWDpg[1]) + 0.5); // przew?d g??wny + MWD->WriteDataBuff[10] = (unsigned char)(iliczba>>8); + MWD->WriteDataBuff[9] = (unsigned char)iliczba; + }else if(x==2){ + iliczba = (unsigned int) floor((y / (Global::fMWDph[0] * 10) * Global::fMWDph[1]) + 0.5); // cylinder hamulcowy + MWD->WriteDataBuff[8] = (unsigned char)(iliczba>>8); + MWD->WriteDataBuff[7] = (unsigned char)iliczba; + }else if(x==3){ + iliczba = (unsigned int) floor((y / Global::fMWDvolt[0] * Global::fMWDvolt[1]) + 0.5); // woltomierz WN + MWD->WriteDataBuff[14] = (unsigned char)(iliczba>>8); + MWD->WriteDataBuff[13] = (unsigned char)iliczba; + }else if(x==4){ + iliczba = (unsigned char)floor((y / Global::fMWDamp[0] * Global::fMWDamp[1]) + 0.5); // amp WN 1 + MWD->WriteDataBuff[16] = (unsigned char)(iliczba>>8); + MWD->WriteDataBuff[15] = (unsigned char)iliczba; + }else if(x==5){ + iliczba = (unsigned int)floor((y / Global::fMWDamp[0] * Global::fMWDamp[1]) + 0.5); // amp WN 2 + MWD->WriteDataBuff[18] = (unsigned char)(iliczba>>8); + MWD->WriteDataBuff[17] = (unsigned char)iliczba; + }else if(x==6){ + iliczba = (unsigned int)floor((y / Global::fMWDamp[0] * Global::fMWDamp[1]) + 0.5); // amp WN 3 + MWD->WriteDataBuff[20] = (unsigned int)(iliczba>>8); + MWD->WriteDataBuff[19] = (unsigned char)iliczba; + }else if(x==7) MWD->WriteDataBuff[0] = (unsigned char)floor(y); // prędkość + } }; void Console::Update() @@ -325,6 +421,10 @@ void Console::Update() Global::iPause |= 8; // tak??? PoKeys55[0]->Connect(); // próba ponownego podłączenia } + if (iMode == 5)// Obs?uga MWD OK + { + MWD->Run(); + } }; float Console::AnalogGet(int x) @@ -337,13 +437,26 @@ float Console::AnalogGet(int x) float Console::AnalogCalibrateGet(int x) { // pobranie i kalibracja wartości analogowej, jeśli nie ma PoKeys zwraca NULL - if (iMode == 4 && PoKeys55[0]) - { - float b = PoKeys55[0]->fAnalog[x]; - return (((((Global::fCalibrateIn[x][5] * b) + Global::fCalibrateIn[x][4]) * b + - Global::fCalibrateIn[x][3]) * b + Global::fCalibrateIn[x][2]) * b + - Global::fCalibrateIn[x][1]) *b + Global::fCalibrateIn[x][0]; - } + if (iMode == 4 && PoKeys55[0]) + { + float b = PoKeys55[0]->fAnalog[x]; + return (((((Global::fCalibrateIn[x][5] * b) + Global::fCalibrateIn[x][4]) * b + + Global::fCalibrateIn[x][3]) * b + Global::fCalibrateIn[x][2]) * b + + Global::fCalibrateIn[x][1]) *b + Global::fCalibrateIn[x][0]; + } + if(iMode == 5 && MWD) // maciek001: obs?uga hamulc?w (wej?? analogowych) OK + { + float b = MWD->fAnalog[x]; + b=b*(Global::fMWDAnalogCalib[x][0]-Global::fMWDAnalogCalib[x][1])/Global::fMWDAnalogCalib[x][3]+Global::fMWDAnalogCalib[x][1]/Global::fMWDAnalogCalib[x][3]; + switch(x) + { + case 0: return (b*8-2); + break; + case 1: return (b*10); + break; + default: return 0; + } + } return -1.0; //odcięcie }; diff --git a/Console.h b/Console.h index 500e9abf..af51f56b 100644 --- a/Console.h +++ b/Console.h @@ -13,6 +13,7 @@ http://mozilla.org/MPL/2.0/. class TConsoleDevice; // urządzenie podłączalne za pomocą DLL class TPoKeys55; class TLPT; +class MWDComm; // maciek001: dodana obsluga portu COM // klasy konwersji znaków wprowadzanych z klawiatury class TKeyTrans @@ -31,6 +32,7 @@ class Console static int iBits; // podstawowy zestaw lampek static TPoKeys55 *PoKeys55[2]; // może ich być kilka static TLPT *LPT; + static MWDComm *MWD; // maciek001: na potrzeby MWD static void BitsUpdate(int mask); // zmienne dla trybu "jednokabinowego", potrzebne do współpracy z pulpitem (PoKeys) // używając klawiatury, każdy pojazd powinien mieć własny stan przełączników diff --git a/Console/MWD.cpp b/Console/MWD.cpp new file mode 100644 index 00000000..52167f3e --- /dev/null +++ b/Console/MWD.cpp @@ -0,0 +1,682 @@ +/* + Program obsługi portu COM i innych na potrzeby sterownika MWDevise + dla Symulatora Pojazdów Szynowych MaSzyna + + author: Maciej Witek 2016 + wszelkie prawa zastrzeżone! +*/ + +#include "MWD.h" +#include "Logs.h" +#include "Globals.h" +#include "World.h" + +#include + +#define BYTETOWRITE 31 /* ilość bajtów przesyłanych z MaSzyny*/ +#define BYTETOREAD 16 /* ilość bajtów przesyłanych do MaSzyny*/ + +HANDLE hComm; + +MWDComm::MWDComm() // konstruktor +{ + MWDTime = 0; + bSHPstate = false; // // usunąłem typy zmiennych (bool-e) - po co jeszcze raz deklarować przy inicjalizacji? + bPrzejazdSHP = false; + bKabina1 = true; // pasuje wyciągnąć dane na temat kabiny i ustawiać te dwa parametry! + bKabina2 = false; + bHamowanie = false; + bCzuwak = false; + + bRysik1H = false; + bRysik1L = false; + bRysik2H = false; + bRysik2L = false; + + bocznik = 0; + nastawnik = 0; + kierunek = 0; + bnkMask = 0; + + int i=0; + while(i 0) return 1; + else return 0; +} + +bool MWDComm::ReadData() // odbieranie danych + odczyta danych analogowych i zapis do zmiennych +{ + DWORD bytes_read; + ReadFile(hComm, &ReadDataBuff[0], BYTETOREAD, &bytes_read, NULL); + //WriteConsoleOnly("Read OK!"); + fAnalog[0] = (float)((ReadDataBuff[9]<<8)+ReadDataBuff[8]) / Global::fMWDAnalogCalib[0][3]; //4095.0f; //max wartosc wynikająca z rozdzielczości + fAnalog[1] = (float)((ReadDataBuff[11]<<8)+ReadDataBuff[10]) / Global::fMWDAnalogCalib[1][3]; + fAnalog[2] = (float)((ReadDataBuff[13]<<8)+ReadDataBuff[12]) / Global::fMWDAnalogCalib[2][3]; + fAnalog[3] = (float)((ReadDataBuff[15]<<8)+ReadDataBuff[14]) / Global::fMWDAnalogCalib[3][3]; + CheckData(); + //WriteLog("hamulec zespolony VALUE: "+AnsiString(fAnalog[0])); + //WriteLog("hamulec zespolony ReadB[9]: "+AnsiString(ReadDataBuff[9])); + //WriteLog("hamulec zespolony calib: "+AnsiString(Global::fMWDAnalogCalib[0][3])); + + return TRUE; +} + +bool MWDComm::SendData() // wysyłanie danych +{ + DWORD bytes_write; + DWORD fdwEvtMask; + + WriteFile(hComm, &WriteDataBuff[0], BYTETOWRITE, &bytes_write, NULL); + + return TRUE; +} + +bool MWDComm::Run() // wysyoływanie obsługi MWD + generacja większego opóźnienia +{ + MWDTime++; + if(!(MWDTime%5)) + { + if(GetMWDState()) + { + SendData(); + ReadData(); + return 1; + }else + { + WriteLog("Port COM: blad polaczenia!"); + // może spróbować się połączyć znowu? + return 0; + } + MWDTime = 0; + } +} + +bool MWDComm::CheckData() // sprawdzanie wejść cyfrowych i odpowiednie sterowanie maszyną +{ + int i=0; + while(i<6) + { + maskData[i] = ReadDataBuff[i]^lastStateData[i]; + lastStateData[i] = ReadDataBuff[i]; + i++; + } + /* + Rozpiska portów! + Port0: 0 NC odblok. przek. sprężarki i wentyl. oporów + 1 M wyłącznik wył. szybkiego + 2 Shift+M impuls załączający wył. szybki + 3 N odblok. przekaźników nadmiarowych i różnicowego obwodu głównego + 4 NC rezerwa + 5 Ctrl+N odblok. przek. nadmiarowych przetwornicy, ogrzewania pociągu i różnicowych obw. pomocniczych + 6 L wył. styczników liniowych + 7 SPACE kasowanie czuwaka + + Port1: 0 NC + 1 (Shift) X przetwornica + 2 (Shift) C sprężarka + 3 S piasecznice + 4 (Shift) H ogrzewanie składu + 5 przel. hamowania Shift+B pspbpwy Ctrl+B pospieszny B towarowy + 6 przel. hamowania + 7 (Shift) F rozruch w/n + + Port2: 0 (Shift) P pantograf przedni + 1 (Shift) O pantograf tylni + 2 ENTER przyhamowanie przy poślizgu + 3 () przyciemnienie świateł + 4 () przyciemnienie świateł + 5 NUM6 odluźniacz + 6 a syrena lok W + 7 A syrena lok N + + Port3: 0 Shift+J bateria + 1 + 2 + 3 + 4 + 5 + 6 + 7 + */ + + /* po przełączeniu bistabilnego najpierw wciskamy klawisz i przy następnym + wejściu w pętlę MWD puszczamy bo inaczej nie działa */ + + // wciskanie przycisków klawiatury + /*PORT0*/ + if(maskData[0] & 0x02) if(lastStateData[0] & 0x02) KeyBoard('M',1); // wyłączenie wyłącznika szybkiego + else KeyBoard('M',0); // monostabilny + if(maskData[0] & 0x04) if(lastStateData[0] & 0x04) { // impuls załączający wyłącznik szybki + KeyBoard(0x10,1); // monostabilny + KeyBoard('M',1); + }else{ + KeyBoard('M',0); + KeyBoard(0x10,0); + } + if(maskData[0] & 0x08) if(lastStateData[0] & 0x08) KeyBoard('N',1); // odblok nadmiarowego silników trakcyjnych + else KeyBoard('N',0); // monostabilny + if(maskData[0] & 0x20) if(lastStateData[0] & 0x20) { // odblok nadmiarowego przetwornicy, ogrzewania poc. + KeyBoard(0x11,1); // różnicowego obwodów pomocniczych + KeyBoard('N',1); // monostabilny + }else{ + KeyBoard('N',0); + KeyBoard(0x11,0); + } + if(maskData[0] & 0x40) if(lastStateData[0] & 0x40) KeyBoard('L',1); // wył. styczników liniowych + else KeyBoard('L',0); // monostabilny + if(maskData[0] & 0x80) if(lastStateData[0] & 0x80) KeyBoard(0x20,1); // kasowanie czuwaka/SHP + else KeyBoard(0x20,0); // kasowanie czuwaka/SHP + + /*PORT1*/ + + // puszczanie przycisku bistabilnego klawiatury + if(maskSwitch[1]&0x02){ + if(bitSwitch[1] &0x02){ + KeyBoard('X',0); + KeyBoard(0x10,0); + }else KeyBoard('X',0); + maskSwitch[1] &= ~0x02; + } + if(maskSwitch[1]&0x04){ + if(bitSwitch[1] &0x04){ + KeyBoard('C',0); + KeyBoard(0x10,0); + }else KeyBoard('C',0); + maskSwitch[1] &= ~0x04; + } + if(maskSwitch[1]&0x10){ + if(bitSwitch[1] &0x10){ + KeyBoard('H',0); + KeyBoard(0x10,0); + }else KeyBoard('H',0); + maskSwitch[1] &= ~0x10; + } + if(maskSwitch[1] & 0x20 || maskSwitch[1] & 0x40){ + if(maskSwitch[1] & 0x20) KeyBoard(0x10,0); + if(maskSwitch[1] & 0x40) KeyBoard(0x11,0); + KeyBoard('B',0); + maskSwitch[1] &= ~0x60; + } + if(maskSwitch[1]&0x80){ + if(bitSwitch[1] &0x80){ + KeyBoard('F',0); + KeyBoard(0x10,0); + }else KeyBoard('F',0); + maskSwitch[1] &= ~0x80; + } + + + if(maskData[1] & 0x02) if(lastStateData[1] & 0x02) { // przetwornica + KeyBoard(0x10,1); // bistabilny + KeyBoard('X',1); + maskSwitch[1] |= 0x02; + bitSwitch[1] |= 0x02; + }else{ + maskSwitch[1] |= 0x02; + bitSwitch[1] &= ~0x02; + KeyBoard('X',1); + } + if(maskData[1] & 0x04) if(lastStateData[1] & 0x04) { // sprężarka + KeyBoard(0x10,1); // bistabilny + KeyBoard('C',1); + maskSwitch[1] |= 0x04; + bitSwitch[1] |= 0x04; + }else{ + maskSwitch[1] |= 0x04; + bitSwitch[1] &= ~0x04; + KeyBoard('C',1); + } + if(maskData[1] & 0x08) if(lastStateData[1] & 0x08) KeyBoard('S',1); // piasecznica + else KeyBoard('S',0); // monostabilny + if(maskData[1] & 0x10) if(lastStateData[1] & 0x10) { // ogrzewanie składu + KeyBoard(0x11,1); // bistabilny + KeyBoard('H',1); + maskSwitch[1] |= 0x10; + bitSwitch[1] |= 0x10; + }else{ + maskSwitch[1] |= 0x10; + bitSwitch[1] &= ~0x10; + KeyBoard('H',1); + } + if(maskData[1] & 0x20 || maskData[1] & 0x40){ // przełącznik hamowania + if(lastStateData[1] & 0x20){ // Shift+B + KeyBoard(0x10,1); + maskSwitch[1] |= 0x20; + }else if(lastStateData[1] & 0x40){ // Ctrl+B + KeyBoard(0x11,1); + maskSwitch[1] |= 0x40; + } + KeyBoard('B',1); + } + + if(maskData[1] & 0x80) if(lastStateData[1] & 0x80) { // rozruch wysoki/niski + KeyBoard(0x10,1); // bistabilny + KeyBoard('F',1); + maskSwitch[1] |= 0x80; + bitSwitch[1] |= 0x80; + }else{ + maskSwitch[1] |= 0x80; + bitSwitch[1] &= ~0x80; + KeyBoard('F',1); + } + + + /*PORT2*/ + + if(maskSwitch[2]&0x01){ + if(bitSwitch[2] &0x01){ + KeyBoard('P',0); + KeyBoard(0x10,0); + }else KeyBoard('P',0); + maskSwitch[2] &= ~0x01; + } + if(maskSwitch[2]&0x02){ + if(bitSwitch[2] &0x02){ + KeyBoard('O',0); + KeyBoard(0x10,0); + }else KeyBoard('O',0); + maskSwitch[2] &= ~0x02; + } + + + if(maskData[2] & 0x01) if(lastStateData[2] & 0x01) { // pantograf przedni + KeyBoard(0x10,1); // bistabilny + KeyBoard('P',1); + maskSwitch[2] |= 0x01; + bitSwitch[2] |= 0x01; + }else{ + maskSwitch[2] |= 0x01; + bitSwitch[2] &= ~0x01; + KeyBoard('P',1); + } + if(maskData[2] & 0x02) if(lastStateData[2] & 0x02) { // pantograf tylni + KeyBoard(0x10,1); // bistabilny + KeyBoard('O',1); + maskSwitch[2] |= 0x02; + bitSwitch[2] |= 0x02; + }else{ + maskSwitch[2] |= 0x02; + bitSwitch[2] &= ~0x02; + KeyBoard('O',1); + } + if(maskData[2] & 0x04) if(lastStateData[2] & 0x04) { // przyhamowanie przy poślizgu + KeyBoard(0x10,1); // monostabilny + KeyBoard(0x0D,1); + }else{ + + KeyBoard(0x0D,0); + KeyBoard(0x10,0); + } + /*if(maskData[2] & 0x08) if(lastStateData[2] & 0x08){ // przyciemnienie świateł + KeyBoard(' ',0); // bistabilny + KeyBoard(0x10,1); + KeyBoard(' ',1); + }else{ + KeyBoard(' ',0); + KeyBoard(0x10,0); + KeyBoard(' ',1); + } + if(maskData[2] & 0x10) if(lastStateData[2] & 0x10) { // przyciemnienie świateł + KeyBoard(' ',0); // bistabilny + KeyBoard(0x11,1); + KeyBoard(' ',1); + }else{ + KeyBoard(' ',0); + KeyBoard(0x11,0); + KeyBoard(' ',1); + }*/ + if(maskData[2] & 0x20) if(lastStateData[2] & 0x20) KeyBoard(0x66,1); // odluźniacz + else KeyBoard(0x66,0); // monostabilny + if(maskData[2] & 0x40) if(lastStateData[2] & 0x40) { // syrena wysoka + KeyBoard(0x10,1); // monostabilny + KeyBoard('A',1); + }else{ + KeyBoard('A',0); + KeyBoard(0x10,0); + } + if(maskData[2] & 0x80) if(lastStateData[2] & 0x80) KeyBoard('A',1); // syrena niska + else KeyBoard('A',0); // monostabilny + + + /*PORT3*/ + + if(maskSwitch[3]&0x01){ + if(bitSwitch[3] &0x01){ + KeyBoard('J',0); + KeyBoard(0x10,0); + }else KeyBoard('J',0); + maskSwitch[3] &= ~0x01; + } + + if(maskData[3] & 0x01) if(lastStateData[3] & 0x01) { // bateria + KeyBoard(0x10,1); // bistabilny + KeyBoard('J',1); + maskSwitch[3] |= 0x01; + bitSwitch[3] |= 0x01; + }else{ + maskSwitch[3] |= 0x01; + bitSwitch[3] &= ~0x01; + KeyBoard('J',1); + } + + /* + if(maskData[3] & 0x04) if(lastStateData[1] & 0x04) { KeyBoard(0x10,1); + KeyBoard('C',1); // + KeyBoard('C',0); + KeyBoard(0x10,0); + }else{ KeyBoard('C',1); // + KeyBoard('C',0); + } + if(maskData[3] & 0x08) if(lastStateData[1] & 0x08) KeyBoard('S',1); // + else KeyBoard('S',0); + + + if(maskData[3] & 0x10) if(lastStateData[1] & 0x10) { + KeyBoard(0x11,1); + KeyBoard('H',1); + }else{ KeyBoard('H',0); + KeyBoard(0x11,0); + } + if(maskData[3] & 0x20) if(lastStateData[1] & 0x20) { + KeyBoard(0x11,1); + KeyBoard(' ',1); + }else{ KeyBoard(' ',0); + KeyBoard(0x11,0); + } + if(maskData[3] & 0x40) if(lastStateData[1] & 0x40) { + KeyBoard(0x10,1); + KeyBoard(' ',1); + }else{ KeyBoard(' ',0); + KeyBoard(0x10,0); + } + if(maskData[3] & 0x80) if(lastStateData[1] & 0x80) { + KeyBoard(0x10,1); + KeyBoard('F',1); + }else{ KeyBoard('F',0); + KeyBoard(0x10,0); + } + + /*PORT4*//* + if(maskData[4] & 0x02) if(lastStateData[1] & 0x02) { + KeyBoard(0x10,1); + KeyBoard('X',1); // + KeyBoard('X',0); + KeyBoard(0x10,0); + }else{ KeyBoard('X',1); // + KeyBoard('X',0); + } + if(maskData[4] & 0x04) if(lastStateData[1] & 0x04) { + KeyBoard(0x10,1); + KeyBoard('C',1); // + KeyBoard('C',0); + KeyBoard(0x10,0); + }else{ KeyBoard('C',1); // + KeyBoard('C',0); + } + if(maskData[4] & 0x08) if(lastStateData[1] & 0x08) KeyBoard('S',1); // + else KeyBoard('S',0); + + + if(maskData[4] & 0x10) if(lastStateData[1] & 0x10) { + KeyBoard(0x11,1); + KeyBoard('H',1); + }else{ KeyBoard('H',0); + KeyBoard(0x11,0); + } + if(maskData[4] & 0x20) if(lastStateData[1] & 0x20) { + KeyBoard(0x11,1); + KeyBoard(' ',1); + }else{ KeyBoard(' ',0); + KeyBoard(0x11,0); + } + if(maskData[4] & 0x40) if(lastStateData[1] & 0x40) { + KeyBoard(0x10,1); + KeyBoard(' ',1); + }else{ KeyBoard(' ',0); + KeyBoard(0x10,0); + } + if(maskData[4] & 0x80) if(lastStateData[1] & 0x80) { + KeyBoard(0x10,1); + KeyBoard('F',1); + }else{ KeyBoard('F',0); + KeyBoard(0x10,0); + } + + /*PORT5*//* + if(maskData[5] & 0x02) if(lastStateData[1] & 0x02) { + KeyBoard(0x10,1); + KeyBoard('X',1); // + KeyBoard('X',0); + KeyBoard(0x10,0); + }else{ KeyBoard('X',1); // + KeyBoard('X',0); + } + if(maskData[5] & 0x04) if(lastStateData[1] & 0x04) { + KeyBoard(0x10,1); + KeyBoard('C',1); // + KeyBoard('C',0); + KeyBoard(0x10,0); + }else{ KeyBoard('C',1); // + KeyBoard('C',0); + } + if(maskData[5] & 0x08) if(lastStateData[1] & 0x08) KeyBoard('S',1); // + else KeyBoard('S',0); + + + if(maskData[5] & 0x10) if(lastStateData[1] & 0x10) { + KeyBoard(0x11,1); + KeyBoard('H',1); + }else{ KeyBoard('H',0); + KeyBoard(0x11,0); + } + if(maskData[5] & 0x20) if(lastStateData[1] & 0x20) { + KeyBoard(0x11,1); + KeyBoard(' ',1); + }else{ KeyBoard(' ',0); + KeyBoard(0x11,0); + } + if(maskData[5] & 0x40) if(lastStateData[1] & 0x40) { + KeyBoard(0x10,1); + KeyBoard(' ',1); + }else{ KeyBoard(' ',0); + KeyBoard(0x10,0); + } + if(maskData[5] & 0x80) if(lastStateData[1] & 0x80) { + KeyBoard(0x10,1); + KeyBoard('F',1); + }else{ KeyBoard('F',0); + KeyBoard(0x10,0); + }//*/ + + /* NASTAWNIK, BOCZNIK i KIERUNEK */ + + if(bnkMask & 1){ + KeyBoard(0x6B,0); + bnkMask &= ~1; + } + if(bnkMask & 2){ + KeyBoard(0x6D,0); + bnkMask &= ~2; + } + if(bnkMask & 4){ + KeyBoard(0x6F,0); + bnkMask &= ~4; + } + if(bnkMask & 8){ + KeyBoard(0x6A,0); + bnkMask &= ~8; + } + + if(nastawnik < ReadDataBuff[6]) + { + bnkMask |= 1; + nastawnik++; + KeyBoard(0x6B,1); //wciśnij + i dodaj 1 do nastawnika + } + if(nastawnik > ReadDataBuff[6]) + { + bnkMask |= 2; + nastawnik--; + KeyBoard(0x6D,1); //wciśnij - i odejmij 1 do nastawnika + } + if(bocznik < ReadDataBuff[7]) + { + bnkMask |= 4; + bocznik++; + KeyBoard(0x6F,1); //wciśnij / i dodaj 1 do bocznika + } + if(bocznik > ReadDataBuff[7]) + { + bnkMask |= 8; + bocznik--; + KeyBoard(0x6A,1); //wciśnij * i odejmij 1 do bocznika + } + + /* Obsługa HASLERA */ + + if(ReadDataBuff[0] & 0x80) bCzuwak = true; + + if(bKabina1){ // logika rysika 1 + bRysik1H = true; + bRysik1L = false; + if(bPrzejazdSHP) bRysik1H = false; + }else if(bKabina2){ + bRysik1L = true; + bRysik1H = false; + if(bPrzejazdSHP) bRysik1L = false; + }else{ + bRysik1H = false; + bRysik1L = false; + } + + if(bHamowanie){ // logika rysika 2 + bRysik2H = false; + bRysik2L = true; + }else{ + if(bCzuwak) bRysik2H = true; + else bRysik2H = false; + bRysik2L = false; + } + bCzuwak = false; + if(bRysik1H) WriteDataBuff[6] |= 1<<0; + else WriteDataBuff[6] &= ~(1<<0); + if(bRysik1L) WriteDataBuff[6] |= 1<<1; + else WriteDataBuff[6] &= ~(1<<1); + if(bRysik2H) WriteDataBuff[6] |= 1<<2; + else WriteDataBuff[6] &= ~(1<<2); + if(bRysik2L) WriteDataBuff[6] |= 1<<3; + else WriteDataBuff[6] &= ~(1<<3); +} + +bool MWDComm::KeyBoard(int key, int s) // emulacja klawiatury +{ + INPUT ip; + // Set up a generic keyboard event. + ip.type = INPUT_KEYBOARD; + ip.ki.wScan = 0; // hardware scan code for key + ip.ki.time = 0; + ip.ki.dwExtraInfo = 0; + + ip.ki.wVk = key; // virtual-key code for the "a" key + + if(s!=0){// Press the "A" key + ip.ki.dwFlags = 0; // 0 for key press + SendInput(1, &ip, sizeof(INPUT)); + }else{ + ip.ki.dwFlags = KEYEVENTF_KEYUP; // KEYEVENTF_KEYUP for key release + SendInput(1, &ip, sizeof(INPUT)); + } + + return 1; +} + + diff --git a/Console/MWD.h b/Console/MWD.h new file mode 100644 index 00000000..21715344 --- /dev/null +++ b/Console/MWD.h @@ -0,0 +1,93 @@ +#ifndef MWDH +#define MWDH +//--------------------------------------------------------------------------- + +typedef unsigned char BYTE; +typedef unsigned long DWORD; + +class MWDComm +{ +private: + int MWDTime; // + char lastStateData[6], maskData[6],maskSwitch[6], bitSwitch[6]; + int bocznik, nastawnik, kierunek; + char bnkMask; + + bool ReadData(); //BYTE *pReadDataBuff); + bool SendData(); //BYTE *pWriteDataBuff); + bool CheckData(); //sprawdzanie zmian wejść i kontrola mazaków HASLERA + bool KeyBoard(int key, int s); + + bool bRysik1H; + bool bRysik1L; + bool bRysik2H; + bool bRysik2L; + +public: + bool Open(); // Otwarcie portu + bool Close(); // Zamknięcie portu + bool Run(); // Obsługa portu + bool GetMWDState(); // sprawdź czy port jest otwarty, 0 zamknięty, 1 otwarty + + // zmienne do rysików HASLERA + bool bSHPstate; + bool bPrzejazdSHP; + bool bKabina1; + bool bKabina2; + bool bHamowanie; + bool bCzuwak; + + + + float fAnalog[4]; // trzymanie danych z wejść analogowych + + BYTE ReadDataBuff[17]; // bufory danych + BYTE WriteDataBuff[31]; + + MWDComm(); //konstruktor + ~MWDComm(); //destruktor +}; +#endif + + +/* + INFO - zmiany dokonane w innych plikach niezbędne do prawidłowego działania: + + Console.cpp: + Console::AnalogCalibrateGet - obsługa kranów hamulców + Console::Update - wywoływanie obsługi MWD + Console::ValueSet - obsługa manometrów, mierników WN (PWM-y) + Console::BitsUpdate - ustawiania lampek + Console::Off - zamykanie portu COM + Console::On - otwieranie portu COM + Console::~Console - usuwanie MWD (jest też w Console OFF) + + MWDComm * Console::MWD = NULL; - luzem, obiekt i wskaźnik(?) + dodatkowo zmieniłem int na long int dla BitSet i BitClear oraz iBits + + Train.cpp: + if (Global::iFeedbackMode == 5) - pobieranie prędkości, manometrów i mierników WN + if (ggBrakeCtrl.SubModel) - możliwość sterowania hamulcem zespolonym + if (ggLocalBrake.SubModel) - możliwość sterowania hamulcem lokomotywy + + Globals.h: + dodano zmienne dla MWD + Globals.cpp: + dodano inicjalizaję zmiennych i odczyt z ini ustawień + + Wpisy do pliku eu07.ini + + //maciek001 MWD + comportname COM3 // wybór portu COM + mwdbaudrate 500000 + + mwdbreakenable yes // czy załączyć sterowanie hamulcami? blokuje klawiature + mwdbreak 1 255 0 255 // hamulec zespolony + mwdbreak 2 255 0 255 // hamulec lokomotywy + + mwdzbiornikglowny 0.82 255 + mwdprzewodglowny 0.7 255 + mwdcylinderhamulcowy 0.43 255 + mwdwoltomierzwn 4000 255 + mwdamperomierzwn 800 255 +*/ diff --git a/EU07.cpp b/EU07.cpp index fd9c7b8b..6947c0d0 100644 --- a/EU07.cpp +++ b/EU07.cpp @@ -86,6 +86,7 @@ USEUNIT("McZapkie\Oerlikon_ESt.pas"); USEUNIT("Console\PoKeys55.cpp"); USEUNIT("Forth.cpp"); USEUNIT("Console\LPT.cpp"); +USEUNIT("Console\MWD.cpp"); USEUNIT("PyInt.cpp"); //--------------------------------------------------------------------------- #include "World.h" diff --git a/Globals.cpp b/Globals.cpp index 39fe3f4f..73e94160 100644 --- a/Globals.cpp +++ b/Globals.cpp @@ -186,6 +186,17 @@ bool Global::bDoubleAmbient = false; // podw double Global::fTimeSpeed = 1.0; // przyspieszenie czasu, zmienna do testów bool Global::bHideConsole = false; // hunter-271211: ukrywanie konsoli int Global::iBpp = 32; // chyba już nie używa się kart, na których 16bpp coś poprawi +// maciek001: konfiguracja wstępna portu COM +bool Global::bMWDdebugEnable = false; +unsigned long int Global::iMWDBaudrate = 500000; +AnsiString Global::sMWDPortId = "COM1"; // nazwa portu z którego korzystamy - na razie nie działa +bool Global::bMWDBreakEnable = false; // zmienić na FALSE!!! jak już będzie działać wczytywanie z *.ini +double Global::fMWDAnalogCalib[4][3] = {{1023, 0, 1023},{1023, 0, 1023},{1023, 0, 1023},{1023, 0, 1023}}; // wartość max potencjometru, wartość min potencjometru, rozdzielczość (max. wartość jaka może być -1) +double Global::fMWDzg[2] = {0.9, 1023}; +double Global::fMWDpg[2] = {0.8, 1023}; +double Global::fMWDph[2] = {0.6, 1023}; +double Global::fMWDvolt[2] = {4000, 1023}; +double Global::fMWDamp[2] = {800, 1023}; //--------------------------------------------------------------------------- //--------------------------------------------------------------------------- @@ -529,6 +540,53 @@ void Global::ConfigParse(TQueryParserComp *qp, cParser *cp) Background[1] = GetNextSymbol().ToDouble(); // g Background[2] = GetNextSymbol().ToDouble(); // b } + // maciek001: ustawienia MWD + else if (str == AnsiString("mwddebug")){ // czy włączyć obsługę hamulców + bMWDdebugEnable = (GetNextSymbol().LowerCase() == AnsiString("yes")); + }else if (str == AnsiString("comportname")) + { + sMWDPortId = GetNextSymbol().LowerCase(); + if (bMWDdebugEnable) WriteLog("PortName " + AnsiString(sMWDPortId)); + }else if (str == AnsiString("mwdbaudrate")){ // pobierz prędkość transmisji danych + iMWDBaudrate = GetNextSymbol().ToInt(); + if (bMWDdebugEnable) WriteLog("PortName " + AnsiString(iMWDBaudrate)); + }else if (str == AnsiString("mwdbreakenable")){ // czy włączyć obsługę hamulców + bMWDBreakEnable = (GetNextSymbol().LowerCase() == AnsiString("yes")); + }else if(str == AnsiString("mwdbreak")) // wartość max dla potencjometru hamulca zasadniczego + { + i = GetNextSymbol().ToIntDef(-1); // numer wejścia + if ((i >= 0) || (i <= 1)){ + fMWDAnalogCalib[i][0] = GetNextSymbol().ToDouble(); // max -> 2^16 -1 + fMWDAnalogCalib[i][1] = GetNextSymbol().ToDouble(); // min -> 0 + fMWDAnalogCalib[i][2] = GetNextSymbol().ToDouble(); // rozdzielczość -> 255 maksymalna możliwa wartość z ADC + if (bMWDdebugEnable) WriteLog("Break settings " + AnsiString(i) + AnsiString(": ") + AnsiString(fMWDAnalogCalib[i][0]) + AnsiString(" ") + AnsiString(fMWDAnalogCalib[i][1]) + AnsiString(" ") + AnsiString(fMWDAnalogCalib[i][2])); + } + } + else if(str == AnsiString("mwdzbiornikglowny")){ + fMWDzg[0] = GetNextSymbol().ToDouble(); + fMWDzg[1] = GetNextSymbol().ToDouble(); + if (bMWDdebugEnable) WriteLog("AirTank settings: " + AnsiString(fMWDzg[0]) + AnsiString(" ") + AnsiString(fMWDzg[1])); + } + else if(str == AnsiString("mwdprzewodglowny")){ + fMWDpg[0] = GetNextSymbol().ToDouble(); + fMWDpg[1] = GetNextSymbol().ToDouble(); + if (bMWDdebugEnable) WriteLog("MainAirPipe settings: " + AnsiString(fMWDpg[0]) + AnsiString(" ") + AnsiString(fMWDpg[1])); + } + else if(str == AnsiString("mwdcylinderhamulcowy")){ + fMWDph[0] = GetNextSymbol().ToDouble(); + fMWDph[1] = GetNextSymbol().ToDouble(); + if (bMWDdebugEnable) WriteLog("AirPipe settings: " + AnsiString(fMWDph[0]) + AnsiString(" ") + AnsiString(fMWDph[1])); + } + else if(str == AnsiString("mwdwoltomierzwn")){ + fMWDvolt[0] = GetNextSymbol().ToDouble(); + fMWDvolt[1] = GetNextSymbol().ToDouble(); + if (bMWDdebugEnable) WriteLog("Volt settings: " + AnsiString(fMWDvolt[0]) + AnsiString(" ") + AnsiString(fMWDvolt[1])); + } + else if(str == AnsiString("mwdamperomierzwn")){ + fMWDamp[0] = GetNextSymbol().ToDouble(); + fMWDamp[1] = GetNextSymbol().ToDouble(); + if (bMWDdebugEnable) WriteLog("Amp settings: " + AnsiString(fMWDamp[0]) + AnsiString(" ") + AnsiString(fMWDamp[1])); + } } while (str != "endconfig"); //(!Parser->EndOfFile) // na koniec trochę zależności if (!bLoadTraction) // wczytywanie drutów i słupów @@ -886,7 +944,7 @@ void TTranscripts::Update() // Ra: tymczasowe rozwiązanie kwestii zagranicznych (czeskich) napisów char bezogonkowo[128] = "E?,?\"_++?%Sstzz" - " ^^L$A|S^CS<--RZo±,l'uP.,as>L\"lz" + " ^^L$A|S^CS<--RZo±,l'uP.,as>L\"lz" "RAAAALCCCEEEEIIDDNNOOOOxRUUUUYTB" "raaaalccceeeeiiddnnoooo-ruuuuyt?"; diff --git a/Globals.h b/Globals.h index 173911ca..a9115ddb 100644 --- a/Globals.h +++ b/Globals.h @@ -322,9 +322,20 @@ class Global static bool AddToQuery(TEvent *event, TDynamicObject *who); static bool DoEvents(); static AnsiString Bezogonkow(AnsiString str, bool _ = false); - static double Min0RSpeed(double vel1, double vel2); - static double CutValueToRange(double min, double value, double max); + static double Min0RSpeed(double vel1, double vel2); + static double CutValueToRange(double min, double value, double max); + // maciek001: zmienne dla MWD + static bool bMWDdebugEnable; + static unsigned long int iMWDBaudrate; + static AnsiString sMWDPortId; + static bool bMWDBreakEnable; + static double fMWDAnalogCalib[4][3]; + static double fMWDzg[2]; + static double fMWDpg[2]; + static double fMWDph[2]; + static double fMWDvolt[2]; + static double fMWDamp[2]; }; //---------------------------------------------------------------------------