Newsgroup: it.comp.lang.c
Titolo: Re: [TU] (si richiede intervento di programmatori in c) Buttha

 iUDPResult = GET_RF_UNQ(&sCodiceRF, sUDP);
Teroicamente *sCodiceRF sarebbe la "stringa" e &CodiceRF referenzia il primo
carattere della stringa o giu' di li e sCodiceRF senza niente è l'indirizzo
del primo elemento della stringa, che casino....
/

 del primo elemento della stringa, che casino....
se si ha una definizione del tipo
char* sCodiceRF = "pippo";
- sCodiceRF e' la variabile di tipo char* che contiene l'indirizzo
  della prima delle locazioni di memoria contigue contenenti la
  sequenza di caratteri 'p''i''p''p''o''\0';
- *sCodiceRF e' il primo carattere delle stringa (ovvero 'p');
- &sCodiceRF e' l'indirizzo della variabile sCodiceRF.
HTH
C:\>iao Angelo
-- 
Posted via Mailgate.ORG Server - 
http://www.Mailgate.ORG

 ha scritto nel messaggio
news:2c55419b4f471715a33...@mygate.mailgate.org...

Quindi in una funzione che deve restituire una stringa come vanno passati i
parametri?
/

 parametri?
????? La domanda per me non ha molto senso.
Tra input e output di una funzione puo' benissimo non esserci nessuna
correlazione: una funzione puo' restituire una stringa anche senza
prendere nessun parametro.
Dimmi cosa deve fare la funzione sulla stringa che deve restituire..
C:\>iao Angelo
P.S. Le altre risposte verranno date solo si iclc.


 P.S. Le altre risposte verranno date solo si iclc.
Ascolta il problema è questo:
Ho delle funzioni su un modulo c che mi gestiscono la radiofrequenza in DOS
di un palmare...
Richiamo queste funzioni da un applicazione principale nel modulo principale
nel seguente modo:
---------------------------------
char *sCodiceRF = "          \0";
.....
.....
.....
strcpy(sCodiceRF,  "          \0");
iUDPResult = GET_RF_UNQ(sCodiceRF, sUDP);
---------------------------------
nel modulo di radiofrequnza ho:
---------------------------------
int GET_RF_UNQ(char *sRispostaRF, int socketn)
{
  ambaradan per prendere il codice dal server...
 strcpy(sRispostaRF, "          \0");
 strncpy(sRispostaRF, sRispostaUDP, 10);
 return 0;
}
--------------------------------
Non sempre avviene che richiamando la funzione in zone diverse
dell'applicativo non sempre la stringa mi viene restituita correttamente
altre volte mi succede addirittura che se passo invece un valore in "sola
lettura" sempre allo stesso modo nella stringa che passo in sola lettura non
c'è scritto quello che ci dovrebbe essere scritto.
Premetto che davvero sono un novizio e sto programmando con VC++ 1.5 e per
fare un "debug" devo perdere 15-20 minuti ogni volta per mandare il
programma sul palmare e l'unico debug possibile è la printf dei valori...
Vi prego ho fatto un progettone mi sto perdendo d'animo per qualche stringa
che non va... help me
/

 --------------------------------
Anche se l'operazione di copia su una stringa costante e' un errore
dal punto di vista della corretta programmazione in "C", non sono
sicuro che sia questo l'errore che ti incasina le stringhe.
Prova ad usare un array, vedi cosa fa il codice e fammi sapere: di
piu', con quello che mi hai postato, non posso dirti.
C:\>iao Angelo


 piu', con quello che mi hai postato, non posso dirti.
Grazie dei consigli, allora io sono un incapace totale con il C, anche se ho
tirato su un bell' applicativo per palmare facendo queste magagnacce
assurde, i problemi sono nati quando ho cominciato a inserire il modulo per
i socket basandomi anche su esempi della symbol fatti con i piedi assai....
Sicuramente l'uso che faccio con le stringhe è errato e ti chiedo se puoi
"riscrivermi" la funzione di sopra nella maniera + corretta in modo che
cambiero' al volo tutto il resto, oppure magari di consigliarmi qualche buon
corso base di c online o al massimo il solito libro.
Un vostro aiuto mi salverà da un ritardo di consegna...
Sono ben accette anche critiche e suggerimenti per il resto del codice...
Oltre al dubbio di sopra ora ho questi due problemi assurdi vi prego help
help...
<1 problema stringa bianca> Cerca nel testo: [ERRORE QUI]
Questa funzione ha sempre funzionato bene anche in RF, ha cominciato a
sbarellare quando ho inserito la gestione del Codice RF.
void menu_1002(char* barcode1, char* barcode2, char* sArtCod, char* sBanUnc,
long lQTARic) //- menu' 1.2 dell'entrata
   {
     int inputOK = FALSE;
     int okInc = FALSE;
     char sNumInc[6];
  char sArtCod2[9] = "        \0";
  char sMapPos[13] = "            \0";
  char sElab;
  char barcode3[13] = "            \0";
  char sBuffRigo[146];
  int iRigoBuff = 0;
  char sQtaBuff[7];
  long iQtaFile;
  char sQtaBar2[5] = "    \0";
     int bar3OK = FALSE;
     char sNDT[16] = "               \0";
     giCurrMenu = 1002;
     strcpy(gsCurrMenu, "1002\0");
  inputOK = FALSE;
        while (inputOK == FALSE)
        {
      itr_cls();
      itr_hidecur();
      itr_setcur(1, 1);
      //------123456789012345678901
      printf("+------------------+\n"); //-01
      printf("| #    # < > [   ] |\n"); //-02
         printf("+------------------+\n"); //-03
         printf("|INC.ENTRATA[     ]|\n"); //-04
         printf("| LETTURA:         |\n"); //-05
         printf("|                  |\n"); //-06
         printf("| PROD:            |\n"); //-07
         printf("|    CODICE SSC    |\n"); //-08
         printf("[                  ]\n"); //-09
         printf("|                  |\n"); //-10
         printf("|                  |\n"); //-11
         printf("|                  |\n"); //-12
         printf("|                  |\n"); //-13
         printf("|                  |\n"); //-14
         printf("+------------------+\n"); //-15
         itr_setcur(2, 4);
   printf(gsCurrMenu);
   itr_setcur(2, 11);
   printf("%c", itr_batteria());
         itr_setcur(2, 15);
   printf(gOPE);
         itr_setcur(4, 14);
   printf(gNLEO);
         itr_setcur(5, 12);
   printf("%d DI %d", gBanCurr, gBanTot);
   itr_setcur(7, 9);
   printf(sArtCod);
   itr_setcur(9, 2);
   printf(sBanUnc);
   iRigoBuff = 0;
   //- cerco nel file il primo rigo con prodotto = e flag elaborato = N
         strcpy(sMapPos, "MA          \0");
         if (bRadio == 0) {
            // per il batch scorro il file
          strncpy(&out_batch[5] ,gNLEO, 5);
           if ((obFile = fopen(out_batch, fRO)) == NULL)
           {
            itr_setcur(12, 2);
            printf("file non trovato");
            itr_hidecur();
            kpressed = get_key();
            menu_0002();
            return; //- esco da questa funzione
           }
           else
           {
            SvuotaBuf();
     //-- ciclo le righe per trovare il n. radio
     while (fgets(fileBuf, obLLen+2, obFile) != NULL)
     {
      iRigoBuff++;
      //- scarto quelli con numero radio diverso
      strcpy(sNumInc, "     \0");
      strncpy(sNumInc,&fileBuf[20], 5);
      strcat(sNumInc, "\0");
      if (strncmp(sNumInc, gNLEO,5) != 0) {
        SvuotaBuf();
        continue;
      }
         //- scarto quelli con prodotto diverso
      strcpy(sArtCod2, "        \0");
      strncpy(sArtCod2,&fileBuf[80],8);
      strcat(sArtCod2, "\0");
      if (strncmp(sArtCod2, sArtCod,8) != 0) {
       SvuotaBuf();
       continue;
      }
      //- scarto quelli con qta non compatibile
      strcpy(sQtaBuff, "      \0");
      strncpy(sQtaBuff, &fileBuf[62], 6);
      iQtaFile = strtol(sQtaBuff, &stopstring, 10);
      if (lQTARic != iQtaFile) {
       SvuotaBuf();
       continue;
      }
      //- scarto quelli già elaborati
       sElab=fileBuf[obLLen-1];
      if (sElab == 'S') {
       SvuotaBuf();
       continue;
      }
      //- determino la stiva
      strncpy(sMapPos,&fileBuf[68],12);
      strcat(sMapPos, "\0");
      //-- salvo il buffer del rigo in elaborazione
      strcpy(sBuffRigo,fileBuf);
      break; //- esco dalla while
     }
            fclose(obFile);
          }
   }
   if (bRadio == 1) {
       // per la radio interrogo il sistema
        itr_setcur(11,1);
    printf("|richiesta udp...  |\n"); //-11
       // richiedo codice rf
       strcpy(sCodiceRF , "          \0");
       iUDPResult = RF_GET_UNQ(sUDP, sCodiceRF);
    if (iUDPResult != 0)
    {
           itr_setcur(11,1);
           printf("| ERRORE RICH. UDP |\n"); //-11
           printf("| RIC. CODICE RF   |\n"); //-12
           err_mov();
           return;
    }
    SvuotaBuf();
    strcpy(sQtaBar2,"    \0");
    strncpy(sQtaBar2, &barcode2[18],4);
    iUDPResult = RF_ENT_GETPOS(sCodiceRF, gNLEO, sArtCod, sQtaBar2, sUDP,
obLLen, fileBuf);
    if (iUDPResult < 0 && iUDPResult != - 20) {
           itr_setcur(11,1);
           printf("| ERRORE RICH. UDP |\n"); //-11
           printf("| PROTOCOLLO ERR   |\n"); //-12
           err_mov();
           //- libero codiceRF
           iUDPResult = RF_OB_CANCEL(sCodiceRF, sUDP);
           return;
       }
       else
       {
     strncpy(sMapPos,&fileBuf[68],12);
     strcat(sMapPos, "\0");
        okInc = TRUE;
    }
   }
   BARCODE_STIVA1100:
   inputOK = FALSE;
         while (inputOK == FALSE)
         {
    if (strncmp(sMapPos, "MA",2) == 0) {
     //- bancale non trovato nel file portare
        itr_setcur(11,1);
           printf("| BANCALE INATTESO |\n"); //-11
           printf("| SCARICO MANUALE  |\n"); //-12
           printf("|  (digitare ma)   |\n"); //-13
           printf("|  [            ]  |\n"); //-14
            err_mov();
            err_mov();
    }
    else
    {
     itr_setcur(11,1);
           printf("| PORTARE IN STIVA |\n"); //-11
           printf("|  #            #  |\n"); //-12
           printf("|                  |\n"); //-13
           printf("|  [            ]  |\n"); //-14
     itr_setcur(12,5);
     printf(sMapPos);
    }
          itr_showcur();
          itr_setcur(14, 5);
          scan_on(scanhandle);
          strupr(gets(sGetBuffer));
             scan_off(scanhandle);
          //- se digitato blank torno a form precedente
          if (strcmp(sGetBuffer, "") == 0) {
             itr_pausa(200);
             //- libero codiceRF
          iUDPResult = RF_OB_CANCEL(sCodiceRF, sUDP);
             return;
    }
          //- controllo se il barcode letto è uguale a quello previsto
          if (strncmp(sGetBuffer, sMapPos, strlen(sGetBuffer)) ==0)
          {
           strcpy(barcode3, "            \0");
           strncpy(barcode3, sGetBuffer, strlen(sGetBuffer));
           strcat(barcode3,"\0"); //- aggiungo terminatore
           bar3OK = TRUE;
           inputOK = TRUE;
        itr_setcur(11,1);
           printf("|     STIVA OK     |\n"); //-11
           printf("|   SALVATAGGIO... |\n"); //-12
            itr_hidecur();
           break;
          }
          else
          {
           itr_setcur(11,1);
           printf("|   STIVA ERRATA   |\n"); //-11
           printf("|    RILEGGERE!    |\n"); //-12
            itr_hidecur();
            err_mov();
          }
   }
   if (bar3OK == TRUE) {
           gBanCurr++;
           if (strncmp(sMapPos, "MA",2) != 0) {
     // - metto flag elaborato a si
     flag_elab(iRigoBuff, 0);
    }
           //- creo il buffer da scrivere in inBatch
    strcpy(siBuff, "
\0");
    //- n.mov+ prog. ban. + n.leo
    if (strncmp(sMapPos, "MA",2) != 0) {
     strncpy(siBuff, &sBuffRigo[5],20);
    }
    else {
     strncpy(siBuff+15, gNLEO, 5);
    }
    //- tipo movimento
    strncpy(siBuff+20, "EN" ,2);
    //- data ora now
    itr_dataora(gsDataOra);
    strncpy(siBuff + 22, gsDataOra, 18);
    //- Operatore
    strncpy(siBuff + 40, gOPE, 3);
    //- Codice apparato ottico
    strncpy(siBuff + 43, gARF, 4);
    //- Posizione
    strncpy(siBuff + 47, barcode3, 12);
    //- Bianco 12
    strncpy(siBuff + 59, "            ", 12);
    //- Qta bancali = 1
    strncpy(siBuff + 71, "000001", 6);
    //- Tipo barcode letto
    strncpy(siBuff + 77, "2", 1);
    strncpy(siBuff + 78, &barcode1[0], 38);
    //- Barcode alto
    strncpy(siBuff + 118 , &barcode2[0], 40);
    //- se radio - invio rigo, altrimenti salvo su file
    if (bRadio == 1) {
     itr_setcur(14,1);
     printf("|richiesta udp...  |\n"); //-14
     printf("(-----(");
     printf(siBuff);  // [ERRORE QUI]  questa stringa è vuota!!!
     printf(")-----)");
     iUDPResult = RF_inBatch(sCodiceRF, siBuff, sUDP);
     if (iUDPResult < 0) {
            itr_setcur(14,1);
            printf("|ERRORE INVIO INBAT|\n"); //-14
            err_mov();
            goto BARCODE_STIVA1100;
     }
     kpressed = get_key();
    }
    else {
     //- aggiungo rigo al file di elaborato
     strncpy(&in_batch[5] ,gNLEO, 5);
     ibFile = fopen(in_batch, fAPP);
     fputs(siBuff, ibFile);
     fputs("\n", ibFile);
     fclose(ibFile);
    }
           //- beep di esito positivo
           ok_mov();
    if (gBanCurr > gBanTot)
    {
     itr_setcur(10,1);
           printf("|                  |\n"); //-10
           printf("|  POSIZIONAMENTO  |\n"); //-11
           printf("|    TERMINATO     |\n"); //-12
           printf("|                  |\n"); //-13
           printf("| PREMERE UN TASTO |\n"); //-14
           printf("+------------------+\n"); //-15
           itr_hidecur();
     kpressed = get_key();
     menu_0002(); //-entrata terminata
    }
           else
           {
           itr_pausa(500);
           return; //-leggo successivo
          }
   }
  }
   }
<secondo problema>
al secondo richiamo della funzione RF_PICK_ART
Questo pezzo di codice non funge come dovrebbe....
 strncpy(sStringa, sCodiceRF, 10);
 strncpy(sStringa + 10, " PA" , 3);
 strncpy(sStringa + 13, sRif , 17);
 strncpy(sStringa + 30, sArtCod , 8);
 strncpy(sStringa + 38, sSSC , 18);
Al primo richiamo sStringa è =
0000000191<blank>PA2004081008806605100184579330116100110942837
Al Secondo richiamo sStringa è =
00000001920112004081008806605100184579330116100110942837
La cosa mi sembra assurda....
void menu_4001(char* sBBancale) //- menu' 4.1 preparazione picking
   {
     int inputOK = FALSE;
     int bar1OK = FALSE;
     char barcode1[39] = "                                      \0";
     int bar3OK = FALSE;
     char barcode3[13] = "            \0";
     int okInc = FALSE;
  char sRichiesta[11];
  char sRichiesta2[11];
  char sNBan[4];
  char sArtCod[9] = "        \0";
  char sArtCod2[9] = "        \0";
  char sBanUnc[19]= "                  \0";
     char sQtaCar[5] = "    \0";
     char sMapPos[13] = "            \0";
  int QtaOK = FALSE;
  int iFinito = FALSE;
  long iQtaDig;
  long iQtaTotale;
  long iQtaPresa;
  long iQtaStrati;
  long iQtaRimanente;
  char sQtaBuff[11] = "          \0";
  int iRigoBuff = 0;
  long iQtaSSC = 0;
  char *sSSCBlo = " \0";
  char *sSSCPik = " \0";
  char sSSC[19] = "                  \0";
  char sElab;
  fpos_t savepos;
     giCurrMenu = 4000;
     strcpy(gsCurrMenu, "4000\0");
  iFinito = FALSE;
  while (iFinito == FALSE) //- loop per leggere + prodotti
  {
   BARCODE1_4000 : //- etichetta per tornare indietro
   inputOK = FALSE;
         while (inputOK == FALSE)
         {
       itr_cls();
       itr_setcur(1, 1);
       //------123456789012345678901
       printf("+------------------+\n"); //-01
       printf("| #    # < > [   ] |\n"); //-02
          printf("+------------------+\n"); //-03
          printf("| RICHIESTA    BAN |\n"); //-04
          printf("|[          ] [   ]|\n"); //-05
          printf("|                  |\n"); //-06
          printf("| LEGGERE BARCODE  |\n"); //-07
          printf("| BANCALE <PADRE>  |\n"); //-08
          printf("|[                  \n"); //-09
          printf("                   ]\n"); //-10
          printf("|                  |\n"); //-11
          printf("|                  |\n"); //-12
          printf("|                  |\n"); //-13
          printf("|                  |\n"); //-14
          printf("+------------------+\n"); //-15
          itr_setcur(2, 4);
    printf(gsCurrMenu);
    itr_setcur(2, 11);
    printf("%c", itr_batteria());
          itr_setcur(2, 15);
    printf(gOPE);
    strcpy(sRichiesta, "          \0");
    strncpy(sRichiesta, &sBBancale[4], 10);
    strcpy(sNBan, "   \0");
    strncpy(sNBan, &sBBancale[14], 3);
          itr_setcur(5, 3);
    printf(sRichiesta);
          itr_setcur(5, 16);
    printf(sNBan);
          itr_showcur();
          itr_setcur(9, 3);
          scan_on(scanhandle);
          strupr(gets(sGetBuffer));
          scan_off(scanhandle);
          //- se digitato bianco esco
          if (strcmp(sGetBuffer, "") == 0) {
             itr_pausa(200);
             menu_4000();
             break;
    }
             itr_hidecur();
          bar1OK = FALSE;
          //- controllo se il barcode ha lunghezza giusta
          if (strlen(sGetBuffer) == 38 || strlen(sGetBuffer) == 36)
          {
           strcpy(barcode1, "                                      \0");
           strncpy(barcode1, sGetBuffer, strlen(sGetBuffer));
           if (strlen(sGetBuffer) == 36)
            strncpy(barcode1 + 36, "  ", 2);
           strcat(barcode1,"\0"); //- aggiungo terminatore
     //-determino codice prodotto
     //- se il barcode è 36 caratteri aggiungo due 00 al codice articolo
     if (strlen(sGetBuffer) == 38)
     {
      strncpy(sArtCod, &barcode1[30], 8);
      strcat(sArtCod,"\0");
     }
     else
     {
      strncpy(sArtCod, &barcode1[28], 6);
      strcat(sArtCod,"\0");
      sArtCod[0] = '0';
      sArtCod[1] = '0';
     }
     //-determino sscc
     strncpy(sBanUnc, &barcode1[2], 18);
     strcat(sBanUnc,"\0");
              if (bRadio == 0)
              {
               //- controllo se il prodotto è inserito nella richiesta
                omFile = fopen(out_misto, fRO);
             iRigoBuff = 0;
             SvuotaBuf();
      //-- ciclo le righe per trovare il n. richiesta
      while (fgets(fileBuf, obLLen+2, omFile) != NULL)
      {
       iRigoBuff++;
       //- scarto quelli con richiesta diversa
       strcpy(sRichiesta2, "          \0");
       strncpy(sRichiesta2, &fileBuf[0], 10);
       strcat(sRichiesta2, "\0");
                         if (strncmp(sRichiesta, sRichiesta2, 10) != 0)
                         {
                           SvuotaBuf();
                           continue;
                         }
          //- scarto quelli con prodotto diverso
       strcpy(sArtCod2, "        \0");
       strncpy(sArtCod2,&fileBuf[10],8);
       strcat(sArtCod2, "\0");
       if (strncmp(sArtCod2, sArtCod,8) != 0) {
        SvuotaBuf();
        continue;
       }
       //- scarto quelli già completi
       sElab = fileBuf[100];
       if (sElab == 'S')
                         {
                           SvuotaBuf();
                           continue;
                         }
       //- se arrivo qui ho trovato quello che cercavo e carico i dati
       strcpy(sQtaBuff, "          \0");
       strncpy(sQtaBuff, &fileBuf[70], 10);
       strcat(sQtaBuff, "\0");
       iQtaTotale = strtol(sQtaBuff, &stopstring, 10);
       strcpy(sQtaBuff, "          \0");
       strncpy(sQtaBuff, &fileBuf[80], 10);
       strcat(sQtaBuff, "\0");
       iQtaStrati = strtol(sQtaBuff, &stopstring, 10);
       strcpy(sQtaBuff, "          \0");
       strncpy(sQtaBuff, &fileBuf[90], 10);
       strcat(sQtaBuff, "\0");
       iQtaPresa = strtol(sQtaBuff, &stopstring, 10);
                iQtaRimanente = iQtaTotale - iQtaPresa;
             bar1OK = TRUE;
             break;
      }
             fclose(omFile);
     }
     else
     {
             //- radio faccio il check
          itr_setcur(13,1);
      printf("|richiesta udp...  |\n"); //-13
         // richiedo codice rf
         strcpy(sCodiceRF , "          \0");
         iUDPResult = RF_GET_UNQ(sUDP, sCodiceRF);
      if (iUDPResult != 0)
      {
             itr_setcur(13,1);
             printf("| ERRORE RICH. UDP |\n"); //-13
             printf("| RIC. CODICE RF   |\n"); //-14
             err_mov();
      }
             else
             {
              itr_setcur(13,1);
       printf("|richiesta udp...  |\n"); //-13
       strcpy(sSSC, "                  \0");
       strncpy(sSSC, &barcode1[2], 18);
       itr_pausa(1000);
       iUDPResult = RF_PICK_ART(sCodiceRF, sBBancale, sArtCod, sSSC, sUDP,
obLLen, fileBuf);
       itr_pausa(1000);
       if (iUDPResult < 0) {
              itr_setcur(13,1);
              printf("| ERRORE RICH. UDP |\n"); //-13
              printf("| N. ERRORE %d ",iUDPResult ); //-14
              err_mov();
          }
          else
          {
        //- se arrivo qui ho trovato quello che cercavo e carico i dati
        strcpy(sQtaBuff, "          \0");
        strncpy(sQtaBuff, &fileBuf[0], 10);
        strcat(sQtaBuff, "\0");
        iQtaTotale = strtol(sQtaBuff, &stopstring, 10);
        strcpy(sQtaBuff, "          \0");
        strncpy(sQtaBuff, &fileBuf[10], 10);
        strcat(sQtaBuff, "\0");
        iQtaPresa = strtol(sQtaBuff, &stopstring, 10);
        strcpy(sQtaBuff, "          \0");
        strncpy(sQtaBuff, &fileBuf[20], 10);
        strcat(sQtaBuff, "\0");
        iQtaStrati = strtol(sQtaBuff, &stopstring, 10);
        strcpy(sQtaBuff, "          \0");
        strncpy(sQtaBuff, &fileBuf[30], 10);
        strcat(sQtaBuff, "\0");
        iQtaSSC = strtol(sQtaBuff, &stopstring, 10);
        strcpy(sSSCPik, " \0");
        strncpy(sSSCPik, &fileBuf[41], 1);
        strcpy(sSSCBlo, " \0");
        strncpy(sSSCBlo, &fileBuf[42], 1);
                 iQtaRimanente = iQtaTotale - iQtaPresa;
        bar1OK = TRUE;
        if (strncmp(sSSCPik, "N",1) == 0)
        {
         itr_hidecur();
         itr_setcur(12, 1);
         err_mov();
         err_mov();
         printf("| ATTENZIONE SSC   |\n"); //-12
         printf("| NON PREVISTO IN  |\n"); //-13
         printf("| ZONA PICKING!!!  |\n"); //-14
         itr_pausa(5000);
        }
        if (strncmp(sSSCBlo, "B",1) == 0)
        {
         itr_hidecur();
         itr_setcur(12, 1);
         err_mov();
         err_mov();
         printf("| ATTENZIONE SSC   |\n"); //-12
         printf("| BLOCCATO NON     |\n"); //-13
         printf("|   PRELEVARE!!!   |\n"); //-14
         itr_pausa(5000);
        }
        if (iQtaSSC <=0)
        {
         itr_hidecur();
         itr_setcur(12, 1);
         err_mov();
         err_mov();
         printf("| ATTENZIONE SSC   |\n"); //-12
         printf("| CON QTA A ZERO   |\n"); //-13
         printf("| VERIFICARE.....  |\n"); //-14
         itr_pausa(5000);
        }
          }
      }
     }
              //- esco dal ciclo di richiesta barcode
     if (bar1OK == TRUE)
     {
            inputOK = TRUE;
            break;
           }
           else
           {
      itr_hidecur();
      itr_setcur(12, 1);
      printf("| PRODOTTO NON IN  |\n"); //-12
      printf("| RICHIESTA O GIA' |\n"); //-13
      printf("| ASSEMBLATO!      |\n"); //-14
      err_mov();
           }
          }
          else
          {
     itr_hidecur();
     itr_setcur(12, 1);
     printf("|  BARCODE ERRATO  | "); //-12
     err_mov();
          } //- fine else lung. incarico
   } //- fine while
   if (bar1OK == TRUE)
   {
             //- RICHIEDO QTA..
    QTA_4100:
    inputOK = FALSE;
       while (inputOK == FALSE)
       {
              itr_setcur(7, 1);
           printf("| PROD:            |\n"); //-07
           if (bRadio == 0)
           {
            printf("|                  |\n"); //-08
            printf("|QTA RICHIESTA:    | "); //-09
            printf("|   QTA STRATI:    |\n"); //-10
            printf("|    QTA PRESA:    |\n"); //-11
            printf("| PRENDERE QTA:    |\n"); //-12
            printf("|                  |\n"); //-13
            printf("|QTA CARTONI:[    ]|\n"); //-14
            itr_setcur(7, 9);
            printf(sArtCod);
            itr_setcur(9, 16);
            printf("%4d", iQtaTotale);
            itr_setcur(10, 16);
            printf("%4d", iQtaStrati);
            itr_setcur(11, 16);
            printf("%4d", iQtaPresa);
            itr_setcur(12, 16);
            printf("%4d", iQtaRimanente);
     }
     else
     {
      itr_setcur(8, 1);
            printf("| BLO [ ] PIK [ ]  |\n"); //-08
            printf("|QTA RICHIESTA:    | "); //-09
            printf("|   QTA STRATI:    |\n"); //-10
            printf("|    QTA PRESA:    |\n"); //-11
            printf("| PRENDERE QTA:    |\n"); //-12
            printf("| QTA SSC RES.:    |\n"); //-13
            printf("|QTA CARTONI:[    ]|\n"); //-14
            itr_setcur(8, 8);
            printf(sSSCBlo);
            itr_setcur(8, 16);
            printf(sSSCPik);
            itr_setcur(9, 16);
            printf("%4d", iQtaTotale);
            itr_setcur(10, 16);
            printf("%4d", iQtaStrati);
            itr_setcur(11, 16);
            printf("%4d", iQtaPresa);
            itr_setcur(12, 16);
            printf("%4d", iQtaRimanente);
            itr_setcur(13, 16);
            printf("%4d", iQtaSSC);
     }
           itr_showcur();
           itr_setcur(14, 15);
           gets(sGetBuffer);
     //- se stringa vuota torno indietro
     if (strlen(sGetBuffer) == 0 ) {
      itr_pausa(200);
         goto BARCODE1_4000;
     }
     //- controllo se è numerico
     if (IsNumero(sGetBuffer, strlen(sGetBuffer)) == TRUE) {
      strcpy(sQtaCar, "    \0");
      strncpy(sQtaCar, sGetBuffer, strlen(sGetBuffer));
       iQtaDig = strtol(sQtaCar, &stopstring, 10);
      //- controllo se le qta lette per quel prodotto sono al max quelle
richieste
      if (iQtaDig <= iQtaRimanente)
      {
       // in caso di Radiofrequenza controllo anche qtaSSC
       if (bRadio == 0)
       {
        inputOK = TRUE;
        QtaOK = TRUE;
       }
       else
       {
        if (iQtaDig <= iQtaSSC)
        {
         inputOK = TRUE;
         QtaOK = TRUE;
        }
        else
        {
               itr_setcur(8,1);
               printf("|                  |\n"); //-08
               printf("|   QTA MAGGIORE   |\n"); //-09
               printf("| DI QUELLA SSC !  |\n"); //-10
               printf("| ACCETTO (S/N) [ ]|\n"); //-11
               printf("|                  |\n"); //-12
                strange_mov();
         valid_key = FALSE;
         while (valid_key == FALSE) {
          itr_setcur(11, 18);
          itr_showcur();
          kpressed = get_key();
                switch(kpressed)
                {
            case 83: case 115: //- lettera S
             itr_beep(100);
                    valid_key = TRUE;
                    inputOK = TRUE;
                    QtaOK = FALSE;
                    break;
            case 78: case 110: //- lettera N
             itr_beep(100);
                    valid_key = TRUE;
                    QtaOK = FALSE;
                    break;
            default:
                  itr_beep(200);
           itr_pausa(200);
                  itr_beep(500);
              valid_key = FALSE;
              break;
          }
         }
        }
       }
      }
      else
      {
             itr_setcur(9,1);
             printf("|   QTA MAGGIORE   |\n"); //-09
             printf("|  RICONTROLLARE!  |\n"); //-10
             printf("|                  |\n"); //-11
              itr_hidecur();
              err_mov();
              QtaOK = FALSE;
      }
     }
     else
     {
            itr_setcur(9,1);
            printf("|    QTA ERRATA    |\n"); //-09
            printf("|   RIDIGITARE!!   |\n"); //-10
            printf("|                  |\n"); //-11
             itr_hidecur();
             err_mov();
             QtaOK = FALSE;
     }
     if (QtaOK == TRUE)
     {
               iQtaPresa = iQtaPresa + iQtaDig;
               iQtaRimanente = iQtaTotale - iQtaPresa;
      break; //- esco dal ciclo
     }
    }
    //- se tutto ok chiedo la stiva
    if (QtaOK == TRUE)
    {
     strcpy(sMapPos, "            \0");
     bar3OK = TRUE;
           //- salvo la posizione in caso di tutto ok
           if (bar3OK == TRUE) {
            //- aggiorno la posizione su out_misto
            if (bRadio == 0)
            {
       omFile = fopen(out_misto, fRW);
                        }
      //- aggiorno qta presa
      strcpy(sQtaBuff, "          \0");
      ltoa(iQtaPresa, sQtaBuff, 10);
      //- arrivo alla riga da modificare ((iRigoBuff - 1) * lunghezza buffer
+ )
      savepos = ((iRigoBuff - 1) * (101+2)) + 90 + (10 - strlen(sQtaBuff));
                        fsetpos(omFile, &savepos);
      fwrite(sQtaBuff , sizeof ( char ), strlen(sQtaBuff), omFile);
      //- Scrivo la S di elaborato se ho finito il rigo
      if (iQtaRimanente == 0)
      {
       fwrite(sSiEla , sizeof ( char ), 1, omFile);
      }
      fclose(omFile);
             //- creo il buffer da scrivere in inBatch
      strcpy(siBuff, "
\0");
      //- tipo movimento
      strncpy(siBuff+20, "MI",2);
      //- data ora now
      itr_dataora(gsDataOra);
      strncpy(siBuff + 22, gsDataOra, 18);
      //- Operatore
      strncpy(siBuff + 40, gOPE, 3);
      //- Codice apparato ottico
      strncpy(siBuff + 43, gARF, 4);
      //- Posizione
      strncpy(siBuff + 47, sMapPos, 12);
      //- Bianco 12
      strncpy(siBuff + 59, "            ", 12);
      //- Qta cartoni
      strncpy(siBuff + 73, sQtaCar , strlen(sQtaCar));
      //- Barcode basso
      strncpy(siBuff + 77, "2", 1);
      strncpy(siBuff + 78, &barcode1[0], 38);
      //- Barcode alto /numero richiesta
      strncpy(siBuff + 118 , sBBancale, 17);
      if (bRadio == 0)
      {
       //- aggiungo rigo al file di elaborato
       strncpy(&in_batch[5] ,"MISTO", 5);
       ibFile = fopen(in_batch, fAPP);
       fputs(siBuff, ibFile);
       fputs("\n", ibFile);
       fclose(ibFile);
      }
      else
      {
       itr_setcur(14,1);
       printf("|richiesta udp...  |\n"); //-14
       iUDPResult = RF_PICK_WRI(sCodiceRF, siBuff, sUDP);
       if (iUDPResult < 0) {
              itr_setcur(14,1);
              printf("|ERRORE INVIO INBAT|\n"); //-14
              err_mov();
              goto QTA_4100;
       }
      }
             //- beep di esito positivo
             ok_mov();
           }
    } //- fine if controllo qta
   } // - fine if controllo barcode basso
  } //- fine loop lettura + prodotti
   } //- fine menu
int RF_PICK_ART(char *sCodiceRF, char *sRif, char *sArtCod, char *sSSC, int
s, int size2, char *sRitornoRF)
{
 int udpOk;
 char *sRisposta = "
\0";
 char *sEvento = "          \0";
 char *sStringa = "                                      \0";
 int lunghezza;
 // funzione di richiesta qta articolo
    // esito positivo(1) dal server per registrazione
    // a buon fine altrimenti esito (0) negativo
 strncpy(sStringa, sCodiceRF, 10);
 strncpy(sStringa + 10, " PA" , 3);
 strncpy(sStringa + 13, sRif , 17);
 strncpy(sStringa + 30, sArtCod , 8);
 strncpy(sStringa + 38, sSSC , 18);
 lunghezza = 56;
    // invio la stringa al pc
    udpOk = UDP_Write(lunghezza, sStringa, s);
 if (udpOk != 0)
 {
  return udpOk;
 }
    // aspetto la risposta di accettazione
    strcpy(sRisposta, "
\0");
    strcpy(recv_buf, "
\0");
 udpOk = UDP_Read(53, sRisposta, s);
 if (udpOk != 0)
 {
  return (udpOk - 50);
 }
 // controllo risposta ricevuta
 strcpy(sEvento, "          \0");
 strncpy(sEvento, sRisposta,10);
 if (strncmp(sEvento, sCodiceRF, 10) !=0)
 {
  return -10;
 }
 else
 {
  //- controllo flag esito
  if (strncmp(&sRisposta[10], "1",1) !=0)
  {
   return -20;
  }
  else
  {
   strncpy(sRitornoRF, &sRisposta[11], 43);
   strcat(sRitornoRF, "\0") ;
   return 0;
  }
 }
}

 La cosa mi sembra assurda....
Effettivamente la cosa e' strana....


 Effettivamente la cosa e' strana....
Provo a effettuare i cambiamenti di sopra e vediamo se anche questo si
risolve.
Grazie
Luther