Activating a Scanner

[josevalle]

Hello

For saving battery I have to activate the scanner when the program is going to use it and desactivate later.

I the Symbol web I hace found some C functions.

1) The Functions are for Microsoft embedded Visual C++ 4.0. Is possible to use that?

2) How do I call a C function

Thanks

[pawelu]

Jose,

Probably, you may use this function similiar to BatteryInfo sample.

Pawel

[Antonio Linares]

Jose,

Please provide the URL or the C code so we can help.

[josevalle]

Hello Antonio:

The developers web for Symbol products is in:

http://devzone.symbol.com/

I attach de code but the solution for this is not urgent for me as I can finish my aplication (I will do that first) and after I will try to optimize the battery life.

Code: Select all  Expand view

//--------------------------------------------------------------------
// FILENAME:      BasicScan.c
//
// Copyright(c) 2002 Symbol Technologies Inc. All rights reserved.
//
// DESCRIPTION:      This simple scanning application demonstrates
//               how to use the Symbol Scan Library.
//               The API's used are as follows:
//
//               SCAN_Open
//               SCAN_Enable
//               SCAN_AllocateBuffer
//               SCAN_ReadLabelMsg
//               SCAN_Flush
//               SCAN_Disable
//               SCAN_DeallocateBuffer
//               SCAN_Close
//               SCAN_SetSoftTrigger
//
//
//
//
//--------------------------------------------------------------------

#include <windows.h>
#include <windowsx.h>

#include <ScanCAPI.h>

#include "resource.h"
   
#define      countof(x)      sizeof(x)/sizeof(x[0])

// Define user messages
enum tagUSERMSGS
{
   UM_SCAN   = WM_USER + 0x200,
   UM_STARTSCANNING,
   UM_STOPSCANNING
};

// Global variables
HINSTANCE      hInst               = NULL;
HANDLE         hScanner            = NULL;
LPSCAN_BUFFER   lpScanBuffer         = NULL;
TCHAR         szScannerName[MAX_PATH] = TEXT("SCN1:");   // default scanner name
DWORD         dwScanSize            = 7095;            // default scan buffer size   
DWORD         dwScanTimeout         = 0;            // default timeout value (0 means no timeout)   
BOOL         bUseText            = TRUE;
BOOL         bTriggerFlag         = FALSE;
BOOL         bRequestPending         = FALSE;
BOOL         bStopScanning         = FALSE;

// Forward declarations
LRESULT CALLBACK BasicScanProc(HWND,UINT,WPARAM,LPARAM);
void   ErrorExit(HWMD, UINT, LPTSTR);
LPTSTR   LoadMsg(UINT, LPTSTR, int);

//----------------------------------------------------------------------------
//
//  FUNCTION:   WinMain(HINSTANCE, HINSTANCE, LPSTR, int)
//
//  PURPOSE:    Entry point function, initializes the application, instance,
//              and then launches the message loop.
//
//  PARAMETERS:
//      hInstance     - handle that uniquely identifies this instance of the
//                      application
//      hPrevInstance - always zero in Win32
//      lpszCmdLine   - any command line arguements pass to the program
//      nCmdShow      - the state which the application shows itself on
//                      startup
//
//  RETURN VALUE:
//      (int) Returns the value from PostQuitMessage().
//
//----------------------------------------------------------------------------

int WINAPI WinMain(HINSTANCE hInstance,
               HINSTANCE hPrevInstance,
               LPWSTR lpszCmdLine,
               int nCmdShow)
{
   int nResult;

   hInst = hInstance;      // save the instance handle to a global variable
   nResult = DialogBox(hInstance, MAKEINTRESOURCE(IDD_DIALOG_SSCAN), NULL,
                  BasicScanProc);

   return nResult;
}


//----------------------------------------------------------------------------
//
//  FUNCTION:   BasicScanProc(HINSTANCE, HINSTANCE, LPSTR, int)
//
//  PURPOSE:    Application-defined callback function that processes messages
//            sent to BasicScan dialog.
//
//  PARAMETERS:
//      hwnd     - handle to the dialog box.
//      uMsg    - specifies the message.
//      wParam   - specifies additional message-specific information.
//      lParam   - specifies additional message-specific information.
//
//  RETURN VALUE:
//      (BOOL) return TRUE if it processed the message, and FALSE if it did not.
//
//----------------------------------------------------------------------------

LRESULT CALLBACK BasicScanProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
   DWORD         dwResult;
   TCHAR         szLabelType[10];
   TCHAR         szLen[MAX_PATH];
   TCHAR         szMsgBuf[256];
   LPSCAN_BUFFER   lpScanBuf;
   HWND         hctl_data, hctl_length, hctl_type;

   switch(uMsg)
    {
      case WM_INITDIALOG:

         PostMessage(hwnd,UM_STARTSCANNING,0,0L);
         break;

      case UM_STARTSCANNING:

         // Open scanner, prepare for scanning,
         // and submit the first read request
         dwResult = SCAN_Open(szScannerName, &hScanner);
         if ( dwResult != E_SCN_SUCCESS )
         {   
            ErrorExit(hwnd, IDS_FAILURE, TEXT("SCAN_Open"));
            break;
         }

         dwResult = SCAN_Enable(hScanner);
         if ( dwResult != E_SCN_SUCCESS )
         {
            ErrorExit(hwnd, IDS_FAILURE, TEXT("SCAN_Enable"));
            break;
         }

         lpScanBuffer = SCAN_AllocateBuffer(bUseText, dwScanSize);
         if (lpScanBuffer == NULL)
         {
            ErrorExit(hwnd, IDS_FAILURE, TEXT("SCAN_AllocateBuffer"));
            return TRUE;
         }

         dwResult = SCAN_ReadLabelMsg(hScanner,
                               lpScanBuffer,
                               hwnd,
                               UM_SCAN,
                               dwScanTimeout,
                               NULL);
         if ( dwResult != E_SCN_SUCCESS )
            ErrorExit(hwnd, IDS_FAILURE, TEXT("SCAN_ReadLabelMsg"));
         else
            bRequestPending = TRUE;

         break;

         return TRUE;

      case UM_STOPSCANNING:

         // We stop scanning in two steps: first, cancel any pending read
         // request; second, after there is no more pending request, disable
         // and close the scanner. We may need to do the second step after
         // a UM_SCAN message told us that the cancellation was completed.
         if (!bStopScanning && bRequestPending)                                       
            SCAN_Flush(hScanner);

         if (!bRequestPending)         
         {                     
            SCAN_Disable(hScanner);

            if (lpScanBuffer)
               SCAN_DeallocateBuffer(lpScanBuffer);

            SCAN_Close(hScanner);

            EndDialog(hwnd, 0);
         }
         bStopScanning = TRUE;

         return TRUE;

      case WM_ACTIVATE:

         // In foreground scanning mode, we need to cancel read requests
         // when the application is deactivated, and re-submit read request
         // when the application is activated again.
         switch(LOWORD(wParam))
         {
            case WA_INACTIVE:

               hctl_data = GetDlgItem(hwnd,IDC_EDIT_DATA);
               hctl_length = GetDlgItem(hwnd,IDC_EDIT_LEN);
               hctl_type = GetDlgItem(hwnd,IDC_EDIT_TYPE);

               Edit_SetText(hctl_data, LoadMsg(IDS_INACTIVE,
                                       szMsgBuf, countof(szMsgBuf)));
               Edit_SetText(hctl_length, TEXT(""));
               Edit_SetText(hctl_type, TEXT(""));

               // Cancel any pending request since we are going to lose focus
               if (bRequestPending)
                  dwResult = SCAN_Flush(hScanner);
                  // Do not set bRequestPending to FALSE until
                  // we get the UM_SCAN message
               break;
            
            default:   // activating

               hctl_data = GetDlgItem(hwnd,IDC_EDIT_DATA);
               Edit_SetText(hctl_data, LoadMsg(IDS_READY,
                                       szMsgBuf, countof(szMsgBuf)));

               if (!bRequestPending && lpScanBuffer != NULL && !bStopScanning)
               {   
                  // Submit a read request if no request pending
                  dwResult = SCAN_ReadLabelMsg(hScanner,
                                        lpScanBuffer,
                                        hwnd,
                                        UM_SCAN,
                                        dwScanTimeout,
                                        NULL);
                  
                  if ( dwResult != E_SCN_SUCCESS )
                     ErrorExit(hwnd, IDS_FAILURE, TEXT("SCAN_ReadLabelMsg"));
                  else
                     bRequestPending = TRUE;
               }
               break;
         }
         break;

      case UM_SCAN:

         bRequestPending = FALSE;

         // Clear the soft trigger
         bTriggerFlag = FALSE;
         SCAN_SetSoftTrigger(hScanner,&bTriggerFlag);

         // Get scan result from the scan buffer, and display it
         lpScanBuf = (LPSCAN_BUFFER)lParam;
         if ( lpScanBuf == NULL )
            ErrorExit(hwnd, IDS_ERR_BUF, 0);

         hctl_data = GetDlgItem(hwnd,IDC_EDIT_DATA);
         hctl_length = GetDlgItem(hwnd,IDC_EDIT_LEN);
         hctl_type = GetDlgItem(hwnd,IDC_EDIT_TYPE);

         switch (SCNBUF_GETSTAT(lpScanBuf))
         {
            case E_SCN_DEVICEFAILURE:

               Edit_SetText(hctl_data, LoadMsg(IDS_DEVICE_FAILURE,
                                       szMsgBuf, countof(szMsgBuf)));
               break;

            case E_SCN_READPENDING:

               Edit_SetText(hctl_data, LoadMsg(IDS_READ_PENDING,
                                       szMsgBuf, countof(szMsgBuf)));
               break;

            case E_SCN_READCANCELLED:

               if (bStopScanning)
               {   // complete the second step of UM_STOPSCANNING
                  SendMessage(hwnd,UM_STOPSCANNING,0,0L);   
                  return TRUE;
               }
               if (!GetFocus())   
                  break;   // Do nothing if read was cancelled while deactivation

               Edit_SetText(hctl_data, LoadMsg(IDS_READ_CANCELLED,
                                       szMsgBuf, countof(szMsgBuf)));
               break;
         
            case E_SCN_SUCCESS:
            
               Edit_SetText(hctl_data, (LPTSTR)SCNBUF_GETDATA(lpScanBuffer));
               
               // Format label type as a hex constant for display
               wsprintf(szLabelType, TEXT("0x%.2X"), SCNBUF_GETLBLTYP(lpScanBuf));
               Edit_SetText(hctl_type, szLabelType);

               wsprintf(szLen, TEXT("%d"), SCNBUF_GETLEN(lpScanBuf));
               Edit_SetText(hctl_length, szLen);

               break;
         }

         // Submit next read request if we are foreground
         if (GetFocus())
         {
            dwResult = SCAN_ReadLabelMsg(hScanner,
                                  lpScanBuffer,
                                  hwnd,
                                  uMsg,
                                  dwScanTimeout,
                                  NULL);
            
            if ( dwResult != E_SCN_SUCCESS )
               ErrorExit(hwnd, IDS_FAILURE, TEXT("SCAN_ReadLabelMsg"));
            else
               bRequestPending = TRUE;
         }

         return TRUE;

      case WM_COMMAND:
         
         switch (LOWORD(wParam))
            {
            case IDC_BUTTON_SOFTTRIGGER:
               // Clear the state first before we set it to TRUE
               bTriggerFlag = FALSE;
               SCAN_SetSoftTrigger(hScanner,&bTriggerFlag);

               bTriggerFlag = TRUE;
               SCAN_SetSoftTrigger(hScanner,&bTriggerFlag);

               break;

            case IDOK:   // fall through

            case IDCANCEL:

               SendMessage(hwnd,UM_STOPSCANNING,0,0L);
               break;
         }

         return TRUE;
   }

   return FALSE;
}

//----------------------------------------------------------------------------
//
//  FUNCTION:   ErrorExit(HWND, UINT, LPTSTR)
//
//  PURPOSE:    Handle critical errors and exit dialog.
//
//  PARAMETERS:
//      hwnd     - handle to the dialog box.
//      uID       - ID of the message string to be displayed
//      szFunc   - function name if it's an API function failure
//
//  RETURN VALUE:
//      None.
//
//----------------------------------------------------------------------------

void ErrorExit(HWND hwnd, UINT uID, LPTSTR szFunc)
{
   TCHAR szMsg[256];
   TCHAR szBuf[256];

   if (szFunc == NULL)
      wcscpy(szMsg, LoadMsg(uID, szBuf, countof(szBuf)));
   else
      wsprintf(szMsg, TEXT("%s %s"), szFunc,
               LoadMsg(uID, szBuf, countof(szBuf)));
   MessageBox(NULL, szMsg, NULL, MB_OK);
   SendMessage(hwnd,UM_STOPSCANNING,0,0L);
}

//----------------------------------------------------------------------------
//
//  FUNCTION:   LoadMsg(UINT, LPTSTR, int)
//
//  PURPOSE:    Load a message string for the string table
//
//  PARAMETERS:
//      uID       - ID of the message string to be loaded
//      lpBuffer - buffer to hold the message string
//      nBufSize - size of lpBuffer
//
//  RETURN VALUE:
//      (LPTSTR) pointer to lpBuffer
//
//----------------------------------------------------------------------------

LPTSTR LoadMsg(UINT uID, LPTSTR lpBuffer, int nBufSize)
{
   if (!LoadString(hInst, uID, lpBuffer, nBufSize))
      wcscpy(lpBuffer, TEXT(""));

   return lpBuffer;
}

[/quote]

[Antonio Linares]

Jose,

You may start using some portions of the code and test them:

From your app, just call Scan_Open() and see if you get or not an error message.

Code: Select all  Expand view

#pragma BEGINDUMP

#include <hbapi.h>
#include <windows.h>
#include <ScanCAPI.h>

HANDLE hScanner = NULL;
TCHAR   szScannerName[MAX_PATH] = L"SCN1:"; 

HB_FUNC( SCAN_OPEN )
{
    DWORD dwResult = SCAN_Open( szScannerName, &hScanner );

    if ( dwResult != E_SCN_SUCCESS )
       MessageBox( GetActiveWindow(), L"Fallo en Scan_Open", L"Ok", 0 );
}

#pragma ENDDUMP


[Maurizio]

Hello Jose

I suggest you use palm with intergrated scanner.
(I use http://na.psc.com/html/f4220.htm )
They work very well and you d'ont need to write any cose,
as it is automatic.
Ihave had negative experiences with external scanner

Regards Maurizio
www.nipeservice.com

[josevalle]

Hello Maurizio.

I have a Symbol 8800 pda with integrated scanner. I can configure it to remain active all the time but the seller told me that was better, for saving battery, to activate a de-activate each time we want to scan a codebar.

I will take a look at the web you point because I thing that 1500€ is very expensive.

Thanks for your information