eu07/maszyna
16
0
Fork 0
mirror of https://github.com/MaSzyna-EU07/maszyna.git synced 2026-07-22 13:59:19 +02:00
Code Issues 123 Wiki Activity

Browse Source
This commit is contained in:
maciek001
2016-11-21 19:47:46 +01:00
parent 05628cfea4
commit c6f0ce8629
7 changed files with 994 additions and 34 deletions
Download Patch File Download Diff File Expand all files Collapse all files

175
Console.cpp
View File

@@ -15,6 +15,7 @@ http://mozilla.org/MPL/2.0/.
#include "Logs.h" #include "Logs.h"
#include "PoKeys55.h" #include "PoKeys55.h"
#include "LPT.h" #include "LPT.h"
#include "MWD.h" // maciek001: obsluga portu COM
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
#pragma package(smart_init) #pragma package(smart_init)
@@ -108,6 +109,7 @@ int Console::iMode = 0;
int Console::iConfig = 0; int Console::iConfig = 0;
TPoKeys55 *Console::PoKeys55[2] = {NULL, NULL}; TPoKeys55 *Console::PoKeys55[2] = {NULL, NULL};
TLPT *Console::LPT = 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::iSwitch[8]; // bistabilne w kabinie, załączane z [Shift], wyłączane bez
int Console::iButton[8]; // monostabilne w kabinie, załączane podczas trzymania klawisza int Console::iButton[8]; // monostabilne w kabinie, załączane podczas trzymania klawisza
@@ -125,6 +127,7 @@ Console::~Console()
{ {
delete PoKeys55[0]; delete PoKeys55[0];
delete PoKeys55[1]; delete PoKeys55[1];
delete MWD;
}; };
void Console::ModeSet(int m, int h) void Console::ModeSet(int m, int h)
@@ -169,6 +172,15 @@ int Console::On()
PoKeys55[0] = NULL; PoKeys55[0] = NULL;
} }
break; 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; return 0;
}; };
@@ -188,6 +200,10 @@ void Console::Off()
PoKeys55[1] = NULL; PoKeys55[1] = NULL;
delete LPT; delete LPT;
LPT = NULL; 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) void Console::BitsSet(int mask, int entry)
@@ -197,8 +213,8 @@ void Console::BitsSet(int mask, int entry)
int old = iBits; // poprzednie stany int old = iBits; // poprzednie stany
iBits |= mask; iBits |= mask;
BitsUpdate(old ^ iBits); // 1 dla bitów zmienionych BitsUpdate(old ^ iBits); // 1 dla bitów zmienionych
if (iMode == 4) if (iMode == 4)
WriteLog("PoKeys::BitsSet: mask: " + AnsiString(mask) + " iBits: " + AnsiString(iBits)); 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); PoKeys55[0]->Write(0x40, 52 - 1, iBits & 0x1000 ? 1 : 0);
if (mask & 0x2000) // b13 Prąd na silnikach do odbijania w haslerze if (mask & 0x2000) // b13 Prąd na silnikach do odbijania w haslerze
PoKeys55[0]->Write(0x40, 53 - 1, iBits & 0x2000 ? 1 : 0); PoKeys55[0]->Write(0x40, 53 - 1, iBits & 0x2000 ? 1 : 0);
if (mask & 0x4000) // b14 Brzęczyk SHP lub CA if (mask & 0x4000) // b14 Brzęczyk SHP lub CA
PoKeys55[0]->Write(0x40, 16 - 1, iBits & 0x4000 ? 1 : 0); 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; break;
} }
}; };
@@ -288,26 +351,59 @@ void Console::ValueSet(int x, double y)
if (iMode == 4) if (iMode == 4)
if (PoKeys55[0]) if (PoKeys55[0])
{ {
x = Global::iPoKeysPWM[x]; x = Global::iPoKeysPWM[x];
if (Global::iCalibrateOutDebugInfo == x) if (Global::iCalibrateOutDebugInfo == x)
WriteLog("CalibrateOutDebugInfo: oryginal=" + AnsiString(y), false); WriteLog("CalibrateOutDebugInfo: oryginal=" + AnsiString(y), false);
if (Global::fCalibrateOutMax[x] > 0) if (Global::fCalibrateOutMax[x] > 0)
{ {
y = Global::CutValueToRange(0, y, Global::fCalibrateOutMax[x]); y = Global::CutValueToRange(0, y, Global::fCalibrateOutMax[x]);
if (Global::iCalibrateOutDebugInfo == x) if (Global::iCalibrateOutDebugInfo == x)
WriteLog(" cutted=" + AnsiString(y),false); WriteLog(" cutted=" + AnsiString(y),false);
y = y / Global::fCalibrateOutMax[x]; // sprowadzenie do <0,1> jeśli podana maksymalna wartość y = y / Global::fCalibrateOutMax[x]; // sprowadzenie do <0,1> jeśli podana maksymalna wartość
if (Global::iCalibrateOutDebugInfo == x) if (Global::iCalibrateOutDebugInfo == x)
WriteLog(" fraction=" + AnsiString(y),false); WriteLog(" fraction=" + AnsiString(y),false);
} }
double temp = (((((Global::fCalibrateOut[x][5] * y) + Global::fCalibrateOut[x][4]) * y + 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][3]) * y + Global::fCalibrateOut[x][2]) * y +
Global::fCalibrateOut[x][1]) * y + Global::fCalibrateOut[x][1]) * y +
Global::fCalibrateOut[x][0]; // zakres <0;1> Global::fCalibrateOut[x][0]; // zakres <0;1>
if (Global::iCalibrateOutDebugInfo == x) if (Global::iCalibrateOutDebugInfo == x)
WriteLog(" calibrated=" + AnsiString(temp)); WriteLog(" calibrated=" + AnsiString(temp));
PoKeys55[0]->PWM(x, 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() void Console::Update()
@@ -325,6 +421,10 @@ void Console::Update()
Global::iPause |= 8; // tak??? Global::iPause |= 8; // tak???
PoKeys55[0]->Connect(); // próba ponownego podłączenia PoKeys55[0]->Connect(); // próba ponownego podłączenia
} }
if (iMode == 5)// Obs?uga MWD OK
{
MWD->Run();
}
}; };
float Console::AnalogGet(int x) float Console::AnalogGet(int x)
@@ -337,13 +437,26 @@ float Console::AnalogGet(int x)
float Console::AnalogCalibrateGet(int x) float Console::AnalogCalibrateGet(int x)
{ // pobranie i kalibracja wartości analogowej, jeśli nie ma PoKeys zwraca NULL { // pobranie i kalibracja wartości analogowej, jeśli nie ma PoKeys zwraca NULL
if (iMode == 4 && PoKeys55[0]) if (iMode == 4 && PoKeys55[0])
{ {
float b = PoKeys55[0]->fAnalog[x]; float b = PoKeys55[0]->fAnalog[x];
return (((((Global::fCalibrateIn[x][5] * b) + Global::fCalibrateIn[x][4]) * b + return (((((Global::fCalibrateIn[x][5] * b) + Global::fCalibrateIn[x][4]) * b +
Global::fCalibrateIn[x][3]) * b + Global::fCalibrateIn[x][2]) * b + Global::fCalibrateIn[x][3]) * b + Global::fCalibrateIn[x][2]) * b +
Global::fCalibrateIn[x][1]) *b + Global::fCalibrateIn[x][0]; 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 return -1.0; //odcięcie
}; };

2
Console.h
View File

@@ -13,6 +13,7 @@ http://mozilla.org/MPL/2.0/.
class TConsoleDevice; // urz¹dzenie pod³¹czalne za pomoc¹ DLL class TConsoleDevice; // urz¹dzenie pod³¹czalne za pomoc¹ DLL
class TPoKeys55; class TPoKeys55;
class TLPT; class TLPT;
class MWDComm; // maciek001: dodana obsluga portu COM
// klasy konwersji znaków wprowadzanych z klawiatury // klasy konwersji znaków wprowadzanych z klawiatury
class TKeyTrans class TKeyTrans
@@ -31,6 +32,7 @@ class Console
static int iBits; // podstawowy zestaw lampek static int iBits; // podstawowy zestaw lampek
static TPoKeys55 *PoKeys55[2]; // mo¿e ich byæ kilka static TPoKeys55 *PoKeys55[2]; // mo¿e ich byæ kilka
static TLPT *LPT; static TLPT *LPT;
static MWDComm *MWD; // maciek001: na potrzeby MWD
static void BitsUpdate(int mask); static void BitsUpdate(int mask);
// zmienne dla trybu "jednokabinowego", potrzebne do wspó³pracy z pulpitem (PoKeys) // 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 // u¿ywaj¹c klawiatury, ka¿dy pojazd powinien mieæ w³asny stan prze³¹czników

682
Console/MWD.cpp Normal file
View File

@@ -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 <windows.h>
#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<BYTETOWRITE)
{
if(i<BYTETOREAD)ReadDataBuff[i] = 0;
WriteDataBuff[i] = 0;
i++;
}
i=0;
while(i<6)
{
lastStateData[i] = 0;
maskSwitch[i] = 0;
bitSwitch[i] = 0;
i++;
}
}
MWDComm::~MWDComm() // destruktor
{
Close();
}
bool MWDComm::Open() // otwieranie portu COM
{
LPCSTR portId = Global::sMWDPortId.c_str();
hComm = CreateFile(portId, GENERIC_READ | GENERIC_WRITE, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
if (hComm == INVALID_HANDLE_VALUE){
if(GetLastError()==ERROR_FILE_NOT_FOUND){
WriteLog("PortCOM ERROR: serial port does not exist"); //serial port does not exist. Inform user.
}
WriteLog("PortCOM ERROR! not open!");
//some other error occurred. Inform user.
return FALSE;
}
DCB CommDCB;
CommDCB.DCBlength = sizeof(DCB);
GetCommState(hComm, &CommDCB);
CommDCB.BaudRate = Global::iMWDBaudrate;
CommDCB.fBinary = TRUE;
CommDCB.fParity = FALSE;
CommDCB.fOutxCtsFlow = FALSE; // No CTS output flow control
CommDCB.fOutxDsrFlow = FALSE; // No DSR output flow control
CommDCB.fDtrControl = FALSE; // DTR flow control type
CommDCB.fDsrSensitivity = FALSE; // DSR sensitivity
CommDCB.fTXContinueOnXoff = FALSE; // XOFF continues Tx
CommDCB.fOutX = FALSE; // No XON/XOFF out flow control
CommDCB.fInX = FALSE; // No XON/XOFF in flow control
CommDCB.fErrorChar = FALSE; // Disable error replacement
CommDCB.fNull = FALSE; // Disable null stripping
CommDCB.fRtsControl = RTS_CONTROL_DISABLE;
CommDCB.fAbortOnError = FALSE;
CommDCB.ByteSize = 8;
CommDCB.Parity = NOPARITY;
CommDCB.StopBits = ONESTOPBIT;
//konfiguracja portu
if (!SetCommState (hComm, &CommDCB))
{
//dwError = GetLastError ();
WriteLog("Unable to configure the serial port!");
return FALSE;
}
WriteLog("PortCOM OPEN and CONFIG!");
return TRUE;
}
bool MWDComm::Close() // zamykanie portu COM
{
WriteLog("zamykam COM-a");
int i = 0;
while(i<BYTETOWRITE)
{
WriteDataBuff[i] = 0;
i++;
}
Sleep(100);
SendData();
Sleep(700);
CloseHandle(hComm);
WriteLog("COM zamkniety");
return TRUE;
}
bool MWDComm::GetMWDState() // sprawdzanie otwarcia portu COM
{
if(hComm > 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;
}

93
Console/MWD.h Normal file
View File

@@ -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
*/

1
EU07.cpp
View File

@@ -86,6 +86,7 @@ USEUNIT("McZapkie\Oerlikon_ESt.pas");
USEUNIT("Console\PoKeys55.cpp"); USEUNIT("Console\PoKeys55.cpp");
USEUNIT("Forth.cpp"); USEUNIT("Forth.cpp");
USEUNIT("Console\LPT.cpp"); USEUNIT("Console\LPT.cpp");
USEUNIT("Console\MWD.cpp");
USEUNIT("PyInt.cpp"); USEUNIT("PyInt.cpp");
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
#include "World.h" #include "World.h"

60
Globals.cpp
View File

@@ -186,6 +186,17 @@ bool Global::bDoubleAmbient = false; // podw
double Global::fTimeSpeed = 1.0; // przyspieszenie czasu, zmienna do testów double Global::fTimeSpeed = 1.0; // przyspieszenie czasu, zmienna do testów
bool Global::bHideConsole = false; // hunter-271211: ukrywanie konsoli 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 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[1] = GetNextSymbol().ToDouble(); // g
Background[2] = GetNextSymbol().ToDouble(); // b 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) } while (str != "endconfig"); //(!Parser->EndOfFile)
// na koniec trochê zale¿noœci // na koniec trochê zale¿noœci
if (!bLoadTraction) // wczytywanie drutów i s³upów 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 // Ra: tymczasowe rozwi¹zanie kwestii zagranicznych (czeskich) napisów
char bezogonkowo[128] = "E?,?\"_++?%S<STZZ?`'\"\".--??s>stzz" char bezogonkowo[128] = "E?,?\"_++?%S<STZZ?`'\"\".--??s>stzz"
" ^^L$A|S^CS<--RZo±,l'uP.,as>L\"lz" " ^^L$A|S^CS<--RZo±,l'uP.,as>L\"lz"
"RAAAALCCCEEEEIIDDNNOOOOxRUUUUYTB" "RAAAALCCCEEEEIIDDNNOOOOxRUUUUYTB"
"raaaalccceeeeiiddnnoooo-ruuuuyt?"; "raaaalccceeeeiiddnnoooo-ruuuuyt?";

15
Globals.h
View File

@@ -322,9 +322,20 @@ class Global
static bool AddToQuery(TEvent *event, TDynamicObject *who); static bool AddToQuery(TEvent *event, TDynamicObject *who);
static bool DoEvents(); static bool DoEvents();
static AnsiString Bezogonkow(AnsiString str, bool _ = false); static AnsiString Bezogonkow(AnsiString str, bool _ = false);
static double Min0RSpeed(double vel1, double vel2); static double Min0RSpeed(double vel1, double vel2);
static double CutValueToRange(double min, double value, double max); 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];
}; };
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------