GerhardHoffmann/DCLibraries
1
0
Fork 1
Code Issues Pull Requests Packages Projects Releases Wiki Activity
7130d052e7
DCLibraries/src/hwapi.cpp

4663 lines
129 KiB
C++
Raw Normal View History

Start repository
2023-11-08 13:02:26 +01:00
/*
* API to the PSA2020 Hardware
* All data come in from device controller via serial interface and will be stored
* PI is updated every 100ms
* This api uses stored data and returns them in the following functions
* created: Q1/2020 TS until Q2/21
14.7.23TS: patch for correct printer state in line 3364 in sys_getDeviceConditions(struct T_moduleCondition *devCond) const
8.9.2023 two new functions (end of file) for mifare test. Interface version 4.4 DC4.40...4.43
14.09.2023: Verriegelung eingebaut, nur noch gültige Abr.Daten zurückgeben, Suchbegriff: <epi_restoreVaultRecord>
alle Mifare-Funktionen ueberprueft und ggf verbessert
18.09.2023: Signal "Kasse entnommen" und Signale "Tuer auf/zu" ueberprueft
20.9.2023: in datif die Abfrage der DynMachineData massiv beschleunigt
und hier in hwapi die entprellten Werte fuer Tueren und Kasse verwenden.
Problem war: Signal "Kasse entnommen" war zu langsam -> manchmal abr nicht gesendet
*/
#include "hwapi.h"
Add headers for download/reporting thread.
2023-12-20 16:50:00 +01:00
#include "download_thread.h"
#include "reporting_thread.h"
#include <cstring>
#include <QThread>
#include <QDebug>
Start repository
2023-11-08 13:02:26 +01:00
static uint32_t hwapi_lastStartAmount;
static uint32_t hwapi_lastTotalAmount;
static uint8_t hwapi_cash_lastCollectionState;
static uint8_t hwapi_paymentStarted;
static uint8_t hwapi_lastDoorState;
static uint8_t bl_startupStep;
hwapi::hwapi(QWidget *parent) : QObject(parent)
{
// constructor
Minor: add some debug output (versions, build times)
2023-12-20 16:50:23 +01:00
qCritical() << " hwapi::hwapi() APP_VERSION:" << APP_VERSION;
qCritical() << " hwapi::hwapi() APP_BUILD_DATE:" << APP_BUILD_DATE;
qCritical() << " hwapi::hwapi() APP_BUILD_TIME:" << APP_BUILD_TIME;
qCritical() << " hwapi::hwapi() APP_EXTENDED_VERSION:" << APP_EXTENDED_VERSION;
qCritical() << "hwapi::hwapi() APP_EXTENDED_VERSION_LIB:" << APP_EXTENDED_VERSION_LIB;
Start repository
2023-11-08 13:02:26 +01:00
// create or attach shared memory segment
m_sharedMem = SharedMem::getShm(sizeof(SharedMem));
if (m_sharedMem) {
if (m_sharedMem->isAttached()) {
qInfo() << "Shared memory ("
<< sizeof(SharedMem) << "bytes) created and attached";
}
} else {
qCritical() << "Creating/attaching shared memory failed";
}
//if (shdMem_firstUse()) // für Master raus
// {
#ifdef THIS_IS_CA_MASTER
Add COMPILER-CHECKS: datif is only valid inside the master-lib.
2023-12-18 10:41:56 +01:00
#ifdef THIS_IS_CA_SLAVE
#error "SLAVE LIB COMPILED INTO MASTER"
#endif
Start repository
2023-11-08 13:02:26 +01:00
myDatif = new T_datif(); // für die CAslave-Lib auskommentieren!
Add COMPILER-CHECKS: datif is only valid inside the master-lib.
2023-12-18 10:41:56 +01:00
Set compiler check: make sure MASTER and SLAVE defines are not set at the same time.
2023-12-18 12:11:45 +01:00
#endif
#ifdef THIS_IS_CA_SLAVE
Add COMPILER-CHECKS: datif is only valid inside the master-lib.
2023-12-18 10:41:56 +01:00
#ifdef THIS_IS_CA_MASTER
#error "MASTER LIB COMPILED INTO MASTER"
Set compiler check: make sure MASTER and SLAVE defines are not set at the same time.
2023-12-18 12:11:45 +01:00
#endif
Add COMPILER-CHECKS: datif is only valid inside the master-lib.
2023-12-18 10:41:56 +01:00
Start repository
2023-11-08 13:02:26 +01:00
#endif
// }
runProcess = new T_runProc();
sendWRcmd_INI();
hwapi_TimerPayment = new QTimer();
hwapi_TimerPayment->setSingleShot(true);
QTimer *hwapi_callPayProc = new QTimer();
connect(hwapi_callPayProc, SIGNAL(timeout()), this, SLOT(hwapi_slotPayProc()));
hwapi_callPayProc->setSingleShot(false);
hwapi_callPayProc->start(100); // in ms
// hwapi_triggerBL = new QTimer();
// connect(hwapi_triggerBL, SIGNAL(timeout()), this, SLOT(bl_performComplStart()));
// hwapi_triggerBL->setSingleShot(false);
// hwapi_triggerBL->stop();
hwapi_lastStartAmount=0;
hwapi_lastTotalAmount=0;
hwapi_cash_lastCollectionState=0;
hwapi_paymentStarted=0;
//csv_startCreatingFile(FILENAME_SHAREDDATA);
hwapi_lastDoorState=0; // default: all doors (should be) closed, coin box inserted
// bit0: upper door 1:middle 2:lower 3=cash-box out
bl_startupStep=0;
// connect(runProcess, SIGNAL(runProc_coinCollectionJustStarted()), this, SLOT(hwapi_coinCollectionJustStarted())); // geht nicht zuverlaessig!
connect(runProcess, SIGNAL(runProc_coinCollectionJustStarted()), this, SLOT(sub_slotCoin01()));
connect(runProcess, SIGNAL(runProc_coinCollectionAborted()), this, SLOT(sub_slotCoin02())); // hwapi_coinCollectionAborted()));
connect(runProcess, SIGNAL(runProc_gotNewCoin()), this, SLOT(sub_slotCoin03())); // hwapi_gotNewCoin()));
connect(runProcess, SIGNAL(runProc_payStopByMax()), this, SLOT(sub_slotCoin04())); // hwapi_payStopByMax()));
connect(runProcess, SIGNAL(runProc_payStopByPushbutton()), this, SLOT(sub_slotCoin05())); // hwapi_payStopByPushbutton()));
connect(runProcess, SIGNAL(runProc_payStopByEscrow()), this, SLOT(sub_slotCoin06())); // hwapi_payStopByEscrow()));
connect(runProcess, SIGNAL(runProc_payStopByError()), this, SLOT(sub_slotCoin07())); // hwapi_payStopByError()));
connect(runProcess, SIGNAL(runProc_payStopByTimeout()), this, SLOT(sub_slotCoin08())); // hwapi_payStopByTimeout()));
connect(runProcess, SIGNAL(runProc_payCancelled()), this, SLOT(sub_slotCoin09())); // hwapi_payCancelled()));
connect(runProcess, SIGNAL(runProc_coinProcessJustStopped()), this, SLOT(sub_slotCoin10())); // hwapi_coinProcessJustStopped()));
connect(runProcess, SIGNAL(runProc_doorServiceDoorOpened()), this, SLOT(sub_slotCoin11())); // hwapi_doorServiceDoorOpened()));
connect(runProcess, SIGNAL(runProc_doorVaultDoorOpened()), this, SLOT(sub_slotCoin12())); // hwapi_doorVaultDoorOpened()));
connect(runProcess, SIGNAL(runProc_doorCoinBoxRemoved()), this, SLOT(sub_slotCoin13())); // hwapi_doorCoinBoxRemoved()));
connect(runProcess, SIGNAL(runProc_doorCoinBoxInserted()), this, SLOT(sub_slotCoin14())); // hwapi_doorCoinBoxInserted()));
connect(runProcess, SIGNAL(runProc_doorCBinAndAllDoorsClosed()), this, SLOT(sub_slotCoin15())); // hwapi_doorCBinAndAllDoorsClosed()));
connect(runProcess, SIGNAL(runProc_doorAllDoorsClosed()), this, SLOT(sub_slotCoin16())); // hwapi_doorAllDoorsClosed()));
}
void hwapi::hwapi_slotPayProc(void)
{
}
void hwapi::sub_slotCoin01(void)
{
emit hwapi_coinCollectionJustStarted();
//qDebug()<<"hwapi::sub_slotCoin01()";
}
void hwapi::sub_slotCoin02(void)
{
emit hwapi_coinCollectionAborted();
//qDebug()<<"hwapi::sub_slotCoin02()";
}
void hwapi::sub_slotCoin03(void)
{
emit hwapi_gotNewCoin();
//qDebug()<<"hwapi::sub_slotCoin03()";
}
void hwapi::sub_slotCoin04(void)
{
emit hwapi_payStopByMax();
//qDebug()<<"hwapi::sub_slotCoin04()";
}
void hwapi::sub_slotCoin05(void)
{
emit hwapi_payStopByPushbutton();
//qDebug()<<"hwapi::sub_slotCoin05()";
}
void hwapi::sub_slotCoin06(void)
{
emit hwapi_payStopByEscrow();
qDebug()<<"hwapi::sub_slotCoin06()";
}
void hwapi::sub_slotCoin07(void)
{
emit hwapi_payStopByError();
//qDebug()<<"hwapi::sub_slotCoin07()";
}
void hwapi::sub_slotCoin08(void)
{
emit hwapi_payStopByTimeout();
//qDebug()<<"hwapi::sub_slotCoin08()";
}
void hwapi::sub_slotCoin09(void)
{
emit hwapi_payCancelled();
//qDebug()<<"hwapi::sub_slotCoin09()";
}
void hwapi::sub_slotCoin10(void)
{
emit hwapi_coinProcessJustStopped();
//qDebug()<<"hwapi::sub_slotCoin10()";
}
void hwapi::sub_slotCoin11(void)
{
emit hwapi_doorServiceDoorOpened();
}
void hwapi::sub_slotCoin12(void)
{
emit hwapi_doorVaultDoorOpened();
}
void hwapi::sub_slotCoin13(void)
{
emit hwapi_doorCoinBoxRemoved();
}
void hwapi::sub_slotCoin14(void)
{
emit hwapi_doorCoinBoxInserted();
}
void hwapi::sub_slotCoin15(void)
{
emit hwapi_doorCBinAndAllDoorsClosed();
}
void hwapi::sub_slotCoin16(void)
{
emit hwapi_doorAllDoorsClosed();
}
/*
void hwapi::sub_storeSendingText(QByteArray *buf) const
{
char local[70], copie[1350]; // 64byte more then max buffer size!
int LL, nn, len, maxruns=20;
epi_resetPrinterStack();
// make a copy of the incoming byteArray as the byteArray can not be moved (crash!)
tslib_strclr(copie, 0, 1350);
LL=buf->length();
for (nn=0; nn<LL; nn++)
{
copie[nn]=buf->at(nn);
}
tslib_strclr(local, 0, 66);
LL=buf->length();
if (LL>1280)
{
qDebug()<<"reducing text size from " << LL << " to 1280 bytes";
LL=1280; // Limit size
} else
qDebug()<<"\n printing text with " << LL << " bytes: ";
do
{
len=tslib_getMinimum(LL, 64);
tslib_strclr(local, 0, 66);
for (nn=0; nn<len; nn++)
{
local[nn]=copie[nn];
}
local[64]=0;
// delete already printed part of big buffer
if (LL<=64)
{
// last block
local[LL]=10;
// new line = cmd to printer: "print, even if line is not filled"
LL=0; // print complete
} else
{
LL-=64;
for (nn=0; nn<LL; nn++)
{
copie[nn]=copie[nn+64];
}
// pad remain with 0 (last but one block)
for (nn=LL; nn<64; nn++)
{
copie[nn]=0;
}
}
epi_storePrnText(local, uint8_t(len)); // no need to care for max PI size
// stores 64byte in PI with every call, maximal 20 calls (1280 byte)
} while(--maxruns>0 && LL>0);
}
*/
bool hwapi::dc_openSerial(int BaudNr, QString BaudStr, QString ComName, uint8_t connect) const
{
// BaudNr: 0:1200 1:9600 2:19200 3:38400 4:57600 5:115200
// BaudStr: for exapmle "19200"
// ComName: for example "COM48"
// connect: 0, 1
#ifdef THIS_IS_CA_MASTER
//qDebug() << "~~>LIB" << "dc_openSerial called... " ;
epi_setSerial(BaudNr, BaudStr, ComName, connect);
// Actions: open serial port with parameters
#else
BaudStr=ComName=""; BaudNr=0; connect=0; // to avoid compiler warning
qCritical()<<"hwapi: error CAslave cannot open serial";
return false;
return BaudNr; // to avoid compiler warning
return connect; // to avoid compiler warning
#endif
epi_setNowIsBootload(false);
return true;
}
void hwapi::dc_closeSerial(void) const
{
#ifdef THIS_IS_CA_MASTER
epi_closeSerial();
#else
qCritical()<<"hwapi: error CAslave cannot close serial";
#endif
}
bool hwapi::dc_isPortOpen(void) const
{
return epi_isSerialPortOpen();
}
void hwapi::dc_autoRequest(bool on) const
{
// automatically request ALL digital and analog sensors, get time/date, get status information
epi_startEmmision(on);
}
void hwapi::dc_requTestResponse() const
{
//sendWRcmd_ setSendCommand0(SENDDIRCMD_TestSerial);
// CMD2DC_TestSerial
// replace by new command form:
sendFDcmd_set(0, CMD2DC_TestSerial, 0,0,0,0,0);
}
bool hwapi::dc_readAnswTestResponse() const
{
return epi_getResult_serialTestOK();
}
uint8_t hwapi::dc_isRequestDone(void) const
{
// retval: 0: request is still in progress
// 1: answer from DC2 was OK
// 2: wrong answer from DC2
return epi_getResultOfLastRequest();
}
uint16_t hwapi::dc_getCompletePayLoad(uint16_t plBufSiz, uint8_t *payLoad) const
{
// get data back in *pl, max 64 byte, can be used for diagnosis
// retval = nr of bytes received. If host buffer too small then
// only plBufSíz bytes are copied to pl
// plBufSíz=size of host buffer
return epi_getLastPayLoad( plBufSiz, payLoad);
}
void hwapi::dc_setWakeFrequency(uint8_t period) const
{
// RTC wakes DC2 (and PTU) by hardware signal every 32seconds
// change wake signal period to 1...64s
sendFDcmd_set(0, CMD2DC_setWakeFrequ,0, period,0,0,0);
}
void hwapi::dc_OrderToReset(void) const
{
uint8_t len, buf[160];
len=dcBL_restartDC(buf);
sendWRcmd_setSendBlock160(len, buf);
}
QString hwapi::dc_getSerialState(void) const
{
#ifdef THIS_IS_CA_MASTER
return epi_getTxt4comStateLine();
#else
qCritical()<<"hwapi: error CAslave cannot use serial";
return "";
#endif
}
void hwapi::dc_clrSerialStateText(void) const
{
#ifdef THIS_IS_CA_MASTER
epi_clrTxt4comStateLine();
#else
qCritical()<<"hwapi: error CAslave cannot use serial";
#endif
}
void hwapi::bl_sendDataDirectly(uint8_t length, uint8_t *buf) const
{
// send without protocol frame, needed for the DC bootloader
sendWRcmd_setSendBlock160(length, buf);
}
uint8_t hwapi::getRawRecLength(void) const
{
return epi_getRawRecLength();
}
uint8_t hwapi::getRawReceivedData(uint8_t *receivedData) const
{
return epi_getRawReceivedData(receivedData);
}
QString hwapi::dc_getSerialParams(void) const
{
return epi_getSlaveParamSTR();
}
QString hwapi::dc_getHWversion(void) const
{
return epi_loadHWver();
}
QString hwapi::dc_getSWversion(void) const
{
return epi_loadSWver();
}
QString hwapi::dc_getState(void) const
{
return epi_loadDCstate();
}
// ----------------------------------------------------------------------------------------------------------
// Date and Time
// ----------------------------------------------------------------------------------------------------------
uint8_t hwapi::rtc_getDateTime(struct Trtc_DateTime *rtc_DateTime) const
{
// void epi_getTime(uint8_t *hh, uint8_t *mm, uint8_t *ss);
// void epi_getDate(uint8_t *yy, uint8_t *mm, uint8_t *dd);
// void epi_getToday(uint8_t *dow, uint16_t *minOfToday, uint32_t *secOfToday);
uint8_t H, M, S;
uint16_t unused16;
uint32_t unused32;
epi_getTime(&H, &M, &S);
rtc_DateTime->rtc_hour=H;
rtc_DateTime->rtc_min=M;
rtc_DateTime->rtc_sec=S;
epi_getDate(&H, &M, &S);
rtc_DateTime->rtc_year=H;
rtc_DateTime->rtc_month=M;
rtc_DateTime->rtc_dayOfMonth=S;
epi_getToday(&H, &unused16, &unused32);
rtc_DateTime->rtc_dayOfWeek=H;
return 0;
}
uint8_t hwapi::rtc_setDateTime(void) const
{
//vorher nur: sendWRcmd_setSendCommand0(SENDDIRCMD_setTime);
// send PC time/date to slave
//uint8_t hour,min, sec, year, month, day, dayOfWeek,
//uint8_t dayOfYear, isLeap, weekOfYear;
uint8_t buff[15];
uint16_t uitmp;
QTime *systTime = new QTime();
// qDebug() << systTime->currentTime().hour() <<":"
// << systTime->currentTime().minute() <<":"
// << systTime->currentTime().second();
buff[0]=uint8_t(systTime->currentTime().hour());
buff[1]=uint8_t(systTime->currentTime().minute());
buff[2]=uint8_t(systTime->currentTime().second());
QDate *systDate = new QDate();
systDate->currentDate();
uitmp= uint16_t(systDate->currentDate().year());
buff[3]=uint8_t(uitmp);
buff[4]=uint8_t(uitmp>>8);
buff[5]=uint8_t(systDate->currentDate().month());
buff[6]=uint8_t(systDate->currentDate().day());
buff[7]=uint8_t(systDate->currentDate().dayOfWeek());
// uitmp=systDate->currentDate().dayOfYear();
// buff[8]=uint8_t(uitmp);
// buff[9]=uint8_t(uitmp>>8);
// buff[10]=uint8_t(systDate->currentDate().isLeapYear(systDate->currentDate().year()));
// buff[11]=uint8_t(systDate->currentDate().weekNumber()); //weekOfYear
// buff[12]=0;
longFDcmd_set(CMD2DC_sendTime,0,0,8,buff);
return 0;
}
Implemented bna-functionality
2023-11-14 08:40:54 +01:00
Start repository
2023-11-08 13:02:26 +01:00
void hwapi::rtc_getTime(uint8_t *hh, uint8_t *mm, uint8_t *ss) const
{
epi_getTime(hh, mm, ss);
}
void hwapi::rtc_getDate(uint8_t *yy, uint8_t *mm, uint8_t *dd) const
{
epi_getDate(yy, mm, dd);
}
uint8_t hwapi::rtc_getToday(uint8_t *dow, uint16_t *minOfToday, uint32_t *secOfToday) const
{
// dow=day of week, 1=monday...7
// minOfToday: 0=midnight...1439= 23:59
// secOfToday: 0=midnight...86399= 23:59:59
epi_getToday(dow, minOfToday, secOfToday);
return 0;
}
bool hwapi::rtc_isLeapYear(uint8_t *lastLeapYear, uint8_t *NextLeapYear) const
{
return epi_isLeapYear(lastLeapYear, NextLeapYear);
}
bool hwapi::rtc_isLeapYear(void) const
{
return epi_isLeapYear();
}
void hwapi::rtc_getWeek(uint8_t *DayOfWeek, uint8_t *HoursOfWeek, uint16_t *MinutesOfWeek) const
{
epi_getSpecialWeekTimeDate(DayOfWeek, HoursOfWeek, MinutesOfWeek);
}
void hwapi::rtc_getMonth(uint8_t *DayOfMonth, uint16_t *HoursOfMonth, uint16_t *MinutesOfMonth) const
{
epi_getSpecialMonthTimeDate(DayOfMonth, HoursOfMonth, MinutesOfMonth);
}
void hwapi::rtc_getYear(uint16_t *DayOfYear, uint16_t *HoursOfYear, uint32_t *MinutesOfYear) const
{
epi_getSpecialYearTimeDate(DayOfYear, HoursOfYear, MinutesOfYear);
}
QString hwapi::rtc_getTimStr() const
{
uint8_t hh, mm, ss, buf[20], nn;
QString qbuf;
char ctmp;
qbuf.clear();
for (nn=0; nn<20; nn++) buf[nn]=0;
epi_getTime(&hh, &mm, &ss);
GetTimeString(hh, mm, ss, HourSys24h, MITSEK, buf); // about 12byte long
for (nn=0; nn<20; nn++)
{
ctmp=buf[nn];
qbuf[nn]=ctmp;
}
return qbuf;
}
QString hwapi::rtc_getDatStr() const
{
uint8_t day, month, year, buf[20], nn;
QString qbuf;
char ctmp;
qbuf.clear();
for (nn=0; nn<20; nn++) buf[nn]=0;
epi_getDate(&year, &month, &day);
GetDateString(day, month, 0x20, year, DateFormatDeutsch, 0, buf);
for (nn=0; nn<20; nn++)
{
ctmp= buf[nn];
qbuf[nn]=ctmp;
}
return qbuf;
}
QString hwapi::rtc_getTimDatStr() const
{
// style: 0: hh:mm 1: hh:mm:ss
QString qbuf;
qbuf.clear();
qbuf.append(rtc_getTimStr());
qbuf.append(" ");
qbuf.append(rtc_getDatStr());
return qbuf;
}
// UID
void hwapi::dc_getUID8byte(uint8_t *buf8byteUid) const
{
epi_getUIDdec(buf8byteUid);
}
QString hwapi::dc_getUIDstr() const
{
return epi_getUIDstr();
}
uint64_t hwapi::dc_getUIDnumber(void) const
{
uint64_t retval=0;
uint8_t buf8byteUid[12], nn;
epi_getUIDdec(buf8byteUid);
for (nn=8; nn>0; nn--)
{
retval+=buf8byteUid[nn-1];
retval<<=8; // *256
}
return retval;
}
// ----------------------------------------------------------------------------------------------------------
// analogs
// ----------------------------------------------------------------------------------------------------------
uint32_t hwapi::dc_getTemperature(void) const
{
//
return epi_loadMeasureValue(MEASCHAN_TEMPERATURE);
}
QString hwapi::dc_getTemperaturStr(void) const
{
return epi_getSlaveTemperatureStr();
}
uint32_t hwapi::dc_getVoltage(void) const
{
// in mV, e.g. 12300 = 12,3V
return epi_loadMeasureValue(MEASCHAN_VOLTAGE);
}
QString hwapi::dc_getVoltagStr(void) const
{
return epi_getSlaveVoltageStr();
}
bool hwapi::dc_mainFuseIsOk(void) const
{
uint32_t ulong=epi_loadMeasureValue(MEASCHAN_VOLTAGE); // in mV, e.g. 12300 = 12,3V
if (ulong>3000)
return true;
return false;
}
// ------------------------------------------------------------------------------
// digital outputs
// ------------------------------------------------------------------------------
// Locks:
uint8_t hwapi::lock_switchUpperLock(uint8_t dir) const
{
// dir 0=off 1=up 2=down
sendFDcmd_set(CMD2DC_MOV_UPLOCK,0,0, dir,0,0,0);
return 0;
}
uint8_t hwapi::lock_switchLowerLock(uint8_t dir) const
{
// dir 0=off 1=up 2=down
sendFDcmd_set(CMD2DC_MOV_DNLOCK,0,0, dir,0,0,0);
return 0;
}
void hwapi::lock_switchVaultDoor(void) const
{
sendFDcmd_set(CMD2DC_VAULT_DOOR,0,0, 0,0,0,0);
}
void hwapi::coin_switchRejectMotor(uint8_t dir) const
{
sendFDcmd_set(CMD2DC_REJMOT_ON,0,0, dir,0,0,0);
}
void hwapi::coin_rejectCoins(void) const
{
sendFDcmd_set(CMD2DC_REJMOT_RUN,0,0, 0,0,0,0);
}
void hwapi::led_switchLedService(uint8_t on) const
{
sendFDcmd_set(CMD2DC_LED_IN, CMD2DC_RdBkAllOutputs, 0, on, 0, 0, 0);
}
void hwapi::led_switchLedPaper(uint8_t on, uint8_t ton, uint8_t tof) const
{
sendFDcmd_set(CMD2DC_LED_TICKET, CMD2DC_RdBkAllOutputs,0, on, ton, tof, 0);
}
void hwapi::led_switchLedPinPad(uint8_t on, uint8_t ton, uint8_t tof) const
{
sendFDcmd_set(CMD2DC_LED_PIN, CMD2DC_RdBkAllOutputs, 0, on, ton, tof, 0);
}
void hwapi::led_switchLedStart(uint8_t on, uint8_t ton, uint8_t tof) const
{
sendFDcmd_set(CMD2DC_LED_START, CMD2DC_RdBkAllOutputs,0, on, ton, tof, 0);
}
void hwapi::led_switchLedCoinbassin(uint8_t on, uint8_t ton, uint8_t tof) const
{
sendFDcmd_set(CMD2DC_LED_COIN, CMD2DC_RdBkAllOutputs, 0, on, ton, tof, 0);
}
void hwapi::fan_switchFan(bool on) const
{
sendFDcmd_set(CMD2DC_FAN, CMD2DC_RdBkAllOutputs,0, on, 0, 0, 0);
}
void hwapi::alarm_switchSiren(bool on) const
{
sendFDcmd_set(CMD2DC_SIREN, CMD2DC_RdBkAllOutputs,0, on, 0, 0, 0);
}
void hwapi::bar_OpenBarrier(bool open) const
{
sendFDcmd_set(CMD2DC_BARRIER, CMD2DC_RdBkAllOutputs,0, open, 0, 0, 0);
}
void hwapi::ptu_switchWake(bool WAKEACTIVE) const
{
sendFDcmd_set(CMD2DC_WAKEPTU,0,0, WAKEACTIVE,0,0,0);
}
// AUX-IO's or barcode reader
void hwapi::aux_power(bool on) const
{
sendFDcmd_set(CMD2DC_SWITCHAUXPWR, CMD2DC_RdBkAllOutputs, 0, on,0,0,0);
}
void hwapi::aux_setUsage(uint8_t PinDirection) const
{
// bit 0= Aux1 bit5=Aux6 1=output 0=input with pullup
sendFDcmd_set(CMD2DC_SWITCHAUXDDR, CMD2DC_RdBkAllOutputs,0, PinDirection,0,0,0);
}
void hwapi::aux_setOutputs(uint8_t PinIsHigh) const
{
// PinIsHigh bit 0..5 =Aux1...6 1=output high 0=set output low
sendFDcmd_set(CMD2DC_SWITCHAUXOUT, CMD2DC_RdBkAllOutputs,0, PinIsHigh,0,0,0);
}
void hwapi::lock_switchContactPower(bool on) const
{
sendFDcmd_set(CMD2DC_UCONTACTON, 0,0, on, 0,0,0);
}
void hwapi::prn_switchPower(bool on) const
{
// also switches and enables serial driver
//sendWRcmd_ setSendCommand4(SENDDIRCMD_PRN2_SWONOFF, on,0,0,0);
indat_storePrinterPower(on);
// PRINTER-ON/OFF zusätzlich statisch abspeichern
// Status-request soll nur gesendet werden wenn der Drucker ein ist
// Status-Abfrage (hier in HWapi) gibt 0 zurück wenn power-off
// dito mit allen anderen Geräten!
// pi ---> storeINdata.cpp speichert diese statische Info (printer on/off) UND
// auch alles rückgelesene
sendFDcmd_set(CMD2DC_PRINTERON,0,0, on,0,0,0);
}
void hwapi::mif_readerOn(bool on) const
{
// DC2 also switches and enables serial driver
//sendWRcmd_ setSendCommand4(SENDDIRCMD_MIF_SWONOFF, on,0,0,0);
sendFDcmd_set(CMD2DC_MIFREADERON,0,0, on,0,0,0);
indat_storeMifarePower(on);
if (on==false)
{
gpi_clearMifAtbData(); // neu 14.9.23
gpi_clearMifHwData(); // neu 8.9.23
}
}
void hwapi::mif_creatAtbCard(uint8_t cardType) const
{
sendFDcmd_set(CMD2DC_MIFREADERON,0,0, cardType,0,0,0);
indat_storeMifarePower(cardType);
}
void hwapi::mod_switchPower(bool on) const
{
sendFDcmd_set(CMD2DC_MOD_ON,0,0, on,0,0,0);
}
void hwapi::mod_switchWake(bool WAKEACTIVE) const
{
sendFDcmd_set(CMD2DC_MOD_WAK,0,0, WAKEACTIVE,0,0,0);
}
void hwapi::mdb_switchPower(bool on) const
{
sendFDcmd_set(CMD2DC_MDB_ON,0,0, on,0,0,0);
indat_storeMDBisOn(CMD2DC_MDB_ON);
}
void hwapi::mdb_switchWake(bool WAKEACTIVE) const
{
sendFDcmd_set(CMD2DC_MDB_SETWAK,0,0, WAKEACTIVE,0,0,0);
}
void hwapi::credit_switchPower(bool on) const
{
sendFDcmd_set(CMD2DC_CRED_ON,0,0, on,0,0,0);
}
void hwapi::credit_switchWake(bool WAKEACTIVE) const
{
sendFDcmd_set(CMD2DC_CRED_WAK,0,0, WAKEACTIVE,0,0,0);
}
void hwapi::shut_move(bool open) const
{
// true:open false:close
sendFDcmd_set(CMD2DC_SHUTTER_OPEN, 0,0, open, 0,0,0);
}
void hwapi::esc_moveFlaps(uint8_t flap ) const
{
// 0: close both 1: open take-flap 2: open return
sendFDcmd_set(CMD2DC_ESCR_OPEN,0,0, flap, 0,0,0);
}
// ------------------------------------------------------------------------------
// door, cashbox and lock switches
// ------------------------------------------------------------------------------
uint8_t hwapi::door_getSwitches(void) const
{
// retval // bit0: upper door 1: low door 2:vault door
uint8_t ret;
ret= epi_getDI_doorSwitches();
// bit0: upper door 1: low door 2:vault door
ret &= 0x08;
return ret;
}
bool hwapi::door_isUpperDoorOpen(void) const
{
// uint8_t ret;
// ret= epi_getDI_doorSwitches();
// // bit0: upper door 1: low door 2:vault door
// if (ret & 1)
// return true;
// return false;
// new, since 20.9.23: use debounced values:
struct T_dynamicCondition myDynMachCond;
sys_getDynMachineConditions(&myDynMachCond);
if (myDynMachCond.upperDoor==0) // 0=zu
return false;
return true; // report "open" even if undefined because "closed" is more important
}
bool hwapi::door_isLowerDoorOpen(void) const
{
// uint8_t ret;
// ret= epi_getDI_doorSwitches();
// if (ret & 2)
// return false;
// return true;
// new, since 20.9.23: use debounced values:
struct T_dynamicCondition myDynMachCond;
sys_getDynMachineConditions(&myDynMachCond);
if (myDynMachCond.lowerDoor==0) // 0=zu
return false;
return true; // report "open" even if undefined because "closed" is more important
}
bool hwapi::vault_isVaultDoorOpen(void) const
{
// uint8_t ret;
// ret= epi_getDI_doorSwitches();
// // bit0: upper door 1: low door 2:vault door
// if (ret & 4)
// return true;
// return false;
// new, since 20.9.23: use debounced values:
struct T_dynamicCondition myDynMachCond;
sys_getDynMachineConditions(&myDynMachCond);
if (myDynMachCond.middleDoor==0) // 0=zu
return false;
return true; // report "open" even if undefined because "closed" is more important
}
uint8_t hwapi::vault_getSwitches(void) const
{
// retval bit0: cash box, bit 1: bill box
uint8_t ret;
ret=epi_getDI_vaultSwitches(); // bit0: cash box 1: bill box in
ret&=0x03;
return ret;
}
bool hwapi::vault_isCoinVaultIn(void) const
{
// uint8_t ret;
// ret=epi_getDI_vaultSwitches(); // bit0: cash box 1: bill box in
// if (ret & 1)
// return true;
// return false;
// new, since 20.9.23: use debounced values:
struct T_dynamicCondition myDynMachCond;
sys_getDynMachineConditions(&myDynMachCond);
if (myDynMachCond.CBinDebounced==0) // 0:fehlt 1:drin
return false;
return true;
}
bool hwapi::vault_isBillVaultIn(void) const
{
uint8_t ret;
ret=epi_getDI_vaultSwitches(); // bit0: cash box 1: bill box in
if (ret & 2)
return true;
return false;
}
uint8_t hwapi::door_getLocks(void) const
{
// retval bit0: upper lever is up
// bit1: upper lever is down
// bit2: lower lever is up
// bit3: lower lever is down
uint8_t ret;
ret= epi_getDI_lockSwitches();
// retval: bit 0: upper lockbar up bit1: upper lockbar is down
// bit 2: lower lockbar up bit1: lower lockbar is down
ret&=0x0F;
return ret;
}
bool hwapi::door_upperDoorIsLocked(void) const
{
uint8_t ret;
ret= epi_getDI_lockSwitches();
if (ret & 2)
return true;
return false;
}
bool hwapi::door_upperDoorIsUnlocked(void) const
{
uint8_t ret;
ret= epi_getDI_lockSwitches();
if (ret & 1)
return true;
return false;
}
bool hwapi::door_lowerDoorIsLocked(void) const
{
uint8_t ret;
ret= epi_getDI_lockSwitches();
if (ret & 8)
return true;
return false;
}
bool hwapi::door_lowerDoorIsUnlocked(void) const
{
uint8_t ret;
ret= epi_getDI_lockSwitches();
if (ret & 4)
return true;
return false;
}
bool hwapi::bar_optoIn1isOn(void) const
{
uint8_t ret=epi_getDI_optos();
// bit0: opto in 1 1: opto in 2
if (ret & 1)
return true;
return false;
}
bool hwapi::bar_optoIn2isOn(void) const
{
uint8_t ret=epi_getDI_optos();
// bit0: opto in 1 1: opto in 2
if (ret & 2)
return true;
return false;
}
uint8_t hwapi::aux_getAuxInputs(void) const
{
// retval: bit0=Aux1....Bit5=Aux6
// 0: input low 1:input high
uint8_t ret=epi_getDI_auxIn();
// bit0: auxin 1 ... 5: auxin 6
ret &=0x3F;
return ret;
}
bool hwapi::ptu_WakeINisActive(void) const
{
return epi_getDI_ptuWake();
}
bool hwapi::mdb_WakeINisActive(void) const
{
return epi_getDI_mdbWake();
}
bool hwapi::prn_readyINisActive(void) const
{
return epi_getDI_prnReady();
}
bool hwapi::coid_isAttached(void) const
{
return epi_getDI_CoinAttach();
}
bool hwapi::coin_escrowIsOpen(void) const
{
return epi_getDI_CoinEscrow();
}
bool hwapi::mif_cardIsAttached(void) const
{
return epi_getDI_mifareCardTapped();
}
//bool hwapi::mod_WakeINisActive(void)
//{
// return epi_getDI_modemWake();
//}
bool hwapi::door_isContactPowerOn(void) const
{
return epi_getDI_contactPwr();
}
bool hwapi::mif_isMifarePowerOn(void) const
{
bool mo=indat_isMifareOn();
bool mi=epi_getDI_mifarePwr();
if (mo && mi)
return true;
return false;
}
bool hwapi::mdb_testIsmdbTxDon(void) const
{
return epi_getDI_mdbTxd();
//return mdb_busVoltageOk(); gleich?
}
bool hwapi::aux_isAuxPowerOn(void) const
{
return epi_getDI_auxPwr();
}
bool hwapi::mod_isGsmPowerOn(void) const
{
return epi_getDI_gsmPwr();
}
bool hwapi::cred_isCreditPowerOn(void) const
{
return epi_getDI_creditPwr();
}
bool hwapi::prn_isPrinterPowerOn(void) const
{
return epi_getDI_printerPwr();
}
uint8_t hwapi::prn_PrnFuseIsOk(void) const
{
//retval: 0: fuse blown 1: fuse OK 2:unknown as printer power is off
if (!epi_getDO_printerPwr())
return 2; // unknown as printer power is off
if (epi_getDI_printerPwr())
return 1; // printer voltage is OK
return 0; // fuse blown
}
bool hwapi::mdb_isMdbPowerOn(void) const
{
//return epi_getDI_mdbPwr(); // all DIs byte 4 bit 7 da ist was verschoben
return mdb_deviceVoltageOK(); // gleich? aus MDB_GET_STATE=107 Byte[1]
}
bool hwapi::cash_getRejectMotorHomePos(void) const
{
// DI=low in Homepos
if (epi_getDI_rejectMotor_homepos())
return 0;
return 1;
}
uint8_t hwapi::cash_getLowPaperSensor(void) const
{
// 0: Sensor sees paper 1: no paper 99: off
return epi_getDI_npe_sensor();
}
// ------------------------------------------------------------------------------
// request commands
// ------------------------------------------------------------------------------
// all read-requests can be sent manually by the following functions
// or automatically in background by: void hwapi::dc_autoRequest(bool on)
void hwapi::request_DC2serialConfig() const
{
sendFDcmd_set(0,CMD2DC_GetSerialConfig,0,0,0,0,0);
}
void hwapi::request_DC2_HWversion() const
{
sendFDcmd_set(0,CMD2DC_RdBkHWversion,0,0,0,0,0);
}
void hwapi::request_DC2_SWversion() const
{
sendFDcmd_set(0,CMD2DC_RdBkSWversion,0,0,0,0,0);
}
void hwapi::request_DC2_condition() const
{
sendFDcmd_set(0,CMD2DC_RdBkDCstate,0,0,0,0,0);
}
void hwapi::request_DC2_UID() const
{
sendFDcmd_set(0,CMD2DC_RdBkUID,0,0,0,0,0);
}
void hwapi::request_DC2_TimeAndDate() const
{
sendFDcmd_set(0,CMD2DC_RdBkTime,0,0,0,0,0);
}
void hwapi::request_DC2_analogues() const
{
sendFDcmd_set(0,CMD2DC_RdBkAnalog,0,0,0,0,0);
}
void hwapi::request_DC2_digitalInputs() const
{
sendFDcmd_set(0,CMD2DC_GetAllInputs,0,0,0,0,0);
}
void hwapi::request_DC2_digitalOutputs() const
{
sendFDcmd_set(0,CMD2DC_RdBkAllOutputs,0,0,0,0,0);
}
// ------------------------------------------------------------------------------
// the folowing device state requests are deployed only if device is powered up:
void hwapi::request_PrinterHwState() const
{
sendFDcmd_set(0,CMD2DC_RdBk_PrnState,0,0,0,0,0);
}
void hwapi::request_PrinterCurrentFonts() const
{
sendFDcmd_set(0,CMD2DC_RdBk_PrnFonts,0,0,0,0,0);
}
void hwapi::request_PrinterStateComplete() const
{
sendFDcmd_set(0,CMD2DC_RdBk_AllPrnData,0,0,0,0,0);
}
void hwapi::request_MifareReaderState() const
{
sendFDcmd_set(0, 24, 0, 0,0,0,0); // return reader type, card state and type and card UID
}
void hwapi::request_MifareCardType() const
{
sendFDcmd_set(0, 109, 0, 0,0,0,0); // ATB Card Type: upper/lower door, test card and card holder
}
void hwapi::request_MifareAtbType() const
{
sendFDcmd_set(0,25,0,0,0,0,0);
}
void hwapi::request_MifareID() const
{
this->request_MifareReaderState();
}
void hwapi::request_MifareData(uint8_t dataBlockNumber) const
{
if (dataBlockNumber<12) // 1k cards return 12 data blocks, 4k cards would return 54 data blocks (not implemented)
sendFDcmd_set(0,28,0, dataBlockNumber,0,0,0); // 1st data = card sequence =blk nr (0...15)
}
void hwapi::request_MDB_Status() const
{
sendFDcmd_set(0,CMD2DC_MDB_GET_STATE,0,0,0,0,0);
}
//void hwapi::request_MDB_wakeInLine() const
//{
// sendWRcmd_setSendCommand0(SEND_REQU_MDB_GETWAK);
//}
void hwapi::request_MDB_lastResponse() const
{
sendFDcmd_set(0,CMD2DC_MDB_GETRESP,0,0,0,0,0);
}
void hwapi::request_EMP_allParameters() const
{
sendFDcmd_set(0,CMD2DC_EMP_GET_ALL,0,0,0,0,0);
}
void hwapi::request_EMP_lastCoin() const
{
sendFDcmd_set(0,CMD2DC_EMP_GOTCOIN,0,0,0,0,0);
}
// ------------------------------------------------------------------------------
// readback digital outputs of connected devices
// these functions are not needed for normal operation
// but can be used to test and verify conditions
// ------------------------------------------------------------------------------
bool hwapi::test_getDO_mdbRXtst(void) const
{
return epi_getDO_mdbRxTestOut();
}
uint8_t hwapi::lock_getDO_motors(void) const
{
// bit0: upper lock forward bit 1 backward
// bit2: lower lock forward bit 3 backward
return epi_getDO_motorOuts();
}
uint8_t hwapi::test_serialState(void) const
{
// test on-board signals for the serials
// serial drv on/off, Serial mux1, Serial mux2
uint8_t ret=epi_getDO_serialSwitch();
// serial drv on/off, Serial mux1, Serial mux2
ret &=0x07;
return ret;
}
bool hwapi::test_serialIsOn(void) const
{
return epi_getDO_serialDriverIsOn();
}
bool hwapi::test_serialMux1isSetToPrinter(void) const
{
return epi_getDO_serialMux1isSetToPrinter();
// mux1 off: serial is switched to printer
}
bool hwapi::test_serialMux1isSetToModem(void) const
{
return epi_getDO_serialMux1isSetToModem();
// mux1 on: serial is switched to modem
}
bool hwapi::test_serialMux2isSetToCredit(void) const
{
return epi_getDO_serialMux2isSetToCredit();
// mux2 off: serial is switched to credit card terminal
}
bool hwapi::test_serialMux2isSetToMifare(void) const
{
return epi_getDO_serialMux2isSetToMifare();
// mux2 on: serial is switched to mifare reader
}
bool hwapi::led_coinIsOn(void) const
{
return epi_getDO_led_coin();
}
bool hwapi::led_frontIsOn(void) const
{
return epi_getDO_led_front();
}
bool hwapi::led_ticketIsOn(void) const
{
return epi_getDO_led_ticket();
}
bool hwapi::led_pinIsOn(void) const
{
return epi_getDO_led_pin();
}
bool hwapi::led_StartIsOn(void) const
{
return epi_getDO_led_start();
}
bool hwapi::led_insideIsOn(void) const
{
return epi_getDO_led_inside();
}
bool hwapi::fan_isOn(void) const
{
return epi_getDO_fan();
}
bool hwapi::siren_isOn(void) const
{
return epi_getDO_sirene();
}
bool hwapi::bar_relayIsOn(void) const
{
return epi_getDO_relay();
}
bool hwapi::ptu_WakeOutIsOn(void) const
{
return epi_getDO_ptuWake();
}
bool hwapi::aux_powerIsOn(void) const
{
return epi_getDO_auxPower();
}
bool hwapi::coin_shutterIsOpen(void) const
{
return epi_getDO_coinShutterOpen();
}
bool hwapi::coin_shutterTestOutput(void) const
{
return epi_getDO_coinShutterTest();
}
uint8_t hwapi::coin_escrowFlapOpened(void) const
{
// retval: 1:return flap is open 2:take flap is open 0:closed
return epi_getDO_coinEscrow();
}
// ------------------------------------------------------------------------------
// devices are operated by DC
// processes with more then one devices
// timer controlled or long term processes
// ------------------------------------------------------------------------------
void hwapi::sendDeviceSettings(uint8_t kindOfPrinter, uint8_t kindOfCoinChecker,
uint8_t kindOfMifareReader, uint8_t suppressSleep,
uint8_t kindOfModem, uint8_t kindOfCredit) const
{
uint8_t buf[64];
tslib_strclr(buf,0,64);
buf[0]=kindOfPrinter;
buf[1]=kindOfCoinChecker;
buf[2]=kindOfMifareReader;
buf[3]=suppressSleep;
buf[4]=kindOfModem;
buf[5]=kindOfCredit;
longFDcmd_set(CMD2DC_DEVICE_PARAM, 0, 0, 6, buf);
}
void hwapi::request_ReadbackDeviceSettings() const
{
sendFDcmd_set(0,CMD2DC_RDBK_DEV_PARA,0,0,0,0,0);
}
void hwapi::readback_DeviceSettings(uint8_t *length, uint8_t *data) const
{
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);
*/
}
// ....................................................................................
void hwapi::sendMachineID(uint16_t customerNr, uint16_t machineNr,
uint16_t borough, uint16_t zone,
uint16_t alias, char *location) const
{
uint8_t buf[64];
tslib_strclr(buf,0,64);
buf[0]=uint2uchar(customerNr, LOWBYTE);
buf[1]=uint2uchar(customerNr, HIGHBYTE);
buf[2]=uint2uchar(machineNr, LOWBYTE);
buf[3]=uint2uchar(machineNr, HIGHBYTE);
buf[4]=uint2uchar(borough, LOWBYTE);
buf[5]=uint2uchar(borough, HIGHBYTE);
buf[6]=uint2uchar(zone, LOWBYTE);
buf[7]=uint2uchar(zone, HIGHBYTE);
buf[8]=uint2uchar(alias, LOWBYTE);
buf[9]=uint2uchar(alias, HIGHBYTE);
tslib_strcpy(location, &buf[10], 32);
longFDcmd_set(CMD2DC_SEND_MACH_ID,0,0,42,buf);
}
void hwapi::request_ReadbackMachineID() const
{
sendFDcmd_set(0,CMD2DC_RDBK_MACH_ID,0,0,0,0,0);
}
void hwapi::readback_machineIDdata(uint8_t *length, uint8_t *data) const
{
epi_restoreMachineIDsettings(length, data);
}
// ....................................................................................
static uint16_t hwapi_shutterTime;
// locks, 2.Level: (Motor stops automatical on end switch or by 5s timeout)
uint8_t hwapi::lock_openUpperDoor(void) const
{
// paras: dat2: 1=upper door lock 2=lower
// dat1: 1=open 2=close
sendFDcmd_set(CMD2DC_UPPER_DOOR,0,0,1,0,0,0);
return 0;
}
uint8_t hwapi::lock_closeUpperDoor(void) const
{
sendFDcmd_set(CMD2DC_UPPER_DOOR,0,0,2,0,0,0);
return 0;
}
uint8_t hwapi::lock_openLowerDoor(void) const
{
sendFDcmd_set(CMD2DC_LOWER_DOOR,0,0,1,0,0,0);
return 0;
}
uint8_t hwapi::lock_closeLowerDoor(void) const
{
sendFDcmd_set(CMD2DC_LOWER_DOOR,0,0,2,0,0,0);
return 0;
}
void hwapi::shut_openOnce(void) const
{
// and close automatic after shutter time
uint16_t zeit=hwapi_shutterTime;
zeit/=100;
sendFDcmd_set(CMD2DC_SHUTTER_OPEN3S, 0,0,uint8_t(zeit) ,0,0,0);
}
void hwapi::shut_openForCoin(bool start) const
{
// start=true: start opening flap if coin is attached
// start=false: stop process
uint16_t zeit=hwapi_shutterTime;
zeit/=100;
sendFDcmd_set(CMD2DC_SHUTTER_COIN, 0,0,uint8_t(start), uint8_t(zeit),0,0);
}
void hwapi::shut_sendOpeningTime(uint16_t timeIn_ms ) const
{
// after this time without retrigger the flap is closed
hwapi_shutterTime=timeIn_ms;
}
void hwapi::esc_takeMoney(void) const
{
// and close automatically after escrow time (1s)
sendFDcmd_set(CMD2DC_ESCR_TAKE,0,0,0,0,0,0);
}
void hwapi::esc_returnMoney(void) const
{
// and close automatically after time
sendFDcmd_set(CMD2DC_ESCR_RETURN,0,0,0,0,0,0);
}
// ----------------------------------------------------------------------------------------------------------
// --------------------------------------------- MIFARE -----------------------------------------------------
// ----------------------------------------------------------------------------------------------------------
// fixed, 8.9.23
uint8_t hwapi::mif_returnReaderStateAndCardType(uint8_t *buf, uint8_t maxBufferSize) const
{
// retval 0=OK 1=error
if (maxBufferSize<64)
return 0;
epi_restoreMifHwData(buf, 64);
return 0;
}
bool hwapi::mif_readerIsOK(void) const
{
// return true if mifare reader is power, serial connected and is the correct one
uint8_t mifData[66];
epi_restoreMifHwData(mifData, 66);
/* stand 8.9.23
struct T_Mifare
{
UCHAR ReaderState; // 1: OK 0: not OK
UCHAR res1;
2: UCHAR ReaderVersion[10];
12: UCHAR CardPresent;
UCHAR CardSelected;
UCHAR Cardtype;
UCHAR CardAllowed; // 0,1 nur Mifare Classic 1k und 4k zugelassen
UCHAR CardSize; // 1 or 4 (kB)
UCHAR LengOfUid; // 4 or 7 (byte)
18: UCHAR UID[8]; // 4 byte oder 7 byte, Format binär
// 26 byte bis hier
UCHAR res2;
UCHAR res3;
28: ULONG UidH; // bei 4byte Uid alles 0
ULONG UidL;
36: UCHAR SectorLogged; // result of loggin: 2=success 3=failed 1=no_tag 8=addr overflow F0=wrongCmd
UCHAR CurrentSector;
UCHAR RD_WR_Result;
UCHAR res4;
// 40byte lang
};
*/
if (mifData[0]==0)
return false;
// Type=currently "SL025-1.8"
if (mifData[2]=='S' && mifData[3]=='L' && mifData[4]=='0' && mifData[5]=='2' && mifData[6]=='5' )
return true;
return false;
}
bool hwapi::mif_cardAttached(void) const // gefixt am 8.9.23
{
return mif_cardIsAttached();
}
uint8_t hwapi::mif_readResult(void) const // geht nicht
{
// 1: read card successful 0: not
uint8_t mifData[66];
epi_restoreMifHwData(mifData, 66);
/* stand 8.9.23
struct T_Mifare
{
UCHAR ReaderState; // 1: OK 0: not OK
UCHAR res1;
2: UCHAR ReaderVersion[10];
12: UCHAR CardPresent;
UCHAR CardSelected;
UCHAR Cardtype;
UCHAR CardAllowed; // 0,1 nur Mifare Classic 1k und 4k zugelassen
UCHAR CardSize; // 1 or 4 (kB)
UCHAR LengOfUid; // 4 or 7 (byte)
18: UCHAR UID[8]; // 4 byte oder 7 byte, Format binär
// 26 byte bis hier
UCHAR res2;
UCHAR res3;
28: ULONG UidH; // bei 4byte Uid alles 0
ULONG UidL;
36: UCHAR SectorLogged; // result of loggin: 2=success 3=failed 1=no_tag 8=addr overflow F0=wrongCmd
UCHAR CurrentSector;
UCHAR RD_WR_Result;
UCHAR res4;
// 40byte lang
};
*/
if (mifData[12]>0 && mifData[15]>0 && (mifData[16]==1 || mifData[16]==4) && (mifData[17]==4 || mifData[17]==7))
return 1;
return 0; // error
}
QString hwapi::mif_cardUID(void) const // OK
{
// new, 8.9.23, works
QString myStr;
uint8_t mifData[66];
epi_restoreMifHwData(mifData, 66);
myStr.clear();
// UID in buf[18...25]
for (int ii=0;ii<8; ii++)
{
myStr+=QString::number(mifData[ii+18],16);
myStr+=" "; // make a gap between numbers
}
return myStr;
}
uint8_t hwapi::mif_getCardDataDec(uint8_t blkNr, uint8_t *buf, uint8_t maxBufferSize) const
{
// come in with cmd 28
return blkNr+buf[0]+maxBufferSize; // just to get rid of warning
}
QString hwapi::mif_getCardDataStr(uint8_t blockNumber) const
{
// come in with cmd 28
// with blockNumber=0...11
QString myStr;
myStr.clear();
if (blockNumber>11)
return myStr;
else
return myStr;
}
// ----------------------------------------------------------------------------------------------------------
// --------------------------------------------- PRINTER ----------------------------------------------------
// ----------------------------------------------------------------------------------------------------------
// already above:
// void hwapi::prn_switchPower(bool on) 0x2A01
// bool hwapi::prn_readyINisActive(void)
// bool hwapi::prn_isPrinterPowerOn(void)
// void hwapi::request_PrinterHwState() 0x2A02
// void hwapi::request_PrinterCurrentFonts() 0x2A12
// void hwapi::request_PrinterStateComplete() // =request_PrinterHwState + request_PrinterCurrentFonts
uint8_t hwapi::prn_getHwState(struct Tprn_hw_state *prn_hw_state) const
{
// return printer hardware state: power is on? rs-driver on? rs_switch ok? hw-ready-line ok?
// printer on error or ok?
return runProcess->prn_getHwState(prn_hw_state);
}
bool hwapi::prn_isUpAndReady(void) const
{
// 25.5.2023: geht nicht richtig :( bringt immer false obwohl Drucker OK
struct Tprn_hw_state prnHwNow;
prn_getHwState(&prnHwNow);
if (prnHwNow.inIdle && prnHwNow.rsSwOk && prnHwNow.rsDrvOk && prnHwNow.powerRdBk )
return true;
return false;
}
void hwapi::prn_getCurrentFontSetting(struct Tprn_currentSettings *prn_fonts) const
{
uint8_t prnFonts[22];
epi_restorePrinterFonts(&prnFonts[0]);
prn_fonts->currFont = prnFonts[0];
prn_fonts->currSize = prnFonts[1];
prn_fonts->currHeigth= prnFonts[2];
prn_fonts->currWidth = prnFonts[3];
prn_fonts->nowBold = prnFonts[4];
prn_fonts->nowInvers = prnFonts[5];
prn_fonts->nowUnderlined= prnFonts[6];
prn_fonts->currDensity = prnFonts[7];
prn_fonts->currSpeed = prnFonts[8];
prn_fonts->nowAligned = prnFonts[9];
}
void hwapi::prn_sendText(QByteArray *buf) const
{
uint16_t nn, pp, mm, leng_byt, leng_blk, llb, freeStak;
uint8_t tmp66[66];
Add some debug output in case the dc-data-valid flag is reset to false.
2023-12-18 12:12:30 +01:00
qCritical() << __PRETTY_FUNCTION__ << "RESET DC DATA VALID";
Start repository
2023-11-08 13:02:26 +01:00
epi_clearDynMachineConditions(); // 24.6.23
gpi_storeDcDataValid(0);
// komplett aendern 11.9.23
memset(tmp66,0,66);
leng_byt=buf->size();
freeStak=check4freeFDstack();
freeStak<<=6;
if ( leng_byt > freeStak)
{
leng_byt=freeStak; // shorten the buffer as we cannot return an error (void function)
}
llb=leng_byt % 64; // length of last block, >0 if not dividable by 64
leng_blk=leng_byt / 64;
pp=0;
for (nn=0; nn<leng_blk; nn++)
{
for (mm=0; mm<64; mm++)
tmp66[mm]=buf->at(pp++);
longFDcmd_set(CMD2DC_PRI_PRINT_TXT, 0,0,64, tmp66);
}
if (llb>0)
{
//leng_blk++; // z.B. 200 = 3 volle blocks und ein block mit nur 8byte
memset(tmp66,0,66);
for (mm=0; mm<llb; mm++)
tmp66[mm]=buf->at(pp++);
for (mm=llb; mm<64; mm++)
tmp66[mm]=0;
longFDcmd_set(CMD2DC_PRI_PRINT_TXT, 0,0,64, tmp66);
}
}
void hwapi::prn_sendPrnSysCmd(uint8_t para1, uint8_t para2, uint32_t para3) const
{
// send three byte through to printer, see printers manual
//sendWRcmd _setSendCommand8(SENDDIRCMD_PRN_SYS_CMD, para1, para2, 0, para3); hat gar nicht funktioniert
uint8_t data[64];
uint32_t ultmp=para3;
memset(data, 0,64);
data[0]=para1;
data[1]=para2;
data[2]=0;
data[3]=0;
data[4]=uint8_t(ultmp); ultmp>>=8;
data[5]=uint8_t(ultmp); ultmp>>=8;
data[6]=uint8_t(ultmp); ultmp>>=8;
data[7]=uint8_t(ultmp);
longFDcmd_set(CMD2DC_PRI_SYS_CMD, 0, 0, 8, data);
// getestet auf richtige uebertragung am 11.9.23TS
}
void hwapi::prn_sendPrnEscCmd(uint8_t para1, uint8_t para2, uint8_t para3, uint8_t para4) const
{
// send four byte through to printer, see printers manual
sendFDcmd_set(CMD2DC_PRI_ESC_CMD, 0,0, para1, para2, para3, para4);
}
void hwapi::prn_sendPrnSetup(uint16_t paperSpeed, uint8_t density, uint8_t alignment, uint8_t orientation) const
{
// send 5 byte: byte 0,1: speed 5...250 mm/s
// byte2: density 0....(25)....50
// byte3: alignment 'l', 'c', 'r' = left, center, right
// byte4: orientation 0, 90, 180 = 0°, 90°, 180° rotation (by now not supported!)
// not batched! don't use twice within 100ms
uint8_t buf[10];
uint16_t uitmp;
uitmp=paperSpeed;
buf[0]=uint8_t(uitmp);
uitmp>>=8;
buf[1]=uint8_t(uitmp);
buf[2]=density;
buf[3]=alignment;
buf[4]=orientation;
buf[5]=0;
longFDcmd_set(CMD2DC_PRI_SETUP,0,0,5, buf);
}
void hwapi::prn_movePaper(uint8_t wayInMm, uint8_t direction) const
{
//direction: 1=forward 2=backward
sendFDcmd_set(CMD2DC_PRI_MOVE, 0,0, wayInMm, direction, 0,0);
}
void hwapi::prn_setFonts(uint8_t font, uint8_t size, uint8_t width, uint8_t height) const
{
// font = kind of font 0...8
// size = 6...20, 9..9: too tiny 10: small ...12 = normal size ...20=huge
// width: 0...4 0=1x 1=2x 2=4x (huge!) 3=8x 4=16x (3,4 make no sense)
// heigth: 0...7 = 1x...8x only 0,1,2,(3) make sense
sendFDcmd_set(CMD2DC_PRI_SETFONT, 0,0, font, size, width, height);
}
void hwapi::prn_setLetters(uint8_t bold, uint8_t invers, uint8_t underlined) const
{
sendFDcmd_set(CMD2DC_PRI_SETLETTER, 0, 0, bold, invers, underlined, 0);
}
void hwapi::prn_cut(uint8_t kindof) const
{
// kindof = 1: full cut 2: partial cut 3=eject (5xLF + full cut)
sendFDcmd_set(CMD2DC_PRI_CUT, 0,0, kindof,0,0,0);
}
void hwapi::prn_newLine(uint8_t nrOfLines) const
{
sendFDcmd_set(CMD2DC_PRI_LF, 0,0, nrOfLines, 0, 0, 0);
}
void hwapi::prn_printCompleteFontTable(void) const
{
sendFDcmd_set(CMD2DC_PRI_PRIFONTTABLE,0,0,0,0,0,0);
}
void hwapi::prn_printBarcode(uint8_t kindOf, uint8_t withText, uint8_t offset, uint8_t rotation, uint8_t dataLeng, uint8_t *data) const
{
uint8_t buf[66], nn;
//uint16_t uitmp;
if (dataLeng>58)
dataLeng=58;
buf[0]=kindOf;
buf[1]=withText;
buf[2]=offset;
buf[3]=rotation;
buf[4]=dataLeng;
// rest: Barcode-data:
for (nn=0; nn<dataLeng; nn++)
buf[5+nn]=data[nn];
longFDcmd_set(CMD2DC_PRI_BARCODE,0,0,(5+dataLeng), buf);
}
void hwapi::prn_sendQRdata(QByteArray *buf) const
{
// maximal 150 alphanummeric bytes
buf->clear();
}
void hwapi::prn_printQRcode(void) const
{
// which was sent before
sendFDcmd_set(CMD2DC_PRI_QR_CODE,0,0,0,0,0,0);
}
void hwapi::prn_printLogo(uint8_t nrOfLogo, uint8_t offset ) const
{
sendFDcmd_set(CMD2DC_PRI_LOGOFROMFLASH, 0,0, nrOfLogo, offset, 0, 0);
}
// .........................................................
// Parking Ticket (print out) designer - obsolete
// .........................................................
/*
static QByteArray ticketTemplate;
void hwapi::pri_startTicketDesign(void) const
{
ticketTemplate.clear();
}
int hwapi::pri_TD_getCurrentSize(void) const
{
return ticketTemplate.size();
}
bool hwapi::pri_TD_addText(QByteArray text) const
{
if ((ticketTemplate.length() + text.length())>1278)
return false;
ticketTemplate.append(text);
qDebug()<<"\nText added "<<ticketTemplate;
return true;
}
bool hwapi::pri_TD_addValue(int val) const
{
// QString tmpStr;
QByteArray tmpStr;
tmpStr.setNum(val,10); // up to 12 chars
if (ticketTemplate.length()>1266)
return false;
ticketTemplate.append(tmpStr);
return true;
}
*/
//bool hwapi::pri_TD_addCommand(char group, char attribute, char p1, char p2, char p3, char p4, char p5) const
//{
// always add 8 byte to the ticket layout: ESC & group & attribute & parameter1...5
/*
char tmpStr[10];
// command has always fixed length of 8 byte
if (ticketTemplate.length()>1270)
return false;
if (group<50 || group>59)
return false;
if (attribute<10 || attribute>30)
return false;
tmpStr[0]=0x1B; // ESC
tmpStr[1]=group;
tmpStr[2]=attribute;
tmpStr[3]=p1;
tmpStr[4]=p2;
tmpStr[5]=p3;
tmpStr[6]=p4;
tmpStr[7]=p5;
ticketTemplate.append(tmpStr, 8);
qDebug()<<"\ncmd added "<<ticketTemplate;
return true;
}
bool hwapi::pri_TD_addNewLine(void) const
{
if (ticketTemplate.length()>1277)
return false;
ticketTemplate.append("\n");
return true;
}
bool hwapi::pri_TD_addSign(char sign) const
{
if (ticketTemplate.length()>1277)
return false;
ticketTemplate.append(sign);
return true;
}
char hwapi::prn_clearDocument(uint8_t documentNumber) const
{
if (documentNumber>15)
return false;
sendWRcmd_ setSendCommand4(SENDDIRCMD_PRN_CLEARDOC, documentNumber, 0, 0, 0);
CMD2DC_PRI_CLEAR_DOC
return true;
}
bool hwapi::prn_store_Document(uint8_t documentNumber ) const
{
// send to DC
// documentNumber=0...15, stored in Eeprom
// maximal 1280 bytes each
// allowed: 0x20...0xFF, 0x0A, 0x0C, 0x1B (LF, CR, Esc)
// 0x1B=start of embedded command (next 7bytes = command)
if (documentNumber>15)
return false;
sub_storeSendingText(&ticketTemplate);
epi_storeUserOfSendingTextBuffer(3,documentNumber,0,0,0); // 3=store document
return true;
}
bool hwapi::prn_printDocument(uint8_t documentNumber, struct T_dynDat *dynTicketData) const
{
if (documentNumber>15)
return false;
epi_store64ByteSendData(64, &(dynTicketData->licensePlate[0]));
sendWRcmd_ setSendCommand4(SENDDIRCMD_PRN_DOC, documentNumber, 0, 0, 0);
return true;
}
*/
// ----------------------------------------------------------------------------------------------------------
// ------------------------------------------- MDB Bus ------------------------------------------------------
// ----------------------------------------------------------------------------------------------------------
void hwapi::mdb_sendBusReset(void) const
{
//sendWRcmd_ setSendCommand4(SENDDIRCMD_MDB_RES, 0,0,0,0);
sendFDcmd_set(CMD2DC_MDB_DORESET, 0,0, 0,0,0,0);
}
#define mdb_device_coinChk 0
#define mdb_device_changer 1
#define mdb_device_bill 2
//#define mdb_device_credit 3 // obsolete
void hwapi::mdb_sendCommand(uint8_t toMdbDevice, uint8_t mdbCommand) const
{
//sendWRcmd _setSendCommand4(SENDDIRCMD_MDB_SENDCMD, toMdbDevice, mdbCommand, 0,0);
sendFDcmd_set(CMD2DC_MDB_SENDCMD, 0,0, toMdbDevice, mdbCommand, 0,0);
}
void hwapi::mdb_sendMessage(uint8_t toMdbDevice, uint8_t mdbCommand, uint8_t nrOfData, uint8_t *dataBuffer) const
{
// nrOfData = sizeOf(dataBuffer) maximal 34 byte according mdb specs
uint8_t myBuf[64], ii;
tslib_strclr(myBuf, 0, 64);
myBuf[0]=toMdbDevice;
myBuf[1]=mdbCommand;
if (nrOfData>34) nrOfData=34;
myBuf[2]=nrOfData;
for (ii=0; ii<nrOfData; ii++)
myBuf[ii+3]=dataBuffer[ii];
//epi_store64ByteSendData(37, myBuf);
//sendWRcmd_setSendCommand0(SENDDIRCMD_MDB_SNDMSG);
longFDcmd_set( CMD2DC_MDB_SENDMSG,0,0,37,myBuf);
}
bool hwapi::mdb_busIsReadyToWork() const
{
return epi_restoreMdbBusReady();
}
bool hwapi::mdb_deviceVoltageOK() const
{
return epi_restoreMdbV12Ready();
}
bool hwapi::mdb_busVoltageOk() const
{
return epi_restoreMdbV5Ready();
}
uint8_t hwapi::mdb_getLastDeviceResponse(uint8_t *fromDevice, uint8_t *lastRequest,
uint8_t *responseLength, uint8_t *responseBuffer) const
{
// fromDevice: device nr from which data was requested 0,1,2,3
// lastRequest: sent mdb command
// responseLength: nr of payload data (after mdb-ack) 0...34
// responseBuffer holds payload data (answer from mdb device)
// return val: mdb result of this request: 1=got ACK 2=got 3xNAK 3=no or bad response 4:got Data (after ACK)
uint8_t leng, ResData[64];
epi_restoreMdbResponse(&leng, ResData);
// last received mdb answer (from mdb device)
// only needed if a special command was sent directly
// DB0: mdb Device-Nr
// DB1: last sent mdb command
// DB2: lastResult 1=got ACK 2=got 3xNAK 3=no or bad response 4:got Data (after ACK)
// DB3: nr of received (payload) data bytes (apart from ACK, can be 0....34)
// DB4...DB39: rec.data (payload)
*fromDevice=ResData[0];
*lastRequest=ResData[1];
*responseLength=ResData[3];
tslib_strcpy(&ResData[4], responseBuffer, ResData[3]);
return ResData[2];
}
// ----------------------------------------------------------------------------------------------------------
// ---------------------------------- Electronic Coin Validator EMP -----------------------------------------
// ----------------------------------------------------------------------------------------------------------
void hwapi::emp_sendSettings(uint16_t coinAcceptance, uint8_t tokenChannel, uint16_t *coinDenomination ) const
{
// coinAcceptance: bit0=coin1 (lowest denomination) bit15=coin16 bitH=accept bit L = deny coin (no validation)
// tokenChannel 0...31: if this signal comes from emp then a token was inserted
// coinDenomination = array of 16 coin values (e.g. 5, 10, 20...)
uint8_t myBuf[64], ii, pp;
uint16_t uitmp=coinAcceptance;
tslib_strclr(myBuf, 0, 64);
myBuf[0]=uint8_t (uitmp);
uitmp>>=8;
myBuf[1]=uint8_t (uitmp);
myBuf[2]=tokenChannel;
pp=3;
for (ii=0; ii<16; ii++)
{
uitmp=coinDenomination[ii];
myBuf[pp]=uint8_t(uitmp);
uitmp>>=8;
myBuf[pp+1]=uint8_t(uitmp);
pp+=2;
}
longFDcmd_set(CMD2DC_EMP_SET,0,0,35, myBuf);
}
void hwapi::emp_pollingOnOff(uint8_t on) const
{
// on: 1=start polling the coin accepter 0=stop
sendFDcmd_set(CMD2DC_EMP_STARTPOLL, 0,0, on,0,0,0);
}
void hwapi::emp_startCoinAcceptance(void) const
{
sendFDcmd_set(CMD2DC_EMP_STARTPAY, 0,0, 0,0,0,0);
}
void hwapi::emp_stopCoinAcceptance(void) const
{
sendFDcmd_set(CMD2DC_EMP_STOPPAY, 0,0, 0,0,0,0);
}
void hwapi::emp_getAllParameters(struct T_emp *emp) const
{
uint8_t leng, data[66], ii, pp;
epi_restoreEmpSettings(&leng, data); // expected length = 64 byte
// get 64 bytes about EMP: see h-file
emp->gotSetup = data[0];
emp->state = data[1];
emp->shaft = data[2];
emp->countryCode= uchar2uint(data[4], data[3]);
emp->scale = data[5];
emp->decimals = data[6];
for (ii=0; ii<16; ii++)
emp->coinValues[ii] = data[7+ii];
emp->coinAccept = uchar2uint(data[24], data[23]);
emp->tokenChannel = data[25];
emp->pollingRunning = data[26];
emp->paymentRunning = data[27];
pp=28;
for (ii=0; ii<16; ii++)
{
emp->denomination[ii] = uchar2uint(data[pp+1], data[pp]);
pp+=2;
}
emp->routing= uchar2uint(data[61], data[60]);
}
uint8_t hwapi::emp_chkIfCoinInserted(void) const
{
// retval: 0...16 coins left in FIFO
return epi_isNewCoinLeft();
}
void hwapi::emp_getNewCoinRecord(uint8_t *valid, uint8_t *signal, uint8_t *error, uint16_t *value) const
{
epi_restoreEmpCoinSignal(valid, signal, error, value);
}
uint8_t hwapi::emp_giveLastCoin(uint16_t *value, uint8_t *signal) const
{
// retval: 0: NO coin stored 1: valid coin 2: got wrong coin or coin denied
// value: if retval1: value of the coin if reval=2: error number
// signal: channel nr reported from checker
uint8_t valid, chan, error;
uint16_t wert;
epi_restoreEmpCoinSignal(&valid, &chan, &error, &wert);
if (valid && error==0xFF )
{
*value=wert;
*signal=chan;
return 1;
}
if (valid && error<0xFF )
{
*value=error;
*signal=chan; // normally 0, but sometimes we get both
return 2;
}
return 0;
}
uint8_t hwapi::emp_returnLastCoin(uint16_t *value, uint8_t *signal) const
{
// use this for coin changer
uint8_t valid, chan, error;
uint16_t wert;
epi_restoreEmpCoinSignal(&valid, &chan, &error, &wert);
if (error)
{
*value=0;
*signal=error;
return 0;
}
*value=wert;
*signal=chan;
return valid;
}
QString hwapi::dc_getTxt4RsDiagWin(void) const
{
#ifdef THIS_IS_CA_MASTER
return epi_getTxt4RsDiagWin();
#else
qCritical()<<"hwapi: error CAslave cannot use serial";
return "";
#endif
}
void hwapi::dc_clrTxt4RsDiagWin(void) const
{
#ifdef THIS_IS_CA_MASTER
epi_clrTxt4RsDiagWin();
#else
qCritical()<<"hwapi: error CAslave cannot use serial";
#endif
}
QString hwapi::dc_get2ndTxt4RsDiagWin(void) const
{
#ifdef THIS_IS_CA_MASTER
return epi_get2ndTxt4RsDiagWin();
#else
qCritical()<<"hwapi: error CAslave cannot use serial";
return "";
#endif
}
void hwapi::dc_clr2ndTxt4RsDiagWin(void) const
{
#ifdef THIS_IS_CA_MASTER
epi_clr2ndTxt4RsDiagWin();
#else
qCritical()<<"hwapi: error CAslave cannot use serial";
#endif
}
QString hwapi::dc_getTxt4HsStateLine(void) const
{
#ifdef THIS_IS_CA_MASTER
// Crash!
return epi_getTxt4HsStateLine();
#else
qCritical()<<"hwapi: error CAslave cannot use serial";
return "";
#endif
}
void hwapi::dc_clrTxt4HsStateLine(void) const
{
#ifdef THIS_IS_CA_MASTER
epi_clrTxt4HsStateLine();
#else
qCritical()<<"hwapi: error CAslave cannot use serial";
#endif
}
QString hwapi::dc_getTxt4masterStateLine(void) const
{
#ifdef THIS_IS_CA_MASTER
return epi_getTxt4masterStateLine();
#else
qCritical()<<"hwapi: error CAslave cannot use serial";
return "";
#endif
}
void hwapi::dc_clrTxt4masterStateLine(void) const
{
#ifdef THIS_IS_CA_MASTER
epi_clrTxt4masterStateLine();
#else
qCritical()<<"hwapi: error CAslave cannot use serial";
#endif
}
QString hwapi::dc_getTxt4resultStateLine(void) const
{
#ifdef THIS_IS_CA_MASTER
return epi_getTxt4resultStateLine();
#else
qCritical()<<"hwapi: error CAslave cannot use serial";
return "";
#endif
}
void hwapi::dc_clrTxt4resultStateLine(void) const
{
#ifdef THIS_IS_CA_MASTER
epi_clrTxt4resultStateLine();
#else
qCritical()<<"hwapi: error CAslave cannot use serial";
#endif
}
QString hwapi::dc_getdataStateLine(void) const
{
#ifdef THIS_IS_CA_MASTER
return epi_getTxt4dataStateLine();
#else
qCritical()<<"hwapi: error CAslave cannot use serial";
return "";
#endif
}
void hwapi::dc_clrTxt4dataStateLine(void) const
{
#ifdef THIS_IS_CA_MASTER
epi_clrTxt4dataStateLine();
#else
qCritical()<<"hwapi: error CAslave cannot use serial";
#endif
}
QString hwapi::dc_getdatifLine(void) const
{
#ifdef THIS_IS_CA_MASTER
return epi_getTxt4datifLine();
#else
qCritical()<<"hwapi: error CAslave cannot use serial";
return "";
#endif
}
void hwapi::dc_clrTxt4datifLine(void) const
{
#ifdef THIS_IS_CA_MASTER
epi_clrTxt4datifLine();
#else
qCritical()<<"hwapi: error CAslave cannot use serial";
#endif
}
// ----------------------------------------------------------------------------------------------------------
// -------- DC Bootloader 1.Version // obsolete
// ----------------------------------------------------------------------------------------------------------
// obsolete
void hwapi::bl_iniChain(void) const
{
}
// obsolete
bool hwapi::bl_importBinFile(QByteArray readBinFile, uint32_t fileSize, char withDispl) const
{
// copy file from QByteArray into local buffer for sending to DC
// calculate size, nr_of_blocks and crc
// just for special usage
return dcBL_importBinFile(readBinFile, fileSize, withDispl);
}
// obsolete
uint8_t hwapi::bl_activatBootloader(uint8_t *sendData) const
{
//return dcBL_activatBootloader(sendData);
// just for special usage
return sendData[0];
}
// obsolete
uint8_t hwapi::bl_startChain(void) const
{
// obsolete
//return dcBL_startChain();
return 0;
}
// obsolete
uint8_t hwapi::bl_readBLversion(uint8_t *sendData) const
{
// minimum size of sendData-buffer: 5byte retval: length
// just for special usage
return dcBL_readBLversion(sendData);
}
// obsolete
uint8_t hwapi::bl_readFWversion(uint8_t *sendData) const
{
// minimum size of sendData-buffer: 5byte retval: length
return dcBL_readFWversion(sendData);
}
// obsolete
uint8_t hwapi::bl_prepareDC_BLcmd(uint8_t Cmd, uint8_t SendDataLength, uint8_t *sendData, uint8_t *outBuf) const
{
// just for very special usage
// make BL protocol, retval = outbuf length (5...133)
// bring data in correct form: start always with 0x02 finish with 0x03 and append checksum
// 0x02 Cmd < ...sendData ..> CRC CRC 0x03
// Data length = 0...64
// special conversion: if data contain 2 or 3 (STX, ETX) then write two bytes: 0x1B (=ESC) and data|0x80
// so maxlength = 5 + 2 x 64 (if all data are 2 or 3) without 2,3: maxlength = 5 + 64
return dcBL_prepareDC_BLcmd(Cmd, SendDataLength, sendData, outBuf);
}
// obsolete
uint8_t hwapi::bl_exitBL(uint8_t *sendData) const
{
// returns command to be sent to DC-BL in order to stop the BL
// just for very special usage
// minimum size of sendData-buffer: 5byte retval: length
return dcBL_exitBL(sendData);
}
// obsolete
void hwapi::led_switchLedIllumination(uint8_t on) const
{
sendFDcmd_set(CMD2DC_LED_IN, CMD2DC_RdBkAllOutputs, 0, on, 0, 0, 0);
}
// ------------------------------------------------------------------------------------
// 27.3.2023: Use Device-Controller's Bootloader to send hex-file
// ------------------------------------------------------------------------------------
void hwapi::bl_rebootDC(void) const // tested 26.09.2023
{
// send command to normal DC-Program requesting a restart
// BL is working for 5s after power-on-reset.
runProcess->bl_rebootDC();
}
void hwapi::bl_startBL(void) const // tested 26.09.2023
{
// use this function within the first 5s after reboot to startup the BL,
// otherwise the BL jumps to normal DC application
runProcess->bl_startBL();
}
void hwapi::bl_checkBL(void) const // tested 26.09.2023
{
// call this function in order to get information, afterwards use "bl_isUp()"
runProcess->bl_checkBL();
}
bool hwapi::bl_isUp(void) const // tested 26.09.2023
{
return runProcess->bl_isUp();
}
// obsolete, better use auto function listed further down
void hwapi::bl_sendAddress(uint16_t blockNumber) const
{
// send start address, nr of 64byte-block, start with 0
// will be sent only for folling block-numbers:
// 0, 1024, 2048, 3072 and 4096, so basically every 64kByte
uint32_t dcBL_BlkCtr=(uint32_t)blockNumber;
uint8_t len, buf[20];
tslib_strclr(buf, 0, 20);
if (dcBL_BlkCtr==0 || dcBL_BlkCtr==1024 || dcBL_BlkCtr==2048 || dcBL_BlkCtr==3072 || dcBL_BlkCtr==4096)
{
dcBL_BlkCtr*=64;
len=dcBL_sendFlashStartAddr2BL(dcBL_BlkCtr, buf); // make command string
// minimum size of sendData-buffer: 13byte retval: length (9...13)
sendWRcmd_setSendBlock160(len, buf); // send command to BL
}
}
// obsolete, better use auto function listed further down
uint8_t hwapi::bl_wasSendingAddOK(void) const
{
// return val: 0: no response by now 1:error 10: OK
return dcBL_sendSuccess(0x21);
}
void hwapi::bl_openBinary(void) const
{
}
// obsolete, better use auto function listed further down
void hwapi::bl_sendDataBlock(uint8_t length, uint8_t *buffer) const
{
// send 64 byte from bin file
uint8_t LL=length, sendBuf[80], sendLen;
if (LL>64) LL=64;
tslib_strclr(sendBuf,0,80);
sendLen=dcBL_prepareDC_BLcmd(0x22, LL, buffer, sendBuf); // pack into protocol frame
sendWRcmd_setSendBlock160(sendLen, sendBuf); // send 140 bytes
delay(100);
}
// obsolete, better use auto function listed further down
void hwapi::bl_sendLastBlock(void) const
{
uint8_t len, buf[20];
len=dcBL_writeLastPage(buf);
sendWRcmd_setSendBlock160(len, buf);
}
// obsolete, better use auto function listed further down
uint8_t hwapi::bl_wasSendingDataOK(void) const
{
// return val: 0: no response by now 1:error 10: OK
return dcBL_sendSuccess(0x22);
}
void hwapi::bl_stopBL(void) const // tested 26.09.2023
{
uint8_t len, buf[20];
len=dcBL_exitBL(buf);
sendWRcmd_setSendBlock160(len, buf);
epi_setNowIsBootload(false);
}
// ------------------------------------------------------------------------------------
// 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::rtc_getExtendedTime(struct T_extTime *exTime) const
{
uint8_t len;
uint16_t LL, nn;
uint8_t *start;
uint8_t buf[66];
epi_restoreExtendedTime(&len, buf);
// Puffer in struct eintragen:
LL=sizeof(struct T_extTime);
start = &(exTime->Hours);
nn=0;
do
{
*start = buf[nn];
start++;
} while(++nn<LL);
return true;
}
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=check4freeFDstack();
// Command-Stack sollte 16 Commands fassen, je 64byte Nutzdaten = 1024byte
// 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=check4freeFDstack();
// Command-Stack sollte 16 Commands fassen, je 64byte Nutzdaten = 1024byte
// 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; // falsch
uitmp+=64;
} while(uitmp < dateiLang);
longFDcmd_set(32, 0,0, 0,temp); // Abschluss
return true;
}
static uint8_t lastSentDynData[64];
//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
memcpy(lastSentDynData, dynPrnVal, 64);
return longFDcmd_set(33,39,0, 64, lastSentDynData);
}
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
Add some debug output in case the dc-data-valid flag is reset to false.
2023-12-18 12:12:30 +01:00
qCritical() << __PRETTY_FUNCTION__ << "RESET DC DATA VALID";
Start repository
2023-11-08 13:02:26 +01:00
epi_clearDynMachineConditions(); // 24.6.23
gpi_storeDcDataValid(0);
return sendFDcmd_set(152, 0,0, nrOftemplate,0,0,0);
}
void hwapi::log_getHoldAccountNumbers(uint8_t *nrOfVals, uint16_t *accNr ) const
{
// returns all acc nrs of the backuped vault records
// use: uint16_t backupedAccNumbers[8]
epi_restoreDCbackupAccNr(nrOfVals, accNr);
}
bool hwapi::log_selectVaultRecord(uint16_t accountNr ) const
{
// return true if sending, false if cmd-stack is full
// and trigger transfer
uint8_t dat1, dat2;
bool ret;
uint8_t frei=check4freeFDstack();
if (frei<8)
return false;
sendFDcmd_clrStack();
epi_startSupervision();
epi_iniVRstorage();
dat1=uint2uchar(accountNr, LOWBYTE);
dat2=uint2uchar(accountNr, HIGHBYTE);
ret=sendFDcmd_set(153, 0,0, dat1,dat2,0,0); // select this record
// true means "will be sent"
sendFDcmd_set(0,38,0, 0,0,0,0); // return VaultRecord block-Nr.0
sendFDcmd_set(0,38,1, 0,0,0,0); // return VaultRecord block-Nr.1
sendFDcmd_set(0,38,2, 0,0,0,0); // return VaultRecord block-Nr.2
sendFDcmd_set(0,38,3, 0,0,0,0); // return VaultRecord block-Nr.3
sendFDcmd_set(0,38,4, 0,0,0,0); // return VaultRecord block-Nr.4
sendFDcmd_set(0,38,5, 0,0,0,0); // return VaultRecord block-Nr.5
// 38: <100 to get long 64byte response
return ret;
}
bool hwapi::log_chkIfVaultRecordAvailable(void) const
{
// return true if completly received
if ( epi_checkIfVaultRecordAvailable() )
{
return true;
}
return false;
}
//uint8_t hwapi::log_getAvailableVaultBlocks(void) const
bool hwapi::log_getVaultRecord(struct T_vaultRecord *retVR) const
// which was selected by: log_selectVaultRecord()
// to be forwarded to Ismas
// return true if completly received
{
#define MAXLENOFVAULTREC 400
uint16_t LL, nn, len;
char *start;
uint8_t buf[MAXLENOFVAULTREC];
bool ret;
ret=epi_restoreVaultRecord(&len, buf); // true if completly received
if (ret==false)
return false;
// Puffer in struct eintragen:
LL=sizeof(struct T_vaultRecord);
if (LL>MAXLENOFVAULTREC) LL=MAXLENOFVAULTREC;
start = &retVR->startbuffer[0];
nn=0;
// 14.9.23 neu: Datensatz erst pruefen, [0..3] enthaelt "Psa>" und [4,5 =Abr.Nr]
uint16_t ds_acc_nr=uchar2uint(buf[5], buf[4]);
Implemented bna-functionality
2023-11-14 08:40:54 +01:00
if (buf[0]=='P' && buf[1]=='s' && buf[2]=='a' && buf[3]=='>' && ds_acc_nr<60000)
Start repository
2023-11-08 13:02:26 +01:00
{
// valid data, copy data to struct
do
{
*start = buf[nn];
start++;
} while(++nn<LL);
return true;
} else
{
// wrong data, clear struct
do
{
*start = 0;
start++;
} while(++nn<LL);
return false;
}
return false;
}
bool hwapi::prn_printAccountReceipt(void) const
{
Add some debug output in case the dc-data-valid flag is reset to false.
2023-12-18 12:12:30 +01:00
qCritical() << __PRETTY_FUNCTION__ << "RESET DC DATA VALID";
Start repository
2023-11-08 13:02:26 +01:00
epi_clearDynMachineConditions(); // 24.6.23
gpi_storeDcDataValid(0);
return sendFDcmd_set(154, 0,0, 0,0,0,0);
}
bool hwapi::prn_printTestTicket(void) const
{
Add some debug output in case the dc-data-valid flag is reset to false.
2023-12-18 12:12:30 +01:00
qCritical() << __PRETTY_FUNCTION__ << "RESET DC DATA VALID";
Start repository
2023-11-08 13:02:26 +01:00
// return true if sending to DC OK, false if cmd-stack is full
epi_clearDynMachineConditions(); // 24.6.23
gpi_storeDcDataValid(0);
return sendFDcmd_set(157, 0,0, 0,0,0,0);
}
bool hwapi::cash_startPayment(uint32_t amount) const
{
return runProcess->cash_startPayment(amount);
}
uint8_t hwapi::cash_paymentProcessing(void) const
{
// no need to use
// will be called automatically
uint8_t collActiv=0;
collActiv = runProcess->cash_paymentProcessing();
return collActiv;
}
uint32_t hwapi::getInsertedAmount(void) const
{
uint32_t ultmp;
ultmp=epi_CurrentPaymentGetAmount();
if (ultmp>65000) ultmp=0; // 19.6.23
qDebug() << "current inserted amount: "<< ultmp;
return ultmp;
}
uint16_t hwapi::getLastInsertedCoin(void) const
{
uint32_t ultmp;
ultmp=epi_CurrentPaymentGetLastCoin();
qDebug() << "last inserted coin: "<< ultmp;
return ultmp;
}
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
cashCancelPayment(): while printing quick request while printing and changing.
2023-12-06 14:35:57 +01:00
//epi_setNowCoinPay(false); // new since 20.9.23
// am 6.12.23 wieder raus, waehrend Druck und wechseln auch schnell abfragen
Start repository
2023-11-08 13:02:26 +01:00
//qCritical() << "cash cancel payment and return coins";
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
Change as for cash_cancelPayment().
2023-12-06 14:37:37 +01:00
//epi_setNowCoinPay(false); // new since 20.9.23
// am 6.12.23 wieder raus, waehrend Druck und wechseln auch schnell abfragen
Start repository
2023-11-08 13:02:26 +01:00
//qCritical() << "cash stop payment and keep coins in escrow";
// qCritical() << "emitting signal StopByPushbutton 2";
emit hwapi_payStopByPushbutton();
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
epi_setNowCoinPay(false); // new since 20.9.23
//qCritical() << "printing finished, encash coins";
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
epi_setNowCoinPay(false); // new since 20.9.23
//qCritical() << "printing failed, encash coins";
return sendFDcmd_set(156, 0,0, 2,0,0,0);
}
// obsolete
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
uint8_t type=0, nn; // buf[8],
char ctmp=0;
for (nn=0;nn<8; nn++)
{
cardholder[nn]=ctmp;
}
return type;
}
uint64_t hwapi::sys_getWakeSource(void) const
{
// retval: 6 bytes, bit coded, 1=event keeps DC awake
return epi_getWakeSources();
}
uint8_t hwapi::sys_getWakeReason(void) const
{
// Master was woken by following reason:
// 1: MDB Event
// 2: Coin Event
// ( 3: Master Event) - will not set the wake line
// ( 4: 32s pulse) - will not set the wake line
// 5: Door Event
// ( 6: Diag Event) - will not set the wake line
// 7: 30min-Pulse for HB
return epi_getWakeReason();
}
void hwapi::sys_getDeviceConditions(uint8_t *leng, uint8_t *data) const
{
//uint8_t leng, data[66];
epi_restoreDeviceConditions(leng, data);
}
void hwapi::sys_getDeviceConditions(struct T_moduleCondition *devCond) const
{
uint16_t LL, nn;
uint8_t *start;
uint8_t buf[70], leng;
epi_restoreDeviceConditions(&leng, buf);
// Puffer in struct eintragen:
LL=sizeof(struct T_moduleCondition);
start = &devCond->ram;
nn=0;
do
{
*start = buf[nn];
start++;
} while(++nn<LL);
// patch for printer error, only needed until DC4.37 ------------------------------
struct T_dynamicCondition myDynMachCond;
sys_getDynMachineConditions(&myDynMachCond);
uint8_t zustand=myDynMachCond.lastPrinterStatus;
if (zustand & 0xE0)
// 0: printer OK
// bit0: near paper end bit1: no paper
// bit2: temperature error bit3: error head open
// bit4: paper jam in cutter
// bit6: no response bit7: serial rec. error
// bit5: printer not ready
devCond->printer=200; // not connected
else
if (zustand & 0x1C)
devCond->printer=201; // on error
else
if (zustand & 0x02)
devCond->printer=202; // no paper
else
if (zustand & 0x01)
devCond->printer=100; // low paper
// ------------------ end of patch -------------------------------------------------
}
void hwapi::sys_getDynMachineConditions(uint8_t *leng, uint8_t *data) const
{
epi_restoreDynMachineConditions(leng, data);
}
void hwapi::sys_getDynMachineConditions(struct T_dynamicCondition *dynMachCond) const
{
uint16_t LL, nn;
char *start;
uint8_t buf[70], leng;
epi_restoreDynMachineConditions(&leng, buf);
// Puffer in struct eintragen:
LL=sizeof(struct T_dynamicCondition);
start = &dynMachCond->allDoorsDebounced;
nn=0;
do
{
*start = buf[nn];
start++;
} while(++nn<LL);
}
uint32_t hwapi::cash_getAmountInVault(void) const
{
return epi_getCashBoxContent();
}
uint16_t hwapi::cash_getNrCoinsInVault(void) const
{
return epi_getNrOfCoinsInCashBox();
}
uint8_t hwapi::prn_getPrintResult() const
{
Fix: return value prn_getPrintResult()
2023-11-30 14:27:17 +01:00
// return: 0: just printing, wait
// 1: OK - last print was succesful
// 2: error - not printed
struct T_dynamicCondition myDynMachCond;
sys_getDynMachineConditions(&myDynMachCond);
return myDynMachCond.resultOfLastTemplPrint;
// 0: unknown or printing in progress
// 1: OK, doc was printed 2: error, doc was not printed
Start repository
2023-11-08 13:02:26 +01:00
}
uint8_t hwapi::prn_getCurrentPrinterState() const
{
// 0: printer OK
// bit0: near paper end bit1: no paper
// bit2: temperature error bit3: error head open
// bit4: paper jam in cutter
// bit6: no response bit7: serial rec. error
// bit5: printer not ready
uint8_t lastPrinterStatus;
uint8_t buf[70], leng;
if (!epi_areDcDataValid()) // was set to 0 with print command
return 0x40; // no response
// 2nd way to get dyn.conditions:
epi_restoreDynMachineConditions(&leng, buf);
lastPrinterStatus=buf[52];
return lastPrinterStatus;
Fix: return value prn_getPrintResult()
2023-11-30 14:27:17 +01:00
// oder mit:
//struct T_dynamicCondition myDynMachCond;
//sys_getDynMachineConditions(&myDynMachCond);
//myDynMachCond.lastPrinterStatus
Start repository
2023-11-08 13:02:26 +01:00
}
// 21.4.23TS: change function "sendDeviceSettings()" to use this struct: "struct T_devices"
void hwapi::sys_sendDeviceParameter(struct T_devices *deviceSettings) const
{
// same as "sendDeviceSettings()" but with much more data
uint8_t buf[64];
uint16_t LL, nn;
tslib_strclr(buf,0,64);
uint8_t *start;
// den gesamten struct in einen Puffer kopieren
LL=sizeof(struct T_devices);
start = &deviceSettings->kindOfPrinter;
nn=0;
do
{
buf[nn] = *start;
start++;
} while(++nn<LL);
longFDcmd_set(CMD2DC_DEVICE_PARAM,0,0,LL, buf);
}
void hwapi::sys_restoreDeviceParameter(struct T_devices *deviceSettings) const
{
// attention: only applies if function "sys_sendDeviceParameter()" was used to send this settings before
// cannot be used to see settings programmed by JsonFile
uint8_t buf[64];
sys_restoreDeviceParameter() check size of struct T_devices
2024-02-06 09:36:26 +01:00
uint8_t LL;
Start repository
2023-11-08 13:02:26 +01:00
tslib_strclr(buf,0,64);
//runProcess->epi_restore64BdevParameter(&LL, buf); // wozu die???
epi_restoreRbDeviceSettings(&LL, buf); // viel besser, stimmt immer
sys_restoreDeviceParameter() check size of struct T_devices
2024-02-06 09:36:26 +01:00
Q_STATIC_ASSERT(sizeof(*deviceSettings) <= sizeof(buf));
Start repository
2023-11-08 13:02:26 +01:00
sys_restoreDeviceParameter() check size of struct T_devices
2024-02-06 09:36:26 +01:00
memcpy(deviceSettings, buf, sizeof(*deviceSettings));
Start repository
2023-11-08 13:02:26 +01:00
}
bool hwapi::sys_areDCdataValid(void) const
{
return epi_areDcDataValid();
}
bool hwapi::sys_sendingTest(void) const
{
/*
uint8_t buf[70], nn;
for (nn=0; nn<64; nn++) buf[nn]=nn+10;
if (check4freeFDstack()<16 )
{
qDebug()<< "hwapi_sys_test_sending: only: " << check4freeFDstack() << " free";
return false;
}
sendFDcmd_set(201, 202,1, 2,3,4,5);
sendFDcmd_set(203, 204,6, 7,8,9,5);
sendFDcmd_set(0, 205,1, 2,3,4,5);
longFDcmd_set (99, 0, 0, 64, buf); // long command must be <100!!!
sendFDcmd_set(0, 207,1, 6,7,8,9);
sendFDcmd_set(208, 209,1, 2,3,4,5);
sendFDcmd_set(210, 211,1, 6,7,8,9);
longFDcmd_set (98, 213,1, 64, buf);
sendFDcmd_set(214, 0,1, 2,3,4,5);
sendFDcmd_set(215, 0,1, 3,4,5,6);
sendFDcmd_set(216, 0,1, 2,3,4,5);
sendFDcmd_set(217, 0,1, 9,8,7,6);
sendFDcmd_set(218, 0,1, 2,3,4,5);
sendFDcmd_set(219, 0,1, 0,1,2,3);
sendFDcmd_set(220, 0,1, 2,3,4,5);
sendFDcmd_set(221, 222,1, 6,7,8,9);
*/
/*
for (nn=0; nn<16; nn++)
{
ll=checkNextFDcmd();
qDebug() << "sys_sendingTest reading: " << ll;
if (ll==2)
{
b_ret=longFDcmd_get(&nextWrCmd, &nextRdCmd, &blockNum, &length, data);
qDebug() << "long cmd: "<<nextWrCmd<<" "<<nextRdCmd<<" "<<blockNum<<" "<<length;
qDebug() << " / "<< data[0] << " / "<< data[1] << " / "<< data[2] << " / "<< data[3] << " / "<< data[4];
} else
if (ll==1)
{
b_ret=sendFDcmd_get(&nextWrCmd, &nextRdCmd, &blockNum, &dat1, &dat2, &dat3, &dat4);
qDebug() << "short cmd: "<<nextWrCmd<<" "<<nextRdCmd<<" "<<blockNum<<" "<<dat1<<" "<<dat2<<" "<<dat3<<" "<<dat4;
}
}
ll=checkNextFDcmd();
qDebug() << "completly read: " << ll;
*/
return true;
}
void hwapi::prn_requestCurrentDynData(void) const
{
sendFDcmd_set(0,39,0,0,0,0,0); // rd data dynData
epi_clearDynData();
}
bool hwapi::prn_getCurrentDynamicPrnValuesFromDC(uint8_t *dynPrnVal ) const
{
// which was sent to DC with: prn_sendDynamicPrnValues(uint8_t *dynPrnVal )
// retval true if data valid
bool isValid;
uint8_t buf[66];
isValid=epi_getDynPrnData(&buf[0]);
// bool epi_getDynPrnData(uint8_t *DCdynDat);
// buffer size: 64 byte
// return true if data are new and valid
if (isValid)
{
memcpy(dynPrnVal, buf, 64);
return true;
}
return false;
}
bool hwapi::prn_dynDataAreEqual(uint8_t *buf) const
{
for (int nn=0; nn<64; nn++)
if (lastSentDynData[nn]!=buf[nn])
return false;
return true;
}
bool hwapi::prn_printKombiticket(uint8_t nrOfKombi) const
// print four of the templates loaded by Json prior
// nr = 1..8
{
// return true if sending, false if cmd-stack is full
if ((nrOfKombi<1) || (nrOfKombi>8))
return false;
Add some debug output in case the dc-data-valid flag is reset to false.
2023-12-18 12:12:30 +01:00
qCritical() << __PRETTY_FUNCTION__ << "RESET DC DATA VALID";
Start repository
2023-11-08 13:02:26 +01:00
epi_clearDynMachineConditions(); // 24.6.23
gpi_storeDcDataValid(0);
return sendFDcmd_set(158, 0,0, nrOfKombi,0,0,0);
}
void hwapi::lock_triggerUpperSolenoid(void) const
{
sendFDcmd_set(159, 0,0, 0,0,0,0);
}
void hwapi::lock_triggerLowerSolenoid(void) const
{
sendFDcmd_set(160, 0,0, 0,0,0,0);
}
bool hwapi::doors_supervise(void) const
{
// no need to use
// will be called automatically
// new from 2023.06.12, generate some signals:
//virtual void hwapi_ doorServiceDoorOpened(void) const=0;
//virtual void hwapi_ doorVaultDoorOpened(void) const=0;
//virtual void hwapi_ doorCBinAndAllDoorsClosed(void) const=0;
//virtual void hwapi_ doorAllDoorsClosed(void) const=0;
//virtual void hwapi_ doorCoinBoxRemoved(void) const=0;
return runProcess->doors_supervise();
}
bool hwapi::dc_isAutoRequestOn(void) const
{
return gpi_isEmmisionOn();
}
uint16_t hwapi::log_getLatestAccountNumber(void) const
{
// new function 27.6.2023
// latest = highest, by now 8 records are stored in DC, prepare for 32
#define maxNrElements 8
uint8_t anz, nn;
uint16_t nummern[maxNrElements], highest=0;
memset(nummern, 0, sizeof(uint16_t)*maxNrElements);
log_getHoldAccountNumbers(&anz, nummern);
if (anz>maxNrElements) anz=maxNrElements;
for (nn=0; nn<anz; nn++)
if (nummern[nn]>highest)
highest=nummern[nn];
return highest;
}
uint8_t hwapi::log_getAvailableVaultBlocks(void) const
{
// return 0x0011 1111 if all 6 blocks arer loaded (one bit per block)
return epi_getLoadedVaultBlocks();
}
uint8_t hwapi::log_getAnswerToLastSlaveRequest(void) const
{
// use only for ONE request/command
// return: 0xFF: result unknown
// 0=OK
// 1= wrong length 2=wrong start sign 5= wrong crc
// 6= slave: master cmd was wrong 7: slave: could not write/read data
// 8=timeout, got no response from slave
return epi_getLastResult();
}
// use for important and extended commands (print more templates, print ticket...)
void hwapi::log_startSupervision(void) const
{
epi_startSupervision();
}
uint8_t hwapi::log_getAnswerToLastCmdBatch(void) const
{
// 0xFF: no command sent by now
// 0: started, in progress
// 1: done and OK
// 2: done and error
return epi_getBatchResult();
}
bool hwapi::log_getVaultData(uint8_t *data) const
{
// get vault record in linear 8bit buffer with 384 byte
uint16_t len=384;
uint8_t buf[400];
bool ret;
int nn;
ret=epi_restoreVaultRecord(&len, buf);
if (ret==false)
return false;
// 14.9.23 neu: Datensatz erst pruefen, [0..3] enthaelt "Psa>" und [4,5 =Abr.Nr]
uint16_t ds_acc_nr=uchar2uint(buf[5], buf[4]);
if (buf[0]=='P' && buf[1]=='S' && buf[2]=='A' && buf[3]=='>' && ds_acc_nr<60000)
{
// valid data, return data
for (nn=0; nn<384; nn++)
data[nn]= buf[nn];
return true;
} else
{
// wrong data, clear array
for (nn=0; nn<384; nn++)
data[nn]=0;
return false;
}
return false;
}
// new from 1.8.23
bool hwapi::prn_printOneAccountReceipt(uint16_t accountNr) const
{
Add some debug output in case the dc-data-valid flag is reset to false.
2023-12-18 12:12:30 +01:00
qCritical() << __PRETTY_FUNCTION__ << "RESET DC DATA VALID";
Start repository
2023-11-08 13:02:26 +01:00
// print one out of eight stored last accounting receipts
// function log_getHoldAccountNumbers() gives a list of acc-Nr. of the stored receipts
epi_clearDynMachineConditions(); // 24.6.23
gpi_storeDcDataValid(0);
uint8_t frei=check4freeFDstack();
if (frei<2)
return false;
uint8_t dat1, dat2;
dat1=uint2uchar(accountNr, LOWBYTE);
dat2=uint2uchar(accountNr, HIGHBYTE);
sendFDcmd_set(153, 0,0, dat1,dat2,0,0); // select this record
sendFDcmd_set(161, 0,0, 0,0,0,0); // print this
return true;
}
bool hwapi::prn_printAllAvailAccountReceipts(void) const
{
// same as: prn_printAccountReceipt() from line 1153
// return true if sending to DC OK, false if cmd-stack is full
return prn_printAccountReceipt();
}
uint16_t biox_crc_xmodem_update(uint16_t crc, uint8_t data)
{
// berechne CRC16 XModem nach Polynom x^16 + x^12 + x^5 + 1
int i;
crc = crc ^ ((uint16_t)data << 8);
for (i=0; i<8; i++)
{
if (crc & 0x8000)
crc = (crc << 1) ^ 0x1021;
else
crc <<= 1;
}
return crc;
}
//bool hwapi::log_verifyVaultRecordByCrc(struct T_vaultRecord *retVR) const
bool hwapi::log_verifyVaultRecordByCrc(void) const
{
// return true if CRC16 is correct, data are 100% OK. Security level 1:65536
// verification is strongly recommended before further processing
// in case of "false"-result please reload from DC
uint16_t myChkSum=0, nn, myOldSum=0, recCheckSum=0;
uint16_t LL=332; //320; // in DC noch falsch, sollte 332 sein
uint8_t val;
uint8_t data[400];
memset(data,0,400);
log_getVaultData(data);
for (nn=0; nn<LL; nn++)
{
val=data[nn];
myChkSum=biox_crc_xmodem_update(myChkSum, val);
}
// Fehler im DC vom 27.7.23 Version 4.39: Berechnung nur bis 320
LL=320;
for (nn=0; nn<LL; nn++)
{
val=data[nn];
myOldSum=biox_crc_xmodem_update(myOldSum, val);
}
// nur bis DC4.40 noetig
// -------------------------------------------------------------
recCheckSum= uchar2uint(data[333], data[332]);
if (recCheckSum == myChkSum || recCheckSum == myOldSum)
return true;
return false;
}
uint16_t hwapi::log_DC_getNextAccountNumber(void) const
{
// the current cash box content will be backuped with this number on next cashbox-change
return epi_getNextDCaccNr();
}
void hwapi::log_DC_setNextAccountNumber(uint16_t newAccountingNumber) const
{
// the current cash box content will be backuped with this number on next cashbox-change
// use only in case of hardware replacements or errors which derailed the number
uint8_t LB, HB;
LB=uint2uchar(newAccountingNumber, LOWBYTE);
HB=uint2uchar(newAccountingNumber, HIGHBYTE);
sendFDcmd_set(162, 0,0, LB,HB,LB,HB);
}
void hwapi::log_DC_deleteAllVaultrecordsInDc(void) const
{
// use only in case of hardware replacements or errors which derailed the number
uint8_t sendData[10];
sendData[0]='D';
sendData[1]='e';
sendData[2]='l';
sendData[3]='e';
sendData[4]=0;
//longFDcmd_set(163, 0, 0, 8, sendData); // falsch!!! ( short Cmd, long data)
sendFDcmd_set(163, 0,0, sendData[0], sendData[1], sendData[2], sendData[3]);
}
void hwapi::log_DC_deleteAllTotalCounters(void) const
{
// use only in case of hardware replacements or errors which derailed the number
uint8_t sendData[10];
sendData[0]='D';
sendData[1]='e';
sendData[2]='l';
sendData[3]='e';
sendData[4]=0;
sendFDcmd_set(164, 0,0, sendData[0], sendData[1], sendData[2], sendData[3]);
}
void hwapi::dc_setNewCustomerNumber(uint16_t newCustNr) const
{
uint8_t LB, HB;
LB=uint2uchar(newCustNr, LOWBYTE);
HB=uint2uchar(newCustNr, HIGHBYTE);
sendFDcmd_set(165, 0,0, LB,HB,LB,HB);
}
void hwapi::dc_setNewMachineNumber(uint16_t newMachNr) const
{
uint8_t LB, HB;
LB=uint2uchar(newMachNr, LOWBYTE);
HB=uint2uchar(newMachNr, HIGHBYTE);
sendFDcmd_set(166, 0,0, LB,HB,LB,HB);
}
void hwapi::dc_setNewBorough(uint16_t newBorough) const
{
uint8_t LB, HB;
LB=uint2uchar(newBorough, LOWBYTE);
HB=uint2uchar(newBorough, HIGHBYTE);
sendFDcmd_set(167, 0,0, LB,HB,LB,HB);
}
void hwapi::dc_setNewZone(uint16_t newZone) const
{
uint8_t LB, HB;
LB=uint2uchar(newZone, LOWBYTE);
HB=uint2uchar(newZone, HIGHBYTE);
sendFDcmd_set(168, 0,0, LB,HB,LB,HB);
}
// ----------------------- new functions from 8.9.23 --------------------------------------
// new mifare functions
// call void hwapi::request_MifareID() before! (cmd24)
// send 24
/* further mifare requests:
void hwapi::request_MifareReaderState() const; // 24
void hwapi::request_MifareCardType() const; // 109
void hwapi::request_MifareAtbType() const; // 25
void hwapi::request_MifareData(uint8_t dataBlockNumber);
// dataBlockNumber=0...11 send cmd 28
*/
QString hwapi::mif_getReaderType(void) const
{
// new, 8.9.23, return reader type and version like "SL025-1.8"
QString myStr;
uint8_t mifData[66];
char myChr;
epi_restoreMifHwData(mifData, 66);
/* stand 8.9.23
struct T_Mifare
{
UCHAR ReaderState; // 1: OK 0: not OK
UCHAR res1;
2: UCHAR ReaderVersion[10];
12: UCHAR CardPresent;
UCHAR CardSelected;
UCHAR Cardtype;
UCHAR CardAllowed; // 0,1 nur Mifare Classic 1k und 4k zugelassen
UCHAR CardSize; // 1 or 4 (kB)
UCHAR LengOfUid; // 4 or 7 (byte)
18: UCHAR UID[8]; // 4 byte oder 7 byte, Format binär
// 26 byte bis hier
UCHAR res2;
UCHAR res3;
28: ULONG UidH; // bei 4byte Uid alles 0
ULONG UidL;
36: UCHAR SectorLogged; // result of loggin: 2=success 3=failed 1=no_tag 8=addr overflow F0=wrongCmd
UCHAR CurrentSector;
UCHAR RD_WR_Result;
UCHAR res4;
// 40byte lang
};
*/
myStr.clear();
// UID in buf[18...25]
for (int ii=0;ii<10; ii++)
{
myChr=(char)mifData[ii+2];
//myStr.append(QString::number()); geht nicht, anzeige als Zahl
myStr.append(myChr);
}
return myStr;
}
// mif_getCardType gibts oben schon!
void hwapi::mif_getCardSize(uint8_t *cardSize, uint8_t *idLeng) const
{
// new, 8.9.23
// cardSize=1k or 4kByte (Mifare Classic)
// idLeng =4Byte or 7 byte
uint8_t mifData[66];
epi_restoreMifHwData(mifData, 66);
*cardSize=mifData[16];
*idLeng=mifData[17];
}
// neu 14.9.23
char hwapi::mif_getAtbCardData(uint8_t *buf, uint8_t maxBuffSiz) const
{
// return complete buffer binary, just for test purpose
uint8_t mifData[66], nn;
if (maxBuffSiz>=64)
{
epi_restoreMifAtbData(mifData, 66);
for (nn=0; nn<64; nn++)
buf[nn]=mifData[nn];
return true;
}
return false;
}
bool hwapi::mif_isValidAtbCard(void) const
{
uint8_t receivedData[66], nn;
//uint32_t mifatb_cunu, mifatb_cardnu, mifatb_creditAmount, mifatb_creditTime;
//QString mifatb_cardTyp, mifatb_lpr, mifatb_group, mifatb_zone;
//uint8_t mifatb_times[10];
uint8_t lprbuff[20];
bool ret;
epi_restoreMifAtbData(receivedData, 66);
for (nn=0; nn<16; nn++)
{
lprbuff[nn]=char(receivedData[12+nn]);
//mifatb_lpr.append(char(receivedData[12+nn])); // "AtbPsa1256Ptu5_!" = recognition ATB card
}
/*
//mifatb_lpr.clear();
mifatb_cunu=uchar2ulong(receivedData[3], receivedData[2],receivedData[1],receivedData[0]);
// 281
mifatb_cardnu=uchar2ulong(receivedData[7], receivedData[6],receivedData[5],receivedData[4]);
// always 0, not used
mifatb_cardTyp.clear();
for (nn=0; nn<4; nn++)
mifatb_cardTyp.append(char(receivedData[8+nn])); // = "PREP" no idea what that means
mifatb_group.clear();
for (nn=0; nn<8; nn++)
mifatb_group.append(char(receivedData[28+nn])); // "7x§0 TPf" used for card type
mifatb_zone.clear();
for (nn=0; nn<8; nn++)
mifatb_zone.append(char(receivedData[36+nn])); // "PNsax001" used for personal number and shortcode
for (nn=0; nn<10; nn++)
mifatb_times[nn]=receivedData[44+nn];
// 0..9: (Start) day, month, year, hh, min (Stop) day, month, year, hh, min,
mifatb_creditAmount= uchar2ulong(receivedData[57], receivedData[56],receivedData[55],receivedData[54]);
// is used as expire date/time
mifatb_creditTime = uchar2ulong(receivedData[61], receivedData[60],receivedData[59],receivedData[58]);
// always 0
// qDebug()<<"got MifAtbData: "<<mifatb_cunu<<" "<< mifatb_cardnu<<" "<< mifatb_cardTyp<<" "<< mifatb_lpr
// <<" "<< mifatb_group<<" "<< mifatb_zone<<" "<< mifatb_times[0]<<" "<< mifatb_times[1]<<" "<< mifatb_times[2]
// <<" "<< mifatb_times[3]<<" "<< mifatb_times[4]<<" "<< mifatb_times[5]<<" "<< mifatb_times[6]
// <<" "<< mifatb_times[7]<<" "<< mifatb_times[8]<<" "<< mifatb_times[9]
// <<" "<< mifatb_creditAmount<<" "<< mifatb_creditTime;
*/
//ret=tslib_strComp(&lprbuff[0], "AtbPsa1256Ptu5_!"); // bringt Warnung, unloesbar.
ret=false;
if (lprbuff[0]=='A' && lprbuff[1]=='t' && lprbuff[2]=='b' && lprbuff[3]=='P' && lprbuff[4]=='s' &&
lprbuff[5]=='a' && lprbuff[6]=='1' && lprbuff[7]=='2' && lprbuff[8]=='5' && lprbuff[9]=='6' &&
lprbuff[10]=='P' && lprbuff[11]=='t' && lprbuff[12]=='u' && lprbuff[13]=='_' && lprbuff[14]=='!' )
ret=1;
//qDebug()<<"hwapi::mif_isValidAtbCard: "<<ret;
return ret;
}
uint32_t hwapi::mif_getAtbCardCuNu(void) const
{
uint8_t receivedData[66];
epi_restoreMifAtbData(receivedData, 66);
return uchar2ulong(receivedData[3], receivedData[2],receivedData[1],receivedData[0]);
}
uint8_t hwapi::mif_getAtbCardTyp(void) const
{
// return 1=upper door card 1=lower door 3=printer-test 4=coin-test
// 0: not a valid atb2020 card
uint8_t receivedData[66];
uint8_t mifatb_group[8], nn;
epi_restoreMifAtbData(receivedData, 66);
//mifatb_group.clear();
for (nn=0; nn<8; nn++)
mifatb_group[nn]=receivedData[28+nn]; // "7x§0 TPf" used for card type
if (mifatb_group[0]=='7' && mifatb_group[1]=='x' && mifatb_group[3]=='0' && mifatb_group[4]==' ' ) // && mifatb_group[2]=='§' geht nicht
{
// card type is valid
if (mifatb_group[5]=='D' && mifatb_group[6]=='U')
return 1;
if (mifatb_group[5]=='D' && mifatb_group[6]=='V')
return 2;
if (mifatb_group[5]=='T' && mifatb_group[6]=='P')
return 3;
if (mifatb_group[5]=='T' && mifatb_group[6]=='C')
return 4;
}
return 0;
}
QString hwapi::mif_getAtbCardPerso(void) const
{
uint8_t receivedData[66], nn;
QString mifatb_zone;
epi_restoreMifAtbData(receivedData, 66);
mifatb_zone.clear();
for (nn=0; nn<8; nn++)
mifatb_zone.append(char(receivedData[36+nn])); // "PNsax001" used for personal number and shortcode
return mifatb_zone;
}
void hwapi::mif_getAtbCardExpire(uint8_t *year, uint8_t *month, uint8_t *day, uint8_t *hour, uint8_t *minute) const
{
uint8_t receivedData[66], nn, mifatb_times[10];
epi_restoreMifAtbData(receivedData, 66);
for (nn=0; nn<10; nn++)
mifatb_times[nn]=receivedData[44+nn];
// 0..9: (Start) day, month, year, hh, min (Stop) day, month, year, hh, min,
// qDebug()<<"hwapi::mif_getAtbCardExpire: "<< mifatb_times[0] << " " << mifatb_times[1] << " "
// << mifatb_times[2] << " " << mifatb_times[3] << " " << mifatb_times[4];
// for the 2020 cards the field "mifatb_creditAmount" is used as expire date/time:
//for (nn=0; nn<5; nn++)
// mifatb_times[nn]=receivedData[54+nn]; falsch
uint32_t ultmp= uchar2ulong(receivedData[57], receivedData[56],receivedData[55],receivedData[54]); // =mifatb_creditAmount
mifatb_times[4]=ultmp%100;
ultmp/=100;
mifatb_times[3]=ultmp%100;
ultmp/=100;
mifatb_times[2]=ultmp%100;
ultmp/=100;
mifatb_times[1]=ultmp%100;
ultmp/=100;
mifatb_times[0]=ultmp%100;
*year = mifatb_times[0];
*month = mifatb_times[1];
*day = mifatb_times[2];
*hour = mifatb_times[3];
*minute = mifatb_times[4];
}
// ------------------------------------------------------------------------------------
// Device-Controller-Bootloader convenient version 21.09.2023
// ------------------------------------------------------------------------------------
// use this to jump to BL:
//void hwapi::bl_rebootDC(void) const
// use this to start BL:
// void hwapi::bl_startBL(void) const
// call this in order to get response from BL:
//void hwapi::bl_checkBL(void) const
// evaluate BL response:
//bool hwapi::bl_isUp(void) const
// 29.9.23: new: "completeStart" function, replaces bl_rebootDC(), bl_startBL() and bl_checkBL()
// result can be verified with bl_isUp() as before
bool hwapi::bl_completeStart(void) const
{
// must be used in DC's normal operation
runProcess->bl_completeStart();
//hwapi_triggerBL->start(100);
return true;
}
// select binfile-name in GUI
// send binfile-name to BL-processor:
bool hwapi::bl_storeFirmware(QString fileName) const
{
// load binary file 3x and compare
// return true if loaded correctly
// return false: error, could not load correctly
return dcBL_loadBinSafe(fileName);
}
// request the number of blocks for this file
uint16_t hwapi::bl_getNrOfFirmwareBlocks(void) const
{
// size of the loaded bin file in 64byte blocks
// call after bl_storeFirmware()
return dcBL_getNrOfBlocks();
}
// call this function with "blockNumber"=0,1,2,3.....bl_getNrOfFirmwareBlocks
//the last block "bl_getNrOfFirmwareBlocks()" is sent as conclusion command (important!)
bool hwapi::bl_blockAutoLoad(uint16_t blockNumber) const
{
// call in loop from block number 0 up to <= "dcBL_getNrOfBlocks()"
// but after every call WAIT (!) for response "bl_blockAutoResponse()" !!!!
// data will be sent to DC, if neccesary addr will be sent additionally
// if neccesary sending will automatically repeat up to 3times
// retval: false if blockNumber>4095, true else
return dcBL_sendOneBlockCpl(blockNumber);
}
// check out this response after every block-sending, wait until >0!!!
int8_t hwapi::bl_blockAutoResponse(void) const
{
// after every "bl_blockAutoLoad()" call this until response
// retval 0: wait 1: OK, blk was sent 2: OK, transfer complete
// 3: error despite repeating, cancel. probably bin file corrupted
// Max duration: 3x no response from BL = 900ms
return dcBL_getBlockResult();
}
// finally call:
// void hwapi::bl_stopBL(void) const
// -------------- end of bootloader ---------------------------------------------------
// new from 28.9.23 and earliest from DC version 4.45
// get all versions of the DC-Jsons
void hwapi::sys_requestJsonVersions(uint8_t jsonNr) const
{
// send one request for every single version
// jsonNr=1...36, 1=config file (cust.Nr) 2=devices 3=cash 4=res.
// 5=printer template 1 ..... 36= template 32
sendFDcmd_set(0, 21, jsonNr,0,0,0,0);
}
void hwapi::sys_getJsonVersions(uint8_t jsonNr, char *versionString) const
{
epi_getJsonVersion(jsonNr, versionString);
// jsonNr=1...36, 1=config file (cust.Nr) 2=devices 3=cash 4=res.
// 5=printer template 1 ..... 36= template 32
// length of buffer is always 16 byte
}
// ------------------------------------------------------------------------------------
// Coin Changer
// ------------------------------------------------------------------------------------
void hwapi::changer_returnCoins(uint32_t amountInCent) const
{
// command to give change
uint8_t buff[8];
buff[0]=ulong2uchar(amountInCent, 0); //LOWBYTE
buff[1]=ulong2uchar(amountInCent, 1);
//buff[2]=ulong2uchar(amountInCent, 2);
//buff[3]=ulong2uchar(amountInCent, 3); // HIGHBYTE
// repeat for security:
buff[2]=ulong2uchar(amountInCent, 0); //LOWBYTE
buff[3]=ulong2uchar(amountInCent, 1);
//buff[6]=ulong2uchar(amountInCent, 2);
//buff[7]=ulong2uchar(amountInCent, 3); // HIGHBYTE
// longFDcmd_set(169, 0,0, 4,buff); // short cmd max 4 byte!
sendFDcmd_set(169,0,0,buff[0], buff[1], buff[2], buff[3]);
}
void hwapi::changer_requestChangeResult(void) const
{
sendFDcmd_set(0, 115,0, 0,0,0,0);
}
uint8_t hwapi::changer_getChangeResult(uint32_t *returnedAmount) const
{
return epi_getChangerResult(returnedAmount);
// get result of coin dispensing
// receivedData[0]: 0: not yet started 1:amount returned
// 2:only partial return 3: no return possible
// receivedData[2,3,4,5]: returned amount
}
void hwapi::changer_getAllParameters(struct T_changer *mw) const
{
// requested automatically with 23, same like EMP
uint8_t leng, data[66], pp, nn;
epi_restoreEmpSettings(&leng, data); // expected length = 64 byte
// get 64 bytes about Changer (mw), see interfaces.h-file
mw->setup = data[0];
mw->state = data[1];
mw->level = data[2];
mw->countryCode = uchar2uint(data[4], data[3]);
mw->scale = data[5];
mw->decimals= data[6];
for (nn=0; nn<16; nn++)
mw->coinSetup[nn]= data[nn+7]; // 7...22
mw->intendedAcceptance = uchar2uint(data[24], data[23]);
mw->tokenChannel= data[25];
mw->pollingRunning= data[26];
mw->paymentRunning= data[27];
pp=28;
for (nn=0; nn<16; nn++)
{
mw->denomination[nn] = uchar2uint(data[pp+1], data[pp]);
pp+=2;
}
// bis pp=60
mw->availableTubes = uchar2uint(data[61], data[60]);
}
void hwapi::changer_requestTubelevel(void) const
{
sendFDcmd_set(0, 40,0, 0,0,0,0);
}
void hwapi::changer_getTubelevel(struct T_chg_Tub *tubLevel) const
{
// don't use tubeDispens[], it's not yet correct!
uint16_t LL, nn;
uint8_t *start;
uint8_t buf[66];
epi_restoreTubeLevel(buf);
// Puffer in struct eintragen:
LL=sizeof(struct T_chg_Tub);
start = &(tubLevel->tubeLevel[0]);
nn=0;
do
{
*start = buf[nn];
start++;
} while(++nn<LL);
}
// ------------------------------------------------------------------------------------
// bank note acceptor
// ------------------------------------------------------------------------------------
void hwapi::bna_sendSettings(uint16_t notesToAccept, uint16_t parameters,
uint16_t *billDenomination,
uint32_t acceptanceLimit) const
{
// notesToAccept: bit0=bill1 (lowest donomination) bitH=accept bit L = deny
// parameters: e.g. use escrow function for some notes
// billDenomination = array of 16 bill values (e.g. 5, 10, 20...)
// these can be set alternatively by Json-File DC2C_cash.json
// acceptanceLimit: device will stop acceptance once this amount is reached and
// optionally keep last bill in escrow until vend_success()
// is called (put bill to stacker) or vend_failed() is called (return bill)
Implemented bna-functionality
2023-11-14 08:40:54 +01:00
uint16_t noteAcc=notesToAccept;
uint16_t para=parameters;
uint16_t denom[16];
uint32_t limit=acceptanceLimit;
uint8_t buf[64], nn, pp;
for (nn=0; nn<16; nn++)
denom[nn]=billDenomination[nn];
buf[0]=uint2uchar(noteAcc, LOWBYTE);
buf[1]=uint2uchar(noteAcc, HIGHBYTE);
buf[2]=uint2uchar(para, LOWBYTE);
buf[3]=uint2uchar(para, HIGHBYTE);
pp=4;
for (nn=0; nn<16; nn++)
{
buf[pp++]=uint2uchar(denom[nn], LOWBYTE);
buf[pp++]=uint2uchar(denom[nn], HIGHBYTE);
}
buf[pp++]=ulong2uchar(limit, 0);
buf[pp++]=ulong2uchar(limit, 1);
buf[pp++]=ulong2uchar(limit, 2);
buf[pp++]=ulong2uchar(limit, 3);
longFDcmd_set(35, 41, 0, pp, buf);
Start repository
2023-11-08 13:02:26 +01:00
}
void hwapi::bna_setCurrentAcceptance(uint16_t notesToAccept) const
{
// can be used to block notes dynamically, example: from now only 5€ bills are allowed (if only 3€ are to be paid)
Implemented bna-functionality
2023-11-14 08:40:54 +01:00
uint8_t LB, HB;
uint16_t val=notesToAccept;
LB=uint2uchar(val, LOWBYTE);
HB=uint2uchar(val, HIGHBYTE);
sendFDcmd_set(170, 0, 0, LB, HB, LB, HB);
Start repository
2023-11-08 13:02:26 +01:00
}
void hwapi::bna_requestParameters(void) const
{
// send command to DC in order to get static invariable device parameters like currency
// device must be powered and polled to get these
Implemented bna-functionality
2023-11-14 08:40:54 +01:00
sendFDcmd_set(0, 41, 0, 0, 0, 0, 0);
Start repository
2023-11-08 13:02:26 +01:00
}
bool hwapi::bna_getAllParameters(struct T_bna *bna) const
{
// get all constant data from reader (e.g. currency)
// and actual Host-Settings (sent with bna_sendSettings() or json)
// retval = true if data are valid
Implemented bna-functionality
2023-11-14 08:40:54 +01:00
uint8_t buf[66], nn, pp;
epi_restoreBnaParams(buf);
bna->setup=buf[0];
bna->FeatureLevel=buf[1];
bna->countryCode=uchar2uint(buf[3], buf[2]);
bna->scalingFactor=uchar2uint(buf[5], buf[4]);
bna->decimalPlace=buf[6];
bna->pad1=0;
bna->stackerCap=uchar2uint(buf[8], buf[7]);
bna->billSecureLevel=uchar2uint(buf[10], buf[9]);
bna->hasEscrow=buf[11];
for (nn=0; nn<16; nn++)
bna->accBillTypes[nn] = buf[nn+12];
bna->currentStackerLevel = uchar2uint(buf[29], buf[28]);
bna->intendedAccept = uchar2uint(buf[31], buf[30]);
bna->pad2=0;
pp=32;
for (nn=0; nn<16; nn++)
{
bna->billDenomination[nn] = uchar2uint(buf[pp+1], buf[pp]);
pp+=2;
}
if (bna->setup)
return true;
else
return false;
Start repository
2023-11-08 13:02:26 +01:00
}
void hwapi::bna_requestCurrentNotes(void) const
{
// send command to DC in order to get transaction data
Implemented bna-functionality
2023-11-14 08:40:54 +01:00
sendFDcmd_set(0, 116, 0, 0, 0, 0, 0);
Start repository
2023-11-08 13:02:26 +01:00
}
uint8_t hwapi::bna_getCurrentNotes(uint16_t latestBill, uint16_t *currentNotes) const
{
// returns number of collected bank notes since start-command (current transaction)
Implemented bna-functionality
2023-11-14 08:40:54 +01:00
// latestBill: not used
// currentNotes[0] = last bill value
// currentNotes[1] = 0/1 1 if bill in escrow 0 if bill in cash box (stacker)
// currentNotes[2,3] = total sum of collected bills within this transaction
// incoming data:
//DB1: nr of bills (this transaction)
//DB2: 1 if bill in escrow
//DB3..6: collected amount
//DB7,8: denomination of last bill
uint8_t buf[10], haveBilInEscrow, haveNrOfBills;
uint16_t lastBillVal;
uint32_t collAmountThisTrans;
epi_restoreBnaCollection(buf);
haveNrOfBills=buf[0];
haveBilInEscrow=buf[1];
collAmountThisTrans = uchar2ulong(buf[5],buf[4],buf[3],buf[2]);
lastBillVal = uchar2uint(buf[7],buf[6]);
currentNotes[0]=latestBill; // just to get rid of compiler warning
currentNotes[0]=lastBillVal;
currentNotes[1]=haveBilInEscrow;
currentNotes[2]=uint16_t(collAmountThisTrans);
collAmountThisTrans>>=16;
currentNotes[3]=uint16_t(collAmountThisTrans);
return haveNrOfBills;
Start repository
2023-11-08 13:02:26 +01:00
}
void hwapi::bna_requestStackerLevel(void) const
{
Implemented bna-functionality
2023-11-14 08:40:54 +01:00
sendFDcmd_set(0, 42, 0, 0, 0, 0, 0);
Start repository
2023-11-08 13:02:26 +01:00
}
uint16_t hwapi::bna_getStackerLevel(uint32_t *amountInStacker, uint16_t *countOfBills) const
{
// return val: nr of bills in stacker
Implemented bna-functionality
2023-11-14 08:40:54 +01:00
// countOfBills[0..7] = count of bills of bill-type 0..7 (e.g. countOfBills[0]=nr of 5€-bills in stacker)
// countOfBills[8..15] = value of bill-type 0...7
// receive data:
//je zwei Byte pro Wert,
//1…16: Anzahl Scheine pro Typ
//33…48: Wertigkeit der Typen
uint8_t buf[66], nn, pp, qq;
uint16_t nrOfBills[16], valueOfBills[16], anzahl=0;
uint32_t totalSum=0;
epi_restoreBnaContent(buf);
pp=0; qq=32;
for (nn=0; nn<16; nn++)
{
nrOfBills[nn]=uchar2uint(buf[pp+1],buf[pp]);
pp+=2;
valueOfBills[nn]=uchar2uint(buf[qq+1],buf[qq]);
qq+=2;
}
//qDebug()<< "CAmaster hwapi::bna_getStackerLevel " << nrOfBills[0] <<" "<< nrOfBills[1]
// <<" "<<nrOfBills[2]<<" "<<nrOfBills[3];
// qDebug()<< valueOfBills[0] <<" "<< valueOfBills[1] <<" "<<valueOfBills[2]<<" "<<valueOfBills[3];
// nur 8 zurueckmelden, mehr kommen derzeit von DC auch nicht
for (nn=0; nn<8; nn++)
{
countOfBills[nn]=nrOfBills[nn];
countOfBills[nn+7]=valueOfBills[nn];
}
for (nn=0; nn<8; nn++)
{
totalSum += nrOfBills[nn] * valueOfBills[nn];
anzahl += nrOfBills[nn];
}
//qDebug()<<"sum: "<< totalSum <<" Anzahl: "<<anzahl;
*amountInStacker=totalSum;
return anzahl;
Start repository
2023-11-08 13:02:26 +01:00
}
Add implementations for helpers for downloading device controller. NOTE : They are not called at the moment.
2023-12-20 16:50:50 +01:00
QObject const *hwapi::getAPI() {
return this;
}
bool hwapi::dcDownloadRequest(QString const &dcFileToDownload) const {
SharedMem *data = SharedMem::getData();
if (!data) {
return false;
}
char *fNameBuffer = data->m_downLoadDC.m_filename[(int)SharedMem::DCDownload::FILE_INDEX::DC_BINARY];
size_t const size = sizeof(data->m_downLoadDC.m_filename);
std::memset(fNameBuffer, 0x00, size);
std::memcpy(fNameBuffer, dcFileToDownload.toStdString().c_str(),
std::min(size, strlen(fNameBuffer)-1));
data->m_downLoadDC.m_totalBlocks = 0;
data->m_downLoadDC.m_currentblockNumber = 0;
data->m_downLoadDC.m_requested = true;
data->m_downLoadDC.m_running = false; // download thread is not running
data->m_downLoadDC.m_finished = true;
return true;
}
bool hwapi::dcDownloadRequested() const {
SharedMem const *data = SharedMem::getData();
// should be false at entry
return data ? data->m_downLoadDC.m_requested.load() : false;
}
bool hwapi::dcDownloadResetRequest() const {
SharedMem *data = SharedMem::getData();
if (data) {
data->m_downLoadDC.m_requested = false;
}
return true;
}
bool hwapi::dcDownloadRequestAck() const {
SharedMem *data = SharedMem::getData();
if (data) {
if (data->m_downLoadDC.m_requested) {
data->m_downLoadDC.m_requested = false;
data->m_downLoadDC.m_running = true;
data->m_downLoadDC.m_finished = false;
}
}
return false;
}
bool hwapi::dcDownloadRunning() const {
SharedMem const *data = SharedMem::getDataConst();
if (data) {
int cnt = 10;
while (--cnt > 0) {
bool running = data->m_downLoadDC.m_running.load();
bool finished = data->m_downLoadDC.m_finished.load();
if (!running || finished) {
if (cnt < 3) {
qCritical() << "DOWNLOAD THREAD NOT RUNNING" << running << finished;
}
QThread::msleep(500);
} else break;
}
// qCritical() << "DOWNLOAD RUNNING" << cnt << (cnt > 0);
return (cnt > 0);
}
return false;
}
void hwapi::dcDownloadThreadFinalize(DownloadThread *dthread) {
delete dthread;
m_downloadThread = nullptr;
}
bool hwapi::dcDownloadFinished() {
SharedMem const *data = SharedMem::getDataConst();
if (data) {
int cnt = 10;
while ((--cnt > 0) &&
((data->m_downLoadDC.m_running.load() == true) &&
(data->m_downLoadDC.m_finished.load() == false))) {
QThread::sleep(1);
}
//if (cnt > 0) {
// delete m_downloadThread;
// m_downloadThread = nullptr;
// return true;
//}
}
return false;
}
// download thread
bool hwapi::dcDownloadThreadStart() {
m_downloadThread = new DownloadThread(this);
if (m_downloadThread) {
m_downloadThread->start();
int cnt = 10;
while (--cnt > 0 && !dcDownloadThreadRunning()) {
QThread::msleep(200);
}
return (cnt > 0);
}
return false;
}
bool hwapi::dcDownloadThreadRunning() const {
return (dcDownloadGetRunning() == true)
&& (dcDownloadGetFinished() == false);
}
bool hwapi::dcDownloadThreadFinished() const {
return (dcDownloadThreadRunning() == false);
}
// report thread
bool hwapi::dcDownloadReportThreadStart() { // only start reporting thread
int cnt = 10; // if download thread is running
while (--cnt > 0 && !dcDownloadRunning()) {
QThread::msleep(500);
}
if (cnt > 0) {
m_reportingThread = new ReportingThread(this);
if (m_reportingThread) {
m_reportingThread->start();
cnt = 10;
while (--cnt > 0 && !dcDownloadReportThreadRunning()) {
QThread::msleep(200);
}
return (cnt > 0);
}
}
return false;
}
bool hwapi::dcDownloadReportThreadRunning() const {
return m_reportingThread ? m_reportingThread->isRunning() : false;
}
Start repository
2023-11-08 13:02:26 +01:00
Add implementations for helpers for downloading device controller. NOTE : They are not called at the moment.
2023-12-20 16:50:50 +01:00
void hwapi::dcDownloadReportThreadFinalize() {
if (m_reportingThread) {
if (m_reportingThread->isFinished()) {
delete m_reportingThread;
m_reportingThread = nullptr;
}
}
}
void hwapi::dcDownloadReportThreadQuit() {
if (m_reportingThread) {
m_reportingThread->quit();
}
}
bool hwapi::dcDownloadReportThreadFinished() const {
return m_reportingThread ? m_reportingThread->isFinished() : false;
}
bool hwapi::dcDownloadReportStart() const {
int cnt = 10;
while (--cnt > 0 && !dcDownloadRunning()) {
QThread::msleep(200);
}
return (cnt == 0);
}
bool hwapi::dcDownloadReportRunning() const {
return dcDownloadReportThreadRunning();
}
bool hwapi::dcDownloadReportFinished() {
int cnt = 10;
while (--cnt > 0 && !dcDownloadReportThreadFinished()) {
QThread::sleep(1);
}
if (cnt == 0 && !dcDownloadReportThreadFinished()) {
return false;
}
if (dcDownloadReportThreadFinished()) {
delete m_reportingThread;
m_reportingThread = nullptr;
}
return true;
}
QString hwapi::dcDownloadFileName() const {
SharedMem const *data = SharedMem::getDataConst();
return data ? data->m_downLoadDC.m_filename[(int)SharedMem::DCDownload::FILE_INDEX::DC_BINARY] : "";
}
bool hwapi::dcDownloadSetRequested(bool requested) {
SharedMem *data = SharedMem::getData();
if (data) {
data->m_downLoadDC.m_requested = requested;
return true;
}
return false;
}
bool hwapi::dcDownloadSetRunning(bool running) {
SharedMem *data = SharedMem::getData();
if (data) {
data->m_downLoadDC.m_running = running;
return true;
}
return false;
}
bool hwapi::dcDownloadSetFinished(bool finished) {
SharedMem *data = SharedMem::getData();
if (data) {
data->m_downLoadDC.m_finished = finished;
return true;
}
return false;
}
void hwapi::dcDownloadSetTotalBlockNumber(uint16_t totalBlockNumber) {
SharedMem::getData()->m_downLoadDC.m_totalBlocks = totalBlockNumber;
}
void hwapi::dcDownloadSetCurrentBlockNumber(uint16_t currentBlockNumber) {
SharedMem::getData()->m_downLoadDC.m_currentblockNumber = currentBlockNumber;
}
uint16_t hwapi::dcDownloadGetTotalBlockNumber() const {
SharedMem const *data = SharedMem::getDataConst();
return data ? data->m_downLoadDC.m_totalBlocks.load() : 0;
}
uint16_t hwapi::dcDownloadGetCurrentBlockNumber() const {
SharedMem const *data = SharedMem::getDataConst();
return data ? data->m_downLoadDC.m_currentblockNumber.load() : 0;
}
bool hwapi::dcDownloadGetRequested() const {
SharedMem const *data = SharedMem::getDataConst();
return data ? data->m_downLoadDC.m_requested.load() : 0;
}
bool hwapi::dcDownloadGetRunning() const {
SharedMem const *data = SharedMem::getDataConst();
return data ? data->m_downLoadDC.m_running.load() : 0;
}
bool hwapi::dcDownloadGetFinished() const {
SharedMem const *data = SharedMem::getDataConst();
return data ? data->m_downLoadDC.m_running.load() : 0;
}
Reference in New Issue Copy Permalink