GerhardHoffmann/UpdatePTUDevCtrl
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge commit 'f214e0ff43594ebf48a00f8debb96613c307c309'

Browse Source 
fetch sources for CashAgentLib 3.3.
This commit is contained in:
Gerhard Hoffmann
2023-04-13 10:58:17 +02:00
parent dc2584e007 f214e0ff43
commit 1b5eaef37a
11 changed files with 2412 additions and 254 deletions
Download Patch File Download Diff File Expand all files Collapse all files

500
DCPlugin/src/datIf.cpp
View File

@@ -61,6 +61,10 @@ char T_datif::datif_cycleSend()
uint8_t dataSendBuf[160], dataBufLen, dbl, who;
static uint8_t BlockCounter;
uint8_t nextWrCmd, nextRdCmd, blockNum, dat1, dat2, dat3, dat4;
uint8_t length, data[66];
bool b_ret;
if (cycl_running)
{
// request is still running, wait for response before next sending
@@ -77,6 +81,43 @@ char T_datif::datif_cycleSend()
if (myDCIF->isSerialFree())
#endif
{
// new, from 11.4.23: direkt access to fastDevice Interface
// always use this three functions to send data:
//void myDCIF->setUserWriteData(uint16_t WriteCmd, uint16_t WrAddr, uint8_t WrDatLen, uint8_t *data);
//void myDCIF->setUserWriteData(uint16_t WriteCmd, uint16_t WrAddr);
//void myDCIF->setUserWriteData(uint16_t WriteCmd);
//void myDCIF->setUserWrite1DB (uint16_t WriteCmd, uint16_t WrAddr, uint8_t val);
//void myDCIF->setUserWrite2DB (uint16_t WriteCmd, uint16_t WrAddr, uint8_t val0, uint8_t val1);
//void myDCIF->setUserReadData( uint16_t ReadCmd, uint16_t RdAddr, uint16_t reserv);
//void myDCIF->setUserReadData( uint16_t ReadCmd, uint16_t RdAddr);
//void myDCIF->setUserReadData( uint16_t ReadCmd);
//void myDCIF->sendUserData(uint16_t slaveAdr);
if (check4FDshortCmd())
{
b_ret=sendFDcmd_get(&nextWrCmd, &nextRdCmd, &blockNum, &dat1, &dat2, &dat3, &dat4);
if (b_ret)
{
data[0]=dat1; data[1]=dat2; data[2]=dat3; data[3]=dat4; data[4]=0;
myDCIF->setUserWriteData(nextWrCmd, blockNum, 4, data);
myDCIF->setUserReadData(nextRdCmd);
myDCIF->sendUserData(selectedSlaveAddr);
}
}
if (check4FDlongCmd())
{
b_ret=longFDcmd_get(&nextWrCmd, &nextRdCmd, &blockNum, &length, data);
if (b_ret)
{
myDCIF->setUserWriteData(nextWrCmd, blockNum, length, data);
myDCIF->setUserReadData(nextRdCmd);
myDCIF->sendUserData(selectedSlaveAddr);
}
}
// direct commands have highest prio (setting OUTPUTS)
nxtAsCmd=sendWRcmd_getSendCommand0(); // command was stored by Gui
if (nxtAsCmd>0)
@@ -624,62 +665,71 @@ char T_datif::sendINrequestsAutomatic(void)
{
//qDebug() << "send IN request " << dif_scanStep;
// one time: 105, 11,12,101,18
// cyclic: 22,23,24,27, 102,103,104,106,107,108,109,
// fehlen: 112, 113,14,17, 19, 30,31,32,33,
// 38 on request
switch (dif_scanStep)
{
// first 5 items are performed only one time after startup as this data never change
case 0:
datif_sendIOrequest(0, CMD2DC_GetSerialConfig, 0);
datif_sendIOrequest(0, CMD2DC_GetSerialConfig, 0); // 105
break;
case 1:
datif_sendIOrequest(0, CMD2DC_RdBkHWversion, 0);
datif_sendIOrequest(0, CMD2DC_RdBkHWversion, 0); // 11
break;
case 2:
datif_sendIOrequest(0, CMD2DC_RdBkSWversion, 0);
datif_sendIOrequest(0, CMD2DC_RdBkSWversion, 0); // 12
break;
case 3:
datif_sendIOrequest(0, CMD2DC_RdBkDCstate, 0);
datif_sendIOrequest(0, CMD2DC_RdBkDCstate, 0); // 101
break;
case 4:
datif_sendIOrequest(0, CMD2DC_RdBkUID, 0);
datif_sendIOrequest(0, CMD2DC_RdBkUID, 0); // 18
break;
// repeat cyclic from here:
case 5:
datif_sendIOrequest(0, CMD2DC_GetAllInputs, 0);
datif_sendIOrequest(0, CMD2DC_GetAllInputs, 0); // 102
break;
case 6:
datif_sendIOrequest(0, CMD2DC_RdBkTime, 0);
datif_sendIOrequest(0, CMD2DC_RdBkTime, 0); // 104
break;
case 7:
datif_sendIOrequest(0, CMD2DC_GetAllInputs, 0);
//datif_sendIOrequest(0, CMD2DC_GetAllInputs, 0);
datif_sendIOrequest(0, 112, 0);
break;
case 8:
datif_sendIOrequest(0, CMD2DC_RdBkAnalog, 0);
datif_sendIOrequest(0, CMD2DC_RdBkAnalog, 0); // 106
break;
case 9:
datif_sendIOrequest(0, CMD2DC_GetAllInputs, 0);
//datif_sendIOrequest(0, CMD2DC_GetAllInputs, 0);
datif_sendIOrequest(0, 113, 0);
break;
case 10:
datif_sendIOrequest(0, CMD2DC_RdBkAllOutputs, 0);
datif_sendIOrequest(0, CMD2DC_RdBkAllOutputs, 0); // 103
break;
case 11:
datif_sendIOrequest(0, CMD2DC_GetAllInputs, 0);
//datif_sendIOrequest(0, CMD2DC_GetAllInputs, 0);
datif_sendIOrequest(0, 14, 0);
break;
case 12:
if (indat_isPrinterOn())
datif_sendIOrequest(0, CMD2DC_RdBk_AllPrnData, 0);
datif_sendIOrequest(0, CMD2DC_RdBk_AllPrnData, 0); // 27
// datif_sendIOrequest(0, CMD2DC_RdBk_PrnState, 0);
break;
@@ -690,20 +740,21 @@ char T_datif::sendINrequestsAutomatic(void)
case 14:
if (indat_isMifareOn())
{
datif_sendIOrequest(0, CMD2DC_RdBk_MifState, 0);
datif_sendIOrequest(0, CMD2DC_RdBk_MifState, 0); // 109
//qDebug()<<"requesting MIF reader state";
}
break;
case 15:
datif_sendIOrequest(0, CMD2DC_GetAllInputs, 0);
//datif_sendIOrequest(0, CMD2DC_GetAllInputs, 0);
datif_sendIOrequest(0, 17, 0);
break;
case 16:
if (indat_isMifareOn())
{
datif_OutCmdpara1=0; // data block number 0 contains the Mifare-ID
datif_sendIOrequest(0, CMD2DC_RdBk_MifData, 1);
datif_sendIOrequest(0, CMD2DC_RdBk_MifData, 1); // 24
// qDebug()<<"automatically requesting mif card data";
if (++RDBLKNR>11)
RDBLKNR=0;
@@ -712,23 +763,24 @@ char T_datif::sendINrequestsAutomatic(void)
} break;
case 17:
datif_sendIOrequest(0, CMD2DC_GetAllInputs, 0);
//datif_sendIOrequest(0, CMD2DC_GetAllInputs, 0);
datif_sendIOrequest(0, 19, 0);
break;
case 18:
if (indat_isMdbOn())
datif_sendIOrequest(0, CMD2DC_MDB_GET_STATE, 0);
datif_sendIOrequest(0, CMD2DC_MDB_GET_STATE, 0); // 107
//else
// dif_scanStep=24; unsinn
break;
case 19:
datif_sendIOrequest(0, CMD2DC_GetAllInputs, 0);
datif_sendIOrequest(0, 30, 0);
break;
case 20:
//if (indat_isMdbOn())
datif_sendIOrequest(0, CMD2DC_MDB_GETRESP, 0);
datif_sendIOrequest(0, CMD2DC_MDB_GETRESP, 0); // 22
break;
@@ -738,23 +790,32 @@ char T_datif::sendINrequestsAutomatic(void)
case 22:
//if (indat_isMdbOn()) // kein eigener Schalter für EMP
datif_sendIOrequest(0, CMD2DC_EMP_GET_ALL, 0);
datif_sendIOrequest(0, CMD2DC_EMP_GET_ALL, 0); // 23
break;
case 23:
datif_sendIOrequest(0, CMD2DC_GetAllInputs, 0);
datif_sendIOrequest(0, 31, 0);
break;
case 24:
//if (indat_isMdbOn()) // kein eigener Schalter für EMP
datif_sendIOrequest(0, CMD2DC_EMP_GOTCOIN, 0);
datif_sendIOrequest(0, CMD2DC_EMP_GOTCOIN, 0); // 108
break;
case 25:
datif_sendIOrequest(0, 32, 0);
break;
case 26:
datif_sendIOrequest(0, 33, 0);
break;
}
dif_scanStep++;
if (dif_scanStep>=25)
dif_scanStep=0; //dif_scanStep=5;
if (dif_scanStep>26)
dif_scanStep=5;
return 0;
@@ -792,13 +853,13 @@ void T_datif::StoredRecData()
char T_datif::loadRecDataFromFrame()
{
// necessary data in T_prot:
uint16_t readSource, uitmp;
uint16_t readSource, uitmp,uit2;
uint16_t readAddress;
//uint8_t pp;
uint8_t SlaveAdr, RdDleng;
uint8_t receivedData[FRAME_DATALEN];
QString localStr;
//uint32_t ultmp;
uint32_t ultmp;
//int portNr;
bool ret;
uint8_t uctmp; // maxai
@@ -837,7 +898,7 @@ char T_datif::loadRecDataFromFrame()
// receivedData[1]='B';
// receivedData[2]='1';
// receivedData[3]='-';
// for (int ii=0; ii<4; ii++) haut hin :)
for (int ii=0; ii<RdDleng; ii++)
{
@@ -847,7 +908,7 @@ char T_datif::loadRecDataFromFrame()
//qDebug() << "got HW version: " << localStr;
switch (readSource) // = request command
{
case CMD2DC_TestSerial: // serial line check
case CMD2DC_TestSerial: // serial line check 10
ret=verifyLineTestresponse(RdDleng, receivedData);
gpi_storeResult_serialTestOK(ret);
if (ret==true)
@@ -856,41 +917,41 @@ char T_datif::loadRecDataFromFrame()
gpi_setTxt4datifLine("false");
break;
case CMD2DC_GetSerialConfig: // get slave's RS232 config
case CMD2DC_GetSerialConfig: // get slave's RS232 config 105
gpi_storeSlaveSerParams(receivedData[0], receivedData[1], receivedData[2], receivedData[3]);
//gpi_storeSlaveBusAddr(SlaveAdr);
break;
case CMD2DC_RdBkHWversion:
case CMD2DC_RdBkHWversion: //11
//qDebug() << "got HW version: " << localStr;
gpi_storeGenerals(0, localStr);
// 0=HW 1=SW 2=State
//gpi_storeSlaveBusAddr(SlaveAdr);
break;
case CMD2DC_RdBkSWversion:
case CMD2DC_RdBkSWversion: //12
//qDebug() << "got SW version: " << localStr;
gpi_storeGenerals(1, localStr);
break;
case CMD2DC_RdBkDCstate:
case CMD2DC_RdBkDCstate: //101
//qDebug() << "got DC state " << localStr;
localStr[8]=0;
gpi_storeGenerals(2, localStr);
// 0=HW 1=SW 2=State
break;
case CMD2DC_RdBkUID: // getback UID in DB0....7
case CMD2DC_RdBkUID: // getback UID in DB0....7 18
gpi_storeUID(receivedData);
break;
case CMD2DC_RdBkTime: // slave returned RTC time and date
case CMD2DC_RdBkTime: // slave returned RTC time and date 104
// new, FastProt: 0=dayOfWeek 1=min 2=sec 3=hours 4=year 5=month 6=dayOfYear
gpi_backupTime(receivedData, RdDleng); // function reads 20 bytes from the buffer
break;
case CMD2DC_RdBkAnalog: // get ALL AIs 0...3, 4byte + 2byte each
case CMD2DC_RdBkAnalog: // get ALL AIs 0...3, 4byte + 2byte each 106
// DB0,1: Value0=Temperature
// DB2,3: Value1=Voltage
@@ -906,7 +967,7 @@ char T_datif::loadRecDataFromFrame()
gpi_storeAIs(1, uitmp);
break;
case CMD2DC_GetAllInputs:
case CMD2DC_GetAllInputs: //102
/*
// alle DI's in einen 8byte Puffer zusammenstellen, werden in einen Rutsch zum Master gesendet
@@ -990,7 +1051,7 @@ char T_datif::loadRecDataFromFrame()
gpi_storeDI_paperLow(receivedData[5]);
break;
case CMD2DC_RdBkAllOutputs:
case CMD2DC_RdBkAllOutputs: //103
/*
// alle DO's in einen 8byte Puffer zusammenstellen, werden in einen Rutsch zum Master gesendet
@@ -1048,27 +1109,27 @@ char T_datif::loadRecDataFromFrame()
break;
case CMD2DC_RdBk_MifState:
case CMD2DC_RdBk_MifState: //109
// get reader status and card type
gpi_storeMifReaderStateAndCardType(receivedData);
break;
case CMD2DC_RdBk_MifData:
case CMD2DC_RdBk_MifData: //24
// one block of data (64byte) comes in
// blkNr 0...11 in "Addr"
gpi_storeMifCardData(readAddress, receivedData);
//qDebug()<<"datif storing mif data: (adr/data) "<<readAddress<<receivedData;
break;
case CMD2DC_RdBk_AtbCardType:
case CMD2DC_RdBk_AtbCardType: //25
// DC reports the type of mif-card (valid ATB card?)
break;
case CMD2DC_RdBk_PrnState: // 0x2A02
case CMD2DC_RdBk_PrnState: // 110
// byte 1...6 come right from printer, see printer manual
// byte 0 = all important infos:
@@ -1080,7 +1141,7 @@ char T_datif::loadRecDataFromFrame()
gpi_storePrinterState(receivedData); // derzeit 10bytes ( 0x2A02)
break;
case CMD2DC_RdBk_PrnFonts: // 0x2A12
case CMD2DC_RdBk_PrnFonts: // 26
//D0: font table/type
//D1: size
//D2: height
@@ -1094,7 +1155,7 @@ char T_datif::loadRecDataFromFrame()
gpi_storePrinterFonts(receivedData); // derzeit 10bytes
break;
case CMD2DC_RdBk_AllPrnData: // 0x2A40
case CMD2DC_RdBk_AllPrnData: // 27
gpi_storePrinterState(receivedData); // derzeit 10bytes ( 0x2A02)
gpi_storePrinterFonts(&receivedData[10]); // derzeit 10bytes
/*
@@ -1107,7 +1168,7 @@ char T_datif::loadRecDataFromFrame()
*/
break;
case CMD2DC_MDB_GET_STATE:
case CMD2DC_MDB_GET_STATE: //107
// DB0: mdb_bus_ready (switched on)
// DB1: rdBackV12devicePower
// DB2: rdBackV5busPwr
@@ -1116,7 +1177,7 @@ char T_datif::loadRecDataFromFrame()
gpi_storeMdbState(receivedData[0],receivedData[1],receivedData[2]);
break;
case CMD2DC_MDB_GETRESP:
case CMD2DC_MDB_GETRESP: //22
// last received mdb answer (from mdb device)
// only needed if a special command was sent directly
// DB0: mdb Device-Nr
@@ -1127,12 +1188,12 @@ char T_datif::loadRecDataFromFrame()
gpi_storeMdbResponse(receivedData[2]+3, receivedData);
break;
case CMD2DC_EMP_GET_ALL:
case CMD2DC_EMP_GET_ALL: //23
//qDebug() << "got emp parameters "<< receivedData[1];
gpi_storeEmpSettings(64, receivedData);
break;
case CMD2DC_EMP_GOTCOIN:
case CMD2DC_EMP_GOTCOIN: //108
// DB0: 1=coin 0xFF=error 0=got nothing
// DB1: last coin signal (value / scale)
// DB2,3: last coin value
@@ -1140,18 +1201,355 @@ char T_datif::loadRecDataFromFrame()
gpi_storeEmpCoinSignal(receivedData[0], &receivedData[1]);
break;
case CMD2DC_RDBK_DEV_PARA:
gpi_storeDeviceSettings(RdDleng, receivedData);
// ab hier neu: XXX
case CMD2DC_RDBK_DEV_PARA: //14
/*
buf66[0]=devPara.kindOfPrinter;
buf66[1]=devPara.kindOfCoinChecker;
buf66[2]=devPara.kindOfMifareReader;
buf66[3]=devPara.suppressSleepMode;
buf66[4]=devPara.kindOfModem;
buf66[5]=devPara.kindOfCreditcard;
buf66[6]=devPara.CoinEscrow;
buf66[7]=devPara.CoinRejectUnit;
buf66[8]=devPara.CoinShutter;
buf66[9]=devPara.BillAcceptor;
buf66[10]=devPara.usevaultLock;
buf66[11]=devPara.autoAlarm;
buf66[12]=devPara.autoOpen;
buf66[13]=devPara.printAccReceipt;
buf66[14]=devPara.printDoorReceipt;
buf66[15]=devPara.printTokenTicket;
uitmp=devPara.VaultFullWarnLevel;
buf66[16]=swl_getOneByteFromUint(uitmp, GETLOWBYT);
buf66[17]=swl_getOneByteFromUint(uitmp, GETHIGHBYT);
uitmp=devPara.VaultFullErrorLevel;
buf66[18]=swl_getOneByteFromUint(uitmp, GETLOWBYT);
buf66[19]=swl_getOneByteFromUint(uitmp, GETHIGHBYT);
*/
gpi_storeRbDeviceSettings(RdDleng, receivedData);
break;
case CMD2DC_RDBK_MACH_ID:
// get machine parameters and location
case CMD2DC_RDBK_MACH_ID: //15
case 17:
/*
buf66[0]=swl_getOneByteFromUint(machPara.customerNumber, GETLOWBYT);
buf66[1]=swl_getOneByteFromUint(machPara.customerNumber, GETHIGHBYT);
buf66[2]=swl_getOneByteFromUint(machPara.machineNumber, GETLOWBYT);
buf66[3]=swl_getOneByteFromUint(machPara.machineNumber, GETHIGHBYT);
buf66[4]=swl_getOneByteFromUint(machPara.borough, GETLOWBYT);
buf66[5]=swl_getOneByteFromUint(machPara.borough, GETHIGHBYT);
buf66[6]=swl_getOneByteFromUint(machPara.zone, GETLOWBYT);
buf66[7]=swl_getOneByteFromUint(machPara.zone, GETHIGHBYT);
buf66[8]=swl_getOneByteFromUint(machPara.alias, GETLOWBYT);
buf66[9]=swl_getOneByteFromUint(machPara.alias, GETHIGHBYT);
for (pp=0; pp<32; pp++)
buf66[10+pp]=machPara.location[pp];
dc2prot_setReadData(42, buf66);
*/
gpi_storeMachineIDsettings(RdDleng, receivedData);
break;
case 19: // get time and date and Extra values
/*
buf[0]=GlobTime.Hours;
buf[1]=GlobTime.Min;
buf[2]=GlobTime.Sec;
buf[3]=GlobTime.Year;
buf[4]=GlobTime.Month;
buf[5]=GlobTime.Day;
buf[6]=GlobTime.DOW;
buf[7]=' '; // immer auf 32bit auffüllen sonst Speicherproblem beim Master!
uitmp=GlobTime.MinOfDay;
buf[8]=swl_getOneByteFromUint(uitmp, 0);
buf[9]=swl_getOneByteFromUint(uitmp, 1);
buf[10]=' ';
buf[11]=' ';
ultmp=GlobTime.SecOfDay;
buf[12]=swl_getOneByteFromUlong(ultmp, 0);
buf[13]=swl_getOneByteFromUlong(ultmp, 1);
buf[14]=swl_getOneByteFromUlong(ultmp, 2);
buf[15]=swl_getOneByteFromUlong(ultmp, 3);
buf[16]=swl_isLeap(GlobTime.Year);
buf[17]=swl_getNextLeapYear(GlobTime.Year);
buf[18]=swl_getLastLeapYear(GlobTime.Year);
buf[19]=swl_hoursOfThisWeek(GlobTime.DOW, GlobTime.Hours);
uitmp=swl_minutesOfThisWeek(GlobTime.DOW, GlobTime.Hours, GlobTime.Min);
buf[20]=swl_getOneByteFromUint(uitmp, 0); // 0=low byte 1=high byte
buf[21]=swl_getOneByteFromUint(uitmp, 1);
uitmp=swl_hoursOfThisMonth(GlobTime.Day, GlobTime.Hours);
buf[22]=swl_getOneByteFromUint(uitmp, 0);
buf[23]=swl_getOneByteFromUint(uitmp, 1);
uitmp=swl_minutesOfThisMonth(GlobTime.Day, GlobTime.Hours, GlobTime.Min);
buf[24]=swl_getOneByteFromUint(uitmp, 0);
buf[25]=swl_getOneByteFromUint(uitmp, 1);
uitmp=swl_GetDaysOfYear(GlobTime.Year, GlobTime.Month, GlobTime.Day);
buf[26]=swl_getOneByteFromUint(uitmp, 0);
buf[27]=swl_getOneByteFromUint(uitmp, 1);
uitmp=swl_GetHoursOfYear(GlobTime.Year, GlobTime.Month, GlobTime.Day, GlobTime.Hours);
buf[28]=swl_getOneByteFromUint(uitmp, 0);
buf[29]=swl_getOneByteFromUint(uitmp, 1);
buf[30]=0;
buf[31]=0;
ultmp= swl_GetMinutesOfYear(GlobTime.Year, GlobTime.Month, GlobTime.Day,
GlobTime.Hours, GlobTime.Min);
buf[32]=swl_getOneByteFromUlong(ultmp, 0);
buf[33]=swl_getOneByteFromUlong(ultmp, 1);
buf[34]=swl_getOneByteFromUlong(ultmp, 2);
buf[35]=swl_getOneByteFromUlong(ultmp, 3);
buf[36]=rtc_getSqwaveSettings();
buf[37]=0;
buf[38]=0;
buf[39]=0;
ultmp= 0; // Minutes of the Millenium
buf[40]=swl_getOneByteFromUlong(ultmp, 0);
buf[41]=swl_getOneByteFromUlong(ultmp, 1);
buf[42]=swl_getOneByteFromUlong(ultmp, 2);
buf[43]=swl_getOneByteFromUlong(ultmp, 3);
dc2prot_setReadData(44, buf);
*/
// speicher-fkt fehlt noch, gpi_backupTime ist nur kurz
gpi_storeExtendedTime(RdDleng, receivedData);
break;
case 111: // get square wafe settings
gpi_backupSquareMode(receivedData[0]);
break;
case 112: // get inserted amount in cent in sum
// byte 0..3: amount just paid 4,5:last coin type 6,7: last coin value
ultmp=uchar2ulong(receivedData[3],receivedData[2],receivedData[1],receivedData[0]);
uitmp=uchar2uint(receivedData[5],receivedData[4]);
uit2=uchar2uint(receivedData[7],receivedData[6]);
gpi_storeCurrentPayment(ultmp, uitmp, uit2);
break;
case 113: // get wake source, 8byte
gpi_storeWakeSources(receivedData);
break;
case 30: // Get Devices Condition (warnings, errors)
/*
outBuf[0]=modCond.ram;
outBuf[1]=modCond.intEe;
outBuf[2]=modCond.extEe;
outBuf[3]=modCond.rtc;
outBuf[4]=modCond.boardHw;
outBuf[5]=modCond.printer;
outBuf[6]=modCond.modem;
outBuf[7]=modCond.signal;
outBuf[8]=modCond.regist;
outBuf[9]=modCond.mdbBus;
outBuf[10]=modCond.coinChecker;
outBuf[11]=modCond.coinEscrow;
outBuf[12]=modCond.mifareReader;
outBuf[13]=modCond.creditTerm;
outBuf[14]=modCond.coinReject;
outBuf[15]=modCond.coinSafe;
outBuf[16]=modCond.billSafe;
outBuf[17]=modCond.voltage;
outBuf[18]=modCond.temper;
outBuf[19]=modCond.poweronTest;
outBuf[20]=modCond.doorState;
outBuf[21]=modCond.doorWasOpened;
outBuf[22]=modCond.changer;
outBuf[23]=modCond.coinBlocker;
outBuf[24]=modCond.billReader;
outBuf[25]=modCond.ResetReason;
outBuf[26]=modCond.allModulesChecked;
outBuf[27]=modCond.alarmState;
outBuf[28]=0;
outBuf[29]=0;
*/
gpi_storeDeviceConditions(RdDleng, receivedData);
break;
case 31: // Get dynamic machine conditions (doors, voltage, alarm….)
/*
outBuf[pBuf++]=dynCond.allDoorsDebounced;
outBuf[pBuf++]=dynCond.openedAuthorized;
outBuf[pBuf++]=dynCond.CBinDebounced;
outBuf[pBuf++]=dynCond.upperDoor;
outBuf[pBuf++]=dynCond.middleDoor;
outBuf[pBuf++]=dynCond.lowerDoor;
outBuf[pBuf++]=dynCond.coinBox;
outBuf[pBuf++]=dynCond.billBox;
outBuf[pBuf++]=dynCond.modeAbrech;
outBuf[pBuf++]=dynCond.onAlarm;
outBuf[pBuf++]=dynCond.nowCardTest;
outBuf[pBuf++]=dynCond.nowPayment;
outBuf[pBuf++]=dynCond.lastMifCardType;
outBuf[pBuf++]=dynCond.lastSDoorState;
outBuf[pBuf++]=dynCond.lastVDoorState;
outBuf[pBuf++]=dynCond.lastCBstate;
outBuf[pBuf++]=dynCond.paymentInProgress;
outBuf[pBuf++]=0;
uitmp=dynCond.U_Batt;
outBuf[pBuf++]=swl_getOneByteFromUint(uitmp, GETLOWBYT);
outBuf[pBuf++]=swl_getOneByteFromUint(uitmp, GETHIGHBYT);
uitmp=dynCond.Temperatur;
outBuf[pBuf++]=swl_getOneByteFromUint(uitmp, GETLOWBYT);
outBuf[pBuf++]=swl_getOneByteFromUint(uitmp, GETHIGHBYT);
uitmp=dynCond.nrCoinsInBox; // send seperate also
outBuf[pBuf++]=swl_getOneByteFromUint(uitmp, GETLOWBYT);
outBuf[pBuf++]=swl_getOneByteFromUint(uitmp, GETHIGHBYT);
ultmp=dynCond.amountInBox; // send seperate also
outBuf[pBuf++]=swl_getOneByteFromUlong(ultmp, GETLOWESTBYT);
outBuf[pBuf++]=swl_getOneByteFromUlong(ultmp, GETLOWMID);
outBuf[pBuf++]=swl_getOneByteFromUlong(ultmp, GETHIGHMID);
outBuf[pBuf++]=swl_getOneByteFromUlong(ultmp, GETHIGHESTBYT);
ultmp=dynCond.totalTransVolume;
outBuf[pBuf++]=swl_getOneByteFromUlong(ultmp, GETLOWESTBYT);
outBuf[pBuf++]=swl_getOneByteFromUlong(ultmp, GETLOWMID);
outBuf[pBuf++]=swl_getOneByteFromUlong(ultmp, GETHIGHMID);
outBuf[pBuf++]=swl_getOneByteFromUlong(ultmp, GETHIGHESTBYT);
ultmp=dynCond.totalNrOfVends;
outBuf[pBuf++]=swl_getOneByteFromUlong(ultmp, GETLOWESTBYT);
outBuf[pBuf++]=swl_getOneByteFromUlong(ultmp, GETLOWMID);
outBuf[pBuf++]=swl_getOneByteFromUlong(ultmp, GETHIGHMID);
outBuf[pBuf++]=swl_getOneByteFromUlong(ultmp, GETHIGHESTBYT);
// 36
outBuf[pBuf++]=dynCond.jsonValid_config;
outBuf[pBuf++]=dynCond.jsonValid_device;
outBuf[pBuf++]=dynCond.jsonValid_cash;
outBuf[pBuf++]=dynCond.jsonValid_print;
outBuf[pBuf++]=dynCond.jsonValid_serial;
outBuf[pBuf++]=dynCond.jsonValid_time;
outBuf[pBuf++]=dynCond.lastFileType;
outBuf[pBuf++]=0;
*/
gpi_storeDynMachineConditions(RdDleng, receivedData);
break;
case 32: // Get current cash level (in vault)
// bytes 0..3: amount bytes 4,5=Nr.ofCoins in vault
break;
case 33: // Get all backuped acc. Numbers
// 8 UINTs with acc-nr
break;
case 38: // Get stored account record backup
/*
struct T_vaultRecord
{
UCHAR startbuffer[4]; // Psa> // never move or change this 1st entry
UINT AccountingNumber;
UINT CUNU;
UINT MANU;
UINT resint1;
//UINT resint2;
UCHAR label1buffer[4]; // tim>
UCHAR year;
UCHAR month;
UCHAR dom;
UCHAR hour;
UCHAR min;
UCHAR sec;
UCHAR DoW;
UCHAR reschar3;
UCHAR label2buffer[4]; // abs>
ULONG AbsIncome1;
ULONG AbsReserve;
ULONG AbsNrOfCuts;
//16
UCHAR label3buffer[4]; // mw >
// Verkauf, Tür zu:
ULONG VKcoinsInserted[16]; // nur für Wechsler, soviel wurde eingeworfen
ULONG VKcoinsReturned[6]; // nur für Wechsler, Anzahl Münzen pro Typ, soviel wurde zurückgegeben
//88
// Service, Tür offen:
UINT ServCoinsInserted[16]; // nur für Wechsler, soviel wurde eingeworfen
UINT ServCoinsReturned[6]; // nur für Wechsler, Anzahl Münzen pro Typ, soviel wurde zurückgegeben
UINT resint3;
UINT resint4;
UINT currentTubeContent[6]; // nur für Wechsler, aktueller Füllstand
UINT resint5;
UINT resint6;
// 56
UCHAR label4buffer[4]; // box>
UINT coinsInVault[16];
UINT billsInStacker[8];
// 48
UCHAR label5buffer[4]; // val>
// actually constant unless exchange rate is changed
UINT coinDenomination[16]; // 5..50000 (z.B. 2€ sind in Ungarn 760Ft)
UINT billDenom[8];
UINT tubeDenom[6];
UINT exchangeRate;
UINT resint9;
// 64
UCHAR endofblock[4]; // end>
// 316 byte Block im Speicher
*/
break;
}
return 0;
}
// fehlen: 112, 113,14,17, 19, 30,31,32,33,
// subs:

403
DCPlugin/src/hwapi.cpp
View File

@@ -1490,8 +1490,32 @@ void hwapi::request_ReadbackDeviceSettings() const
void hwapi::readback_DeviceSettings(uint8_t *length, uint8_t *data) const
{
epi_restoreDeviceSettings(length, data);
epi_restoreRbDeviceSettings(length, data);
/*
buf66[0]=devPara.kindOfPrinter;
buf66[1]=devPara.kindOfCoinChecker;
buf66[2]=devPara.kindOfMifareReader;
buf66[3]=devPara.suppressSleepMode;
buf66[4]=devPara.kindOfModem;
buf66[5]=devPara.kindOfCreditcard;
buf66[6]=devPara.CoinEscrow;
buf66[7]=devPara.CoinRejectUnit;
buf66[8]=devPara.CoinShutter;
buf66[9]=devPara.BillAcceptor;
buf66[10]=devPara.usevaultLock;
buf66[11]=devPara.autoAlarm;
buf66[12]=devPara.autoOpen;
buf66[13]=devPara.printAccReceipt;
buf66[14]=devPara.printDoorReceipt;
buf66[15]=devPara.printTokenTicket;
uitmp=devPara.VaultFullWarnLevel;
buf66[16]=swl_getOneByteFromUint(uitmp, GETLOWBYT);
buf66[17]=swl_getOneByteFromUint(uitmp, GETHIGHBYT);
uitmp=devPara.VaultFullErrorLevel;
buf66[18]=swl_getOneByteFromUint(uitmp, GETLOWBYT);
buf66[19]=swl_getOneByteFromUint(uitmp, GETHIGHBYT);
*/
}
// ....................................................................................
@@ -1530,6 +1554,22 @@ void hwapi::request_ReadbackMachineID() const
void hwapi::readback_machineIDdata(uint8_t *length, uint8_t *data) const
{
epi_restoreMachineIDsettings(length, data);
/*
buf66[0]=swl_getOneByteFromUint(machPara.customerNumber, GETLOWBYT);
buf66[1]=swl_getOneByteFromUint(machPara.customerNumber, GETHIGHBYT);
buf66[2]=swl_getOneByteFromUint(machPara.machineNumber, GETLOWBYT);
buf66[3]=swl_getOneByteFromUint(machPara.machineNumber, GETHIGHBYT);
buf66[4]=swl_getOneByteFromUint(machPara.borough, GETLOWBYT);
buf66[5]=swl_getOneByteFromUint(machPara.borough, GETHIGHBYT);
buf66[6]=swl_getOneByteFromUint(machPara.zone, GETLOWBYT);
buf66[7]=swl_getOneByteFromUint(machPara.zone, GETHIGHBYT);
buf66[8]=swl_getOneByteFromUint(machPara.alias, GETLOWBYT);
buf66[9]=swl_getOneByteFromUint(machPara.alias, GETHIGHBYT);
for (pp=0; pp<32; pp++)
buf66[10+pp]=machPara.location[pp];
dc2prot_setReadData(42, buf66);
*/
}
@@ -2831,6 +2871,10 @@ void hwapi::led_switchLedIllumination(uint8_t on) const
// neu, 25.3.23
// ------------------------------------------------------------------------------------
// 27.3.2023: Use Device-Controller's Bootloader to send hex-file
// ------------------------------------------------------------------------------------
void hwapi::bl_rebootDC(void) const
{
uint8_t len, buf[20];
@@ -3014,4 +3058,361 @@ void hwapi::bl_sendFile(void) const
*/
// ------------------------------------------------------------------------------------
// 6.4.2023: new functions for coin collection and printing
// some new system functions
// ------------------------------------------------------------------------------------
// use:
// bool sendFDcmd_set(uint8_t nextWrCmd, uint8_t nextRdCmd, uint8_t blockNum, uint8_t dat1, uint8_t dat2, uint8_t dat3, uint8_t dat4);
// write Command to memory, wait for transport
// bool longFDcmd_set(uint8_t nextWrCmd, uint8_t nextRdCmd, uint8_t blockNum, uint8_t length, uint8_t *data);
// write Command to memory, wait for transport
// data buffer size always 64! data[64], padded with 0
bool hwapi::rtc_setTimeDateDirect(struct Trtc_DateTime *DateTime) const
{
// return true if successful. could fail if more the 8 commands are waiting
uint8_t temp[66];
bool b_ret;
/* in interfaces.h:
struct Trtc_DateTime
{
uint8_t rtc_hour;
uint8_t rtc_min;
uint8_t rtc_sec;
uint8_t rtc_dayOfMonth;
uint8_t rtc_month;
uint8_t rtc_year;
uint8_t rtc_dayOfWeek;
};
*/
tslib_strclr(temp,0,66);
temp[0]= DateTime->rtc_hour;
temp[1]= DateTime->rtc_min;
temp[2]= DateTime->rtc_sec;
temp[3]= 20;
temp[4]= DateTime->rtc_year;
temp[5]= DateTime->rtc_month;
temp[6]= DateTime->rtc_dayOfMonth;
temp[7]= DateTime->rtc_dayOfWeek;
b_ret=longFDcmd_set(20,0,0,8,temp);
return b_ret;
}
bool hwapi::rtc_getExtendedTime(uint8_t *leng, uint8_t *data) const
{
epi_restoreExtendedTime(leng, data);
return true;
/*
buf[0]=GlobTime.Hours;
buf[1]=GlobTime.Min;
buf[2]=GlobTime.Sec;
buf[3]=GlobTime.Year;
buf[4]=GlobTime.Month;
buf[5]=GlobTime.Day;
buf[6]=GlobTime.DOW;
buf[7]=' '; // immer auf 32bit auffüllen sonst Speicherproblem beim Master!
uitmp=GlobTime.MinOfDay;
buf[8]=swl_getOneByteFromUint(uitmp, 0);
buf[9]=swl_getOneByteFromUint(uitmp, 1);
buf[10]=' ';
buf[11]=' ';
ultmp=GlobTime.SecOfDay;
buf[12]=swl_getOneByteFromUlong(ultmp, 0);
buf[13]=swl_getOneByteFromUlong(ultmp, 1);
buf[14]=swl_getOneByteFromUlong(ultmp, 2);
buf[15]=swl_getOneByteFromUlong(ultmp, 3);
buf[16]=swl_isLeap(GlobTime.Year);
buf[17]=swl_getNextLeapYear(GlobTime.Year);
buf[18]=swl_getLastLeapYear(GlobTime.Year);
buf[19]=swl_hoursOfThisWeek(GlobTime.DOW, GlobTime.Hours);
uitmp=swl_minutesOfThisWeek(GlobTime.DOW, GlobTime.Hours, GlobTime.Min);
buf[20]=swl_getOneByteFromUint(uitmp, 0); // 0=low byte 1=high byte
buf[21]=swl_getOneByteFromUint(uitmp, 1);
uitmp=swl_hoursOfThisMonth(GlobTime.Day, GlobTime.Hours);
buf[22]=swl_getOneByteFromUint(uitmp, 0);
buf[23]=swl_getOneByteFromUint(uitmp, 1);
uitmp=swl_minutesOfThisMonth(GlobTime.Day, GlobTime.Hours, GlobTime.Min);
buf[24]=swl_getOneByteFromUint(uitmp, 0);
buf[25]=swl_getOneByteFromUint(uitmp, 1);
uitmp=swl_GetDaysOfYear(GlobTime.Year, GlobTime.Month, GlobTime.Day);
buf[26]=swl_getOneByteFromUint(uitmp, 0);
buf[27]=swl_getOneByteFromUint(uitmp, 1);
uitmp=swl_GetHoursOfYear(GlobTime.Year, GlobTime.Month, GlobTime.Day, GlobTime.Hours);
buf[28]=swl_getOneByteFromUint(uitmp, 0);
buf[29]=swl_getOneByteFromUint(uitmp, 1);
buf[30]=0;
buf[31]=0;
ultmp= swl_GetMinutesOfYear(GlobTime.Year, GlobTime.Month, GlobTime.Day,
GlobTime.Hours, GlobTime.Min);
buf[32]=swl_getOneByteFromUlong(ultmp, 0);
buf[33]=swl_getOneByteFromUlong(ultmp, 1);
buf[34]=swl_getOneByteFromUlong(ultmp, 2);
buf[35]=swl_getOneByteFromUlong(ultmp, 3);
buf[36]=rtc_getSqwaveSettings();
buf[37]=0;
buf[38]=0;
buf[39]=0;
ultmp= 0; // Minutes of the Millenium
buf[40]=swl_getOneByteFromUlong(ultmp, 0);
buf[41]=swl_getOneByteFromUlong(ultmp, 1);
buf[42]=swl_getOneByteFromUlong(ultmp, 2);
buf[43]=swl_getOneByteFromUlong(ultmp, 3);
dc2prot_setReadData(44, buf);
*/
}
bool hwapi::sys_runCompleteTest(void) const
{
// warning: lasts 20s in one pace
return sendFDcmd_set(149, 0,0, 0,0,0,0);
}
bool hwapi::sys_ready4sending(void) const
{
// return true if a Json-file can be sent
// check free memory
uint8_t frei=FDLONG_STACKDEPTH - check4FDlongCmd();
// Command-Stack sollte 16 Commands fassen, je 64byte Nutzdaten = 1024byte
// in check4FDlongCmd() steht wieviele Plaetze bereits belegt sind
// frei gibt also die Anzahl freier 64byte Bloecke zurueck
// das Json-File hat max 800 byte = 13 bloecke
if (frei<16) // Puffer muss ganz leer sein! nicht dass was durcheinander kommt
return false;
return true;
}
bool hwapi::sys_sendJsonFileToDc(uint8_t kindOfFile, uint8_t nrOfTemplate, uint8_t *content ) const
{
// kindOfFile: 1=config, 2=device, 3=cash, 4=serial, 5=time, 6=printer
// nrOfTemplate=1...32 if kindOfFile==6
// content = content of the Json file, max 800byte ascii signs
// file is 0-terminated
// return false if sending is not possible, wait a second
uint8_t dateiArt, NummDesTempl;
uint8_t inhaltOfJson[802], temp[66];
uint16_t dateiLang, uitmp;
uint8_t nrOfBlocks;
uint8_t frei, bn=0;
dateiArt=kindOfFile;
NummDesTempl=nrOfTemplate;
tslib_strclr(inhaltOfJson,0,801);
dateiLang=tslib_strlen(content);
if (dateiLang>800) dateiLang=800;
tslib_strcpy(content, inhaltOfJson, dateiLang); // enthaelt genaue Laenge, Rest =0
nrOfBlocks=dateiLang/64;
if (dateiLang%64>0)
nrOfBlocks++;
dateiLang=nrOfBlocks;
dateiLang<<=6; // auf volle 64byte aufgerundet
// check free memory
frei=FDLONG_STACKDEPTH - check4FDlongCmd();
// Command-Stack sollte 16 Commands fassen, je 64byte Nutzdaten = 1024byte
// in check4FDlongCmd() steht wieviele Plaetze bereits belegt sind
// frei gibt also die Anzahl freier 64byte Bloecke zurueck
// das Json-File hat max 800 byte = 13 bloecke
if (frei<16) // Puffer muss ganz leer sein! nicht dass was durcheinander kommt
return false;
// Start- und Stop auch als langes Kommando schicken
// PROBLEM: wuerden sie in einem anderen Batch gespeichert (short command stack),
// dann kann die Reihenfolge nicht gewaehrleistet werden
// Das Startkommando muss sicher zuerst kommen
// Das Abschlusskommando muss sicher zuletzt kommen
tslib_strclr(temp,0,65);
temp[0]=dateiArt;
temp[1]=NummDesTempl;
longFDcmd_set(30, 0,0, 2,temp); // sende "Starte-file-DL"
uitmp=0; bn=0;
do
{
biox_CopyBlock(inhaltOfJson, uitmp, temp, 0, 64);
longFDcmd_set(31,0, bn++, 64, temp);
uitmp<<=6;
} while(uitmp < dateiLang);
longFDcmd_set(32, 0,0, 0,temp); // Abschluss
return true;
}
//char prn_dynPrnVal[8][8];
bool hwapi::prn_sendDynamicPrnValues(uint8_t *dynPrnVal ) const
// dynPrnVal = array of 8 Variables with 8 byte each, come as ascii string
// like: char prn_dynPrnVal[8][8];
// return true if sending, false if cmd-stack is full
{
uint8_t temp[66];
tslib_strcpy(dynPrnVal, temp, 64); // Vorsicht, kann \0en enthalten
return longFDcmd_set(33,0,0, 64, temp);
}
bool hwapi::prn_printTemplate(uint8_t nrOftemplate) const
// print one of the templates loaded by Json prior
// nr = 1..32
{
// return true if sending, false if cmd-stack is full
return sendFDcmd_set(152, 0,0, nrOftemplate,0,0,0);
}
void hwapi::log_getHoldAccountNumbers(uint32_t *accNr ) const
// returns all acc nrs of the backuped vault records
// use: uint32_t backupedAccNumbers[8]
{
Q_UNUSED(accNr);
}
bool hwapi::log_selectVaultRecord(uint16_t accountNr ) const
{
// return true if sending, false if cmd-stack is full
uint8_t dat1, dat2;
dat1=uint2uchar(accountNr, LOWBYTE);
dat2=uint2uchar(accountNr, HIGHBYTE);
return sendFDcmd_set(153, 0,0, dat1,dat2,0,0);
}
//request, isAvailable
void hwapi::log_getVaultRecord(struct T_vaultRecord *retVR) const
// which was selected by: log_selectVaultRecord()
// to be forwarded to Ismas
{
Q_UNUSED(retVR);
}
bool hwapi::prn_printAccountReceipt(void) const
{
return sendFDcmd_set(154, 0,0, 0,0,0,0);
}
bool hwapi::prn_printTestTicket(void) const
{
// return true if sending to DC OK, false if cmd-stack is full
return sendFDcmd_set(157, 0,0, 0,0,0,0);
}
bool hwapi::cash_startPayment(uint16_t amount) const
{
uint8_t dat1, dat2;
epi_clearCurrentPayment();
dat1=uint2uchar(amount, LOWBYTE);
dat2=uint2uchar(amount, HIGHBYTE);
return sendFDcmd_set(155, 0,0, dat1,dat2,0,0);
}
uint32_t hwapi::getInsertedAmount(void) const
{
return epi_CurrentPaymentGetAmount();
}
uint16_t hwapi::getLastInsertedCoin(void) const
{
return epi_CurrentPaymentGetLastCoin();
}
bool hwapi::getAllInsertedCoins(uint16_t *types, uint16_t *values) const
{
// alle bei diesem Verkauf eingeworfenen Münzen sind gespeichert, max 64
return epi_CurrentPaymentGetAllCoins(types, values);
}
bool hwapi::cash_cancelPayment(void) const
// and return coins
{
// DB1: 1=encash 2=cancel & return coins
// 3=stop and keep coins in escrow
return sendFDcmd_set(156, 0,0, 2,0,0,0);
}
bool hwapi::cash_stopPayment(void) const
// and keep coins in escrow
{
// DB1: 1=encash 2=cancel & return coins
// 3=stop and keep coins in escrow
return sendFDcmd_set(156, 0,0, 3,0,0,0);
}
// after ticket/goods issue:
bool hwapi::vend_success(void) const
// conclude payment process, encash all inserted coins to vault. Printing was successful
// if possible return change
{
// DB1: 1=encash 2=cancel & return coins
// 3=stop and keep coins in escrow
return sendFDcmd_set(156, 0,0, 1,0,0,0);
}
bool hwapi::vend_failed(void) const
// conclude payment process and return all inserted coins
{
// DB1: 1=encash 2=cancel & return coins
// 3=stop and keep coins in escrow
return sendFDcmd_set(156, 0,0, 2,0,0,0);
}
uint8_t hwapi::mif_getCardType(QString cardholder) const
// return 1,2,3,4 = upper, lower access card, printer test, coin test
// cardholder: 7byte Name-String
{
Q_UNUSED(cardholder);
return 0; // to satisfy compiler
}
uint64_t hwapi::sys_getWakeSource(void) const
{
// retval: 6 bytes, bit coded, 1=event keeps DC awake
return epi_getWakeSources();
}
//void hwapi::sys_getDeviceConditions(struct T_moduleCondition *devCond) const
void hwapi::sys_getDeviceConditions(uint8_t *leng, uint8_t *data) const
{
//uint8_t leng, data[66];
epi_restoreDeviceConditions(leng, data);
}
//void hwapi::sys_getDynMachineConditions(struct T_dynamicCondition *dynMachCond) const
void hwapi::sys_getDynMachineConditions(uint8_t *leng, uint8_t *data) const
{
epi_restoreDeviceConditions(leng, data);
}

243
DCPlugin/src/sendWRcmd.cpp
View File

@@ -13,7 +13,8 @@ void sendWRcmd_INI(void)
sendWRcmd_clrCmdStack();
sendWRcmd_clrCmd4Stack();
sendFDcmd_clrStack();
longFDcmd_clrStack();
}
// Command Stack for commands without parameters
@@ -60,13 +61,19 @@ bool sendWRcmd_setSendCommand0(uint16_t nextCmd)
uint16_t sendWRcmd_getSendCommand0(void)
{
uint16_t nxtAsynchCmd;
uint8_t nn;
uint8_t nn, ll;
if (nrOfCmdsInQueue==0 || nrOfCmdsInQueue>CMDSTACKDEPTH)
return 0; // error
nxtAsynchCmd=nextAsynchsendCmd0[0];
// move Puffer down by one element
for (nn=0; nn<CMDSTACKDEPTH; nn++)
if (CMDSTACKDEPTH>0)
ll=CMDSTACKDEPTH-1;
else
ll=0;
for (nn=0; nn<ll; nn++)
nextAsynchsendCmd0[nn]=nextAsynchsendCmd0[nn+1];
if (nrOfCmdsInQueue>0)
nrOfCmdsInQueue--;
//qDebug() << "PI cmd queued:"<< nxtAsynchCmd << ", restored, pp now =" << nrOfCmdsInQueue;
@@ -138,7 +145,7 @@ bool sendWRcmd_setSendCommand4(uint16_t nextCmd, uint8_t dat1, uint8_t dat2, uin
uint16_t sendWRcmd_getSendCommand4(uint8_t *dat1, uint8_t *dat2, uint8_t *dat3, uint8_t *dat4)
{
uint16_t nxtAsynchCmd;
uint8_t nn;
uint8_t nn, ll;
if (nrOfCmds4InQueue==0 || nrOfCmds4InQueue>CMD4STACKDEPTH)
return 0; // error
@@ -152,7 +159,11 @@ uint16_t sendWRcmd_getSendCommand4(uint8_t *dat1, uint8_t *dat2, uint8_t *dat3,
// " data3: " << nextCmd4para3[0] << " data4: " << nextCmd4para4[0];
// move Puffer down by one element
for (nn=0; nn<CMD4STACKDEPTH; nn++)
if (CMD4STACKDEPTH>0)
ll=CMD4STACKDEPTH-1;
else
ll=0;
for (nn=0; nn<ll; nn++)
{
nextAsynchsendCmd4[nn]=nextAsynchsendCmd4[nn+1];
nextCmd4para1[nn]=nextCmd4para1[nn+1];
@@ -211,9 +222,9 @@ bool sendWRcmd_setSendCommand8(uint16_t nextCmd, uint8_t dat1, uint8_t dat2, uin
uint16_t sendWRcmd_getSendCommand8(uint8_t *dat1, uint8_t *dat2, uint16_t *dat3, uint32_t *dat4)
{
uint16_t nxtAsynchCmd;
uint8_t nn;
uint8_t nn, ll;
if (nrOfCmds8InQueue==0 || nrOfCmds8InQueue>CMD4STACKDEPTH)
if (nrOfCmds8InQueue==0 || nrOfCmds8InQueue>CMD8STACKDEPTH)
return 0; // error
nxtAsynchCmd=nextAsynchsendCmd8[0];
*dat1=nextCmd8para1[0];
@@ -222,7 +233,11 @@ uint16_t sendWRcmd_getSendCommand8(uint8_t *dat1, uint8_t *dat2, uint16_t *dat3,
*dat4=nextCmd8para4[0];
// move buffer down by one element
for (nn=0; nn<CMD8STACKDEPTH; nn++)
if (CMD8STACKDEPTH>0)
ll=CMD8STACKDEPTH-1;
else
ll=0;
for (nn=0; nn<ll; nn++)
{
nextAsynchsendCmd8[nn]=nextAsynchsendCmd8[nn+1];
nextCmd8para1[nn]=nextCmd8para1[nn+1];
@@ -433,3 +448,215 @@ uint8_t gpi_chk4remainingText(void)
// ---------------------------------------------------------------------------------
// 11.4.23 neu, Kommando direkt an "FastDevice"-protokoll senden, nicht mehr umsetzen
// ---------------------------------------------------------------------------------
// short command, 4 data bytes
static uint8_t nextFDwrCmd[FDCMD_STACKDEPTH];
static uint8_t nextFDrdCmd[FDCMD_STACKDEPTH];
static uint8_t nextFDblkNr[FDCMD_STACKDEPTH];
static uint8_t nextFDpara1[FDCMD_STACKDEPTH];
static uint8_t nextFDpara2[FDCMD_STACKDEPTH];
static uint8_t nextFDpara3[FDCMD_STACKDEPTH];
static uint8_t nextFDpara4[FDCMD_STACKDEPTH];
static uint8_t p_nextFDcmdsInQueue;
/* convention: use simple (not rotating) FIFO Stack:
Example: nrOfCmdsInQueue=4 then
nextAsynchsendCmd0[0]=cmd1 // was stored as first
nextAsynchsendCmd0[1]=cmd2
nextAsynchsendCmd0[2]=cmd3
nextAsynchsendCmd0[3]=cmd4 // came in as last
Send: [0] first, then move buffer 1 down:
nextAsynchsendCmd0[0]=cmd2
nextAsynchsendCmd0[1]=cmd3
nextAsynchsendCmd0[2]=cmd4
nextAsynchsendCmd0[3]=0;
nrOfCmdsInQueue=3 now
*/
void sendFDcmd_clrStack(void)
{
uint8_t nn;
for (nn=0; nn<FDCMD_STACKDEPTH; nn++)
{
nextFDwrCmd[nn]=0;
nextFDrdCmd[nn]=0;
nextFDblkNr[nn]=0;
nextFDpara1[nn]=0;
nextFDpara2[nn]=0;
nextFDpara3[nn]=0;
nextFDpara4[nn]=0;
}
p_nextFDcmdsInQueue=0;
}
bool sendFDcmd_set(uint8_t nextWrCmd, uint8_t nextRdCmd, uint8_t blockNum, uint8_t dat1, uint8_t dat2, uint8_t dat3, uint8_t dat4)
{
// write Command to memory, wait for transport
if (p_nextFDcmdsInQueue>=FDCMD_STACKDEPTH)
{
qDebug() << "cannot save cmd because stack is full";
return false; // not possible
}
nextFDwrCmd[p_nextFDcmdsInQueue]=nextWrCmd;
nextFDrdCmd[p_nextFDcmdsInQueue]=nextRdCmd;
nextFDblkNr[p_nextFDcmdsInQueue]=blockNum;
nextFDpara1[p_nextFDcmdsInQueue]=dat1;
nextFDpara2[p_nextFDcmdsInQueue]=dat2;
nextFDpara3[p_nextFDcmdsInQueue]=dat3;
nextFDpara4[p_nextFDcmdsInQueue]=dat4;
//qDebug() << "data with 4 data byte saved, pp=" << nrOfCmds4InQueue;
//qDebug() << " dat1=" << nextCmd4para1[nrOfCmds4InQueue] << " dat2=" << nextCmd4para2[nrOfCmds4InQueue]
// << " dat3=" << nextCmd4para3[nrOfCmds4InQueue] << " dat4=" << nextCmd4para4[nrOfCmds4InQueue];
p_nextFDcmdsInQueue++;
return true; // ok, will be sent
}
bool sendFDcmd_get(uint8_t *nextWrCmd, uint8_t *nextRdCmd, uint8_t *blockNum, uint8_t *dat1, uint8_t *dat2, uint8_t *dat3, uint8_t *dat4)
{
uint8_t nn, ll;
if (p_nextFDcmdsInQueue==0 || p_nextFDcmdsInQueue>FDCMD_STACKDEPTH)
return false; // not possible
*nextWrCmd=nextFDwrCmd[0];
*nextRdCmd=nextFDrdCmd[0];
*blockNum=nextFDblkNr[0];
*dat1=nextFDpara1[0];
*dat2=nextFDpara2[0];
*dat3=nextFDpara3[0];
*dat4=nextFDpara4[0];
//qDebug() << "cmd4 restored to send from [0]; pp=" << nrOfCmds4InQueue;
//qDebug() << " data1: " << nextCmd4para1[0] << " data2: " << nextCmd4para2[0] <<
// " data3: " << nextCmd4para3[0] << " data4: " << nextCmd4para4[0];
// move Puffer down by one element
if (FDCMD_STACKDEPTH>0)
ll=FDCMD_STACKDEPTH-1;
else
ll=0;
for (nn=0; nn<ll; nn++)
{
nextFDwrCmd[nn]=nextFDwrCmd[nn+1];
nextFDrdCmd[nn]=nextFDrdCmd[nn+1];
nextFDblkNr[nn]=nextFDblkNr[nn+1];
nextFDpara1[nn]=nextFDpara1[nn+1];
nextFDpara2[nn]=nextFDpara2[nn+1];
nextFDpara3[nn]=nextFDpara3[nn+1];
nextFDpara4[nn]=nextFDpara4[nn+1];
}
if (p_nextFDcmdsInQueue>0)
p_nextFDcmdsInQueue--;
//qDebug() << "cmd4 after push down: pp=" << nrOfCmds4InQueue;
return true; // ok, will be sent
}
uint8_t check4FDshortCmd(void)
{
// returns number of waiting command
return p_nextFDcmdsInQueue;
}
// long command, 64 data bytes
static uint8_t longFDwrCmd[FDLONG_STACKDEPTH];
static uint8_t longFDrdCmd[FDLONG_STACKDEPTH];
static uint8_t longFDblkNr[FDLONG_STACKDEPTH];
static uint8_t longFDlength[FDLONG_STACKDEPTH];
static uint8_t longFDpara[FDLONG_STACKDEPTH][64];
static uint8_t p_longFDcmdsInQueue;
void longFDcmd_clrStack(void)
{
uint8_t nn, mm;
for (nn=0; nn<FDLONG_STACKDEPTH; nn++)
{
longFDwrCmd[nn]=0;
longFDrdCmd[nn]=0;
longFDblkNr[nn]=0;
longFDlength[nn]=0;
for (mm=0; mm<64; mm++)
longFDpara[nn][mm]=0;
}
p_longFDcmdsInQueue=0;
}
bool longFDcmd_set(uint8_t nextWrCmd, uint8_t nextRdCmd, uint8_t blockNum, uint8_t length, uint8_t *data)
{
// write Command to memory, wait for transport
// data buffer size always 64! data[64], padded with 0
uint8_t nn;
if (p_longFDcmdsInQueue>=FDLONG_STACKDEPTH)
{
qDebug() << "cannot save cmd because stack is full";
return false; // not possible
}
longFDwrCmd[p_longFDcmdsInQueue]=nextWrCmd;
longFDrdCmd[p_longFDcmdsInQueue]=nextRdCmd;
longFDblkNr[p_longFDcmdsInQueue]=blockNum;
longFDlength[p_longFDcmdsInQueue]=length;
for (nn=0; nn<64; nn++)
longFDpara[p_longFDcmdsInQueue][nn]=data[nn];
p_longFDcmdsInQueue++;
return true; // ok, will be sent
}
bool longFDcmd_get(uint8_t *nextWrCmd, uint8_t *nextRdCmd, uint8_t *blockNum, uint8_t *length, uint8_t *data)
{
uint8_t nn, mm, ll;
if (p_longFDcmdsInQueue==0 || p_longFDcmdsInQueue>FDLONG_STACKDEPTH)
return false; // not possible
*nextWrCmd= longFDwrCmd[0];
*nextRdCmd= longFDrdCmd[0];
*blockNum = longFDblkNr[0];
*length = longFDlength[0];
for (mm=0; mm<64; mm++)
data[mm] = longFDpara[0][mm];
// move Puffer down by one element
if (FDLONG_STACKDEPTH>0)
ll=FDLONG_STACKDEPTH-1;
else
ll=0;
for (nn=0; nn<ll; nn++)
{
longFDwrCmd[nn] = longFDwrCmd[nn+1];
longFDrdCmd[nn] = longFDrdCmd[nn+1];
longFDblkNr[nn] = longFDblkNr[nn+1];
longFDlength[nn] = longFDlength[nn+1];
for (mm=0; mm<64; mm++)
longFDpara[nn][mm] = longFDpara[nn+1][mm];
}
if (p_longFDcmdsInQueue>0)
p_longFDcmdsInQueue--;
return true; // ok, will be sent
}
uint8_t check4FDlongCmd(void)
{
// returns number of waiting command
return p_longFDcmdsInQueue;
}

133
DCPlugin/src/storeINdata.cpp
View File

@@ -1522,20 +1522,17 @@ qDebug()<<"read emp data, nr "<<ctr_gotCoin << "valid: " << *valid
static uint8_t Sdata_NrOfDeviceSetting;
static uint8_t Sdata_DeviceSettingBuff[66];
void gpi_storeDeviceSettings(uint8_t leng, uint8_t *data)
void gpi_storeRbDeviceSettings(uint8_t leng, uint8_t *data) // getestet am 12.4.23TS
{
if (leng>64) leng=64;
Sdata_NrOfDeviceSetting=leng;
tslib_strcpy(data, Sdata_DeviceSettingBuff, leng);
tslib_strcpy(data, Sdata_DeviceSettingBuff, leng); // getestet am 12.4.23TS
}
void epi_restoreDeviceSettings(uint8_t *leng, uint8_t *data)
void epi_restoreRbDeviceSettings(uint8_t *leng, uint8_t *data) // getestet am 12.4.23TS
{
*leng=Sdata_NrOfDeviceSetting;
@@ -1563,10 +1560,134 @@ void epi_restoreMachineIDsettings(uint8_t *leng, uint8_t *data)
}
static uint32_t store_insertedAmount;
static uint16_t store_lastCoinType[64];
static uint16_t store_lastCoinValue[64];
static uint8_t p_lastCoin;
void epi_clearCurrentPayment(void)
{
// call at beginning of coin collection
store_insertedAmount=0;
p_lastCoin=0;
}
void gpi_storeCurrentPayment(uint32_t insertedAmount, uint16_t lastCoinType, uint16_t lastCoinValue)
{
store_insertedAmount=insertedAmount;
store_lastCoinType[p_lastCoin]=lastCoinType;
store_lastCoinValue[p_lastCoin]=lastCoinValue;
p_lastCoin++;
}
uint32_t epi_CurrentPaymentGetAmount(void)
{
return store_insertedAmount;
}
uint16_t epi_CurrentPaymentGetLastCoin(void)
{
uint8_t pp;
pp=p_lastCoin;
if (pp==0)
return 0; // noch keine Münze erhalten
if (pp>0) pp--;
return store_lastCoinValue[pp];
}
bool epi_CurrentPaymentGetAllCoins(uint16_t *types, uint16_t *values)
{
// alle bei diesem Verkauf eingeworfenen Münzen sind gespeichert falls die jmd. braucht
uint8_t nn;
if (p_lastCoin==0)
return false;
for (nn=0; nn<64; nn++)
{
types[nn]=store_lastCoinType[nn];
values[nn]=store_lastCoinValue[nn];
}
return true;
}
uint64_t stor_wakSrc;
void gpi_storeWakeSources(uint8_t *receivedData)
{
uint8_t uctmp;
int nn;
stor_wakSrc=0;
for (nn=7; nn>=0; nn--)
{
uctmp=receivedData[nn];
stor_wakSrc |=uctmp;
stor_wakSrc<<=8;
}
}
uint64_t epi_getWakeSources(void)
{
return stor_wakSrc;
}
static uint8_t store_rbDevParamLen;
static uint8_t store_rbDevParams[66];
void gpi_storeExtendedTime(uint8_t leng, uint8_t *data)
{
if (leng>64) leng=64;
store_rbDevParamLen=leng;
tslib_strcpy(data, store_rbDevParams, leng);
}
void epi_restoreExtendedTime(uint8_t *leng, uint8_t *data)
{
*leng=store_rbDevParamLen;
tslib_strcpy(store_rbDevParams, data, store_rbDevParamLen);
}
// store device conditions
static uint8_t store_deviceCondLen;
static uint8_t store_deviceCond[66];
void gpi_storeDeviceConditions(uint8_t leng, uint8_t *data)
{
if (leng>64) leng=64;
store_deviceCondLen=leng;
tslib_strcpy(data, store_deviceCond, leng);
}
void epi_restoreDeviceConditions(uint8_t *leng, uint8_t *data)
{
*leng=store_deviceCondLen;
tslib_strcpy(store_deviceCond, data, store_deviceCondLen);
}
// store dynamic machine conditions
static uint8_t store_machCondLen;
static uint8_t store_machCond[66];
void gpi_storeDynMachineConditions(uint8_t leng, uint8_t *data)
{
if (leng>64) leng=64;
store_machCondLen=leng;
tslib_strcpy(data, store_machCond, leng);
}
void epi_restoreDynMachineConditions(uint8_t *leng, uint8_t *data)
{
*leng=store_machCondLen;
tslib_strcpy(store_machCond, data, store_machCondLen);
}

24
DCPlugin/src/tslib.cpp
View File

@@ -344,6 +344,15 @@ uint16_t tslib_strlen(char *buf)
return 0;
}
uint16_t tslib_strlen(uint8_t *buf)
{
uint16_t nn;
for (nn=0; nn<0xFFF0; nn++)
if (buf[nn]==0)
return nn;
return 0;
}
void tslib_strclr(char *buf, char clrsign, uint16_t len)
{
@@ -555,3 +564,18 @@ uint8_t tslib_sendFlashStartAddr2BL(uint32_t startAddr, uint8_t *sendData)
// -----------------------------------------------------------------------------------------------
void biox_CopyBlock(uint8_t *src, uint16_t srcPos, uint8_t *dest, uint16_t destPos, uint16_t len)
{
// both buffers starting from pos 0
uint16_t xx,yy,zz,ii;
xx = srcPos;
yy = destPos;
zz = len;
for (ii = 0; ii < zz; ++ii)
{
dest[yy + ii] = src[xx + ii];
}
}