Diff: MARY_CAMERA.cpp

Revision:

11:61a025e8ab68

Parent:

10:82394d226c74

Child:

12:614be3290c47

--- a/MARY_CAMERA.cpp	Thu Mar 06 12:34:25 2014 +0000
+++ b/MARY_CAMERA.cpp	Sat Mar 08 04:59:00 2014 +0000
@@ -4,27 +4,6 @@
 #define PARAM_NUM       99
 #define CAM_I2C_ADDR    0x42
 
-const char param[2][PARAM_NUM] = {
-    {
-        0x01,0x02,0x03,0x0c,0x0e,0x0f,0x11,0x12,0x15,0x16,0x17,0x18,0x19,0x1a,0x1e,0x21,0x22,
-        0x29,0x32,0x33,0x34,0x35,0x37,0x38,0x39,0x3b,0x3c,0x3d,0x3e,0x3f,0x40,0x41,0x41,
-        0x43,0x44,0x45,0x46,0x47,0x48,0x4b,0x4c,0x4d,0x4e,0x4f,0x50,0x51,0x52,0x53,
-        0x54,0x56,0x58,0x59,0x5a,0x5b,0x5c,0x5d,0x5e,0x69,0x6a,0x6b,0x6c,0x6d,0x6e,
-        0x6f,0x70,0x71,0x72,0x73,0x74,0x75,0x76,0x77,0x78,0x79,0x8d,0x8e,0x8f,0x90,
-        0x91,0x96,0x96,0x97,0x98,0x99,0x9a,0x9a,0x9b,0x9c,0x9d,0x9e,0xa2,0xa4,0xb0,
-        0xb1,0xb2,0xb3,0xb8,0xc8,0xc9
-    },
-    {
-        0x40,0x60,0x02,0x0c,0x61,0x4b,0x81,0x04 ,0x00,0x02,0x39,0x03,0x03,0x7b,0x37,0x02,0x91,
-        0x07,0x80,0x0b,0x11,0x0b,0x1d,0x71,0x2a,0x12,0x78,0xc3,0x11,0x00,0xd0,0x08,0x38,
-        0x0a,0xf0,0x34,0x58,0x28,0x3a,0x09,0x00,0x40,0x20,0x80,0x80,0x00,0x22,0x5e,
-        0x80,0x40,0x9e,0x88,0x88,0x44,0x67,0x49,0x0e,0x00,0x40,0x0a,0x0a,0x55,0x11,
-        0x9f,0x3a,0x35,0x11,0xf1,0x10,0x05,0xe1,0x01,0x04,0x01,0x4f,0x00,0x00,0x00,
-        0x00,0x00,0x00,0x30,0x20,0x30,0x00,0x84,0x29,0x03,0x4c,0x3f,0x52,0x88,0x84,
-        0x0c,0x0e,0x82,0x0a,0xf0,0x60
-    }
-};
-
 #define     RESET_PULSE_WIDTH   100     //  mili-seconds
 #define     RESET_RECOVERY_TIME 100     //  mili-seconds
 
@@ -57,128 +36,151 @@
     _reset( cam_reset ),
     _i2c( I2C_sda, I2C_scl )
 {
+#ifdef IGNORE_INITIALIZATION_ERROR
     init();
+#else
+    if ( 0 != init() )
+        error( "camera initialization failed." );
+#endif
 }
 
-
+int MARY_CAMERA::init( void )
+{
+    const char camera_register_setting[2][PARAM_NUM] = {
+        {
+            0x01,0x02,0x03,0x0c,0x0e,0x0f,0x11,0x12,0x15,0x16,0x17,0x18,0x19,0x1a,0x1e,0x21,0x22,
+            0x29,0x32,0x33,0x34,0x35,0x37,0x38,0x39,0x3b,0x3c,0x3d,0x3e,0x3f,0x40,0x41,0x41,
+            0x43,0x44,0x45,0x46,0x47,0x48,0x4b,0x4c,0x4d,0x4e,0x4f,0x50,0x51,0x52,0x53,
+            0x54,0x56,0x58,0x59,0x5a,0x5b,0x5c,0x5d,0x5e,0x69,0x6a,0x6b,0x6c,0x6d,0x6e,
+            0x6f,0x70,0x71,0x72,0x73,0x74,0x75,0x76,0x77,0x78,0x79,0x8d,0x8e,0x8f,0x90,
+            0x91,0x96,0x96,0x97,0x98,0x99,0x9a,0x9a,0x9b,0x9c,0x9d,0x9e,0xa2,0xa4,0xb0,
+            0xb1,0xb2,0xb3,0xb8,0xc8,0xc9
+        },
+        {
+            0x40,0x60,0x02,0x0c,0x61,0x4b,0x81,0x04,0x00,0x02,0x39,0x03,0x03,0x7b,0x37,0x02,0x91,
+            0x07,0x80,0x0b,0x11,0x0b,0x1d,0x71,0x2a,0x12,0x78,0xc3,0x11,0x00,0xd0,0x08,0x38,
+            0x0a,0xf0,0x34,0x58,0x28,0x3a,0x09,0x00,0x40,0x20,0x80,0x80,0x00,0x22,0x5e,
+            0x80,0x40,0x9e,0x88,0x88,0x44,0x67,0x49,0x0e,0x00,0x40,0x0a,0x0a,0x55,0x11,
+            0x9f,0x3a,0x35,0x11,0xf1,0x10,0x05,0xe1,0x01,0x04,0x01,0x4f,0x00,0x00,0x00,
+            0x00,0x00,0x00,0x30,0x20,0x30,0x00,0x84,0x29,0x03,0x4c,0x3f,0x52,0x88,0x84,
+            0x0c,0x0e,0x82,0x0a,0xf0,0x60
+        }
+    };
+    char    s[ 2 ];
 
-/** initialiation
- *
- *  Performs reset and initialization
- */
-void MARY_CAMERA::init( void )
-{
-    _cs      = 1;
+    //  SPI settings
+
+    _cs     = 1;                        //  set ChipSelect signal HIGH
+    _spi.format( 8 );                   //  camera SPI : 8bits/transfer
+    _spi.frequency( SPI_FREQUENCY );    //  SPI frequency setting
+
+    //  reset
 
     _reset = 0;
-    wait_ms( RESET_PULSE_WIDTH );
-
+    wait_ms( RESET_PULSE_WIDTH );   //  assert RESET signal
     _reset = 1;
-    wait_ms( RESET_RECOVERY_TIME );
+    wait_ms( RESET_RECOVERY_TIME ); //  deassert RESET signal
 
+    //  set camera registers
 
     for ( int i = 0; i < PARAM_NUM; i++ ) {
-#if 1
-        _i2c.start();
-        _i2c.write( CAM_I2C_ADDR );
-        _i2c.write( param[ 0 ][ i ] );
-        _i2c.write( param[ 1 ][ i ] );
-        _i2c.stop();
-        
-        _error_state    = 0;
-#else
+        s[ 0 ]  = camera_register_setting[ 0 ][ i ];    //  register sddress
+        s[ 1 ]  = camera_register_setting[ 1 ][ i ];    //  register value
 
-        char    s[ 2 ];
-
-        s[ 0 ]  = param[ 0 ][ i ];
-        s[ 1 ]  = param[ 1 ][ i ];
+        //  camera register setting through I2C
+        //  abort initialization if the I2C has problem
+        
+        if ( 0 != (_error_state = _i2c.write( CAM_I2C_ADDR, s, 2 )) )
+            break;  
 
-        if ( _error_state = _i2c.write( CAM_I2C_ADDR, s, 2 ) )
-            break;
-
-#endif
-        wait_ms( 20 );
+        wait_ms( 20 );  //  camera register writing requires this interval
     }
 
-    _spi.format( 8 );
-    _spi.frequency( SPI_FREQUENCY );
+    return _error_state;    //  return non-zero if I2C access failed
 }
 
 int MARY_CAMERA::ready( void )
 {
-    return _error_state;
+    return _error_state;    //  return last state of I2C access
 }
 
 void MARY_CAMERA::transfer_a_line( short *p, int line_number, int x_offset, int n_of_pixels )
 {
     char    tmp;
 
+    //  set camera module's buffer address
     set_address( line_number * BYTE_PER_LINE + x_offset * BYTE_PER_PIXEL );
 
+    //  put a read command, first return byte should be ignored
     read_register( CAMERA_DATA_REGISTER );
-//wait_us( 1 );
+
     for( int x = 0; x < n_of_pixels; x++ ) {
-        tmp     = read_register( CAMERA_DATA_REGISTER );
-//wait_us( 1 );
-        *p++    = (read_register( CAMERA_DATA_REGISTER ) << 8) | tmp;
-//wait_us( 1 );
+        //  perform 2 bytes read. a pixel data is in RGB565 format (16bits)
+        tmp     = read_register( CAMERA_DATA_REGISTER );                //  read lower byte
+        *p++    = (read_register( CAMERA_DATA_REGISTER ) << 8) | tmp;   //  read upper byte
     }
 }
 
-void MARY_CAMERA::write_register( char reg, char value )
-{
-    send_spi( COMMAND_WRITE | reg );
-    send_spi( value );
-}
-
-int MARY_CAMERA::read_register( char reg )
-{
-    return ( send_spi( COMMAND_READ | reg | ((reg == CAMERA_DATA_REGISTER) ? COMMAND_ADDR_INCREMENT : 0x00) ) );
-}
-
-//#define     USE_READY_SIGNAL
-
 void MARY_CAMERA::open_transfer( void )
 {
+    //  send command to pause the camera buffer update
     write_register( CONTROL_DATA_REGISTER, CONTROL__PAUSE_BUFFER_UPDATE );
 
+    //  read status register (first return byte should be ignored)
     read_register( STATUS_REGISTER );
 
-    while ( 0x51 != read_register( STATUS_REGISTER ) );
+    //  wait until the status register become 0x51(ready to transfer data)
+    while ( 0x51 != read_register( STATUS_REGISTER ) )
+        ;
 }
 
 void MARY_CAMERA::close_transfer( void )
 {
+    //  send command to resume the camera buffer update
     write_register( CONTROL_DATA_REGISTER, CONTROL__RESUME_BUFFER_UPDATE );
 
+    //  read status register (first return byte should be ignored)
     read_register( STATUS_REGISTER );
 
-    while ( 0x50 != read_register( STATUS_REGISTER ) );
+    //  wait until the status register become 0x50(camera updating the buffer)
+    while ( 0x50 != read_register( STATUS_REGISTER ) )
+        ;
 }
 
-
 void MARY_CAMERA::set_address( int address )
 {
+    //  set memory address (3 bytes)
+    
     write_register( MEMORY_ADDR_LOW__REGISTER, (address >>  0) & 0xFF );
     write_register( MEMORY_ADDR_MID__REGISTER, (address >>  8) & 0xFF );
     write_register( MEMORY_ADDR_HIGH_REGISTER, (address >> 16) & 0xFF );
 }
 
-#define     W_TIME 20
+void MARY_CAMERA::write_register( char reg, char value )
+{
+    //  camera register write
+    
+    send_spi( COMMAND_WRITE | reg );    //  send command and register number
+    send_spi( value );                  //  send register value
+}
+
+int MARY_CAMERA::read_register( char reg )
+{
+    //  camera register read
+    //  returning current data in SPI buffer (data returned by previous command)
+
+    return ( send_spi( COMMAND_READ | reg | ((reg == CAMERA_DATA_REGISTER) ? COMMAND_ADDR_INCREMENT : 0x00) ) );
+}
 
 int MARY_CAMERA::send_spi( char data )
 {
     int     tmp;
-        unsigned long   msk;
+    
+    //  SPI access
 
     _cs     = 0;
-#ifdef W_TIME
-    wait_us( W_TIME );
-#endif
     tmp     = _spi.write( data );
-#ifdef W_TIME
-    wait_us( W_TIME );
-#endif
     _cs     = 1;
+    
     return ( tmp );
 }