Skip to content
  • Categories
  • Recent
  • Tags
  • Popular
  • Users
  • Groups
  • Search
  • Get Qt Extensions
  • Unsolved
Collapse
Brand Logo
  1. Home
  2. International
  3. Italian
  4. Problema progetto When executing step "Make"
Forum Updated to NodeBB v4.3 + New Features

Problema progetto When executing step "Make"

Scheduled Pinned Locked Moved Solved Italian
4 Posts 2 Posters 495 Views 1 Watching
  • Oldest to Newest
  • Newest to Oldest
  • Most Votes
Reply
  • Reply as topic
Log in to reply
This topic has been deleted. Only users with topic management privileges can see it.
  • A Offline
    A Offline
    AntonioValentin
    wrote on last edited by AntonioValentin
    #1

    Buon giorno, a tutti.

    Ho un problema da parecchi giorni con il mio progetto...dopo aver reinstallato
    l'ubuntu su un'altra macchina ho esportato il progetto attuale dove sto lavorando.

    Su questa nuova macchina incontro questo problema..e non riesco a capire da dove ...spunta.

    Qualcuno riesce ad aiutarmi?

    Grazie mille.

    ../agejet/program.cpp: In static member function ‘static Program* Program::import_program(std::__cxx11::string)’:
    ../agejet/program.cpp:28:37: error: cannot convert ‘bool’ to ‘Program*’ in return
         if(!prog_file.is_open()) return false;
                                         ^~~~~
    Makefile:1165: recipe for target 'program.o' failed
    make: *** [program.o] Error 1
    09:28:46: The process "/usr/bin/make" exited with code 2.
    Error while building/deploying project agejet (kit: Agejet)
    The kit Agejet has configuration issues which might be the root cause for this problem.
    When executing step "Make"
    09:28:46: Elapsed time: 00:02.   /// elenco errore, giù troverà il codice sorgente
    
    Program *Program::import_program(string path)
    {
        ifstream prog_file;
        string line;
        QString name;
        QString support_qs;
        float fr_temp;
        float en_temp;
        QString void_prog;
        bool is_number;
        Program *new_p = new Program();
        new_p->treatment = new Treatment(10,"Program");
        new_p->is_void=1;
        prog_file.open(path);
        if(!prog_file.is_open()) return false; ////  < - errore
        getline(prog_file,line);
        void_prog = QString::fromStdString(line);
        if(void_prog!="0"){
            prog_file.close();
            return new_p;
        }  
    
    // il problema compare alla riga ( 15 ) 
    
    1 Reply Last reply
    0
    • VRoninV Offline
      VRoninV Offline
      VRonin
      wrote on last edited by
      #2

      L'errore e' molto chiaro. La tua funzione ritorna un Program*, tu stai tentando di far ritornare un bool facendo return false;. cambialo in return NULL; e funziona

      "La mort n'est rien, mais vivre vaincu et sans gloire, c'est mourir tous les jours"
      ~Napoleon Bonaparte

      On a crusade to banish setIndexWidget() from the holy land of Qt

      A 1 Reply Last reply
      0
      • VRoninV VRonin

        L'errore e' molto chiaro. La tua funzione ritorna un Program*, tu stai tentando di far ritornare un bool facendo return false;. cambialo in return NULL; e funziona

        A Offline
        A Offline
        AntonioValentin
        wrote on last edited by
        #3

        @VRonin

        Ciao,,

        Ho modificato il commando solo che adesso succede questo dentro ad'unaltro file.

        I errori sono questi

        ../agejet/rfid_worker.cpp: In constructor ‘rfid_worker::rfid_worker(QObject*)’:
        ../agejet/rfid_worker.cpp:8:35: warning: unused parameter ‘parent’ [-Wunused-parameter]
         rfid_worker::rfid_worker(QObject *parent)
                                           ^~~~~~
        ../agejet/rfid_worker.cpp: In member function ‘void rfid_worker::check_card_type()’:
        ../agejet/rfid_worker.cpp:80:36: warning: narrowing conversion of ‘(uchar)((rfid_worker*)this)->rfid_worker::MODEL_ADDR_OLD’ from ‘uchar {aka unsigned char}’ to ‘char’ inside { } [-Wnarrowing]
             char read_uid_c[] = {0x0E,0x03,MODEL_ADDR_OLD};
                                            ^~~~~~~~~~~~~~
        ../agejet/rfid_worker.cpp: In member function ‘void rfid_worker::find()’:
        ../agejet/rfid_worker.cpp:113:36: warning: narrowing conversion of ‘(uchar)((rfid_worker*)this)->rfid_worker::UID_ADDR’ from ‘uchar {aka unsigned char}’ to ‘char’ inside { } [-Wnarrowing]
             char read_uid_c[] = {0x04,0x03,UID_ADDR};
                                            ^~~~~~~~
        ../agejet/rfid_worker.cpp:123:25: warning: ISO C++ says that these are ambiguous, even though the worst conversion for the first is better than the worst conversion for the second:
                     if(answ[0]==0x05){
                                 ^~~~
        In file included from /usr/include/x86_64-linux-gnu/qt5/QtCore/qstring.h:49:0,
                         from /usr/include/x86_64-linux-gnu/qt5/QtCore/qobject.h:47,
                         from /usr/include/x86_64-linux-gnu/qt5/QtCore/QObject:1,
                         from ../agejet/rfid_worker.h:4,
                         from ../agejet/rfid_worker.cpp:1:
        /usr/include/x86_64-linux-gnu/qt5/QtCore/qbytearray.h:534:17: note: candidate 1: bool QByteRef::operator==(char) const
             inline bool operator==(char c) const
                         ^~~~~~~~
        ../agejet/rfid_worker.cpp:123:25: note: candidate 2: operator==(int, int) <built-in>
                     if(answ[0]==0x05){
                                 ^~~~
        ../agejet/rfid_worker.cpp: In member function ‘void rfid_worker::open_session()’:
        ../agejet/rfid_worker.cpp:136:35: error: narrowing conversion of ‘250’ from ‘int’ to ‘char’ inside { } [-Wnarrowing]
             char init_bytes[] = {0xFA,0x12};
                                           ^
        ../agejet/rfid_worker.cpp: In member function ‘QString rfid_worker::rnd()’:
        ../agejet/rfid_worker.cpp:182:10: warning: unused variable ‘o’ [-Wunused-variable]
             bool o;
                  ^
        ../agejet/rfid_worker.cpp: In member function ‘void rfid_worker::tips_charge()’:
        ../agejet/rfid_worker.cpp:234:41: warning: narrowing conversion of ‘(uchar)((rfid_worker*)this)->rfid_worker::TIP_CHARGE_ADDR_OLD’ from ‘uchar {aka unsigned char}’ to ‘char’ inside { } [-Wnarrowing]
             char read_tips_cmd_c[] = {0x0e,0x03,TIP_CHARGE_ADDR_OLD};
                                                 ^~~~~~~~~~~~~~~~~~~
        ../agejet/rfid_worker.cpp: In member function ‘void rfid_worker::hp_charge()’:
        ../agejet/rfid_worker.cpp:259:41: warning: narrowing conversion of ‘(uchar)((rfid_worker*)this)->rfid_worker::HP_CHARGE_ADDR_OLD’ from ‘uchar {aka unsigned char}’ to ‘char’ inside { } [-Wnarrowing]
             char read_tips_cmd_c[] = {0x0e,0x03,HP_CHARGE_ADDR_OLD};
                                                 ^~~~~~~~~~~~~~~~~~
        ../agejet/rfid_worker.cpp: In member function ‘void rfid_worker::create_aes_masked()’:
        ../agejet/rfid_worker.cpp:281:180: error: narrowing conversion of ‘255’ from ‘int’ to ‘char’ inside { } [-Wnarrowing]
             char aes_c[] = {0xFF,0xFF,0xFF,(*card_uid)[0],(*card_uid)[1],(*card_uid)[2],(*card_uid)[3],0xFF,0xFF,0xFF,0xFF,0xFF,(*card_uid)[0],(*card_uid)[1],(*card_uid)[2],(*card_uid)[3]};
                                                                                                                                                                                            ^
        ../agejet/rfid_worker.cpp:281:180: error: narrowing conversion of ‘255’ from ‘int’ to ‘char’ inside { } [-Wnarrowing]
        ../agejet/rfid_worker.cpp:281:180: error: narrowing conversion of ‘255’ from ‘int’ to ‘char’ inside { } [-Wnarrowing]
        ../agejet/rfid_worker.cpp:281:180: error: narrowing conversion of ‘255’ from ‘int’ to ‘char’ inside { } [-Wnarrowing]
        ../agejet/rfid_worker.cpp:281:180: error: narrowing conversion of ‘255’ from ‘int’ to ‘char’ inside { } [-Wnarrowing]
        ../agejet/rfid_worker.cpp:281:180: error: narrowing conversion of ‘255’ from ‘int’ to ‘char’ inside { } [-Wnarrowing]
        ../agejet/rfid_worker.cpp:281:180: error: narrowing conversion of ‘255’ from ‘int’ to ‘char’ inside { } [-Wnarrowing]
        ../agejet/rfid_worker.cpp:281:180: error: narrowing conversion of ‘255’ from ‘int’ to ‘char’ inside { } [-Wnarrowing]
        ../agejet/rfid_worker.cpp: In member function ‘void rfid_worker::delete_old_card()’:
        ../agejet/rfid_worker.cpp:288:36: warning: narrowing conversion of ‘(uchar)((rfid_worker*)this)->rfid_worker::TIP_CHARGE_ADDR_OLD’ from ‘uchar {aka unsigned char}’ to ‘char’ inside { } [-Wnarrowing]
             char delete_cmd[] = {0x10,0x13,TIP_CHARGE_ADDR_OLD,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00};
                                            ^~~~~~~~~~~~~~~~~~~
        ../agejet/rfid_worker.cpp:302:21: warning: ISO C++ says that these are ambiguous, even though the worst conversion for the first is better than the worst conversion for the second:
                 if(answ[2]!=0x00){
                             ^~~~
        In file included from /usr/include/x86_64-linux-gnu/qt5/QtCore/qstring.h:49:0,
                         from /usr/include/x86_64-linux-gnu/qt5/QtCore/qobject.h:47,
                         from /usr/include/x86_64-linux-gnu/qt5/QtCore/QObject:1,
                         from ../agejet/rfid_worker.h:4,
                         from ../agejet/rfid_worker.cpp:1:
        /usr/include/x86_64-linux-gnu/qt5/QtCore/qbytearray.h:536:17: note: candidate 1: bool QByteRef::operator!=(char) const
             inline bool operator!=(char c) const
                         ^~~~~~~~
        ../agejet/rfid_worker.cpp:302:21: note: candidate 2: operator!=(int, int) <built-in>
                 if(answ[2]!=0x00){
                             ^~~~
        ../agejet/rfid_worker.cpp:318:21: warning: ISO C++ says that these are ambiguous, even though the worst conversion for the first is better than the worst conversion for the second:
                 if(answ[2]==0x00){
                             ^~~~
        In file included from /usr/include/x86_64-linux-gnu/qt5/QtCore/qstring.h:49:0,
                         from /usr/include/x86_64-linux-gnu/qt5/QtCore/qobject.h:47,
                         from /usr/include/x86_64-linux-gnu/qt5/QtCore/QObject:1,
                         from ../agejet/rfid_worker.h:4,
                         from ../agejet/rfid_worker.cpp:1:
        /usr/include/x86_64-linux-gnu/qt5/QtCore/qbytearray.h:534:17: note: candidate 1: bool QByteRef::operator==(char) const
             inline bool operator==(char c) const
                         ^~~~~~~~
        ../agejet/rfid_worker.cpp:318:21: note: candidate 2: operator==(int, int) <built-in>
                 if(answ[2]==0x00){
                             ^~~~
        ../agejet/rfid_worker.cpp: In member function ‘void rfid_worker::delete_new_card()’:
        ../agejet/rfid_worker.cpp:337:36: warning: narrowing conversion of ‘(uchar)((rfid_worker*)this)->rfid_worker::MODEL_ADDR’ from ‘uchar {aka unsigned char}’ to ‘char’ inside { } [-Wnarrowing]
             char delete_cmd[] = {0x10,0x13,MODEL_ADDR,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00};
                                            ^~~~~~~~~~
        ../agejet/rfid_worker.cpp:351:21: warning: ISO C++ says that these are ambiguous, even though the worst conversion for the first is better than the worst conversion for the second:
                 if(answ[2]!=0x00){
                             ^~~~
        In file included from /usr/include/x86_64-linux-gnu/qt5/QtCore/qstring.h:49:0,
                         from /usr/include/x86_64-linux-gnu/qt5/QtCore/qobject.h:47,
                         from /usr/include/x86_64-linux-gnu/qt5/QtCore/QObject:1,
                         from ../agejet/rfid_worker.h:4,
                         from ../agejet/rfid_worker.cpp:1:
        /usr/include/x86_64-linux-gnu/qt5/QtCore/qbytearray.h:536:17: note: candidate 1: bool QByteRef::operator!=(char) const
             inline bool operator!=(char c) const
                         ^~~~~~~~
        ../agejet/rfid_worker.cpp:351:21: note: candidate 2: operator!=(int, int) <built-in>
                 if(answ[2]!=0x00){
                             ^~~~
        ../agejet/rfid_worker.cpp: In member function ‘bool rfid_worker::check_tips(QByteArray, uint)’:
        ../agejet/rfid_worker.cpp:384:1: warning: control reaches end of non-void function [-Wreturn-type]
         }
         ^
        Makefile:1179: recipe for target 'rfid_worker.o' failed
        make: *** [rfid_worker.o] Error 1
        12:45:11: The process "/usr/bin/make" exited with code 2.
        Error while building/deploying project agejet (kit: Agejet)
        The kit Agejet has configuration issues which might be the root cause for this problem.
        When executing step "Make"
        12:45:11: Elapsed time: 00:02.
        

        File. - >

        #include "rfid_worker.h"
        #include <iostream>
        #include <fstream>
        #include <QString>
        #include "agejet.h"
        
        using namespace std;
        rfid_worker::rfid_worker(QObject *parent)
        {
            key_hex_clean = &Agejet::key_hex_clean;
            iv_hex = &Agejet::iv_hex;
            card_uid = &Agejet::card_uid;
        
            rs.setPortName(Agejet::rfid_serial_path);
            //rs.setPortName("/dev/ttyUSB1");
            rs.setBaudRate(QSerialPort::Baud9600);
            rs.setDataBits(QSerialPort::Data8);
            rs.setParity(QSerialPort::NoParity);
            rs.setStopBits(QSerialPort::OneStop);
            rs.setFlowControl(QSerialPort::NoFlowControl);
            rs.setDataBits(QSerialPort::Data8);
        }
        
        rfid_worker::~rfid_worker()
        {
        
        }
        
        void rfid_worker::run()
        {
            if(!rs.isOpen()){
                rs.open(QSerialPort::ReadWrite);
            }
            *outer_lock = true;
            if(rfid_function=="find"){
                find();
            }
            else {
                if(rfid_function=="open_session"){
                    open_session();
                }
                else {
                    if(rfid_function=="check_card"){
                        check_card_type();
                    }
                    else {
                        if(rfid_function=="hp_charge"){
                            hp_charge();
                        }
                        else {
                            if(rfid_function=="tip_charge"){
                                tips_charge();
                            }
                            else {
                                if(rfid_function=="tip_charge"){
                                    tips_charge();
                                }
                                else {
                                    if(rfid_function=="delete_old_card"){
                                        delete_old_card();
                                    }
                                    else {
                                        if(rfid_function=="delete_new_card"){
                                            delete_new_card();
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
            *outer_lock = false;
            rs.close();
        }
        
        void rfid_worker::check_card_type()
        {
        
            char read_uid_c[] = {0x0E,0x03,MODEL_ADDR_OLD};
            QByteArray ba_cmd = QByteArray(read_uid_c,4);
            QByteArray answ;
            QByteArray card_type_enc;
        
            rs.write(ba_cmd,3);
            rs.flush();
            rs.waitForBytesWritten(300);
            rs.waitForReadyRead(400);
        
            answ=rs.readAll();
            if(answ.length()==19){
                card_type_enc=answ.mid(3);
                Agejet::old_card_type = true;
            }
            else{
                Agejet::rfid_error=Agejet::CARD_TYPE;
                return;
            }
        
        
            //REIMPLEMNTARE:TOLTO PER HONG KONG
            /*int model_read = 17;
            Agejet::model==17;
            if(!model_read == Agejet::model){
                Agejet::rfid_error=Agejet::CARD_TYPE;
                return;
            }*/
        
        }
        
        void rfid_worker::find()
        {
            char read_uid_c[] = {0x04,0x03,UID_ADDR};
            QByteArray read_uid = QByteArray(read_uid_c);
            QByteArray answ;
            for(int i=0;i<wait_for_card_t;i+=retry_find_card_t){
                rs.write(read_uid,3);
                rs.flush();
                rs.waitForBytesWritten(200);
                rs.waitForReadyRead(300);
                answ=rs.readAll();
                if(answ.length()==7){
                    if(answ[0]==0x05){
                        *card_uid = answ.mid(3);
                        create_aes_masked();
                        Agejet::rfid_error=Agejet::NO_ERROR;
                        return;
                    }
                }
            }
            Agejet::rfid_error=Agejet::NOT_FOUND;
        }
        
        void rfid_worker::open_session()
        {
            char init_bytes[] = {0xFA,0x12};
            QByteArray ba_cmd = QByteArray(init_bytes);
            //QString rndA = rnd();
            QByteArray rndA = "AAAAAAAAAAAAAAAA";
            QByteArray rndA_enc;
            encrypt(rndA,rndA_enc);
            ba_cmd.append(rndA_enc);
        
            rs.write(ba_cmd,18);
            rs.flush();
            rs.waitForBytesWritten(200);
            rs.waitForReadyRead(300);
            QByteArray ba_answ = rs.readAll();
            QByteArray rndA_enc_shift_l = ba_answ.mid(3,16);
            QByteArray rndA_xor_rndB_enc_shift_l_reader = ba_answ.mid(19,16);
            QByteArray rndA_shift;
            decrypt(rndA_enc_shift_l,rndA_shift,*key_hex_clean);
            QByteArray rndA_from_reader;
            rndA_from_reader = rndA_shift.prepend(rndA_shift.at(15));
            rndA_from_reader = rndA_from_reader.mid(0,16);
            QByteArray rndA_xor_rndB_shift_l_reader;
            QByteArray rndB;
            decrypt(rndA_xor_rndB_enc_shift_l_reader,rndA_xor_rndB_shift_l_reader,*key_hex_clean);
            for(int i= 0;i < 16;i++) {
                rndB.append(((uchar)rndA_xor_rndB_shift_l_reader[i])^((uchar)rndA_enc[i]));
            }
            QByteArray rndB_shift;
            rndB_shift=rndB;
            rndB_shift.append(rndB_shift.at(0));
            rndB_shift= rndB_shift.mid(1,16);
        
            QByteArray rndB_shift_enc;
            encrypt(rndB_shift,rndB_shift_enc);
        
            QByteArray ba_cmd2 = init_bytes;
            ba_cmd2.append(rndB_shift_enc);
            rs.write(ba_cmd2,18);
            rs.flush();
            rs.waitForBytesWritten(200);
            rs.waitForReadyRead(300);
            ba_answ = rs.readAll();
        }
        
        QString rfid_worker::rnd()
        {
            int i=0;
            bool o;
            QString rnd_hex= "";
            while (i<2) {
                QString rnd=QString::number(qrand(),16);
                if(rnd.length()==8){
                    rnd_hex+=rnd;
                    i++;
                }
            }
            return rnd_hex;
        }
        
        void rfid_worker::decrypt(QByteArray cry, QByteArray &dec, QString key_hex)
        {
            QString param = "openssl enc -aes128 -d -nopad -nosalt -in %1 -out %2 -iv %3 -K %4 ";
            QString in_file = "/opt/crypt";
            QString out_file = "/opt/decrypt";
            ofstream o_strm (in_file.toLatin1().data(), ios::out | ios::binary);
            o_strm.write (cry.constData(), 16);
            o_strm.close();
            QString cmd = param.arg(in_file,out_file,*iv_hex,key_hex);
            system(cmd.toUtf8().constData());
            ifstream i_strm (out_file.toLatin1().data(), ios::in | ios::binary);
            char buffer[16];
            i_strm.read(buffer,16);
            dec = QByteArray(buffer,16);
            i_strm.close();
        }
        
        void rfid_worker::encrypt(QByteArray dec, QByteArray &enc)
        {
            QString param = "openssl enc -aes128 -nopad -nosalt -in %1 -out %2 -iv %3 -K %4 ";
            QString in_file = "/opt/clean";
            QString out_file = "/opt/crypt";
            ofstream o_strm (in_file.toLatin1().data(), ios::out | ios::binary);
            o_strm.write(dec.constData(), 16);
            o_strm.close();
            QString cmd = param.arg(in_file,out_file,*iv_hex,*key_hex_clean);
            system(cmd.toUtf8().constData());
            QThread::msleep(100);
            ifstream i_strm (out_file.toLatin1().data(), ios::in | ios::binary);
            char buffer[16];
            i_strm.read(buffer,16);
            enc = QByteArray(buffer,16);
            i_strm.close();
        }
        
        void rfid_worker::tips_charge()
        {
            QByteArray answ;
            QByteArray tips_enc;
            QByteArray tips_dec;
            char read_tips_cmd_c[] = {0x0e,0x03,TIP_CHARGE_ADDR_OLD};
            QByteArray read_tips_cmd = QByteArray(read_tips_cmd_c);
            rs.write(read_tips_cmd,3);
            rs.flush();
            rs.waitForBytesWritten(200);
            rs.waitForReadyRead(300);
            answ=rs.readAll();
            if(answ.length()==19){
                tips_enc=answ.mid(3);
            }
            QString aes_hex_QS = QString(aes_masked_key.toHex());
            decrypt(tips_enc,tips_dec,aes_hex_QS);
            if(check_tips(tips_dec,Agejet::DIV)){
                Agejet::rfid_error=Agejet::NO_ERROR;
            }
            else {
                Agejet::rfid_error=Agejet::TIPS_VALUE;
            }
        }
        
        void rfid_worker::hp_charge()
        {
            QByteArray answ;
            QByteArray tips_enc;
            QByteArray tips_dec;
            char read_tips_cmd_c[] = {0x0e,0x03,HP_CHARGE_ADDR_OLD};
            QByteArray read_tips_cmd = QByteArray(read_tips_cmd_c);
            rs.write(read_tips_cmd,3);
            rs.flush();
            rs.waitForBytesWritten(200);
            rs.waitForReadyRead(300);
            answ=rs.readAll();
            if(answ.length()==19){
                tips_enc=answ.mid(3);
            }
            QString aes_hex_QS = QString(aes_masked_key.toHex());
            decrypt(tips_enc,tips_dec,aes_hex_QS);
            if(check_tips(tips_dec,Agejet::DIV)){
                Agejet::rfid_error=Agejet::NO_ERROR;
            }
            else {
                Agejet::rfid_error=Agejet::NOT_VALID;
            }
        }
        
        void rfid_worker::create_aes_masked()
        {
            char aes_c[] = {0xFF,0xFF,0xFF,(*card_uid)[0],(*card_uid)[1],(*card_uid)[2],(*card_uid)[3],0xFF,0xFF,0xFF,0xFF,0xFF,(*card_uid)[0],(*card_uid)[1],(*card_uid)[2],(*card_uid)[3]};
            aes_masked_key = QByteArray(aes_c,16);
        }
        
        void rfid_worker::delete_old_card()
        {
            first_auth=false;
            char delete_cmd[] = {0x10,0x13,TIP_CHARGE_ADDR_OLD,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00};
            QByteArray delete_cmd_q = QByteArray(delete_cmd,19);
            QByteArray payload = QByteArray(delete_cmd_q.mid(3,16));
            QByteArray payload_enc;
            encrypt(payload,payload_enc);
            delete_cmd_q = delete_cmd_q.mid(0,3);
            delete_cmd_q += payload_enc;
            rs.write(delete_cmd_q,19);
            rs.flush();
            rs.waitForBytesWritten(200);
            rs.waitForReadyRead(300);
            QByteArray answ;
            answ=rs.readAll();
            if(answ.length()==3){
                if(answ[2]!=0x00){
                   Agejet::rfid_error=Agejet::SESSION_ERROR;
                   return;
                }
            }
            else {
                Agejet::rfid_error=Agejet::SESSION_ERROR;
                return;
            }
            delete_cmd_q[2] = HP_CHARGE_ADDR_OLD;
            rs.write(delete_cmd_q,19);
            rs.flush();
            rs.waitForBytesWritten(200);
            rs.waitForReadyRead(300);
            answ=rs.readAll();
            if(answ.length()==3){
                if(answ[2]==0x00){
                    Agejet::rfid_error=Agejet::NO_ERROR;
                    return;
                }
                else {
                    cout<<"C"<<endl;
                   Agejet::rfid_error=Agejet::SESSION_ERROR;
                   return;
                }
            }
            else {
                cout<<"D"<<endl;
                Agejet::rfid_error=Agejet::SESSION_ERROR;
                return;
            }
        }
        
        void rfid_worker::delete_new_card()
        {
            char delete_cmd[] = {0x10,0x13,MODEL_ADDR,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00};
            QByteArray delete_cmd_q = QByteArray(delete_cmd,19);
            QByteArray payload = QByteArray(delete_cmd_q.mid(3,16));
            QByteArray payload_enc;
            encrypt(payload,payload_enc);
            delete_cmd_q = delete_cmd_q.mid(0,3);
            delete_cmd_q += payload_enc;
            rs.write(delete_cmd_q,19);
            rs.flush();
            rs.waitForBytesWritten(200);
            rs.waitForReadyRead(300);
            QByteArray answ;
            answ=rs.readAll();
            if(answ.length()==3){
                if(answ[2]!=0x00){
                   Agejet::rfid_error=Agejet::SESSION_ERROR;
                   return;
                }
            }
            else {
                Agejet::rfid_error=Agejet::SESSION_ERROR;
                return;
            }
        }
        
        
        bool rfid_worker::check_tips(QByteArray tips_dec,uint div)
        {
            QByteArray tips_number_a = tips_dec.mid(0,4);
            bool ok;
            uint tips_number = tips_number_a.toHex().toInt(&ok,16);
            if(((tips_number % div)== 0)&&(tips_number!=0)){
                if(Agejet::charge_type.contains("tip")){
                    Agejet::tips_charged_shoots=tips_number;
                    return true;
                }
                else {
                    if(Agejet::charge_type.contains("hp")){
                        Agejet::hp_charged_shoots=tips_number;
                        return true;
                    }
                }
            }
            else {
               Agejet::rfid_error=Agejet::NOT_VALID;
               return false;
            }
        }
        
        QByteArray rfid_worker::aes_masked_key;
        QString *rfid_worker::key_hex_clean = NULL;
        QString *rfid_worker::iv_hex = NULL;
        QByteArray *rfid_worker::card_uid = NULL;
        
        /*
        void rfid_worker::check_card_type()
        {
        
            char read_uid_c[] = {0x0E,0x03,MODEL_ADDR_OLD};
            QByteArray ba_cmd = QByteArray(read_uid_c,4);
            QByteArray answ;
            QByteArray card_type_enc;
            QByteArray card_type_dec;
            rs.write(ba_cmd,3);
            rs.flush();
            rs.waitForBytesWritten(300);
            rs.waitForReadyRead(400);
        
            answ=rs.readAll();
            cout<<answ.toHex().constData()<<endl;
            if(answ.length()==19){
                card_type_enc=answ.mid(3);
                Agejet::old_card_type = true;
                cout<<"VECCHIA"<<endl;
            }
            else{
        
                ba_cmd[2] = MODEL_ADDR;
                rs.write(ba_cmd,3);
                rs.flush();
                rs.waitForBytesWritten(300);
                rs.waitForReadyRead(400);
                answ=rs.readAll();
                cout<<"HEX"<<answ.toHex().constData()<<endl;
                if(answ.length()==19){
                    card_type_enc=answ.mid(3);
                    cout<<"NUOBA"<<endl;
                    Agejet::old_card_type = true;
                }
                else{
                    cout<<"NESSUNA"<<endl;
                    Agejet::rfid_error=Agejet::CARD_TYPE;
                    return;
                }
            }
            QString aes_hex_QS = QString(aes_masked_key.toHex());
            decrypt(card_type_enc,card_type_dec,aes_hex_QS);
            card_type_dec=card_type_dec.mid(0,4);
            bool ok;
            int mod = card_type_dec.at(3);
            if(!Agejet::old_card_type){
                if(Agejet::model==mod){
                    Agejet::rfid_error=Agejet::NO_ERROR;
                    cout<<"mod "<<mod<<endl;
                }
                else{
                    Agejet::rfid_error=Agejet::CARD_TYPE;
                    cout<<"aaaaamod "<<mod<<endl;
                    return;
                }
            }
            else {
                if(mod==0){
                    Agejet::rfid_error=Agejet::NO_ERROR;
                    cout<<"SIIIIIIIIIIIIIIIIIIIIIIIIIIIImod "<<mod<<endl;
                    return;
                }
                else{
                    Agejet::rfid_error=Agejet::CARD_TYPE;
                    cout<<"aaaaamod "<<mod<<endl;
                    return;
                }
            }
            card_type_enc = 0x00;
            if(Agejet::old_card_type)
            ba_cmd[2]= MODEL_ADDR_OLD;
            else
            ba_cmd[2]= MODEL_ADDR;
        
            rs.write(ba_cmd,3);
            rs.flush();
            rs.waitForBytesWritten(300);
            rs.waitForReadyRead(400);
            answ=rs.readAll();
            if(answ.length()==19){
                card_type_enc=answ.mid(3);
            }
            mod = card_type_dec.at(3);
            if(Agejet::model==mod){
                 cout<<"mod = "<<mod<<endl;
                Agejet::rfid_error=Agejet::NO_ERROR;
            }
            else{
                cout<<"mod = "<<mod<<endl;
                Agejet::rfid_error=Agejet::CARD_TYPE;
            }
        */
        
        
        
        1 Reply Last reply
        0
        • VRoninV Offline
          VRoninV Offline
          VRonin
          wrote on last edited by
          #4

          Di nuovo, l'errore e' chiaro: ti sei dimenticato un return dentro a rfid_worker::check_tips.
          se: ((tips_number % div)== 0)&&(tips_number!=0) e vero, Agejet::charge_type.contains("tip") e' falso e Agejet::charge_type.contains("hp") e' falso la tua funzione non sa cosa ritornare

          "La mort n'est rien, mais vivre vaincu et sans gloire, c'est mourir tous les jours"
          ~Napoleon Bonaparte

          On a crusade to banish setIndexWidget() from the holy land of Qt

          1 Reply Last reply
          0

          • Login

          • Login or register to search.
          • First post
            Last post
          0
          • Categories
          • Recent
          • Tags
          • Popular
          • Users
          • Groups
          • Search
          • Get Qt Extensions
          • Unsolved