Logo Search packages:      
Sourcecode: libgphoto2 version File versions

status.c

/**********************************************************************
*       Minolta Dimage V digital camera communication library         *
*               Copyright  2000,2001 Gus Hartmann                  *
*                                                                     *
*    This program is free software; you can redistribute it and/or    *
*    modify it under the terms of the GNU General Public License as   *
*    published by the Free Software Foundation; either version 2 of   *
*    the License, or (at your option) any later version.              *
*                                                                     *
*    This program is distributed in the hope that it will be useful,  *
*    but WITHOUT ANY WARRANTY; without even the implied warranty of   *
*    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the    *
*    GNU General Public License for more details.                     *
*                                                                     *
*    You should have received a copy of the GNU General Public        *
*    License along with this program; if not, write to the Free       *
*    Software Foundation, Inc., 59 Temple Place, Suite 330,           *
*    Boston, MA 02111-1307 USA                                        *
*                                                                     *
**********************************************************************/

/* $Id: status.c 5969 2002-12-15 11:45:10Z asl $ */

#include "config.h"

#include "dimagev.h"

#define GP_MODULE "dimagev"

/* This is the parent function, who calls most of the functions below.
   It returns GP_ERROR if it cannot get the camera data, and GP_OK otherwise.
   The subroutines will print out more detained information should they fail.
*/
int dimagev_get_camera_status(dimagev_t *dimagev) {
      dimagev_packet *p, *raw;
      unsigned char char_buffer;

      /* Check the device. */
      if ( dimagev->dev == NULL ) {
            GP_DEBUG( "dimagev_get_camera_status::device not valid");
            return GP_ERROR_BAD_PARAMETERS;
      }

      /* Let's say hello and get the current status. */
      if ( ( p = dimagev_make_packet(DIMAGEV_GET_STATUS, 1, 0)) == NULL ) {
            GP_DEBUG( "dimagev_get_camera_status::unable to allocate packet");
            return GP_ERROR_IO;
      }

      if ( gp_port_write(dimagev->dev, p->buffer, p->length) < GP_OK ) {
            GP_DEBUG( "dimagev_get_camera_status::unable to write packet");
            free(p);
            return GP_ERROR_IO;
      } else if ( gp_port_read(dimagev->dev, &char_buffer, 1) < GP_OK ) {
            GP_DEBUG( "dimagev_get_camera_status::no response from camera");
            free(p);
            return GP_ERROR_IO;
      }

      free(p);

      switch ( char_buffer ) {
            case DIMAGEV_ACK:
                  break;
            case DIMAGEV_NAK:
                  GP_DEBUG( "dimagev_get_camera_status::camera did not acknowledge transmission");
                  return dimagev_get_camera_status(dimagev);
/*                return GP_ERROR_IO;*/
            case DIMAGEV_CAN:
                  GP_DEBUG( "dimagev_get_camera_status::camera cancels transmission");
                  return GP_ERROR_IO;
            default:
                  GP_DEBUG( "dimagev_get_camera_status::camera responded with unknown value %x", char_buffer);
                  return GP_ERROR_IO;
      }

      if ( ( p = dimagev_read_packet(dimagev) ) == NULL ) {
            GP_DEBUG( "dimagev_get_camera_status::unable to read packet");
            return GP_ERROR_IO;
      }

      char_buffer = DIMAGEV_EOT;
      if ( gp_port_write(dimagev->dev, &char_buffer, 1) < GP_OK ) {
            GP_DEBUG( "dimagev_get_camera_status::unable to send EOT");
            free(p);
            return GP_ERROR_IO;
      }

      if ( gp_port_read(dimagev->dev, &char_buffer, 1) < GP_OK ) {
            GP_DEBUG( "dimagev_get_camera_status::no response from camera");
            free(p);
            return GP_ERROR_IO;
      }

      switch ( char_buffer ) {
            case DIMAGEV_ACK:
                  break;
            case DIMAGEV_NAK:
                  GP_DEBUG( "dimagev_get_camera_status::camera did not acknowledge transmission");
                  free(p);
                  return GP_ERROR_IO;
            case DIMAGEV_CAN:
                  GP_DEBUG( "dimagev_get_camera_status::camera cancels transmission");
                  free(p);
                  return GP_ERROR_IO;
            default:
                  GP_DEBUG( "dimagev_get_camera_status::camera responded with unknown value %x", char_buffer);
                  free(p);
                  return GP_ERROR_IO;
      }

      if ( ( raw = dimagev_strip_packet(p) ) == NULL ) {
            GP_DEBUG( "dimagev_get_camera_status::unable to strip data packet");
            free(p);
            return GP_ERROR;
      }
      
      free(p);

      if ( ( dimagev->status = dimagev_import_camera_status(raw->buffer) ) == NULL ) {
            GP_DEBUG( "dimagev_get_camera_status::unable to read camera status");
            free(raw);
            return GP_ERROR;
      }

      free(raw);
      return GP_OK;
}

/* This function converts a few chars of data, such as is given by the camera
   to indicate status, and massages it into a dimagev_status_t.
*/
dimagev_status_t *dimagev_import_camera_status(unsigned char *raw_data) {
      dimagev_status_t *processed_data;

      if ( raw_data == NULL ) {
            return NULL;
      }
      
      if ( ( processed_data = malloc(sizeof(dimagev_status_t)) ) == NULL ) {
            return NULL;
      }

      processed_data->battery_level = raw_data[0];
      processed_data->number_images = ( raw_data[1] * 256 ) + ( raw_data[2] );
      processed_data->minimum_images_can_take = ( raw_data[3] * 256 ) + ( raw_data[4] );
      processed_data->busy = ( raw_data[5] & 0x40 ) >> 6;
      processed_data->flash_charging = ( raw_data[5] & 0x10 ) >> 4;
      processed_data->lens_status = ( raw_data[5] & 0x0c ) >> 2 ;
      processed_data->card_status = ( raw_data[5] & 0x03 );
      processed_data->id_number = raw_data[6];

      return processed_data;
}

/* This is a fairly simple dump function, using the GPIO debug funtions. It
   just prints the current status to stderr in a reasonably readable format.
*/
void dimagev_dump_camera_status(dimagev_status_t *status) {

      if ( status == NULL ) {
            GP_DEBUG( "Unable to dump NULL status");
            return;
      }

      GP_DEBUG( "========= Begin Camera Status =========");
      GP_DEBUG( "Battery level: %d", status->battery_level);
      GP_DEBUG( "Number of images: %d", status->number_images);
      GP_DEBUG( "Minimum images remaining: %d", status->minimum_images_can_take);
      GP_DEBUG( "Busy: %s ( %d )", status->busy != (unsigned char) 0 ? "Busy" : "Not Busy", status->busy);
      GP_DEBUG( "Flash charging: %s ( %d )", status->flash_charging != (unsigned char) 0 ? "Charging" : "Ready", status->flash_charging);

      GP_DEBUG( "Lens status: ");
      switch ( status->lens_status ) {
            case 0:
                  GP_DEBUG( "Normal ( 0 )");
                  break;
            case 1: case 2:
                  GP_DEBUG( "Lens direction does not match flash light ( %d )", status->lens_status );
                  break;
            case 3:
                  GP_DEBUG( "Lens is not attached ( 3 )");
                  break;
            default:
                  GP_DEBUG( "Bad value for lens status ( %d )", status->lens_status);
                  break;
      }

      GP_DEBUG( "Card status: ");
      switch ( status->card_status ) {
            case 0:
                  GP_DEBUG( "Normal ( 0 )");
                  break;
            case 1:
                  GP_DEBUG( "Full ( 1 )");
                  break;
            case 2:
                  GP_DEBUG( "Write-protected ( 2 )");
                  break;
            case 3:
                  GP_DEBUG( "Card not valid for this camera ( 3 )");
                  break;
            default:
                  GP_DEBUG( "Invalid value for card status ( %d )", status->card_status);
                  break;
      }

      GP_DEBUG( "Card ID Data: %02x", status->id_number);
      GP_DEBUG( "========== End Camera Status ==========");

      return;
}

Generated by  Doxygen 1.6.0   Back to index