4. Serial Comm Handle Problem

Serial Comm Handle Problem

  • B

    Hallo Leute,

    I wrote a code to do serial communication with an equipament.
    When i use the code outside of threaded class it seens work properly,
    but when i put inside a class and execute a thread in the first seconds the
    communication is ok, later i receive read/write error.
    I´ve been in MSDN site and there i discover that the read/write error is a
    INVALID_HANDLE problem. But why??? I just create the serial communication
    file and use it.
    Anyone can help me?

    Here is the code

    /* cut /
    /    --------------------------------------------------------------------*/
    /* Main Class */

    #ifndef _IGERENCIADOREQUIPAMENTO_H
    #define _IGERENCIADOREQUIPAMENTO_H

    #include <stdio.h>
    #include <windows.h>

    #define SERIAL_PARITY_NONE 0
    #define SERIAL_PARITY_ODD 1
    #define SERIAL_PARITY_EVEN 2

    #define SERIAL_MAX_RX 256 // Input buffer max size
    #define SERIAL_MAX_TX 256 // output buffer max size

    #define SERIAL_CONNECTED 0
    #define SERIAL_DISCONNECTED 1
    #define SERIAL_DATA_SENT 2
    #define SERIAL_DATA_ARRIVAL 3
    #define SERIAL_RING 4
    #define SERIAL_CD_ON 5
    #define SERIAL_CD_OFF 6
    #define SERIAL_DATA_RECV 7

    #define SERIAL_SIGNAL_NBR 7

    class IGerenciadorEquipamento;

    typedef struct
    {
    HANDLE serialFD;
    IGerenciadorEquipamento* pIGE;
    }_SERIALCOM_IONICS;

    class IGerenciadorEquipamento: public IThread
    {

    private:
    HANDLE hSerial;
    char *cPortaSerial;
    DWORD dwBaudRate;
    BYTE byByteSize;
    BYTE byTipoParidade;
    bool conectado;
    bool bRX_In_Progress; // BOOL indicating if a
    ReadFile is
    // in progress
    bool bTX_In_Progress; // BOOL indicating if a
    WriteFile is
    // in progress

    unsigned char pacoteIN[256];
    unsigned char pacoteOUT[256];

    bool bConectado;

    int ConfigTimeouts(COMMTIMEOUTS mCommtimeout);
    int ConfigDCB(DCB mDCB);

    public:
    IGerenciadorEquipamento(char *mcPortaSerial, DWORD mdwBaudRate,
    BYTE mbyByteSize, BYTE mbyiTipoParidade);
    ~IGerenciadorEquipamento();

    int AtivaEquipamento(BOOL mbIniciaThread = true);
    int DesativaEquipamento(BOOL mbFinalizaThread = true);
    int EscreveMensagem(HANDLE hSerialCOM,unsigned char* mcMensagem, int
    miTamanho);
    int LeMensagem(HANDLE hSerialCOM,unsigned char* mcMensagem, int
    miTamanho);
    void PurgeSerial(void);
    bool VerificaEstado(void);
    int Run(void);
    HANDLE GetSerialHND(void);
    void OnSendRecv(void);
    unsigned char *GetDadosRecebidos(void);
    unsigned char *GetDadosEnviados(void);

    int EnviaPOLLING(HANDLE hSerialCOM);
    int ConcedePrivilegio(HANDLE hSerialCOM, BYTE byEndereco);
    void TraduzMens(unsigned char *ucPacote, DWORD miTamanho);
    DWORD IGerenciadorEquipamento::ExtraiCMD(unsigned char ucPacoteIN,
    DWORD dStartpos,
    DWORD dQtdebytes,
    unsigned char     ucPacoteOUT);

    };

    //DWORD WINAPI ComSendRecv(LPVOID p);
    int ComSendRecv(LPVOID p);

    #endif

    /--------------------------------------------------------------------/
    /* until here */

    /* cut /
    /    --------------------------------------------------------------------*/
    /* Main Class Code */

    //#define STRICT
    #include <cstdlib>
    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    #include <process.h>
    #include <conio.h>
    #include <windows.h>
    #include <iostream>
    #include <math.h>
    #include "IGerenciadorEquipamento.hpp"
    #include "StringMethods.hpp"
    #include "Consts.hpp"
    #include "TipoProtocolo.hpp"

    #define SIG_POWER_DOWN 0
    #define SIG_READER 1
    #define SIG_READ_DONE 2 // data received has been read
    #define SIG_WRITER 3
    #define SIG_DATA_TO_TX 4 // data waiting to be sent
    #define SIG_MODEM_EVENTS 5
    #define SIG_MODEM_CHECKED 6

    using namespace std;

    typedef struct
    {
    BYTE controladora;
    BYTE tentativas;
    bool detectaprot;
    }STRU_CONFCONTROL;

    STRU_CONFCONTROL ConfControl;

    unsigned char *IGerenciadorEquipamento::GetDadosRecebidos(void)
    {
    return pacoteOUT;
    }

    unsigned char *IGerenciadorEquipamento::GetDadosEnviados(void)
    {
    return pacoteIN;
    }

    int IGerenciadorEquipamento::EnviaPOLLING(HANDLE hSerialCOM)
    {
    unsigned char ucPacoteIN[256];
    unsigned char ucPacoteOUT[256];
    int iTotalLido;

    ZeroMemory(ucPacoteIN,3);

    ucPacoteIN[0] = SYN;
    ucPacoteIN[1] = '1';
    ucPacoteIN[2] = 0x55;

    EscreveMensagem(hSerialCOM ,ucPacoteIN,3);
    iTotalLido=LeMensagem(hSerialCOM ,ucPacoteOUT,30);
    if (iTotalLido)
    {
    if ((ucPacoteOUT[0] == SYN) && (ucPacoteOUT[1] == '1') &&
    (ucPacoteOUT[2] == 0xAA))
    ConfControl.detectaprot = false;
    }
    return iTotalLido;
    }

    int IGerenciadorEquipamento::ConcedePrivilegio(HANDLE hSerialCOM, BYTE
    byEndereco)
    {
    unsigned char ucPacoteIN[256];
    int iTotalEscrito;

    ZeroMemory(ucPacoteIN,3);

    // privilegio
    ucPacoteIN[0] = SYN;
    ucPacoteIN[1] = byEndereco+48;
    ucPacoteIN[2] = ACK;

    iTotalEscrito=EscreveMensagem(hSerialCOM ,ucPacoteIN,3);
    return iTotalEscrito;
    }

    void IGerenciadorEquipamento::TraduzMens(unsigned char *ucPacote, DWORD
    miTamanho)
    {
    int iCanal;
    double dLitros;
    char cPulsos[8];
    double dPulsos;
    char parcelaPacote;
    char cInd;
    int iInd;
    int k;

    dLitros = 0;

    iCanal = ((((BYTE)ucPacote[1])-49)*8);
    iInd = ucPacote[3] & 0x0F;

    switch(iInd)
    {
    case 0:
    iCanal += ((((BYTE)ucPacote[4])-47)+100);
    printf("Bomba %i ligada\n",iCanal-100);
    break;
    case 1:
    iCanal += ((((BYTE)ucPacote[4])-47)+100);
    printf("Bomba %i desligada\n",iCanal-100);

    dPulsos = 0;
    k=0;
    ZeroMemory(cPulsos,8);
    for (int i=5;i<13;i++)
    {
    cPulsos[k] = ucPacote[i];
    k++;
    }
    dPulsos = atof(cPulsos);

    dLitros = round(dPulsos/1*100)/100;

    if ((iCanal > 100) && (iCanal < 133))
    {
    printf("Bomba %i abasteceu %4.2f litros \n",iCanal-100, dLitros);
    }
    else
    printf("Bomba %i abasteceu %4.2f litros \n",iCanal-100, 0.00);

    break;
    case 7:
    printf("APM Reenergizado\n");
    break;
    }

    }

    DWORD IGerenciadorEquipamento::ExtraiCMD(unsigned char ucPacoteIN,
    DWORD dStartpos,
    DWORD dQtdebytes,
    unsigned char     ucPacoteOUT)
    {
    int i;
    DWORD dPosETX = 0;
    DWORD dPosSTX = 0;
    DWORD dPosDC2 = 0;
    bool bOneMoreSYN;
    bool bMensTexto;
    bool bContinuar = true;
    DWORD dBytesToSYN;
    int iTotalBytes;

    iTotalBytes = 0;
    dBytesToSYN = 0;
    bMensTexto = false;
    bOneMoreSYN = true;
    dPosETX = 0;
    dPosSTX = 0;
    dPosDC2 = 0;

    for(i=dQtdebytes-1;(i>=0);i--)
    {

    if (bOneMoreSYN)
    dBytesToSYN++;

    switch(ucPacoteIN[i])
    {
    case SYN:
    if ((dPosETX) && (dPosSTX) && ((dPosSTX-i) == 2) && (dQtdebytes
    > dPosETX))
    {
    bMensTexto = true;
    bContinuar = false;
    break;
    }
    else
    {
    if ((dPosDC2) && (dPosDC2-i) == 2)
    {
    if ((!bOneMoreSYN) && (dBytesToSYN > 0))
    {
    return iTotalBytes;
    }
    else
    {
    bContinuar = false;
    break;
    }
    }
    else
    {
    if (!bOneMoreSYN) { return 0; }
    bOneMoreSYN = false;
    dPosDC2 = 0;
    dPosETX = 0;
    dPosSTX = 0;
    }

    }
    break;

    case DC2: dPosDC2 = i; break;
    case STX: dPosSTX = i; break;
    case ETX: dPosETX = i; break;
    }
    if (!bContinuar) break;

    }

    if ((i != 0xFFFF) && (ucPacoteIN[i] == SYN))
    {
    if (bMensTexto)
    dPosETX++;
    else
    dPosETX = dPosDC2;

    for(int j=i;j<=dPosETX;j++)
    {
    ucPacoteOUT[iTotalBytes] = ucPacoteIN[j];
    iTotalBytes++;
    }
    }
    return iTotalBytes;
    }

    IGerenciadorEquipamento::IGerenciadorEquipamento(char *mcPortaSerial,
    DWORD mdwBaudRate,
    BYTE mbyByteSize,
    BYTE mbyTipoParidade)
    {
    cPortaSerial = mcPortaSerial;
    dwBaudRate = mdwBaudRate;
    mbyTipoParidade = mbyTipoParidade;
    mbyByteSize = mbyByteSize;
    hSerial = INVALID_HANDLE_VALUE;
    conectado = false;
    bRX_In_Progress = false;
    bTX_In_Progress = false;
    ConfControl.detectaprot = true;
    ConfControl.tentativas = 0;
    ConfControl.controladora = 0;

    }

    IGerenciadorEquipamento::~IGerenciadorEquipamento()
    {
    conectado = false;
    cPortaSerial = "";
    dwBaudRate = 0;
    byTipoParidade = SERIAL_PARITY_NONE;
    byByteSize = 0;

    if (GetThreadHND()!=0)
    WaitForSingleObject(GetThreadHND(), 2000);

    bRX_In_Progress = false;
    bTX_In_Progress = false;

    if (hSerial != INVALID_HANDLE_VALUE)
    CloseHandle(hSerial);
    hSerial = INVALID_HANDLE_VALUE;
    }

    int IGerenciadorEquipamento::ConfigTimeouts(COMMTIMEOUTS mCommtimeout)
    {

    // configura os timeouts da Porta Serial
    mCommtimeout.ReadIntervalTimeout = 20;
    mCommtimeout.ReadTotalTimeoutMultiplier = 1;
    mCommtimeout.ReadTotalTimeoutConstant = 20;
    mCommtimeout.WriteTotalTimeoutMultiplier = 5;
    mCommtimeout.WriteTotalTimeoutConstant = 5;

    return SetCommTimeouts(hSerial,&mCommtimeout);
    }

    int IGerenciadorEquipamento::ConfigDCB(DCB mDCB)
    {
    // recupera as informações do DCB
    if (!GetCommState(hSerial,&mDCB))
    {
    CloseHandle(hSerial);
    return ERROR_INVALID_HANDLE;
    }

    // set DCB to configure the serial port
    mDCB.DCBlength = sizeof(mDCB);

    /* ---------- Serial Port Config ------- */
    mDCB.BaudRate = dwBaudRate;

    switch(byTipoParidade)
    {
    case SERIAL_PARITY_NONE:
    mDCB.Parity = NOPARITY;
    mDCB.fParity = 0;
    break;
    case SERIAL_PARITY_EVEN:
    mDCB.Parity = EVENPARITY;
    mDCB.fParity = 1;
    break;
    case SERIAL_PARITY_ODD:
    mDCB.Parity = ODDPARITY;
    mDCB.fParity = 1;
    break;
    }

    mDCB.StopBits = ONESTOPBIT;
    mDCB.ByteSize = 8;
    mDCB.fBinary = 0;
    mDCB.fAbortOnError = 0;
    mDCB.wReserved = 0;
    mDCB.XonLim = 100;
    mDCB.XoffLim = 100;
    mDCB.XonChar = 0x0D;
    mDCB.XoffChar = 0x0A;
    mDCB.ErrorChar = 0;
    mDCB.EofChar = 0;
    mDCB.EvtChar = 0;
    mDCB.wReserved1 = 0;

    return SetCommState(hSerial,&mDCB);

    }

    int IGerenciadorEquipamento::AtivaEquipamento(BOOL mbIniciaThread)
    {
    int iErro;
    DCB dcb;
    int i;

    COMMTIMEOUTS cto;

    if (hSerial != INVALID_HANDLE_VALUE)
    CloseHandle(hSerial);
    hSerial = INVALID_HANDLE_VALUE;

    if (cPortaSerial != "")
    {
    iErro = 0;

    hSerial = CreateFile(cPortaSerial, // filename
    GENERIC_READ | GENERIC_WRITE, // acesso
    desejado
    0, // modo de
    compartilhamento
    NULL, // atributos
    de segurança
    OPEN_EXISTING, // disposição
    da criação do arquivo
    FILE_FLAG_NO_BUFFERING,
    // flag de criação
    NULL); // indica se
    pode ou não copiar os
    // atributos do
    arquivo atual para outro
    // arquivo
    if (hSerial != INVALID_HANDLE_VALUE)
    {
    bConectado = true;

    // aplica os timeous
    if (!ConfigTimeouts(cto))
    iErro = 2;

    // aplica o DCB
    if (!ConfigDCB(dcb))
    iErro = 4;

    }
    }
    else
    iErro = -2;

    /* --------------------------------------------- */
    if (iErro > 0)
    {
    CloseHandle(hSerial);
    hSerial = INVALID_HANDLE_VALUE;
    }
    else
    {

    HANDLE hThread1;
    DWORD dThreadID1;
    if(mbIniciaThread)
    {
    printf("Connected ! \n");

    hThread1 = CreateThread(NULL, // default
    security attributes
    0, // use default
    stack size
    (DWORD (_stdcall *)(void ))ComSendRecv,
    // thread function
    (void    )this, // argument to thread
    function
    0, // use default
    creation flags
    &dThreadID1); // returns the
    thread identifier

    */

    }
    }

    /* --------------------------------------------- */
    return iErro;

    }

    int IGerenciadorEquipamento::DesativaEquipamento(BOOL mbFinalizaThread)
    {
    conectado = false;

    if(mbFinalizaThread)
    {

    }
    if (hSerial != INVALID_HANDLE_VALUE)
    CloseHandle(hSerial);
    hSerial = INVALID_HANDLE_VALUE;

    if (this->GetThreadHND())
    {
    if (WaitForSingleObject (this->GetThreadHND(), 2000) == WAIT_TIMEOUT)
    {
    TerminateThread (this->GetThreadHND(), 1);
    CloseHandle (this->GetThreadHND());
    }
    else CloseHandle (this->GetThreadHND());
    }
    CloseHandle(this->GetThreadHND());

    printf("Disconnected ! \n");

    }

    int IGerenciadorEquipamento::EscreveMensagem(HANDLE hSerialCOM,unsigned
    char* mcMensagem, int miTamanho)

    {
    char cTXBuffer[SERIAL_MAX_RX];
    DWORD iQtdebytesEscritos;
    int iTamanhoBuffer = 0;
    int iSuccess = 0;
    int Error = 0;
    HANDLE hCom;

    if (!bTX_In_Progress)
    {
    PurgeComm(hSerialCOM,PURGE_TXCLEAR | PURGE_RXCLEAR);
    //hCom = hSerialCOM;

    iSuccess = WriteFile(hSerialCOM,
    mcMensagem,
    miTamanho,
    &iQtdebytesEscritos,
    NULL);

    if (!iSuccess)
    {
    // failure
    if((Error = GetLastError()) != ERROR_IO_PENDING )
    printf("erro: %i , qtde: %i => WriteFile error (not pending)\
    n", Error,iQtdebytesEscritos & 0xFFFF);
    }

    bTX_In_Progress = false;

    }

    return iQtdebytesEscritos;
    }

    int IGerenciadorEquipamento::LeMensagem(HANDLE hSerialCOM,unsigned char*
    mcMensagem, int miTamanho)
    {
    DWORD iQtdebytesLidos;
    DWORD iLenMensagem = 0;
    int iSuccess = 0;
    int Error = 0;
    HANDLE hCom;

    ZeroMemory(mcMensagem,SERIAL_MAX_RX);

    if (!bRX_In_Progress)
    {
    // locking reading
    bRX_In_Progress = true;
    //hCom = hSerialCOM;

    // starting a new read
    iSuccess = ReadFile(hSerialCOM, // handle do arquivo
    mcMensagem, // buffer de leitura
    miTamanho, // número de bytes a serem lidos
    &iQtdebytesLidos, // número de bytes realmente
    lidos
    NULL); // usado para leitura
    concorrente
    // da serial

    if (!iSuccess)
    {
    // failure
    if((Error = GetLastError()) != ERROR_IO_PENDING)
    {
    printf("erro: %i , qtde: %i => Readfile error (not pending)\
    n", Error,iQtdebytesLidos & 0xFFFF);
    }
    }
    bRX_In_Progress = false;
    }

    return iQtdebytesLidos;
    }

    void IGerenciadorEquipamento::PurgeSerial(void)
    {
    PurgeComm(hSerial,PURGE_TXCLEAR | PURGE_RXCLEAR);
    }

    bool IGerenciadorEquipamento::VerificaEstado(void)
    {
    // return (bRX_In_Progress || bTX_In_Progress);
    }

    int ComSendRecv(LPVOID p)
    {
    IGerenciadorEquipamento* pIGE;

    pIGE = (IGerenciadorEquipamento*)p;

    if (pIGE !=0)
    return pIGE->Run();

    }

    BYTE CalculaCRC(unsigned char *msg, int qtdeBytes)
    {
    BYTE valor_crc = 0;

    for (int i=0; i<=qtdeBytes-1;i++)
    {
    valor_crc += msg[i];
    }
    return valor_crc;
    }

    int IGerenciadorEquipamento::Run(void)
    {
    bool bDone;
    unsigned char ucPacoteIN[256];
    unsigned char ucPacoteOUT[256];
    unsigned char ucPacoteCMD[256];
    int iRetry;
    BYTE byPacoteCRC, byPacoteCalcCRC;
    // char *lista[3];

    int iTotalLido = 0;
    int iTamPacoteCMD = 0;

    bDone = false;
    bRX_In_Progress = false;
    bTX_In_Progress = false;

    GetLastError(); // just to clear any pending error

    HANDLE hComm = hSerial;

    char cmd[5];

    while(!bDone)
    {

    Sleep(1000);

    if (ConfControl.detectaprot)
    EnviaPOLLING(hSerial);

    if (ConfControl.controladora)
    {
    iTotalLido = LeMensagem(hSerial ,pacoteOUT,30);
    if (iTotalLido)
    {
    ConcedePrivilegio(hSerial,ConfControl.controladora);
    ConfControl.tentativas = 5;
    }
    ConfControl.tentativas--;
    if (ConfControl.tentativas <= 0)
    {
    ConfControl.tentativas = 0;
    ConfControl.controladora = 0;
    }
    }

    ConcedePrivilegio(hSerial,0);

    iRetry = 1;

    while (iRetry >0)
    {

    iRetry--;

    iTotalLido = LeMensagem(hSerial,ucPacoteOUT,30);
    if (iTotalLido)
    {
    ZeroMemory(ucPacoteCMD,SERIAL_MAX_RX);

    iTamPacoteCMD = ExtraiCMD
    (ucPacoteOUT,1,iTotalLido,ucPacoteCMD);
    if (iTamPacoteCMD > 0)
    {

    ZeroMemory(ucPacoteIN,SERIAL_MAX_RX);

    switch(ucPacoteCMD[2])
    {
    case DC2:
    if (isdigit(ucPacoteCMD[1]))
    {
    iRetry = 1;
    ConcedePrivilegio(hSerial,((BYTE)ucPacoteCMD[1]
    -48));
    }
    break;

    case STX:
    byPacoteCalcCRC = CalculaCRC
    (ucPacoteCMD,iTamPacoteCMD-1);
    byPacoteCRC = (BYTE)ucPacoteCMD[iTamPacoteCMD-1];
    if (byPacoteCRC == byPacoteCalcCRC)
    {
    iRetry = 0;
    if (isdigit(ucPacoteCMD[1]))
    {

    ConfControl.controladora = (BYTE)(
    (ucPacoteCMD[1])- 48);
    ConfControl.tentativas = 5;
    ConcedePrivilegio(hSerial,((BYTE)ucPacoteCMD
    [1]-48));
    PurgeComm(hSerial, PURGE_RXCLEAR);
    }
    TraduzMens(ucPacoteCMD,iTamPacoteCMD);

    /* teste do comando pede abastecimento
    if (gets(cmd) != NULL)
    {
    y = dividePorCaractere(cmd," ",lista);

    if (y > 1)
    {
    if (strcmp(lista[0],"abast") == 0)
    {
    PedeAbastecimentoManual(atoi(lista[1])
    +100);
    }
    }
    if (strcmp(cmd,"quit") == 0)
    {
    break;
    }
    }
    */
    }
    break;
    }
    }
    }

    }

    }
    DesativaEquipamento(true);
    }

    /--------------------------------------------------------------------/
    /* until here */

    /* cut /
    /    --------------------------------------------------------------------*/
    /* Main Exec Code */

    /***********************************************************************
    main.cpp - The main() routine for all the "Basic Winsock" suite of
    programs from the Winsock Programmer's FAQ. This function parses
    the command line, starts up Winsock, and calls an external function
    called DoWinsock to do the actual work.

    This program is hereby released into the public domain. There is
    ABSOLUTELY NO WARRANTY WHATSOEVER for this product. Caveat hacker.
    ***********************************************************************/

    #include "IThreadConnect.hpp"
    #include "IGerenciadorEquipamento.hpp"
    #include <windows.h>
    #include <vector>
    #include <algorithm>

    using namespace std;

    BOOL CtrlHandler(DWORD fdwCtrlType)
    {
    switch( fdwCtrlType )
    {
    // Handle the CTRL+C signal.
    case CTRL_C_EVENT:
    //printf( "Ctrl-C event\n\n" );
    Beep( 750, 300 );
    return( TRUE );

    // CTRL+CLOSE: confirm that the user wants to exit.
    case CTRL_CLOSE_EVENT:
    Beep( 600, 200 );
    //printf( "Ctrl-Close event\n\n" );
    return( TRUE );

    // Pass other signals to the next handler.
    case CTRL_BREAK_EVENT:
    Beep( 900, 200 );
    //printf( "Ctrl-Break event\n\n" );
    return FALSE;

    case CTRL_LOGOFF_EVENT:
    Beep( 1000, 200 );
    //printf( "Ctrl-Logoff event\n\n" );
    return FALSE;

    case CTRL_SHUTDOWN_EVENT:
    Beep( 750, 500 );
    //printf( "Ctrl-Shutdown event\n\n" );
    return FALSE;

    default:
    return FALSE;
    }
    system("PAUSE");
    }

    //// main //////////////////////////////////////////////////////////////
    int main(int argc, char* argv[])
    {
    IThreadConnect threadConnect(0);
    IGerenciadorEquipamento gerente1("COM1", 9600, 8, SERIAL_PARITY_NONE);
    // IGerenciadorEquipamento gerente2("COM3", 9600, 8, SERIAL_PARITY_NONE);
    // IGerenciadorEquipamento gerente3("COM3", 9600, 8, SERIAL_PARITY_NONE);

    vector<IGerenciadorEquipamento> vEquipamento;

    if( SetConsoleCtrlHandler((PHANDLER_ROUTINE) CtrlHandler, TRUE))
    {

    gerente1.AtivaEquipamento();
    printf("1 - Connected ! \n");

    }
    else
    printf( "\nERROR: Could not set control handler");
    //system("PAUSE");

    // exit(1);
    }

    /--------------------------------------------------------------------/
    /* until here */

    villen Dank,
    Berti

    0
Anmelden zum Antworten