HEPTA-Sat Hands－On
ChargeControl
Dependencies: mbed PowerControl SDFileSystem
Fork of
ChargeControl
by 
智也 大野
Revision 0:0842f00470eb, committed 2016-12-09
- Comitter:
- tomoya123
- Date:
- Fri Dec 09 05:04:37 2016 +0000
- Child:
- 1:cbbad81dc88d
- Commit message:
- Charge control
Changed in this revision
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/hepta_sat/HeptaAccel.cpp Fri Dec 09 05:04:37 2016 +0000
@@ -0,0 +1,317 @@
+#include "HeptaAccel.h"
+#include "mbed.h"
+
+HeptaAccel::HeptaAccel(PinName sda, PinName scl, int aaddr ) : accel(sda,scl),addr(aaddr)
+{
+ _cmd[0] = 0x2A;//CTL_REG
+ _cmd[1] = 0x01;//ACTIVE
+ accel.write(addr, _cmd, 2);
+ accel.start();
+ accel.write(addr);
+ accel.stop();
+}
+
+void HeptaAccel::setup()
+{
+ _cmd[0] = 0x2A;
+ _cmd[1] = 0x01;
+ accel.frequency(100000);
+ accel.write(addr, _cmd, 2);
+ accel.start();
+ accel.write(addr);
+ accel.stop();
+}
+
+void HeptaAccel::sensing(float *ax,float *ay,float *az)
+{
+ int16_t acc;
+ accel.start();//start
+ accel.write(addr);//write address
+ accel.write(0x01);//X-axis_MSB_REG
+ accel.start();//restart, switch from write to read
+ accel.write(addr|0x01);//read address
+ _xmsb = accel.read(0);//read from selected register with NACK
+ accel.stop();
+ accel.start();
+ accel.write(addr);
+ accel.write(0x02);//X-axis_LSB_REG
+ accel.start();
+ accel.write(addr|0x01);
+ _xlsb = accel.read(0);
+ accel.stop();
+ acc = (_xmsb << 6) | (_xlsb >> 2);
+ if (acc > UINT14_MAX/2)
+ {
+ acc -= UINT14_MAX;
+ }
+ *ax = acc/4096.0*9.81;
+
+ accel.start();
+ accel.write(addr);
+ accel.write(0x03);
+ accel.start();
+ accel.write(addr|0x01);
+ _ymsb = accel.read(0);
+ accel.stop();
+ accel.start();
+ accel.write(addr);
+ accel.write(0x04);
+ accel.start();
+ accel.write(addr|0x01);
+ _ylsb = accel.read(0);
+ accel.stop();
+ acc = (_ymsb << 6) | (_ylsb >> 2);
+ if (acc > UINT14_MAX/2)
+ {
+ acc -= UINT14_MAX;
+ }
+ *ay = acc/4096.0*9.81;
+
+ accel.start();
+ accel.write(addr);
+ accel.write(0x05);
+ accel.start();
+ accel.write(addr|0x01);
+ _zmsb = accel.read(0);
+ accel.stop();
+ accel.start();
+ accel.write(addr);
+ accel.write(0x06);
+ accel.start();
+ accel.write(addr|0x01);
+ _zlsb = accel.read(0);
+ accel.stop();
+ acc = (_zmsb << 6) | (_zlsb >> 2);
+ if (acc > UINT14_MAX/2)
+ {
+ acc -= UINT14_MAX;
+ }
+ *az = acc/4096.0*9.81;
+}
+
+float HeptaAccel::x()
+{
+ int16_t acc;
+ float ax;
+ accel.start();
+ accel.write(addr);
+ accel.write(0x01);
+ accel.start();
+ accel.write(addr|0x01);
+ _xmsb = accel.read(0);
+ accel.stop();
+ accel.start();
+ accel.write(addr);
+ accel.write(0x02);
+ accel.start();
+ accel.write(addr|0x01);
+ _xlsb = accel.read(0);
+ accel.stop();
+ acc = (_xmsb << 6) | (_xlsb >> 2);
+ if (acc > UINT14_MAX/2)
+ {
+ acc -= UINT14_MAX;
+ }
+ ax = acc/4096.0*9.81;
+ return(ax);
+}
+
+float HeptaAccel::y()
+{
+ int16_t acc;
+ float ay;
+ accel.start();
+ accel.write(addr);
+ accel.write(0x03);
+ accel.start();
+ accel.write(addr|0x01);
+ _ymsb = accel.read(0);
+ accel.stop();
+ accel.start();
+ accel.write(addr);
+ accel.write(0x04);
+ accel.start();
+ accel.write(addr|0x01);
+ _ylsb = accel.read(0);
+ accel.stop();
+ acc = (_ymsb << 6) | (_ylsb >> 2);
+ if (acc > UINT14_MAX/2)
+ {
+ acc -= UINT14_MAX;
+ }
+ ay = acc/4096.0*9.81;
+ return(ay);
+}
+
+float HeptaAccel::z()
+{
+ int16_t acc;
+ float az;
+ accel.start();
+ accel.write(addr);
+ accel.write(0x2C);
+ accel.start();
+ accel.write(addr|0x01);
+ _zmsb = accel.read(0);
+ accel.stop();
+ accel.start();
+ accel.write(addr);
+ accel.write(0x2D);
+ accel.start();
+ accel.write(addr|0x01);
+ _zlsb = accel.read(0);
+ accel.stop();
+ acc = (_zmsb << 6) | (_zlsb >> 2);
+ if (acc > UINT14_MAX/2)
+ {
+ acc -= UINT14_MAX;
+ }
+ az = acc/4096.0*9.81;
+ return(az);
+}
+
+void HeptaAccel::sensing_u16(char* ax_u16,char* ay_u16,char* az_u16, int *dsize)
+{
+ char a1[8]={0x00},a2[8]={0x00};
+ accel.start();
+ accel.write(addr);
+ accel.write(0x01);
+ accel.start();
+ accel.write(addr|0x01);
+ _xmsb = accel.read(0);
+ accel.stop();
+ accel.start();
+ accel.write(addr);
+ accel.write(0x02);
+ accel.start();
+ accel.write(addr|0x01);
+ _xlsb = accel.read(0);
+ accel.stop();
+ sprintf( a1, "%02X", ((_xmsb)) & 0xFF);
+ sprintf( a2, "%02X", ((_xlsb)) & 0xFF);
+ ax_u16[0]=a1[0];
+ ax_u16[1]=a1[1];
+ ax_u16[2]=a2[0];
+ ax_u16[3]=a2[1];
+
+ accel.start();
+ accel.write(addr);
+ accel.write(0x03);
+ accel.start();
+ accel.write(addr|0x01);
+ _ymsb = accel.read(0);
+ accel.stop();
+ accel.start();
+ accel.write(addr);
+ accel.write(0x04);
+ accel.start();
+ accel.write(addr|0x01);
+ _ylsb = accel.read(0);
+ accel.stop();
+ sprintf( a1, "%02X", ((_ymsb)) & 0xFF);
+ sprintf( a2, "%02X", ((_ylsb)) & 0xFF);
+ ay_u16[0]=a1[0];
+ ay_u16[1]=a1[1];
+ ay_u16[2]=a2[0];
+ ay_u16[3]=a2[1];
+
+ accel.start();
+ accel.write(addr);
+ accel.write(0x05);
+ accel.start();
+ accel.write(addr|0x01);
+ _zmsb = accel.read(0);
+ accel.stop();
+ accel.start();
+ accel.write(addr);
+ accel.write(0x06);
+ accel.start();
+ accel.write(addr|0x01);
+ _zlsb = accel.read(0);
+ accel.stop();
+ sprintf( a1, "%02X", ((_zmsb)) & 0xFF);
+ sprintf( a2, "%02X", ((_zlsb)) & 0xFF);
+ az_u16[0]=a1[0];
+ az_u16[1]=a1[1];
+ az_u16[2]=a2[0];
+ az_u16[3]=a2[1];
+ *dsize = 4;
+}
+
+void HeptaAccel::x_u16(char* a_u16, int *dsize)
+{
+ char a1[8]={0x00},a2[8]={0x00};
+ accel.start();
+ accel.write(addr);
+ accel.write(0x01);
+ accel.start();
+ accel.write(addr|0x01);
+ _xmsb = accel.read(0);
+ accel.stop();
+ accel.start();
+ accel.write(addr);
+ accel.write(0x02);
+ accel.start();
+ accel.write(addr|0x01);
+ _xlsb = accel.read(0);
+ accel.stop();
+ sprintf( a1, "%02X", ((_xmsb)) & 0xFF);
+ sprintf( a2, "%02X", ((_xlsb)) & 0xFF);
+ a_u16[0]=a1[0];
+ a_u16[1]=a1[1];
+ a_u16[2]=a2[0];
+ a_u16[3]=a2[1];
+ *dsize = 4;
+}
+
+void HeptaAccel::y_u16(char* a_u16, int *dsize)
+{
+ char a1[8]={0x00},a2[8]={0x00};
+ accel.start();
+ accel.write(addr);
+ accel.write(0x03);
+ accel.start();
+ accel.write(addr|0x01);
+ _ymsb = accel.read(0);
+ accel.stop();
+ accel.start();
+ accel.write(addr);
+ accel.write(0x04);
+ accel.start();
+ accel.write(addr|0x01);
+ _ylsb = accel.read(0);
+ accel.stop();
+ sprintf( a1, "%02X", ((_ymsb)) & 0xFF);
+ sprintf( a2, "%02X", ((_ylsb)) & 0xFF);
+ a_u16[0]=a1[0];
+ a_u16[1]=a1[1];
+ a_u16[2]=a2[0];
+ a_u16[3]=a2[1];
+ *dsize = 4;
+}
+
+void HeptaAccel::z_u16(char* a_u16, int *dsize)
+{
+ char a1[8]={0x00},a2[8]={0x00};
+ accel.start();
+ accel.write(addr);
+ accel.write(0x05);
+ accel.start();
+ accel.write(addr|0x01);
+ _zmsb = accel.read(0);
+ accel.stop();
+ accel.start();
+ accel.write(addr);
+ accel.write(0x06);
+ accel.start();
+ accel.write(addr|0x01);
+ _zlsb = accel.read(0);
+ accel.stop();
+ sprintf( a1, "%02X", ((_zmsb)) & 0xFF);
+ sprintf( a2, "%02X", ((_zlsb)) & 0xFF);
+ a_u16[0]=a1[0];
+ a_u16[1]=a1[1];
+ a_u16[2]=a2[0];
+ a_u16[3]=a2[1];
+ *dsize = 4;
+}
\ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/hepta_sat/HeptaAccel.h Fri Dec 09 05:04:37 2016 +0000
@@ -0,0 +1,30 @@
+#ifndef MBED_HEPTAACCEL_H
+#define MBED_HEPTAACCEL_H
+#include "mbed.h"
+#define UINT14_MAX 16383
+
+//3axis Accel Sensor MMA8451Q
+class HeptaAccel{
+public:
+ I2C accel;
+ int addr;
+ HeptaAccel(
+ PinName sda,// Accel I2C port
+ PinName scl,// Accel I2C port
+ int aaddr
+ );
+ void setup();
+ void sensing(float *ax,float *ay,float *az);
+ void sensing_u16(char* ax_u16,char* ay_u16,char* az_u16, int *dsize);
+ float x();
+ float y();
+ float z();
+ void x_u16(char* a_u16, int *dsize);
+ void y_u16(char* a_u16, int *dsize);
+ void z_u16(char* a_u16, int *dsize);
+private:
+ char _cmd[2];
+ short int _xmsb,_xlsb,_ymsb,_ylsb,_zmsb,_zlsb;
+};
+
+#endif
\ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/hepta_sat/HeptaBattery.cpp Fri Dec 09 05:04:37 2016 +0000
@@ -0,0 +1,72 @@
+#include "HeptaBattery.h"
+#include "mbed.h"
+
+HeptaBattery::HeptaBattery(PinName bat, PinName bat_ct, PinName reg_st) : _bat(bat),_bat_ct(bat_ct),_reg_st(reg_st)
+{
+ _bat_ct = 0; // disable battery charge
+ _reg_st = 1; // able 3.3V regulator out
+ PHY_PowerDown();// disable Ethernet connection
+}
+void HeptaBattery::vol(float* bt)
+{
+ *bt = (_bat.read()*1.431*3.3);
+}
+void HeptaBattery::vol_u16(char* bt_u16, int *dsize)
+{
+ unsigned short bt_datas;
+ char bt1[8]={0x00},bt2[8]={0x00};
+ bt_datas=_bat.read_u16()>>4;
+ sprintf( bt1, "%02X", (bt_datas >> 8) & 0x0F);
+ sprintf( bt2, "%02X", (bt_datas) & 0xFF);
+ bt_u16[0]=bt1[0]; bt_u16[1]=bt1[1];
+ bt_u16[2]=bt2[0]; bt_u16[3]=bt2[1];
+ *dsize = 4;
+}
+void HeptaBattery::chargecontrol(int state, int *save_flag)
+{
+ float Bat;
+ switch(state){
+ case 1:
+ //Battery Voltage High Level
+ Peripheral_PowerUp(0xFDFF6FF7);
+ _bat_ct = 0;
+ _reg_st = 1;
+ *save_flag = 0;
+ break;
+ case 2:
+ //Battery Voltage Normal Level
+ Peripheral_PowerUp(0xFDFF6FF7);
+ _reg_st = 1;
+ _bat_ct = 1;
+ *save_flag = 0;
+ break;
+ case 3:
+ //Battery Voltage Low Level
+ Peripheral_PowerDown(0x7D7E6DF1);
+ _bat_ct = 1;
+ _reg_st = 0;
+ *save_flag = 1;
+ break;
+ case 4:
+ //Battery Voltage Auto Charge
+ Bat = _bat.read()*1.431*3.3;
+ if(Bat>=4.2){
+ Peripheral_PowerUp(0xFDFF6FF7);
+ printf("voltage high level = %f\r\n",Bat);
+ printf("Complete!!!");
+ _bat_ct = 0;
+ _reg_st = 1;
+ *save_flag = 0;
+ }
+ Peripheral_PowerDown(0x7D7E6DF1);
+ printf("voltage low level = %f\r\n",Bat);
+ _bat_ct = 1;
+ _reg_st = 0;
+ *save_flag = 1;
+ break;
+ default:
+ printf("error\r\n");
+ break;
+ }
+}
+
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/hepta_sat/HeptaBattery.h Fri Dec 09 05:04:37 2016 +0000
@@ -0,0 +1,24 @@
+#ifndef MBED_HEPTABATTERY_H
+#define MBED_HEPTABATTERY_H
+#include "mbed.h"
+#include "PowerControl/PowerControl.h"
+#include "PowerControl/EthernetPowerControl.h"
+
+class HeptaBattery{
+public:
+ HeptaBattery(
+ PinName bat,
+ PinName bat_ct,
+ PinName reg_st
+ );
+ void vol(float* bt);
+ void vol_u16(char* bt_u16, int *dsize);
+ void chargecontrol(int state, int *save_flag);
+
+private:
+ AnalogIn _bat;
+ DigitalOut _bat_ct;
+ DigitalOut _reg_st;
+};
+
+#endif
\ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/hepta_sat/HeptaCamera.cpp Fri Dec 09 05:04:37 2016 +0000
@@ -0,0 +1,1311 @@
+#include "HeptaCamera.h"
+#include "mbed.h"
+
+int sizex = 0;
+int sizey = 0;
+
+#if defined(BITMAPFILE) || defined(BAYERBITMAPFILE)
+
+#define FILEHEADERSIZE 14 //ファイルヘッダのサイズ
+#define INFOHEADERSIZE 40 //情報ヘッダのサイズ
+#define HEADERSIZE (FILEHEADERSIZE+INFOHEADERSIZE)
+
+int create_header(FILE *fp, int width, int height) {
+ int real_width;
+ unsigned char header_buf[HEADERSIZE]; //ヘッダを格納する
+ unsigned int file_size;
+ unsigned int offset_to_data;
+ unsigned long info_header_size;
+ unsigned int planes;
+ unsigned int color;
+ unsigned long compress;
+ unsigned long data_size;
+ long xppm;
+ long yppm;
+
+ real_width = width*3 + width%4;
+
+ //ここからヘッダ作成
+ file_size = height * real_width + HEADERSIZE;
+ offset_to_data = HEADERSIZE;
+ info_header_size = INFOHEADERSIZE;
+ planes = 1;
+ color = 24;
+ compress = 0;
+ data_size = height * real_width;
+ xppm = 1;
+ yppm = 1;
+
+ header_buf[0] = 'B';
+ header_buf[1] = 'M';
+ memcpy(header_buf + 2, &file_size, sizeof(file_size));
+ header_buf[6] = 0;
+ header_buf[7] = 0;
+ header_buf[8] = 0;
+ header_buf[9] = 0;
+ memcpy(header_buf + 10, &offset_to_data, sizeof(offset_to_data));
+ memcpy(header_buf + 14, &info_header_size, sizeof(info_header_size));
+ memcpy(header_buf + 18, &width, sizeof(width));
+ height = height * -1; // データ格納順が逆なので、高さをマイナスとしている
+ memcpy(header_buf + 22, &height, sizeof(height));
+ memcpy(header_buf + 26, &planes, sizeof(planes));
+ memcpy(header_buf + 28, &color, sizeof(color));
+ memcpy(header_buf + 30, &compress, sizeof(compress));
+ memcpy(header_buf + 34, &data_size, sizeof(data_size));
+ memcpy(header_buf + 38, &xppm, sizeof(xppm));
+ memcpy(header_buf + 42, &yppm, sizeof(yppm));
+ header_buf[46] = 0;
+ header_buf[47] = 0;
+ header_buf[48] = 0;
+ header_buf[49] = 0;
+ header_buf[50] = 0;
+ header_buf[51] = 0;
+ header_buf[52] = 0;
+ header_buf[53] = 0;
+
+ //ヘッダの書き込み
+ fwrite(header_buf, sizeof(unsigned char), HEADERSIZE, fp);
+
+ return 0;
+}
+#endif
+
+HeptaCamera::HeptaCamera(PinName sda, PinName scl, PinName vs, PinName hr,PinName we, PinName d7, PinName d6, PinName d5, PinName d4,
+ PinName d3, PinName d2, PinName d1, PinName d0, PinName rt, PinName o, PinName rc ) : camera(sda,scl),vsync(vs),href(hr),wen(we),data(d0,d1,d2,d3,d4,d5,d6,d7),rrst(rt),oe(o),rclk(rc)
+{
+ camera.stop();
+ camera.frequency(OV7670_I2CFREQ);
+ vsync.fall(this,&HeptaCamera::VsyncHandler);
+ href.rise(this,&HeptaCamera::HrefHandler);
+ CaptureReq = false;
+ Busy = false;
+ Done = false;
+ LineCounter = 0;
+ rrst = 1;
+ oe = 1;
+ rclk = 1;
+ wen = 0;
+}
+ // capture request
+ void HeptaCamera::CaptureNext(void)
+ {
+ CaptureReq = true;
+ Busy = true;
+ }
+
+ // capture done? (with clear)
+ bool HeptaCamera::CaptureDone(void)
+ {
+ bool result;
+ if (Busy) {
+ result = false;
+ } else {
+ result = Done;
+ Done = false;
+ }
+ return result;
+ }
+
+ // write to camera
+ void HeptaCamera::WriteReg(int addr,int data)
+ {
+ // WRITE 0x42,ADDR,DATA
+ camera.start();
+ camera.write(OV7670_WRITE);
+ wait_us(OV7670_WRITEWAIT);
+ camera.write(addr);
+ wait_us(OV7670_WRITEWAIT);
+ camera.write(data);
+ camera.stop();
+ }
+
+ // read from camera
+ int HeptaCamera::ReadReg(int addr)
+ {
+ int data;
+
+ // WRITE 0x42,ADDR
+ camera.start();
+ camera.write(OV7670_WRITE);
+ wait_us(OV7670_WRITEWAIT);
+ camera.write(addr);
+ camera.stop();
+ wait_us(OV7670_WRITEWAIT);
+
+ // WRITE 0x43,READ
+ camera.start();
+ camera.write(OV7670_READ);
+ wait_us(OV7670_WRITEWAIT);
+ data = camera.read(OV7670_NOACK);
+ camera.stop();
+
+ return data;
+ }
+
+ // print register
+ void HeptaCamera::PrintRegister(void) {
+ printf("AD : +0 +1 +2 +3 +4 +5 +6 +7 +8 +9 +A +B +C +D +E +F");
+ for (int i=0;i<OV7670_REGMAX;i++) {
+ int data;
+ data = ReadReg(i); // READ REG
+ if ((i & 0x0F) == 0) {
+ printf("\r\n%02X : ",i);
+ }
+ printf("%02X ",data);
+ }
+ printf("\r\n");
+ }
+
+ void HeptaCamera::Reset(void) {
+ WriteReg(REG_COM7,COM7_RESET); // RESET CAMERA
+ wait_ms(200);
+ }
+
+ void HeptaCamera::InitForFIFOWriteReset(void) {
+ WriteReg(REG_COM10, COM10_VS_NEG);
+ }
+
+ void HeptaCamera::InitSetColorbar(void) {
+ int reg_com7 = ReadReg(REG_COM7);
+ // color bar
+ WriteReg(REG_COM17, reg_com7|COM17_CBAR);
+ }
+
+ void HeptaCamera::InitDefaultReg(void) {
+ // Gamma curve values
+ WriteReg(0x7a, 0x20);
+ WriteReg(0x7b, 0x10);
+ WriteReg(0x7c, 0x1e);
+ WriteReg(0x7d, 0x35);
+ WriteReg(0x7e, 0x5a);
+ WriteReg(0x7f, 0x69);
+ WriteReg(0x80, 0x76);
+ WriteReg(0x81, 0x80);
+ WriteReg(0x82, 0x88);
+ WriteReg(0x83, 0x8f);
+ WriteReg(0x84, 0x96);
+ WriteReg(0x85, 0xa3);
+ WriteReg(0x86, 0xaf);
+ WriteReg(0x87, 0xc4);
+ WriteReg(0x88, 0xd7);
+ WriteReg(0x89, 0xe8);
+
+ // AGC and AEC parameters. Note we start by disabling those features,
+ //then turn them only after tweaking the values.
+ WriteReg(REG_COM8, COM8_FASTAEC | COM8_AECSTEP | COM8_BFILT);
+ WriteReg(REG_GAIN, 0);
+ WriteReg(REG_AECH, 0);
+ WriteReg(REG_COM4, 0x40);
+ // magic reserved bit
+ WriteReg(REG_COM9, 0x18);
+ // 4x gain + magic rsvd bit
+ WriteReg(REG_BD50MAX, 0x05);
+ WriteReg(REG_BD60MAX, 0x07);
+ WriteReg(REG_AEW, 0x95);
+ WriteReg(REG_AEB, 0x33);
+ WriteReg(REG_VPT, 0xe3);
+ WriteReg(REG_HAECC1, 0x78);
+ WriteReg(REG_HAECC2, 0x68);
+ WriteReg(0xa1, 0x03);
+ // magic
+ WriteReg(REG_HAECC3, 0xd8);
+ WriteReg(REG_HAECC4, 0xd8);
+ WriteReg(REG_HAECC5, 0xf0);
+ WriteReg(REG_HAECC6, 0x90);
+ WriteReg(REG_HAECC7, 0x94);
+ WriteReg(REG_COM8, COM8_FASTAEC|COM8_AECSTEP|COM8_BFILT|COM8_AGC|COM8_AEC);
+
+ // Almost all of these are magic "reserved" values.
+ WriteReg(REG_COM5, 0x61);
+ WriteReg(REG_COM6, 0x4b);
+ WriteReg(0x16, 0x02);
+ WriteReg(REG_MVFP, 0x07);
+ WriteReg(0x21, 0x02);
+ WriteReg(0x22, 0x91);
+ WriteReg(0x29, 0x07);
+ WriteReg(0x33, 0x0b);
+ WriteReg(0x35, 0x0b);
+ WriteReg(0x37, 0x1d);
+ WriteReg(0x38, 0x71);
+ WriteReg(0x39, 0x2a);
+ WriteReg(REG_COM12, 0x78);
+ WriteReg(0x4d, 0x40);
+ WriteReg(0x4e, 0x20);
+ WriteReg(REG_GFIX, 0);
+ WriteReg(0x6b, 0x0a);
+ WriteReg(0x74, 0x10);
+ WriteReg(0x8d, 0x4f);
+ WriteReg(0x8e, 0);
+ WriteReg(0x8f, 0);
+ WriteReg(0x90, 0);
+ WriteReg(0x91, 0);
+ WriteReg(0x96, 0);
+ WriteReg(0x9a, 0);
+ WriteReg(0xb0, 0x84);
+ WriteReg(0xb1, 0x0c);
+ WriteReg(0xb2, 0x0e);
+ WriteReg(0xb3, 0x82);
+ WriteReg(0xb8, 0x0a);
+
+ // More reserved magic, some of which tweaks white balance
+ WriteReg(0x43, 0x0a);
+ WriteReg(0x44, 0xf0);
+ WriteReg(0x45, 0x34);
+ WriteReg(0x46, 0x58);
+ WriteReg(0x47, 0x28);
+ WriteReg(0x48, 0x3a);
+ WriteReg(0x59, 0x88);
+ WriteReg(0x5a, 0x88);
+ WriteReg(0x5b, 0x44);
+ WriteReg(0x5c, 0x67);
+ WriteReg(0x5d, 0x49);
+ WriteReg(0x5e, 0x0e);
+ WriteReg(0x6c, 0x0a);
+ WriteReg(0x6d, 0x55);
+ WriteReg(0x6e, 0x11);
+ WriteReg(0x6f, 0x9f);
+ // "9e for advance AWB"
+ WriteReg(0x6a, 0x40);
+ WriteReg(REG_BLUE, 0x40);
+ WriteReg(REG_RED, 0x60);
+ WriteReg(REG_COM8, COM8_FASTAEC|COM8_AECSTEP|COM8_BFILT|COM8_AGC|COM8_AEC|COM8_AWB);
+
+ // Matrix coefficients
+ WriteReg(0x4f, 0x80);
+ WriteReg(0x50, 0x80);
+ WriteReg(0x51, 0);
+ WriteReg(0x52, 0x22);
+ WriteReg(0x53, 0x5e);
+ WriteReg(0x54, 0x80);
+ WriteReg(0x58, 0x9e);
+
+ WriteReg(REG_COM16, COM16_AWBGAIN);
+ WriteReg(REG_EDGE, 0);
+ WriteReg(0x75, 0x05);
+ WriteReg(0x76, 0xe1);
+ WriteReg(0x4c, 0);
+ WriteReg(0x77, 0x01);
+ WriteReg(0x4b, 0x09);
+ WriteReg(0xc9, 0x60);
+ WriteReg(REG_COM16, 0x38);
+ WriteReg(0x56, 0x40);
+
+ WriteReg(0x34, 0x11);
+ WriteReg(REG_COM11, COM11_EXP|COM11_HZAUTO_ON);
+ WriteReg(0xa4, 0x88);
+ WriteReg(0x96, 0);
+ WriteReg(0x97, 0x30);
+ WriteReg(0x98, 0x20);
+ WriteReg(0x99, 0x30);
+ WriteReg(0x9a, 0x84);
+ WriteReg(0x9b, 0x29);
+ WriteReg(0x9c, 0x03);
+ WriteReg(0x9d, 0x4c);
+ WriteReg(0x9e, 0x3f);
+ WriteReg(0x78, 0x04);
+
+ // Extra-weird stuff. Some sort of multiplexor register
+ WriteReg(0x79, 0x01);
+ WriteReg(0xc8, 0xf0);
+ WriteReg(0x79, 0x0f);
+ WriteReg(0xc8, 0x00);
+ WriteReg(0x79, 0x10);
+ WriteReg(0xc8, 0x7e);
+ WriteReg(0x79, 0x0a);
+ WriteReg(0xc8, 0x80);
+ WriteReg(0x79, 0x0b);
+ WriteReg(0xc8, 0x01);
+ WriteReg(0x79, 0x0c);
+ WriteReg(0xc8, 0x0f);
+ WriteReg(0x79, 0x0d);
+ WriteReg(0xc8, 0x20);
+ WriteReg(0x79, 0x09);
+ WriteReg(0xc8, 0x80);
+ WriteReg(0x79, 0x02);
+ WriteReg(0xc8, 0xc0);
+ WriteReg(0x79, 0x03);
+ WriteReg(0xc8, 0x40);
+ WriteReg(0x79, 0x05);
+ WriteReg(0xc8, 0x30);
+ WriteReg(0x79, 0x26);
+ }
+
+ void HeptaCamera::InitRGB444(void){
+ int reg_com7 = ReadReg(REG_COM7);
+
+ WriteReg(REG_COM7, reg_com7|COM7_RGB);
+ WriteReg(REG_RGB444, RGB444_ENABLE|RGB444_XBGR);
+ WriteReg(REG_COM15, COM15_R01FE|COM15_RGB444);
+
+ WriteReg(REG_COM1, 0x40); // Magic reserved bit
+ WriteReg(REG_COM9, 0x38); // 16x gain ceiling; 0x8 is reserved bit
+ WriteReg(0x4f, 0xb3); // "matrix coefficient 1"
+ WriteReg(0x50, 0xb3); // "matrix coefficient 2"
+ WriteReg(0x51, 0x00); // vb
+ WriteReg(0x52, 0x3d); // "matrix coefficient 4"
+ WriteReg(0x53, 0xa7); // "matrix coefficient 5"
+ WriteReg(0x54, 0xe4); // "matrix coefficient 6"
+ WriteReg(REG_COM13, COM13_GAMMA|COM13_UVSAT|0x2); // Magic rsvd bit
+
+ WriteReg(REG_TSLB, 0x04);
+ }
+
+ void HeptaCamera::InitRGB555(void){
+ int reg_com7 = ReadReg(REG_COM7);
+
+ WriteReg(REG_COM7, reg_com7|COM7_RGB);
+ WriteReg(REG_RGB444, RGB444_DISABLE);
+ WriteReg(REG_COM15, COM15_RGB555|COM15_R00FF);
+
+ WriteReg(REG_TSLB, 0x04);
+
+ WriteReg(REG_COM1, 0x00);
+ WriteReg(REG_COM9, 0x38); // 16x gain ceiling; 0x8 is reserved bit
+ WriteReg(0x4f, 0xb3); // "matrix coefficient 1"
+ WriteReg(0x50, 0xb3); // "matrix coefficient 2"
+ WriteReg(0x51, 0x00); // vb
+ WriteReg(0x52, 0x3d); // "matrix coefficient 4"
+ WriteReg(0x53, 0xa7); // "matrix coefficient 5"
+ WriteReg(0x54, 0xe4); // "matrix coefficient 6"
+ WriteReg(REG_COM13, COM13_GAMMA|COM13_UVSAT);
+ }
+
+ void HeptaCamera::InitRGB565(void){
+ int reg_com7 = ReadReg(REG_COM7);
+
+ WriteReg(REG_COM7, reg_com7|COM7_RGB);
+ WriteReg(REG_RGB444, RGB444_DISABLE);
+ WriteReg(REG_COM15, COM15_R00FF|COM15_RGB565);
+
+ WriteReg(REG_TSLB, 0x04);
+
+ WriteReg(REG_COM1, 0x00);
+ WriteReg(REG_COM9, 0x38); // 16x gain ceiling; 0x8 is reserved bit
+ WriteReg(0x4f, 0xb3); // "matrix coefficient 1"
+ WriteReg(0x50, 0xb3); // "matrix coefficient 2"
+ WriteReg(0x51, 0x00); // vb
+ WriteReg(0x52, 0x3d); // "matrix coefficient 4"
+ WriteReg(0x53, 0xa7); // "matrix coefficient 5"
+ WriteReg(0x54, 0xe4); // "matrix coefficient 6"
+ WriteReg(REG_COM13, COM13_GAMMA|COM13_UVSAT);
+ }
+
+ void HeptaCamera::InitYUV(void){
+ int reg_com7 = ReadReg(REG_COM7);
+
+ WriteReg(REG_COM7, reg_com7|COM7_YUV);
+ WriteReg(REG_RGB444, RGB444_DISABLE);
+ WriteReg(REG_COM15, COM15_R00FF);
+
+ WriteReg(REG_TSLB, 0x04);
+// WriteReg(REG_TSLB, 0x14);
+// WriteReg(REG_MANU, 0x00);
+// WriteReg(REG_MANV, 0x00);
+
+ WriteReg(REG_COM1, 0x00);
+ WriteReg(REG_COM9, 0x18); // 4x gain ceiling; 0x8 is reserved bit
+ WriteReg(0x4f, 0x80); // "matrix coefficient 1"
+ WriteReg(0x50, 0x80); // "matrix coefficient 2"
+ WriteReg(0x51, 0x00); // vb
+ WriteReg(0x52, 0x22); // "matrix coefficient 4"
+ WriteReg(0x53, 0x5e); // "matrix coefficient 5"
+ WriteReg(0x54, 0x80); // "matrix coefficient 6"
+ WriteReg(REG_COM13, COM13_GAMMA|COM13_UVSAT|COM13_UVSWAP);
+ }
+
+ void HeptaCamera::InitBayerRGB(void){
+ int reg_com7 = ReadReg(REG_COM7);
+
+ // odd line BGBG... even line GRGR...
+ WriteReg(REG_COM7, reg_com7|COM7_BAYER);
+ // odd line GBGB... even line RGRG...
+ //WriteReg(REG_COM7, reg_com7|COM7_PBAYER);
+
+ WriteReg(REG_RGB444, RGB444_DISABLE);
+ WriteReg(REG_COM15, COM15_R00FF);
+
+ WriteReg(REG_COM13, 0x08); /* No gamma, magic rsvd bit */
+ WriteReg(REG_COM16, 0x3d); /* Edge enhancement, denoise */
+ WriteReg(REG_REG76, 0xe1); /* Pix correction, magic rsvd */
+
+ WriteReg(REG_TSLB, 0x04);
+ }
+
+ void HeptaCamera::InitVGA(void) {
+ // VGA
+ int reg_com7 = ReadReg(REG_COM7);
+
+ WriteReg(REG_COM7,reg_com7|COM7_VGA);
+
+ WriteReg(REG_HSTART,HSTART_VGA);
+ WriteReg(REG_HSTOP,HSTOP_VGA);
+ WriteReg(REG_HREF,HREF_VGA);
+ WriteReg(REG_VSTART,VSTART_VGA);
+ WriteReg(REG_VSTOP,VSTOP_VGA);
+ WriteReg(REG_VREF,VREF_VGA);
+ WriteReg(REG_COM3, COM3_VGA);
+ WriteReg(REG_COM14, COM14_VGA);
+ WriteReg(REG_SCALING_XSC, SCALING_XSC_VGA);
+ WriteReg(REG_SCALING_YSC, SCALING_YSC_VGA);
+ WriteReg(REG_SCALING_DCWCTR, SCALING_DCWCTR_VGA);
+ WriteReg(REG_SCALING_PCLK_DIV, SCALING_PCLK_DIV_VGA);
+ WriteReg(REG_SCALING_PCLK_DELAY, SCALING_PCLK_DELAY_VGA);
+ }
+
+ void HeptaCamera::InitFIFO_2bytes_color_nealy_limit_size(void) {
+ // nealy FIFO limit 544x360
+ int reg_com7 = ReadReg(REG_COM7);
+
+ WriteReg(REG_COM7,reg_com7|COM7_VGA);
+
+ WriteReg(REG_HSTART,HSTART_VGA);
+ WriteReg(REG_HSTOP,HSTOP_VGA);
+ WriteReg(REG_HREF,HREF_VGA);
+ WriteReg(REG_VSTART,VSTART_VGA);
+ WriteReg(REG_VSTOP,VSTOP_VGA);
+ WriteReg(REG_VREF,VREF_VGA);
+ WriteReg(REG_COM3, COM3_VGA);
+ WriteReg(REG_COM14, COM14_VGA);
+ WriteReg(REG_SCALING_XSC, SCALING_XSC_VGA);
+ WriteReg(REG_SCALING_YSC, SCALING_YSC_VGA);
+ WriteReg(REG_SCALING_DCWCTR, SCALING_DCWCTR_VGA);
+ WriteReg(REG_SCALING_PCLK_DIV, SCALING_PCLK_DIV_VGA);
+ WriteReg(REG_SCALING_PCLK_DELAY, SCALING_PCLK_DELAY_VGA);
+
+ WriteReg(REG_HSTART, 0x17);
+ WriteReg(REG_HSTOP, 0x5b);
+ WriteReg(REG_VSTART, 0x12);
+ WriteReg(REG_VSTOP, 0x6c);
+ }
+
+ void HeptaCamera::InitVGA_3_4(void) {
+ // VGA 3/4 -> 480x360
+ int reg_com7 = ReadReg(REG_COM7);
+
+ WriteReg(REG_COM7,reg_com7|COM7_VGA);
+
+ WriteReg(REG_HSTART,HSTART_VGA);
+ WriteReg(REG_HSTOP,HSTOP_VGA);
+ WriteReg(REG_HREF,HREF_VGA);
+ WriteReg(REG_VSTART,VSTART_VGA);
+ WriteReg(REG_VSTOP,VSTOP_VGA);
+ WriteReg(REG_VREF,VREF_VGA);
+ WriteReg(REG_COM3, COM3_VGA);
+ WriteReg(REG_COM14, COM14_VGA);
+ WriteReg(REG_SCALING_XSC, SCALING_XSC_VGA);
+ WriteReg(REG_SCALING_YSC, SCALING_YSC_VGA);
+ WriteReg(REG_SCALING_DCWCTR, SCALING_DCWCTR_VGA);
+ WriteReg(REG_SCALING_PCLK_DIV, SCALING_PCLK_DIV_VGA);
+ WriteReg(REG_SCALING_PCLK_DELAY, SCALING_PCLK_DELAY_VGA);
+
+ WriteReg(REG_HSTART, 0x1b);
+ WriteReg(REG_HSTOP, 0x57);
+ WriteReg(REG_VSTART, 0x12);
+ WriteReg(REG_VSTOP, 0x6c);
+ }
+
+ void HeptaCamera::InitQVGA(void) {
+ // QQVGA
+ int reg_com7 = ReadReg(REG_COM7);
+
+ WriteReg(REG_COM7,reg_com7|COM7_QVGA);
+
+ WriteReg(REG_HSTART,HSTART_QVGA);
+ WriteReg(REG_HSTOP,HSTOP_QVGA);
+ WriteReg(REG_HREF,HREF_QVGA);
+ WriteReg(REG_VSTART,VSTART_QVGA);
+ WriteReg(REG_VSTOP,VSTOP_QVGA);
+ WriteReg(REG_VREF,VREF_QVGA);
+ WriteReg(REG_COM3, COM3_QVGA);
+ WriteReg(REG_COM14, COM14_QVGA);
+ WriteReg(REG_SCALING_XSC, SCALING_XSC_QVGA);
+ WriteReg(REG_SCALING_YSC, SCALING_YSC_QVGA);
+ WriteReg(REG_SCALING_DCWCTR, SCALING_DCWCTR_QVGA);
+ WriteReg(REG_SCALING_PCLK_DIV, SCALING_PCLK_DIV_QVGA);
+ WriteReg(REG_SCALING_PCLK_DELAY, SCALING_PCLK_DELAY_QVGA);
+ }
+
+ void HeptaCamera::InitQQVGA(void) {
+ // QQVGA
+ int reg_com7 = ReadReg(REG_COM7);
+
+ WriteReg(REG_COM7,reg_com7|COM7_QQVGA);
+
+ WriteReg(REG_HSTART,HSTART_QQVGA);
+ WriteReg(REG_HSTOP,HSTOP_QQVGA);
+ WriteReg(REG_HREF,HREF_QQVGA);
+ WriteReg(REG_VSTART,VSTART_QQVGA);
+ WriteReg(REG_VSTOP,VSTOP_QQVGA);
+ WriteReg(REG_VREF,VREF_QQVGA);
+ WriteReg(REG_COM3, COM3_QQVGA);
+ WriteReg(REG_COM14, COM14_QQVGA);
+ WriteReg(REG_SCALING_XSC, SCALING_XSC_QQVGA);
+ WriteReg(REG_SCALING_YSC, SCALING_YSC_QQVGA);
+ WriteReg(REG_SCALING_DCWCTR, SCALING_DCWCTR_QQVGA);
+ WriteReg(REG_SCALING_PCLK_DIV, SCALING_PCLK_DIV_QQVGA);
+ WriteReg(REG_SCALING_PCLK_DELAY, SCALING_PCLK_DELAY_QQVGA);
+ }
+
+ // vsync handler
+ void HeptaCamera::VsyncHandler(void)
+ {
+ // Capture Enable
+ if (CaptureReq) {
+ wen = 1;
+ Done = false;
+ CaptureReq = false;
+ } else {
+ wen = 0;
+ if (Busy) {
+ Busy = false;
+ Done = true;
+ }
+ }
+
+ // Hline Counter
+ LastLines = LineCounter;
+ LineCounter = 0;
+ }
+
+ // href handler
+ void HeptaCamera::HrefHandler(void)
+ {
+ LineCounter++;
+ }
+
+ // Data Read
+ int HeptaCamera::ReadOneByte(void)
+ {
+ int result;
+ rclk = 1;
+// wait_us(1);
+ result = data;
+ rclk = 0;
+ return result;
+ }
+
+ // Data Start
+ void HeptaCamera::ReadStart(void)
+ {
+ rrst = 0;
+ oe = 0;
+ wait_us(1);
+ rclk = 0;
+ wait_us(1);
+ rclk = 1;
+ wait_us(1);
+ rrst = 1;
+ }
+
+ // Data Stop
+ void HeptaCamera::ReadStop(void)
+ {
+ oe = 1;
+ ReadOneByte();
+ rclk = 1;
+ }
+
+void HeptaCamera::shoot()
+{
+ //pc.baud(115200);
+
+ //pc.printf("Camera resetting..\r\n");
+ HeptaCamera::Reset();
+
+ //pc.printf("Before Init...\r\n");
+ HeptaCamera::PrintRegister();
+ char color_format = '1';
+ /*pc.printf("Select color format.\r\n") ;
+ pc.printf("1: RGB444.\r\n");
+ pc.printf("2: RGB555.\r\n");
+ pc.printf("3: RGB565.\r\n");
+ pc.printf("4: YUV(UYVY).\r\n");
+ pc.printf("5: Bayer RGB(BGBG... GRGR...).\r\n");*/
+
+ /*while(!pc.readable());
+ char color_format = pc.getc();
+ switch (color_format) {
+ case '1':
+ camera.InitRGB444();
+ break;
+ case '2':
+ camera.InitRGB555();
+ break;
+ case '3':
+ camera.InitRGB565();
+ break;
+ case '4':
+ camera.InitYUV();
+ break;
+ case '5':
+ camera.InitBayerRGB();
+ break;
+ }
+ pc.printf("select %c\r\n", color_format);
+
+ pc.printf("Select screen size.\r\n") ;
+ switch (color_format) {
+ case '5':
+ pc.printf("1: VGA(640x480).\r\n");
+ case '1':
+ case '2':
+ case '3':
+ case '4':
+ pc.printf("2: FIFO nealy limit(544x360).\r\n");
+ pc.printf("3: VGA*3/4(480x360).\r\n");
+ pc.printf("4: QVGA(320x240).\r\n");
+ pc.printf("5: QQVGA(160x120).\r\n");
+ break;
+ }
+ char screen_size = 4;
+ while(!pc.readable());
+ char screen_size = pc.getc() ;
+ switch (screen_size) {
+ case '1':
+ sizex = 640;
+ sizey = 480;
+ camera.InitVGA();
+ break;
+ case '2':
+ sizex = 544;
+ sizey = 360;
+ camera.InitFIFO_2bytes_color_nealy_limit_size();
+ break;
+ case '3':
+ sizex = 480;
+ sizey = 360;
+ camera.InitVGA_3_4();
+ break;
+ case '4':
+ sizex = 320;
+ sizey = 240;
+ camera.InitQVGA();
+ break;
+ case '5':
+ sizex = 160;
+ sizey = 120;
+ camera.InitQQVGA();
+ break;
+ }
+ pc.printf("select %c\r\n", screen_size);*/
+ char screen_size = '4';
+ HeptaCamera::InitRGB444();
+ sizex = 320;
+ sizey = 240;
+ HeptaCamera::InitQVGA();
+ HeptaCamera::InitForFIFOWriteReset();
+ HeptaCamera::InitDefaultReg();
+
+#ifdef COLORBAR
+ HeptaCamera::InitSetColorbar();
+#endif
+
+ //pc.printf("After Init...\r\n");
+ HeptaCamera::PrintRegister();
+
+ // CAPTURE and SEND LOOP
+
+#if defined(BITMAPFILE) || defined(BAYERBITMAPFILE) || defined(HEXFILE)
+ //pc.printf("Hit Any Key %dx%d Capture Data.\r\n", sizex, sizey) ;
+ //while(!pc.readable());
+ //pc.printf("*\r\n");
+ //pc.getc();
+
+ int real_width = sizex*3 + sizey%4;
+
+ unsigned char *bmp_line_data; //画像1行分のRGB情報を格納する
+ if((bmp_line_data = (unsigned char *)malloc(sizeof(unsigned char)*real_width)) == NULL){
+ fprintf(stderr, "Error: Allocation error.\n");
+ //return 1;
+ }
+
+ //RGB情報を4バイトの倍数に合わせている
+ for(int i=sizex*3; i<real_width; i++){
+ bmp_line_data[i] = 0;
+ }
+#endif
+#if defined(BITMAPFILE) || defined(BAYERBITMAPFILE)
+ FILE *fp;
+ char *filename = "/local/test.bmp";
+ if((fp = fopen(filename, "wb")) == NULL){
+ //pc.printf("Error: %s could not open.", filename);
+ //return 1;
+ }
+
+ create_header(fp, sizex, sizey);
+#endif
+#ifdef HEXFILE
+ FILE *fp2;
+ char *filename2 = "/local/test.txt";
+ if((fp2 = fopen(filename2, "w")) == NULL){
+ pc.printf("Error: %s could not open.", filename2);
+ return 1;
+ }
+#endif
+
+ HeptaCamera::CaptureNext();
+ while(HeptaCamera::CaptureDone() == false);
+ HeptaCamera::ReadStart();
+
+ int r=0, g=0, b=0, d1, d2;
+
+ switch (color_format) {
+ case '1':
+ case '2':
+ case '3':
+
+ for (int y=0; y<sizey; y++) {
+ for (int x=0; x<sizex; x++) {
+ d1 = HeptaCamera::ReadOneByte();
+ d2 = HeptaCamera::ReadOneByte();
+
+ switch (color_format) {
+ case '1':
+ // RGB444 to RGB888
+ b = (d1 & 0x0F) << 4;
+ g = (d2 & 0xF0);
+ r = (d2 & 0x0F) << 4;
+ break;
+ case '2':
+ // RGB555 to RGB888
+ b = (d1 & 0x1F) << 3;
+ g = (((d1 & 0xE0) >> 2) | ((d2 & 0x03) << 6));
+ r = (d2 & 0x7c) << 1;
+ break;
+ case '3':
+ // RGB565 to RGB888
+ b = (d1 & 0x1F) << 3;
+ g = (((d1 & 0xE0) >> 3) | ((d2 & 0x07) << 5));
+ r = (d2 & 0xF8);
+ break;
+ }
+#if defined(BITMAPFILE) || defined(HEXFILE)
+ bmp_line_data[x*3] = (unsigned char)b;
+ bmp_line_data[x*3 + 1] = (unsigned char)g;
+ bmp_line_data[x*3 + 2] = (unsigned char)r;
+#endif
+/*
+ // RGB
+ pc.printf ("%2X%2X%2X", r, g, b) ;
+*/
+ }
+#ifdef BITMAPFILE
+ fwrite(bmp_line_data, sizeof(unsigned char), real_width, fp);
+#endif
+#ifdef HEXFILE
+ for(int i=0; i<sizex*3; i++){
+ fprintf(fp2, "%02X", bmp_line_data[i]);
+ }
+#endif
+// pc.printf("\r\n") ;
+ }
+ break;
+
+ case '4':
+ int index = 0;
+ for (int y=0; y<sizey; y++) {
+ int U0=0, Y0=0, V0=0, Y1=0;
+ for (int x=0; x<sizex; x++) {
+ if(index%2 == 0) {
+ U0 = HeptaCamera::ReadOneByte();
+ Y0 = HeptaCamera::ReadOneByte();
+ V0 = HeptaCamera::ReadOneByte();
+ Y1 = HeptaCamera::ReadOneByte();
+
+ b = Y0 + 1.77200 * (U0 - 128);
+ g = Y0 - 0.34414 * (U0 - 128) - 0.71414 * (V0 - 128);
+ r = Y0 + 1.40200 * (V0 - 128);
+ } else {
+ b = Y1 + 1.77200 * (U0 - 128);
+ g = Y1 - 0.34414 * (U0 - 128) - 0.71414 * (V0 - 128);
+ r = Y1 + 1.40200 * (V0 - 128);
+ }
+
+ b = min(max(b, 0), 255);
+ g = min(max(g, 0), 255);
+ r = min(max(r, 0), 255);
+
+#if defined(BITMAPFILE) || defined(HEXFILE)
+ bmp_line_data[x*3] = (unsigned char)b;
+ bmp_line_data[x*3 + 1] = (unsigned char)g;
+ bmp_line_data[x*3 + 2] = (unsigned char)r;
+#endif
+/*
+ // RGB
+ pc.printf ("%2X%2X%2X", r, g, b) ;
+*/
+ index++;
+ }
+#ifdef BITMAPFILE
+ fwrite(bmp_line_data, sizeof(unsigned char), real_width, fp);
+#endif
+#ifdef HEXFILE
+ for(int i=0; i<sizex*3; i++){
+ fprintf(fp2, "%02X", bmp_line_data[i]);
+ }
+#endif
+// pc.printf("\r\n") ;
+ }
+ break;
+
+ case '5':
+ unsigned char *bayer_line[2];
+ unsigned char *bayer_line_data[2]; //画像1行分のRGB情報を格納する2行分
+ for(int i=0; i<2; i++) {
+ if((bayer_line_data[i] = (unsigned char *)malloc(sizeof(unsigned char)*sizex)) == NULL){
+ fprintf(stderr, "Error: Allocation error.\n");
+ //return 1;
+ }
+ }
+
+ for (int x=0; x<sizex; x++) {
+ // odd line BGBG... even line GRGR...
+ bayer_line_data[0][x] = (unsigned char)HeptaCamera::ReadOneByte();
+#ifdef BAYERBITMAPFILE
+ bmp_line_data[x*3] = (unsigned char)bayer_line_data[0][x];
+ bmp_line_data[x*3 + 1] = (unsigned char)bayer_line_data[0][x];
+ bmp_line_data[x*3 + 2] = (unsigned char)bayer_line_data[0][x];
+#endif
+ }
+#ifdef BAYERBITMAPFILE
+ fwrite(bmp_line_data, sizeof(unsigned char), real_width, fp);
+#endif
+ bayer_line[1] = bayer_line_data[0];
+
+ for (int y=1; y<sizey; y++) {
+ int line = y%2;
+
+ for (int x=0; x<sizex; x++) {
+ // odd line BGBG... even line GRGR...
+ bayer_line_data[line][x] = (unsigned char)HeptaCamera::ReadOneByte();
+#ifdef BAYERBITMAPFILE
+ bmp_line_data[x*3] = (unsigned char)bayer_line_data[line][x];
+ bmp_line_data[x*3 + 1] = (unsigned char)bayer_line_data[line][x];
+ bmp_line_data[x*3 + 2] = (unsigned char)bayer_line_data[line][x];
+#endif
+ }
+#ifdef BAYERBITMAPFILE
+ fwrite(bmp_line_data, sizeof(unsigned char), real_width, fp);
+#endif
+ bayer_line[0] = bayer_line[1];
+ bayer_line[1] = bayer_line_data[line];
+
+ for (int x=0; x<sizex - 1; x++) {
+ if(y%2==1) {
+ if(x%2==0) {
+ // BG
+ // GR
+ b = bayer_line[0][x];
+ g = ((int)bayer_line[0][x+1] + bayer_line[1][x])>>1;
+ r = bayer_line[1][x+1];
+ } else {
+ // GB
+ // RG
+ b = bayer_line[0][x+1];
+ g = ((int)bayer_line[0][x] + bayer_line[1][x+1])>>1;
+ r = bayer_line[1][x];
+ }
+ } else {
+ if(x%2==0) {
+ // GR
+ // BG
+ b = bayer_line[1][x];
+ g = ((int)bayer_line[0][x] + bayer_line[1][x+1])>>1;
+ r = bayer_line[0][x+1];
+ } else {
+ // RG
+ // GB
+ b = bayer_line[1][x+1];
+ g = ((int)bayer_line[0][x+1] + bayer_line[1][x])>>1;
+ r = bayer_line[0][x];
+ }
+ }
+#if defined(BITMAPFILE) || defined(HEXFILE)
+ bmp_line_data[x*3] = (unsigned char)b;
+ bmp_line_data[x*3 + 1] = (unsigned char)g;
+ bmp_line_data[x*3 + 2] = (unsigned char)r;
+#endif
+ }
+
+#ifdef BITMAPFILE
+ fwrite(bmp_line_data, sizeof(unsigned char), real_width, fp);
+#endif
+
+#ifdef HEXFILE
+ for(int i=0; i<sizex*3; i++){
+ fprintf(fp2, "%02X", bmp_line_data[i]);
+ }
+#endif
+ }
+
+ for(int i=0; i<2; i++) {
+ free(bayer_line_data[i]);
+ }
+#ifdef BITMAPFILE
+ fwrite(bmp_line_data, sizeof(unsigned char), real_width, fp);
+#endif
+ break;
+ }
+ HeptaCamera::ReadStop();
+
+#if defined(BITMAPFILE) || defined(BAYERBITMAPFILE)
+ free(bmp_line_data);
+ fclose(fp);
+#endif
+#ifdef HEXFILE
+ fclose(fp2);
+#endif
+
+}
+
+void HeptaCamera::shoot2()
+{
+ //pc.baud(115200);
+
+ //pc.printf("Camera resetting..\r\n");
+ HeptaCamera::Reset();
+
+ //pc.printf("Before Init...\r\n");
+ HeptaCamera::PrintRegister();
+ char color_format = '1';
+ /*pc.printf("Select color format.\r\n") ;
+ pc.printf("1: RGB444.\r\n");
+ pc.printf("2: RGB555.\r\n");
+ pc.printf("3: RGB565.\r\n");
+ pc.printf("4: YUV(UYVY).\r\n");
+ pc.printf("5: Bayer RGB(BGBG... GRGR...).\r\n");*/
+
+ /*while(!pc.readable());
+ char color_format = pc.getc();
+ switch (color_format) {
+ case '1':
+ camera.InitRGB444();
+ break;
+ case '2':
+ camera.InitRGB555();
+ break;
+ case '3':
+ camera.InitRGB565();
+ break;
+ case '4':
+ camera.InitYUV();
+ break;
+ case '5':
+ camera.InitBayerRGB();
+ break;
+ }
+ pc.printf("select %c\r\n", color_format);
+
+ pc.printf("Select screen size.\r\n") ;
+ switch (color_format) {
+ case '5':
+ pc.printf("1: VGA(640x480).\r\n");
+ case '1':
+ case '2':
+ case '3':
+ case '4':
+ pc.printf("2: FIFO nealy limit(544x360).\r\n");
+ pc.printf("3: VGA*3/4(480x360).\r\n");
+ pc.printf("4: QVGA(320x240).\r\n");
+ pc.printf("5: QQVGA(160x120).\r\n");
+ break;
+ }
+ char screen_size = 4;
+ while(!pc.readable());
+ char screen_size = pc.getc() ;
+ switch (screen_size) {
+ case '1':
+ sizex = 640;
+ sizey = 480;
+ camera.InitVGA();
+ break;
+ case '2':
+ sizex = 544;
+ sizey = 360;
+ camera.InitFIFO_2bytes_color_nealy_limit_size();
+ break;
+ case '3':
+ sizex = 480;
+ sizey = 360;
+ camera.InitVGA_3_4();
+ break;
+ case '4':
+ sizex = 320;
+ sizey = 240;
+ camera.InitQVGA();
+ break;
+ case '5':
+ sizex = 160;
+ sizey = 120;
+ camera.InitQQVGA();
+ break;
+ }
+ pc.printf("select %c\r\n", screen_size);*/
+ char screen_size = '4';
+ HeptaCamera::InitRGB444();
+ sizex = 320;
+ sizey = 240;
+ HeptaCamera::InitQVGA();
+ HeptaCamera::InitForFIFOWriteReset();
+ HeptaCamera::InitDefaultReg();
+
+#ifdef COLORBAR
+ HeptaCamera::InitSetColorbar();
+#endif
+
+ //pc.printf("After Init...\r\n");
+ HeptaCamera::PrintRegister();
+
+ // CAPTURE and SEND LOOP
+
+#if defined(BITMAPFILE) || defined(BAYERBITMAPFILE) || defined(HEXFILE)
+ //pc.printf("Hit Any Key %dx%d Capture Data.\r\n", sizex, sizey) ;
+ //while(!pc.readable());
+ //pc.printf("*\r\n");
+ //pc.getc();
+
+ int real_width = sizex*3 + sizey%4;
+
+ unsigned char *bmp_line_data; //画像1行分のRGB情報を格納する
+ if((bmp_line_data = (unsigned char *)malloc(sizeof(unsigned char)*real_width)) == NULL){
+ fprintf(stderr, "Error: Allocation error.\n");
+ //return 1;
+ }
+
+ //RGB情報を4バイトの倍数に合わせている
+ for(int i=sizex*3; i<real_width; i++){
+ bmp_line_data[i] = 0;
+ }
+#endif
+#if defined(BITMAPFILE) || defined(BAYERBITMAPFILE)
+ mkdir("/sd/mydir", 0777);
+ FILE *fp = fopen("/sd/mydir/picture.bmp","w");
+ if(fp == NULL) {
+ error("Could not open file for write\r\n");
+ }
+
+ create_header(fp, sizex, sizey);
+#endif
+#ifdef HEXFILE
+ FILE *fp2;
+ char *filename2 = "/local/test.txt";
+ if((fp2 = fopen(filename2, "w")) == NULL){
+ pc.printf("Error: %s could not open.", filename2);
+ return 1;
+ }
+#endif
+
+ HeptaCamera::CaptureNext();
+ while(HeptaCamera::CaptureDone() == false);
+ HeptaCamera::ReadStart();
+
+ int r=0, g=0, b=0, d1, d2;
+
+ switch (color_format) {
+ case '1':
+ case '2':
+ case '3':
+
+ for (int y=0; y<sizey; y++) {
+ for (int x=0; x<sizex; x++) {
+ d1 = HeptaCamera::ReadOneByte();
+ d2 = HeptaCamera::ReadOneByte();
+
+ switch (color_format) {
+ case '1':
+ // RGB444 to RGB888
+ b = (d1 & 0x0F) << 4;
+ g = (d2 & 0xF0);
+ r = (d2 & 0x0F) << 4;
+ break;
+ case '2':
+ // RGB555 to RGB888
+ b = (d1 & 0x1F) << 3;
+ g = (((d1 & 0xE0) >> 2) | ((d2 & 0x03) << 6));
+ r = (d2 & 0x7c) << 1;
+ break;
+ case '3':
+ // RGB565 to RGB888
+ b = (d1 & 0x1F) << 3;
+ g = (((d1 & 0xE0) >> 3) | ((d2 & 0x07) << 5));
+ r = (d2 & 0xF8);
+ break;
+ }
+#if defined(BITMAPFILE) || defined(HEXFILE)
+ bmp_line_data[x*3] = (unsigned char)b;
+ bmp_line_data[x*3 + 1] = (unsigned char)g;
+ bmp_line_data[x*3 + 2] = (unsigned char)r;
+#endif
+/*
+ // RGB
+ pc.printf ("%2X%2X%2X", r, g, b) ;
+*/
+ }
+#ifdef BITMAPFILE
+ fwrite(bmp_line_data, sizeof(unsigned char), real_width, fp);
+#endif
+#ifdef HEXFILE
+ for(int i=0; i<sizex*3; i++){
+ fprintf(fp2, "%02X", bmp_line_data[i]);
+ }
+#endif
+// pc.printf("\r\n") ;
+ }
+ break;
+
+ case '4':
+ int index = 0;
+ for (int y=0; y<sizey; y++) {
+ int U0=0, Y0=0, V0=0, Y1=0;
+ for (int x=0; x<sizex; x++) {
+ if(index%2 == 0) {
+ U0 = HeptaCamera::ReadOneByte();
+ Y0 = HeptaCamera::ReadOneByte();
+ V0 = HeptaCamera::ReadOneByte();
+ Y1 = HeptaCamera::ReadOneByte();
+
+ b = Y0 + 1.77200 * (U0 - 128);
+ g = Y0 - 0.34414 * (U0 - 128) - 0.71414 * (V0 - 128);
+ r = Y0 + 1.40200 * (V0 - 128);
+ } else {
+ b = Y1 + 1.77200 * (U0 - 128);
+ g = Y1 - 0.34414 * (U0 - 128) - 0.71414 * (V0 - 128);
+ r = Y1 + 1.40200 * (V0 - 128);
+ }
+
+ b = min(max(b, 0), 255);
+ g = min(max(g, 0), 255);
+ r = min(max(r, 0), 255);
+
+#if defined(BITMAPFILE) || defined(HEXFILE)
+ bmp_line_data[x*3] = (unsigned char)b;
+ bmp_line_data[x*3 + 1] = (unsigned char)g;
+ bmp_line_data[x*3 + 2] = (unsigned char)r;
+#endif
+/*
+ // RGB
+ pc.printf ("%2X%2X%2X", r, g, b) ;
+*/
+ index++;
+ }
+#ifdef BITMAPFILE
+ fwrite(bmp_line_data, sizeof(unsigned char), real_width, fp);
+#endif
+#ifdef HEXFILE
+ for(int i=0; i<sizex*3; i++){
+ fprintf(fp2, "%02X", bmp_line_data[i]);
+ }
+#endif
+// pc.printf("\r\n") ;
+ }
+ break;
+
+ case '5':
+ unsigned char *bayer_line[2];
+ unsigned char *bayer_line_data[2]; //画像1行分のRGB情報を格納する2行分
+ for(int i=0; i<2; i++) {
+ if((bayer_line_data[i] = (unsigned char *)malloc(sizeof(unsigned char)*sizex)) == NULL){
+ fprintf(stderr, "Error: Allocation error.\n");
+ //return 1;
+ }
+ }
+
+ for (int x=0; x<sizex; x++) {
+ // odd line BGBG... even line GRGR...
+ bayer_line_data[0][x] = (unsigned char)HeptaCamera::ReadOneByte();
+#ifdef BAYERBITMAPFILE
+ bmp_line_data[x*3] = (unsigned char)bayer_line_data[0][x];
+ bmp_line_data[x*3 + 1] = (unsigned char)bayer_line_data[0][x];
+ bmp_line_data[x*3 + 2] = (unsigned char)bayer_line_data[0][x];
+#endif
+ }
+#ifdef BAYERBITMAPFILE
+ fwrite(bmp_line_data, sizeof(unsigned char), real_width, fp);
+#endif
+ bayer_line[1] = bayer_line_data[0];
+
+ for (int y=1; y<sizey; y++) {
+ int line = y%2;
+
+ for (int x=0; x<sizex; x++) {
+ // odd line BGBG... even line GRGR...
+ bayer_line_data[line][x] = (unsigned char)HeptaCamera::ReadOneByte();
+#ifdef BAYERBITMAPFILE
+ bmp_line_data[x*3] = (unsigned char)bayer_line_data[line][x];
+ bmp_line_data[x*3 + 1] = (unsigned char)bayer_line_data[line][x];
+ bmp_line_data[x*3 + 2] = (unsigned char)bayer_line_data[line][x];
+#endif
+ }
+#ifdef BAYERBITMAPFILE
+ fwrite(bmp_line_data, sizeof(unsigned char), real_width, fp);
+#endif
+ bayer_line[0] = bayer_line[1];
+ bayer_line[1] = bayer_line_data[line];
+
+ for (int x=0; x<sizex - 1; x++) {
+ if(y%2==1) {
+ if(x%2==0) {
+ // BG
+ // GR
+ b = bayer_line[0][x];
+ g = ((int)bayer_line[0][x+1] + bayer_line[1][x])>>1;
+ r = bayer_line[1][x+1];
+ } else {
+ // GB
+ // RG
+ b = bayer_line[0][x+1];
+ g = ((int)bayer_line[0][x] + bayer_line[1][x+1])>>1;
+ r = bayer_line[1][x];
+ }
+ } else {
+ if(x%2==0) {
+ // GR
+ // BG
+ b = bayer_line[1][x];
+ g = ((int)bayer_line[0][x] + bayer_line[1][x+1])>>1;
+ r = bayer_line[0][x+1];
+ } else {
+ // RG
+ // GB
+ b = bayer_line[1][x+1];
+ g = ((int)bayer_line[0][x+1] + bayer_line[1][x])>>1;
+ r = bayer_line[0][x];
+ }
+ }
+#if defined(BITMAPFILE) || defined(HEXFILE)
+ bmp_line_data[x*3] = (unsigned char)b;
+ bmp_line_data[x*3 + 1] = (unsigned char)g;
+ bmp_line_data[x*3 + 2] = (unsigned char)r;
+#endif
+ }
+
+#ifdef BITMAPFILE
+ fwrite(bmp_line_data, sizeof(unsigned char), real_width, fp);
+#endif
+
+#ifdef HEXFILE
+ for(int i=0; i<sizex*3; i++){
+ fprintf(fp2, "%02X", bmp_line_data[i]);
+ }
+#endif
+ }
+
+ for(int i=0; i<2; i++) {
+ free(bayer_line_data[i]);
+ }
+#ifdef BITMAPFILE
+ fwrite(bmp_line_data, sizeof(unsigned char), real_width, fp);
+#endif
+ break;
+ }
+ HeptaCamera::ReadStop();
+
+#if defined(BITMAPFILE) || defined(BAYERBITMAPFILE)
+ free(bmp_line_data);
+ fclose(fp);
+#endif
+#ifdef HEXFILE
+ fclose(fp2);
+#endif
+
+}
\ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/hepta_sat/HeptaCamera.h Fri Dec 09 05:04:37 2016 +0000
@@ -0,0 +1,335 @@
+#define BITMAPFILE
+#undef BAYERBITMAPFILE
+#undef HEXFILE
+#undef COLORBAR
+#include <algorithm>
+
+#ifndef MBED_HEPTACAMERA_H
+#define MBED_HEPTACAMERA_H
+#include "mbed.h"
+
+// size register
+#define REG_COM7 0x12 /* Control 7 */
+#define REG_HSTART 0x17 /* Horiz start high bits */
+#define REG_HSTOP 0x18 /* Horiz stop high bits */
+#define REG_HREF 0x32 /* HREF pieces */
+#define REG_VSTART 0x19 /* Vert start high bits */
+#define REG_VSTOP 0x1a /* Vert stop high bits */
+#define REG_VREF 0x03 /* Pieces of GAIN, VSTART, VSTOP */
+#define REG_COM3 0x0c /* Control 3 */
+#define REG_COM14 0x3e /* Control 14 */
+#define REG_SCALING_XSC 0x70
+#define REG_SCALING_YSC 0x71
+#define REG_SCALING_DCWCTR 0x72
+#define REG_SCALING_PCLK_DIV 0x73
+#define REG_SCALING_PCLK_DELAY 0xa2
+
+// VGA setting
+#define COM7_VGA 0x00
+#define HSTART_VGA 0x13
+#define HSTOP_VGA 0x01
+#define HREF_VGA 0x36 //0xb6 0x36
+#define VSTART_VGA 0x02
+#define VSTOP_VGA 0x7a
+#define VREF_VGA 0x0a
+#define COM3_VGA 0x00
+#define COM14_VGA 0x00
+#define SCALING_XSC_VGA 0x3a
+#define SCALING_YSC_VGA 0x35
+#define SCALING_DCWCTR_VGA 0x11
+#define SCALING_PCLK_DIV_VGA 0xf0
+#define SCALING_PCLK_DELAY_VGA 0x02
+
+// QVGA setting
+#define COM7_QVGA 0x00
+#define HSTART_QVGA 0x16
+#define HSTOP_QVGA 0x04
+#define HREF_QVGA 0x00
+#define VSTART_QVGA 0x02
+#define VSTOP_QVGA 0x7a
+#define VREF_QVGA 0x0a
+#define COM3_QVGA 0x04
+#define COM14_QVGA 0x19
+#define SCALING_XSC_QVGA 0x3a
+#define SCALING_YSC_QVGA 0x35
+#define SCALING_DCWCTR_QVGA 0x11
+#define SCALING_PCLK_DIV_QVGA 0xf1
+#define SCALING_PCLK_DELAY_QVGA 0x02
+
+// QQVGA setting
+#define COM7_QQVGA 0x00
+#define HSTART_QQVGA 0x16
+#define HSTOP_QQVGA 0x04
+#define HREF_QQVGA 0xa4 //0x24? 0xa4?
+#define VSTART_QQVGA 0x02
+#define VSTOP_QQVGA 0x7a
+#define VREF_QQVGA 0x0a
+#define COM3_QQVGA 0x04
+#define COM14_QQVGA 0x1a
+#define SCALING_XSC_QQVGA 0x3a
+#define SCALING_YSC_QQVGA 0x35
+#define SCALING_DCWCTR_QQVGA 0x22
+#define SCALING_PCLK_DIV_QQVGA 0xf2
+#define SCALING_PCLK_DELAY_QQVGA 0x02
+
+// CIF setting no tested linux src 2.6.29-rc5 ov7670_soc.c
+#define COM7_CIF 0x00
+#define HSTART_CIF 0x15
+#define HSTOP_CIF 0x0b
+#define HREF_CIF 0xb6
+#define VSTART_CIF 0x03
+#define VSTOP_CIF 0x7b
+#define VREF_CIF 0x02
+#define COM3_CIF 0x08
+#define COM14_CIF 0x11
+#define SCALING_XSC_CIF 0x3a
+#define SCALING_YSC_CIF 0x35
+#define SCALING_DCWCTR_CIF 0x11
+#define SCALING_PCLK_DIV_CIF 0xf1
+#define SCALING_PCLK_DELAY_CIF 0x02
+
+// QCIF setting no tested no tested linux src 2.6.29-rc5 ov7670_soc.c
+#define COM7_QCIF 0x00
+#define HSTART_QCIF 0x39
+#define HSTOP_QCIF 0x03
+#define HREF_QCIF 0x80
+#define VSTART_QCIF 0x03
+#define VSTOP_QCIF 0x7b
+#define VREF_QCIF 0x02
+#define COM3_QCIF 0x0c
+#define COM14_QCIF 0x11
+#define SCALING_XSC_QCIF 0x3a
+#define SCALING_YSC_QCIF 0x35
+#define SCALING_DCWCTR_QCIF 0x11
+#define SCALING_PCLK_DIV_QCIF 0xf1
+#define SCALING_PCLK_DELAY_QCIF 0x52
+
+// YUV
+#define REG_COM13 0x3d /* Control 13 */
+#define REG_TSLB 0x3a /* lots of stuff */
+
+#define COM7_YUV 0x00 /* YUV */
+#define COM13_UV 0x00 /* U before V - w/TSLB */
+#define COM13_UVSWAP 0x01 /* V before U - w/TSLB */
+#define TSLB_VLAST 0x00 /* YUYV - see com13 */
+#define TSLB_ULAST 0x00 /* YVYU - see com13 */
+#define TSLB_YLAST 0x08 /* UYVY or VYUY - see com13 */
+
+// RGB
+#define COM7_RGB 0x04 /* bits 0 and 2 - RGB format */
+
+// RGB444
+#define REG_RGB444 0x8c /* RGB 444 control */
+#define REG_COM15 0x40 /* Control 15 */
+
+#define RGB444_ENABLE 0x02 /* Turn on RGB444, overrides 5x5 */
+#define RGB444_XBGR 0x00
+#define RGB444_BGRX 0x01 /* Empty nibble at end */
+#define COM15_RGB444 0x10 /* RGB444 output */
+
+// RGB555
+#define RGB444_DISABLE 0x00 /* Turn off RGB444, overrides 5x5 */
+#define COM15_RGB555 0x30 /* RGB555 output */
+
+// RGB565
+#define COM15_RGB565 0x10 /* RGB565 output */
+
+// Bayer RGB
+#define COM7_BAYER 0x01 /* Bayer format */
+#define COM7_PBAYER 0x05 /* "Processed bayer" */
+
+
+// data format
+#define COM15_R10F0 0x00 /* Data range 10 to F0 */
+#define COM15_R01FE 0x80 /* 01 to FE */
+#define COM15_R00FF 0xc0 /* 00 to FF */
+
+// Night mode, flicker, banding /
+#define REG_COM11 0x3b /* Control 11 */
+#define COM11_NIGHT 0x80 /* NIght mode enable */
+#define COM11_NIGHT_MIN_RATE_1_1 0x00 /* Normal mode same */
+#define COM11_NIGHT_MIN_RATE_1_2 0x20 /* Normal mode 1/2 */
+#define COM11_NIGHT_MIN_RATE_1_4 0x40 /* Normal mode 1/4 */
+#define COM11_NIGHT_MIN_RATE_1_8 0x60 /* Normal mode 1/5 */
+#define COM11_HZAUTO_ON 0x10 /* Auto detect 50/60 Hz on */
+#define COM11_HZAUTO_OFF 0x00 /* Auto detect 50/60 Hz off */
+#define COM11_60HZ 0x00 /* Manual 60Hz select */
+#define COM11_50HZ 0x08 /* Manual 50Hz select */
+#define COM11_EXP 0x02
+
+#define REG_MTX1 0x4f
+#define REG_MTX2 0x50
+#define REG_MTX3 0x51
+#define REG_MTX4 0x52
+#define REG_MTX5 0x53
+#define REG_MTX6 0x54
+#define REG_BRIGHT 0x55 /* Brightness */
+#define REG_CONTRAS 0x56 /* Contrast control */
+#define REG_CONTRAS_CENTER 0x57
+#define REG_MTXS 0x58
+#define REG_MANU 0x67
+#define REG_MANV 0x68
+#define REG_GFIX 0x69 /* Fix gain control */
+#define REG_GGAIN 0x6a
+#define REG_DBLV 0x6b
+
+#define REG_COM9 0x14 // Control 9 - gain ceiling
+#define COM9_AGC_2X 0x00
+#define COM9_AGC_4X 0x10
+#define COM9_AGC_8X 0x20
+#define COM9_AGC_16X 0x30
+#define COM9_AGC_32X 0x40
+#define COM9_AGC_64X 0x50
+#define COM9_AGC_128X 0x60
+#define COM9_AGC_MASK 0x70
+#define COM9_FREEZE 0x01
+#define COM13_GAMMA 0x80 /* Gamma enable */
+#define COM13_UVSAT 0x40 /* UV saturation auto adjustment */
+#define REG_GAIN 0x00 /* Gain lower 8 bits (rest in vref) */
+#define REG_BLUE 0x01 /* blue gain */
+#define REG_RED 0x02 /* red gain */
+#define REG_COM1 0x04 /* Control 1 */
+#define COM1_CCIR656 0x40 /* CCIR656 enable */
+#define REG_BAVE 0x05 /* U/B Average level */
+#define REG_GbAVE 0x06 /* Y/Gb Average level */
+#define REG_AECHH 0x07 /* AEC MS 5 bits */
+#define REG_RAVE 0x08 /* V/R Average level */
+#define REG_COM2 0x09 /* Control 2 */
+#define COM2_SSLEEP 0x10 /* Soft sleep mode */
+#define REG_PID 0x0a /* Product ID MSB */
+#define REG_VER 0x0b /* Product ID LSB */
+#define COM3_SWAP 0x40 /* Byte swap */
+#define COM3_SCALEEN 0x08 /* Enable scaling */
+#define COM3_DCWEN 0x04 /* Enable downsamp/crop/window */
+#define REG_COM4 0x0d /* Control 4 */
+#define REG_COM5 0x0e /* All "reserved" */
+#define REG_COM6 0x0f /* Control 6 */
+#define REG_AECH 0x10 /* More bits of AEC value */
+#define REG_CLKRC 0x11 /* Clocl control */
+#define CLK_EXT 0x40 /* Use external clock directly */
+#define CLK_SCALE 0x3f /* Mask for internal clock scale */
+#define COM7_RESET 0x80 /* Register reset */
+#define COM7_FMT_MASK 0x38
+#define COM7_FMT_VGA 0x00
+#define COM7_FMT_CIF 0x20 /* CIF format */
+#define COM7_FMT_QVGA 0x10 /* QVGA format */
+#define COM7_FMT_QCIF 0x08 /* QCIF format */
+#define REG_COM8 0x13 /* Control 8 */
+#define COM8_FASTAEC 0x80 /* Enable fast AGC/AEC */
+#define COM8_AECSTEP 0x40 /* Unlimited AEC step size */
+#define COM8_BFILT 0x20 /* Band filter enable */
+#define COM8_AGC 0x04 /* Auto gain enable */
+#define COM8_AWB 0x02 /* White balance enable */
+#define COM8_AEC 0x01 /* Auto exposure enable */
+#define REG_COM9 0x14 /* Control 9 - gain ceiling */
+#define REG_COM10 0x15 /* Control 10 */
+#define COM10_HSYNC 0x40 /* HSYNC instead of HREF */
+#define COM10_PCLK_HB 0x20 /* Suppress PCLK on horiz blank */
+#define COM10_HREF_REV 0x08 /* Reverse HREF */
+#define COM10_VS_LEAD 0x04 /* VSYNC on clock leading edge */
+#define COM10_VS_NEG 0x02 /* VSYNC negative */
+#define COM10_HS_NEG 0x01 /* HSYNC negative */
+#define REG_PSHFT 0x1b /* Pixel delay after HREF */
+#define REG_MIDH 0x1c /* Manuf. ID high */
+#define REG_MIDL 0x1d /* Manuf. ID low */
+#define REG_MVFP 0x1e /* Mirror / vflip */
+#define MVFP_MIRROR 0x20 /* Mirror image */
+#define MVFP_FLIP 0x10 /* Vertical flip */
+#define REG_AEW 0x24 /* AGC upper limit */
+#define REG_AEB 0x25 /* AGC lower limit */
+#define REG_VPT 0x26 /* AGC/AEC fast mode op region */
+#define REG_HSYST 0x30 /* HSYNC rising edge delay */
+#define REG_HSYEN 0x31 /* HSYNC falling edge delay */
+#define REG_COM12 0x3c /* Control 12 */
+#define COM12_HREF 0x80 /* HREF always */
+#define COM14_DCWEN 0x10 /* DCW/PCLK-scale enable */
+#define REG_EDGE 0x3f /* Edge enhancement factor */
+#define REG_COM16 0x41 /* Control 16 */
+#define COM16_AWBGAIN 0x08 /* AWB gain enable */
+#define REG_COM17 0x42 /* Control 17 */
+#define COM17_AECWIN 0xc0 /* AEC window - must match COM4 */
+#define COM17_CBAR 0x08 /* DSP Color bar */
+#define REG_CMATRIX_BASE 0x4f
+#define CMATRIX_LEN 6
+#define REG_REG76 0x76 /* OV's name */
+#define R76_BLKPCOR 0x80 /* Black pixel correction enable */
+#define R76_WHTPCOR 0x40 /* White pixel correction enable */
+#define REG_HAECC1 0x9f /* Hist AEC/AGC control 1 */
+#define REG_HAECC2 0xa0 /* Hist AEC/AGC control 2 */
+#define REG_BD50MAX 0xa5 /* 50hz banding step limit */
+#define REG_HAECC3 0xa6 /* Hist AEC/AGC control 3 */
+#define REG_HAECC4 0xa7 /* Hist AEC/AGC control 4 */
+#define REG_HAECC5 0xa8 /* Hist AEC/AGC control 5 */
+#define REG_HAECC6 0xa9 /* Hist AEC/AGC control 6 */
+#define REG_HAECC7 0xaa /* Hist AEC/AGC control 7 */
+#define REG_BD60MAX 0xab /* 60hz banding step limit */
+
+#define OV7670_WRITE (0x42)
+#define OV7670_READ (0x43)
+#define OV7670_WRITEWAIT (20)
+#define OV7670_NOACK (0)
+#define OV7670_REGMAX (201)
+#define OV7670_I2CFREQ (50000)
+
+//Camera OV7670
+
+class HeptaCamera{
+public:
+ I2C camera;
+ InterruptIn vsync,href;
+ DigitalOut wen;
+ BusIn data;
+ DigitalOut rrst,oe,rclk;
+ volatile int LineCounter;
+ volatile int LastLines;
+ volatile bool CaptureReq;
+ volatile bool Busy;
+ volatile bool Done;
+
+ HeptaCamera(
+ PinName sda,// Camera I2C port
+ PinName scl,// Camera I2C port
+ PinName vs, // VSYNC
+ PinName hr, // HREF
+ PinName we, // WEN
+ PinName d7, // D7
+ PinName d6, // D6
+ PinName d5, // D5
+ PinName d4, // D4
+ PinName d3, // D3
+ PinName d2, // D2
+ PinName d1, // D1
+ PinName d0, // D0
+ PinName rt, // /RRST
+ PinName o, // /OE
+ PinName rc // RCLK
+ );
+ void CaptureNext(void);
+ bool CaptureDone(void);
+ void WriteReg(int addr,int data);
+ int ReadReg(int addr);
+ void PrintRegister(void);
+ void Reset(void);
+ void InitForFIFOWriteReset(void);
+ void InitSetColorbar(void);
+ void InitDefaultReg(void);
+ void InitRGB444(void);
+ void InitRGB555(void);
+ void InitRGB565(void);
+ void InitYUV(void);
+ void InitBayerRGB(void);
+ void InitVGA(void);
+ void InitFIFO_2bytes_color_nealy_limit_size(void);
+ void InitVGA_3_4(void);
+ void InitQVGA(void);
+ void InitQQVGA();
+ void VsyncHandler(void);
+ void HrefHandler(void);
+ int ReadOneByte(void);
+ void ReadStart(void);
+ void ReadStop(void);
+ void shoot();
+ void shoot2();
+private:
+};
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/hepta_sat/HeptaGPS.cpp Fri Dec 09 05:04:37 2016 +0000
@@ -0,0 +1,167 @@
+#include "HeptaGPS.h"
+#include "mbed.h"
+
+HeptaGPS::HeptaGPS(PinName tx, PinName rx) : gps(tx,rx)
+{
+}
+void HeptaGPS::baud(int rate)
+{
+ gps.baud(rate);
+}
+char HeptaGPS::getc()
+{
+ c = gps.getc();
+ return c;
+}
+int HeptaGPS::readable()
+{
+ i = gps.readable();
+ return i;
+}
+void HeptaGPS::flushSerialBuffer(void)
+{
+ ite = 0;
+ while (gps.readable())
+ {
+ gps.getc();
+ ite++;
+ if(ite==100){break;};
+ }
+ return;
+}
+void HeptaGPS::gga_sensing(float *time, float *latitude, char *ns, float *longitude, char *ew, int *quality, int *stnum, float *hacu, float *altitude, char *aunit, int *gps_check)
+{
+ int ite = 0;
+ while(gps.getc()!='$'){
+ ite++;
+ if(ite==10000) break;
+ }
+ for(int i=0; i<5; i++){
+ msg[i] = gps.getc();
+ }
+ if((msg[2]=='G')&(msg[3]=='G')&(msg[4]=='A')){
+ for(int j=0; j<6; j++){
+ if(j==0){
+ for(int i=5; i<256; i++){
+ msg[i] = gps.getc();
+ if(msg[i] == '\r') {
+ msg[i] = 0;
+ break;
+ }
+ }
+ }else{
+ for(int i=0; i<256; i++){
+ msgd[i] = gps.getc();
+ if(msgd[i] == '\r') {
+ break;
+ }
+ }
+ if((msgd[4]=='V')&(msgd[5]=='T')&(msgd[6]=='G')){
+ break;
+ }
+ }
+ }
+ if(sscanf(msg, "GPGGA,%f,%f,%c,%f,%c,%d,%d,%f,%f,%c", time, latitude, ns, longitude, ew, quality, stnum, hacu, altitude, aunit) >= 1) {
+ if(!(quality)) {
+ //latitude(unit transformation)
+ *latitude=int(*latitude/100)+(*latitude-int(*latitude/100)*100)/60;
+ //longitude(unit transformation)
+ *longitude = int(*longitude/100)+(*longitude-int(*longitude/100)*100)/60;
+ *gps_check = 0;
+ } else {
+ //latitude(unit transformation)
+ *latitude=int(*latitude/100)+(*latitude-int(*latitude/100)*100)/60;
+ //longitude(unit transformation)
+ *longitude = int(*longitude/100)+(*longitude-int(*longitude/100)*100)/60;
+ *gps_check = 1;
+ }
+ }
+ else{
+ printf("No Data");
+ *gps_check = 2;
+ }
+ }
+ else{
+ *gps_check = 3;
+ }
+}
+void HeptaGPS::lat_log_sensing_u16(char *lat, char *log, int *dsize)
+{
+ char gph1[8]={0x00},gph2[8]={0x00},gph3[8]={0x00},gph4[8]={0x00},gpt1[8]={0x00},gpt2[8]={0x00},gpt3[8]={0x00},gpt4[8]={0x00};
+ int i=0,j=0;
+ while (gps.readable()){
+ gps.getc();
+ }
+ loop:
+ while(gps.getc()!='$'){}
+ for(j=0;j<5;j++){
+ gps_data[1][j]=gps.getc();
+ }
+ if((gps_data[1][2]==0x52)&(gps_data[1][3]==0x4d)&(gps_data[1][4]==0x43)){
+ for(j=0;j<1;j++){
+ if(j==0){
+ i=0;
+ while((gps_data[j+1][i+5] = gps.getc()) != '\r'){
+ //pc.putc(gps_data[j+1][i+5]);
+ i++;
+ }
+ gps_data[j+1][i+5]='\0';
+ i=0;
+ //pc.printf("\n\r");
+ }
+ else{
+ while(gps.getc()!='$'){}
+ i=0;
+ while((gps_data[j+1][i] = gps.getc()) != '\r'){
+ //pc.putc(gps_data[j+1][i]);
+ i++;
+ }
+ gps_data[j+1][i]='\0';
+ i=0;
+ //pc.printf("\n\r");
+ }
+ }
+ }
+ else
+ {
+ goto loop;
+ }
+ if( sscanf(gps_data[1],"GPRMC,%f,%c,%f,%c,%f,%c,%f",&time,&statas,&hokui,&ns,&tokei,&ew,&vel) >= 1){
+ //hokui
+ d_hokui=int(hokui/100);
+ m_hokui=(hokui-d_hokui*100);
+ //m_hokui=(hokui-d_hokui*100)/60;
+ g_hokui=d_hokui+(hokui-d_hokui*100)/60;
+ sprintf( gph1, "%02X", (char(d_hokui)) & 0xFF);
+ sprintf( gph2, "%02X", (char(m_hokui)) & 0xFF);
+ sprintf( gph3, "%02X", (char((m_hokui-char(m_hokui))*100)) & 0xFF);
+ sprintf( gph4, "%02X", (char(((m_hokui-char(m_hokui))*100-char((m_hokui-char(m_hokui))*100))*100)) & 0xFF);
+
+ //tokei
+ d_tokei=int(tokei/100);
+ m_tokei=(tokei-d_tokei*100);
+ //m_tokei=(tokei-d_tokei*100)/60;
+ g_tokei=d_tokei+(tokei-d_tokei*100)/60;
+ sprintf( gpt1, "%02X", (char(d_tokei)) & 0xFF);
+ sprintf( gpt2, "%02X", (char(m_tokei)) & 0xFF);
+ sprintf( gpt3, "%02X", (char((m_tokei-char(m_tokei))*100)) & 0xFF);
+ sprintf( gpt4, "%02X", (char(((m_tokei-char(m_tokei))*100-char((m_tokei-char(m_tokei))*100))*100)) & 0xFF);
+ lat[0] = gph1[0];
+ lat[1] = gph1[1];
+ lat[2] = gph2[0];
+ lat[3] = gph2[1];
+ lat[4] = gph3[0];
+ lat[5] = gph3[1];
+ lat[6] = gph4[0];
+ lat[7] = gph4[1];
+ log[0] = gpt1[0];
+ log[1] = gpt1[1];
+ log[2] = gpt2[0];
+ log[3] = gpt2[1];
+ log[4] = gpt3[0];
+ log[5] = gpt3[1];
+ log[6] = gpt4[0];
+ log[7] = gpt4[1];
+ }
+ *dsize = 8;
+}
\ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/hepta_sat/HeptaGPS.h Fri Dec 09 05:04:37 2016 +0000
@@ -0,0 +1,29 @@
+#ifndef MBED_HEPTAGPS_H
+#define MBED_HEPTAGPS_H
+#include "mbed.h"
+
+class HeptaGPS{
+public:
+ Serial gps;
+ HeptaGPS(
+ PinName tx,
+ PinName rx
+ );
+ void baud(int rate);
+ char getc();
+ int readable();
+ void flushSerialBuffer(void);
+ void gga_sensing(float *time, float *latitude, char *ns, float *longitude, char *ew, int *quality, int *stnum, float *hacu, float *altitude, char *aunit, int *gps_check);
+ void lat_log_sensing_u16(char *lat, char *log, int *dsize);
+private:
+ char msg[256],msgd[256];
+ int i,ite,rlock,stn;
+ char c;
+ char gps_data[7][1000];
+ char ns,ew,statas;
+ float time,hokui,tokei,vel;
+ float g_hokui,g_tokei;
+ float d_hokui,m_hokui,d_tokei,m_tokei;
+ int h_time,m_time,s_time;
+};
+#endif
\ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/hepta_sat/HeptaGyro.cpp Fri Dec 09 05:04:37 2016 +0000
@@ -0,0 +1,279 @@
+#include "HeptaGyro.h"
+#include "mbed.h"
+
+HeptaGyro::HeptaGyro(PinName sda, PinName scl, int aaddr ) : gyro(sda,scl),addr(aaddr)
+{
+ _cmd[0] = 0x20;
+ _cmd[1] = 0x0F;
+ gyro.frequency(100000);
+ gyro.write(addr, _cmd, 2);
+ gyro.start();
+ gyro.write(addr);
+ gyro.stop();
+}
+
+void HeptaGyro::setup()
+{
+ _cmd[0] = 0x20;
+ _cmd[1] = 0x0F;
+ gyro.frequency(100000);
+ gyro.write(addr, _cmd, 2);
+ gyro.start();
+ gyro.write(addr);
+ gyro.stop();
+}
+
+void HeptaGyro::sensing(float *gx,float *gy,float *gz)
+{
+ gyro.start();
+ gyro.write(addr);
+ gyro.write(0x28);
+ gyro.start();
+ gyro.write(addr|0x01);
+ _xl = gyro.read(0);
+ gyro.stop();
+ gyro.start();
+ gyro.write(addr);
+ gyro.write(0x29);
+ gyro.start();
+ gyro.write(addr|0x01);
+ _xh = gyro.read(0);
+ gyro.stop();
+ *gx = (short((_xh<<8)|_xl)*0.00875);
+
+ gyro.start();
+ gyro.write(addr);
+ gyro.write(0x2A);
+ gyro.start();
+ gyro.write(addr|0x01);
+ _yl = gyro.read(0);
+ gyro.stop();
+ gyro.start();
+ gyro.write(addr);
+ gyro.write(0x2B);
+ gyro.start();
+ gyro.write(addr|0x01);
+ _yh = gyro.read(0);
+ gyro.stop();
+ *gy = (short((_yh<<8)|_yl)*0.00875);
+
+ gyro.start();
+ gyro.write(addr);
+ gyro.write(0x2C);
+ gyro.start();
+ gyro.write(addr|0x01);
+ _zl = gyro.read(0);
+ gyro.stop();
+ gyro.start();
+ gyro.write(addr);
+ gyro.write(0x2D);
+ gyro.start();
+ gyro.write(addr|0x01);
+ _zh = gyro.read(0);
+ gyro.stop();
+ *gz = (short((_zh<<8)|_zl)*0.00875);
+}
+
+float HeptaGyro::x()
+{
+
+ gyro.start();
+ gyro.write(addr);
+ gyro.write(0x28);
+ gyro.start();
+ gyro.write(addr|0x01);
+ _xl = gyro.read(0);
+ gyro.stop();
+ gyro.start();
+ gyro.write(addr);
+ gyro.write(0x29);
+ gyro.start();
+ gyro.write(addr|0x01);
+ _xh = gyro.read(0);
+ gyro.stop();
+ return(short((_xh<<8)|_xl)*0.00875);
+}
+
+float HeptaGyro::y()
+{
+ gyro.start();
+ gyro.write(addr);
+ gyro.write(0x2A);
+ gyro.start();
+ gyro.write(addr|0x01);
+ _yl = gyro.read(0);
+ gyro.stop();
+ gyro.start();
+ gyro.write(addr);
+ gyro.write(0x2B);
+ gyro.start();
+ gyro.write(addr|0x01);
+ _yh = gyro.read(0);
+ gyro.stop();
+ return(short((_yh<<8)|_yl)*0.00875);
+}
+
+float HeptaGyro::z()
+{
+ gyro.start();
+ gyro.write(addr);
+ gyro.write(0x2C);
+ gyro.start();
+ gyro.write(addr|0x01);
+ _zl = gyro.read(0);
+ gyro.stop();
+ gyro.start();
+ gyro.write(addr);
+ gyro.write(0x2D);
+ gyro.start();
+ gyro.write(addr|0x01);
+ _zh = gyro.read(0);
+ gyro.stop();
+ return(short((_zh<<8)|_zl)*0.00875);
+}
+
+void HeptaGyro::sensing_u16(char* gx_u16,char* gy_u16,char* gz_u16, int *dsize)
+{
+ char g1[8]={0x00},g2[8]={0x00};
+ gyro.start();
+ gyro.write(addr);
+ gyro.write(0x28);
+ gyro.start();
+ gyro.write(addr|0x01);
+ _xl = gyro.read(0);
+ gyro.stop();
+ gyro.start();
+ gyro.write(addr);
+ gyro.write(0x29);
+ gyro.start();
+ gyro.write(addr|0x01);
+ _xh = gyro.read(0);
+ gyro.stop();
+ sprintf( g1, "%02X", ((_xh)) & 0xFF);
+ sprintf( g2, "%02X", ((_xl)) & 0xFF);
+ gx_u16[0]=g1[0];
+ gx_u16[1]=g1[1];
+ gx_u16[2]=g2[0];
+ gx_u16[3]=g2[1];
+
+ gyro.start();
+ gyro.write(addr);
+ gyro.write(0x2A);
+ gyro.start();
+ gyro.write(addr|0x01);
+ _yl = gyro.read(0);
+ gyro.stop();
+ gyro.start();
+ gyro.write(addr);
+ gyro.write(0x2B);
+ gyro.start();
+ gyro.write(addr|0x01);
+ _yh = gyro.read(0);
+ gyro.stop();
+ sprintf( g1, "%02X", ((_yh)) & 0xFF);
+ sprintf( g2, "%02X", ((_yl)) & 0xFF);
+ gy_u16[0]=g1[0];
+ gy_u16[1]=g1[1];
+ gy_u16[2]=g2[0];
+ gy_u16[3]=g2[1];
+
+ gyro.start();
+ gyro.write(addr);
+ gyro.write(0x2C);
+ gyro.start();
+ gyro.write(addr|0x01);
+ _zl = gyro.read(0);
+ gyro.stop();
+ gyro.start();
+ gyro.write(addr);
+ gyro.write(0x2D);
+ gyro.start();
+ gyro.write(addr|0x01);
+ _zh = gyro.read(0);
+ gyro.stop();
+ sprintf( g1, "%02X", ((_zh)) & 0xFF);
+ sprintf( g2, "%02X", ((_zl)) & 0xFF);
+ gz_u16[0]=g1[0];
+ gz_u16[1]=g1[1];
+ gz_u16[2]=g2[0];
+ gz_u16[3]=g2[1];
+ *dsize = 4;
+}
+
+void HeptaGyro::x_u16(char* g_u16, int *dsize)
+{
+ char g1[8]={0x00},g2[8]={0x00};
+ gyro.start();
+ gyro.write(addr);
+ gyro.write(0x28);
+ gyro.start();
+ gyro.write(addr|0x01);
+ _xl = gyro.read(0);
+ gyro.stop();
+ gyro.start();
+ gyro.write(addr);
+ gyro.write(0x29);
+ gyro.start();
+ gyro.write(addr|0x01);
+ _xh = gyro.read(0);
+ gyro.stop();
+ sprintf( g1, "%02X", ((_xh)) & 0xFF);
+ sprintf( g2, "%02X", ((_xl)) & 0xFF);
+ g_u16[0]=g1[0];
+ g_u16[1]=g1[1];
+ g_u16[2]=g2[0];
+ g_u16[3]=g2[1];
+ *dsize = 4;
+}
+
+void HeptaGyro::y_u16(char* g_u16, int *dsize)
+{
+ char g1[8]={0x00},g2[8]={0x00};
+ gyro.start();
+ gyro.write(addr);
+ gyro.write(0x2A);
+ gyro.start();
+ gyro.write(addr|0x01);
+ _yl = gyro.read(0);
+ gyro.stop();
+ gyro.start();
+ gyro.write(addr);
+ gyro.write(0x2B);
+ gyro.start();
+ gyro.write(addr|0x01);
+ _yh = gyro.read(0);
+ gyro.stop();
+ sprintf( g1, "%02X", ((_yh)) & 0xFF);
+ sprintf( g2, "%02X", ((_yl)) & 0xFF);
+ g_u16[0]=g1[0];
+ g_u16[1]=g1[1];
+ g_u16[2]=g2[0];
+ g_u16[3]=g2[1];
+ *dsize = 4;
+}
+
+void HeptaGyro::z_u16(char* g_u16, int *dsize)
+{
+ char g1[8]={0x00},g2[8]={0x00};
+ gyro.start();
+ gyro.write(addr);
+ gyro.write(0x2C);
+ gyro.start();
+ gyro.write(addr|0x01);
+ _zl = gyro.read(0);
+ gyro.stop();
+ gyro.start();
+ gyro.write(addr);
+ gyro.write(0x2D);
+ gyro.start();
+ gyro.write(addr|0x01);
+ _zh = gyro.read(0);
+ gyro.stop();
+ sprintf( g1, "%02X", ((_zh)) & 0xFF);
+ sprintf( g2, "%02X", ((_zl)) & 0xFF);
+ g_u16[0]=g1[0];
+ g_u16[1]=g1[1];
+ g_u16[2]=g2[0];
+ g_u16[3]=g2[1];
+ *dsize = 4;
+}
\ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/hepta_sat/HeptaGyro.h Fri Dec 09 05:04:37 2016 +0000
@@ -0,0 +1,29 @@
+#ifndef MBED_HEPTAGYRO_H
+#define MBED_HEPTAGYRO_H
+#include "mbed.h"
+
+//3axis Gyro Sensor ML3GD20
+
+class HeptaGyro{
+public:
+ I2C gyro;
+ int addr;
+ HeptaGyro(
+ PinName sda,// Gyro I2C port
+ PinName scl,// Gyro I2C port
+ int aaddr
+ );
+ void setup();
+ void sensing(float *gx,float *gy,float *gz);
+ void sensing_u16(char* gx_u16,char* gy_u16,char* gz_u16, int *dsize);
+ float x();
+ float y();
+ float z();
+ void x_u16(char* g_u16, int *dsize);
+ void y_u16(char* g_u16, int *dsize);
+ void z_u16(char* g_u16, int *dsize);
+private:
+ char _cmd[2];
+ short int _xl,_xh,_yl,_yh,_zl,_zh;
+};
+#endif
\ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/hepta_sat/HeptaLcd.h Fri Dec 09 05:04:37 2016 +0000
@@ -0,0 +1,242 @@
+#ifndef MBED_HeptaLcd
+#define MBED_HeptaLcd
+
+#include <stdarg.h>
+#include "mbed.h"
+#include "I2cBusDevice.h"
+
+// SB1602E IIC address
+
+const char SB1602E_addr = 0x7C;
+
+// SB1602E initialization command sequence
+
+#ifdef INIT_VALUE_DATASHEET_ORIGINAL
+
+const char Comm_FunctionSet_Normal = 0x38;
+const char Comm_FunctionSet_Extended = 0x39;
+const char Comm_InternalOscFrequency = 0x14;
+const char Comm_ContrastSet = 0x78;
+const char Comm_PwrIconContrast = 0x5E;
+const char Comm_FollowerCtrl = 0x6A;
+const char Comm_DisplayOnOff = 0x0C;
+const char Comm_ClearDisplay = 0x01;
+const char Comm_EntryModeSet = 0x06;
+
+#else
+
+const char Comm_FunctionSet_Normal = 0x38;
+const char Comm_FunctionSet_Extended = 0x39;
+const char Comm_InternalOscFrequency = 0x14;
+const char Comm_ContrastSet = 0x70;
+const char Comm_PwrIconContrast = 0x5C;
+const char Comm_FollowerCtrl = 0x60;
+const char Comm_DisplayOnOff = 0x0C;
+const char Comm_ClearDisplay = 0x01;
+const char Comm_EntryModeSet = 0x04;
+const char Comm_ReturnHome = 0x02;
+
+#endif
+
+// SB1602E general commands
+
+const char Comm_SetDDRAMAddress = 0x80;
+const char DDRAMAddress_Ofst[] = { 0x00, 0x40 };
+
+const char Comm_SetCGRAM = 0x40;
+
+// SB1602E setting values
+
+const char default_Contrast = 0x35;
+
+const char COMMAND = 0x00;
+const char DATA = 0x40;
+
+const char MaxCharsInALine = 0x10; // buffer deoth for one line (no scroll function used)
+
+const char init_seq0_length = 7;
+const char init_seq0[ init_seq0_length ]
+= {
+ Comm_FunctionSet_Normal,
+ Comm_ReturnHome, // This may be required to reset the scroll function
+ Comm_FunctionSet_Extended,
+ Comm_InternalOscFrequency,
+ Comm_ContrastSet | ( default_Contrast & 0xF),
+ Comm_PwrIconContrast | ((default_Contrast >> 4) & 0x3),
+ Comm_FollowerCtrl | 0x0A,
+
+};
+// required 30us interval
+
+const char init_seq1_length = 3;
+const char init_seq1[ init_seq1_length ]
+= {
+ Comm_DisplayOnOff,
+ Comm_ClearDisplay,
+ Comm_EntryModeSet,
+};
+// required 30us, 2ms interval
+
+
+class HeptaLcd : I2cBusDevice {
+public:
+ I2C lcd;
+ int addr;
+ explicit HeptaLcd(PinName sda, PinName scl, char dev_address = SB1602E_addr, char *init_massage = " " ) : lcd(sda,scl),addr(dev_address),I2cBusDevice(&lcd, dev_address ) {
+ wait( 0.04 ); // interval after hardware reset
+
+ for ( int i = 0; i < init_seq0_length; i++ ) {
+ lcd_command( init_seq0[ i ] );
+ wait( 30e-6 );
+ }
+
+ wait( 0.2 );
+
+ for ( int i = 0; i < init_seq1_length; i++ ) {
+ lcd_command( init_seq1[ i ] );
+ wait( 2e-3 );
+ }
+
+ if ( init_massage )
+ puts( 0, init_massage );
+
+ set_CGRAM( 7, '\x1F' );
+
+ curs[ 0 ] = 0;
+ curs[ 1 ] = 0;
+ }
+
+
+ ~HeptaLcd() {
+ }
+
+ void clear( void ) {
+ lcd_command( Comm_ClearDisplay );
+ wait( 2e-3 );
+ curs[ 0 ] = 0;
+ curs[ 1 ] = 0;
+ }
+
+ void initilize(){
+ char *init_massage = " ";
+ for ( int i = 0; i < init_seq0_length; i++ ) {
+ lcd_command( init_seq0[ i ] );
+ wait( 30e-6 );
+ }
+
+ wait( 0.2 );
+
+ for ( int i = 0; i < init_seq1_length; i++ ) {
+ lcd_command( init_seq1[ i ] );
+ wait( 2e-3 );
+ }
+
+ if ( init_massage )
+ puts( 0, init_massage );
+
+ set_CGRAM( 7, '\x1F' );
+
+ curs[ 0 ] = 0;
+ curs[ 1 ] = 0;
+ }
+ void put_custom_char( char c_code, const char *cg, char x, char y ) {
+ for ( int i = 0; i < 5; i++ ) {
+ set_CGRAM( c_code, cg );
+ putcxy( c_code, x, y );
+ }
+ }
+
+ void contrast( char contrast ) {
+ lcd_command( Comm_FunctionSet_Extended );
+ lcd_command( Comm_ContrastSet | (contrast & 0x0f) );
+ lcd_command( Comm_PwrIconContrast | ((contrast>>4) & 0x03) );
+ lcd_command( Comm_FunctionSet_Normal );
+ }
+
+ void set_CGRAM( char char_code, const char* cg ) {
+ for ( int i = 0; i < 8; i++ ) {
+ lcd_command( (Comm_SetCGRAM | (char_code << 3) | i) );
+ lcd_data( *cg++ );
+ }
+ }
+
+ void set_CGRAM( char char_code, char v ) {
+ char c[ 8 ];
+
+ for ( int i = 0; i < 8; i++ )
+ c[ i ] = v;
+
+ set_CGRAM( char_code, c );
+ }
+
+ void putcxy( char c, char x, char y ) {
+ if ( (x >= MaxCharsInALine) || (y >= 2) )
+ return;
+
+ lcd_command( (Comm_SetDDRAMAddress | DDRAMAddress_Ofst[ y ]) + x );
+ lcd_data( c );
+ }
+
+ void putc( char line, char c ) {
+ if ( (c == '\n') || (c == '\r') ) {
+ clear_lest_of_line( line );
+ curs[ line ] = 0;
+ return;
+ }
+
+ putcxy( c, curs[ line ]++, line );
+ }
+
+ void puts( char line, char *s ) {
+ while ( char c = *s++ )
+ putc( line, c );
+ }
+
+ void printf( char line, char *format, ... ) {
+ char s[ 32 ];
+ va_list args;
+
+ va_start( args, format );
+ vsnprintf( s, 32, format, args );
+ va_end( args );
+
+ puts( line, s );
+ }
+
+private:
+ char curs[2];
+
+ void clear_lest_of_line( char line ) {
+ for ( int i = curs[ line ]; i < MaxCharsInALine; i++ )
+ putcxy( ' ', i, line );
+ }
+
+ int lcd_write( char first, char second ) {
+ char cmd[2];
+
+ cmd[ 0 ] = first;
+ cmd[ 1 ] = second;
+
+ return ( write( cmd, 2 ) );
+
+ }
+
+ int lcd_command( char command ) {
+ return ( lcd_write( COMMAND, command ) );
+ }
+
+ int lcd_data( char data ) {
+ return ( lcd_write( DATA, data ) );
+ }
+}
+;
+
+#endif
+
+
+
+
+
+
+
+
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/hepta_sat/HeptaVoice.cpp Fri Dec 09 05:04:37 2016 +0000
@@ -0,0 +1,52 @@
+#include "HeptaVoice.h"
+
+HeptaVoice::HeptaVoice(PinName sda, PinName scl, int addr):_i2c(sda, scl),_addr(addr)
+{
+ _addr = addr;
+ _poll_wait.reset();
+ _poll_wait.start();
+}
+
+bool HeptaVoice::IsActive(int timeout_ms)
+{
+ wait_ms(AQTK_STARTUP_WAIT_MS);
+ Timer t;
+ t.reset();
+ t.start();
+ while(t.read_ms() < timeout_ms) {
+ _poll_wait.reset();
+ if (_i2c.write(_addr, NULL, 0) == 0) {
+ return true;
+ }
+ wait_ms(AQTK_POLL_WAIT_MS);
+ }
+ return false;
+}
+
+void HeptaVoice::Synthe(const char* msg)
+{
+ while(IsBusy()) {
+ ;
+ }
+ Write(msg);
+ Write("\r");
+}
+
+void HeptaVoice::Write(const char *msg)
+{
+ _i2c.write(_addr, msg, strlen(msg));
+ _poll_wait.reset();
+}
+
+bool HeptaVoice::IsBusy()
+{
+ if (AQTK_POLL_WAIT_MS > _poll_wait.read_ms()) {
+ return true;
+ }
+ _poll_wait.reset();
+ char c = 0x00;
+ if (_i2c.read(_addr, &c, 1) != 0) {
+ return false;
+ }
+ return c == '*' || c == 0xff;
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/hepta_sat/HeptaVoice.h Fri Dec 09 05:04:37 2016 +0000
@@ -0,0 +1,45 @@
+#include "mbed.h"
+
+#pragma once
+
+#define AQTK_I2C_ADDR (0x2E<<1)
+#define AQTK_STARTUP_WAIT_MS 80
+#define AQTK_POLL_WAIT_MS 10
+
+/** HeptaVoice class
+ *
+ * AquesTalk pico LSI I2C interface
+ * Example:
+ * @code
+ * #include "HeptaVoice.h"
+ * HeptaVoice talk(P0_10,P0_11); // I2C sda scl
+ *
+ * int main() {
+ * talk.Synthe("konnichiwa.");
+ * for(int n = 1; ; n++) {
+ * char buf[32];
+ * snprintf(buf, sizeof(buf), "<NUMK VAL=%d>.", n);
+ * talk.Synthe(buf);
+ * }
+ * }
+ * @endcode
+ *
+ */
+class HeptaVoice {
+public:
+ /** Create a AquesTalk pico LSI I2C interface
+ *
+ * @param sda I2C data pin
+ * @param scl I2C clock pin
+ * @param addr I2C address
+ */
+ HeptaVoice(PinName sda, PinName scl, int addr = AQTK_I2C_ADDR);
+ bool IsActive(int timeout_ms = 500);
+ void Synthe(const char* msg);
+ void Write(const char* msg);
+ bool IsBusy();
+private:
+ int _addr;
+ I2C _i2c;
+ Timer _poll_wait;
+};
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/hepta_sat/HeptaXbee.cpp Fri Dec 09 05:04:37 2016 +0000
@@ -0,0 +1,99 @@
+#include "HeptaXbee.h"
+#include "mbed.h"
+#include <stdarg.h>
+
+HeptaXbee::HeptaXbee(PinName tx, PinName rx) : xbee(tx,rx)
+{
+ rcmd = 0;
+ cmdflag = 0;
+}
+void HeptaXbee::baud(int rate)
+{
+ xbee.baud(rate);
+}
+void HeptaXbee::xbee_recieve(int *xrcmd, int *xcmdflag) {
+ xbee.attach(this,&HeptaXbee::commandget,Serial::RxIrq);
+ //xbee.printf("ssXbeedata= %d,%d",HeptaXbee::rcmd,HeptaXbee::cmdflag);
+ *xrcmd = HeptaXbee::rcmd;
+ *xcmdflag = HeptaXbee::cmdflag;
+}
+
+void HeptaXbee::initialize(){
+ HeptaXbee::rcmd = 0;
+ HeptaXbee::cmdflag = 0;
+}
+
+void HeptaXbee::commandget(){
+ HeptaXbee::rcmd=xbee.getc();
+ HeptaXbee::cmdflag = 1;
+ //xbee.printf("Xbeedata= %d,%d",rcmd,cmdflag);
+}
+void HeptaXbee::putc(char data)
+{
+ xbee.putc(data);
+}
+void HeptaXbee::xbee_transmit(char* output_data,size_t output_n,
+ char data1[],char data2[],char data3[],char data4[],char data5[],char data6[],char data7[],char data8[],char data9[],
+ int n1,int n2,int n3,int n4,int n5,int n6,int n7,int n8,int n9)
+{
+ int N=0,i=0,ii,jj=0;
+ for(i = 0; i <= n1-1; i++){
+ output_data[N+i] = data1[i];
+ }
+ N=i;
+ for(i = 0; i <= n2-1; i++){
+ output_data[N+i] = data2[i];
+ }
+ N=N+i;
+ for(i = 0; i <= n3-1; i++){
+ output_data[N+i] = data3[i];
+ }
+ N=N+i;
+ for(i = 0; i <= n4-1; i++){
+ output_data[N+i] = data4[i];
+ }
+ N=N+i;
+ for(i = 0; i <= n5-1; i++){
+ output_data[N+i] = data5[i];
+ }
+ N=N+i;
+ for(i = 0; i <= n6-1; i++){
+ output_data[N+i] = data6[i];
+ }
+ N=N+i;
+ for(i = 0; i <= n7-1; i++){
+ output_data[N+i] = data7[i];
+ }
+ N=N+i;
+ for(i = 0; i <= n8-1; i++){
+ output_data[N+i] = data8[i];
+ }
+ N=N+i;
+ for(i = 0; i <= n9-1; i++){
+ output_data[N+i] = data9[i];
+ }
+ for(ii=0;ii<output_n;ii++){
+ xbee.putc(output_data[ii]);
+ jj++;
+ if(jj==2)
+ {
+ xbee.putc(0x20);
+ jj=0;
+ }
+ }
+ xbee.putc(0x0a);
+}
+void HeptaXbee::puts( char *s ) {
+ while ( char c = *s++ )
+ xbee.putc( c );
+}
+void HeptaXbee::printf( char *format, ... ) {
+ char s[ 32 ];
+ va_list args;
+
+ va_start( args, format );
+ vsnprintf( s, 32, format, args );
+ va_end( args );
+
+ xbee.puts( s );
+}
\ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/hepta_sat/HeptaXbee.h Fri Dec 09 05:04:37 2016 +0000
@@ -0,0 +1,28 @@
+#ifndef MBED_HEPTAXBEE_H
+#define MBED_HEPTAXBEE_H
+#include "mbed.h"
+
+//Xbee Series2
+
+class HeptaXbee{
+public:
+ Serial xbee;
+ int rcmd;
+ int cmdflag;
+ HeptaXbee(
+ PinName tx,
+ PinName rx
+ );
+ void baud(int rate);
+ void xbee_recieve(int *xrcmd, int *xcmdflag);
+ void initialize();
+ void commandget();
+ void putc(char data);
+ void xbee_transmit(char* output_data,size_t output_n,
+ char data1[],char data2[],char data3[],char data4[],char data5[],char data6[],char data7[],char data8[],char data9[],
+ int n1,int n2,int n3,int n4,int n5,int n6,int n7,int n8,int n9);
+ void puts( char *s );
+ void printf(char *format, ... );
+private:
+};
+#endif
\ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/hepta_sat/I2cBusDevice.h Fri Dec 09 05:04:37 2016 +0000
@@ -0,0 +1,44 @@
+#ifndef MBED_I2cBusDevice
+#define MBED_I2cBusDevice
+
+#include "mbed.h"
+
+class I2cBusDevice {
+public:
+
+ I2cBusDevice( I2C *i2c, char dev_address ) {
+ bus = i2c;
+ device = dev_address;
+ }
+
+ ~I2cBusDevice() {
+ }
+
+ int write( char *data, int length ) {
+ return ( bus->write( device, data, length) );
+ }
+
+ int read( char *data, int length ) {
+ return ( bus->read( device, data, length) );
+ }
+
+ int read( char reg_ptr, char *data, int length ) {
+ if ( bus->write( device, ®_ptr, 1 ) )
+ return ( 1 );
+
+ if ( bus->read( device, data, length ) )
+ return ( 1 );
+
+ return ( 0 );
+ }
+
+protected:
+ I2C *bus;
+ char device;
+
+private:
+ static char i2c_error;
+}
+;
+
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/hepta_sat/PowerControl.lib Fri Dec 09 05:04:37 2016 +0000 @@ -0,0 +1,1 @@ +http://mbed.org/users/JST2011/code/PowerControl/#d0fa2aeb02a4
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/hepta_sat/SDFileSystem.lib Fri Dec 09 05:04:37 2016 +0000 @@ -0,0 +1,1 @@ +http://mbed.org/users/mbed_official/code/SDFileSystem/#c8f66dc765d4
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/main.cpp Fri Dec 09 05:04:37 2016 +0000
@@ -0,0 +1,19 @@
+#include "mbed.h"
+#include "HeptaBattery.h"
+Serial pc(USBTX,USBRX);
+HeptaBattery battery(p16,p29,p26);
+
+int main(){
+ pc.baud(9600);
+ int save_flag,bc_state;
+ float bt_dec;
+ for(int i=0;i<10;i++){
+ battery.vol(&bt_dec);
+ if(bt_dec>=4.2) bc_state=1;
+ else if(bt_dec < 4.2&&bt_dec>=3.5) bc_state=2;
+ else if(bt_dec<3.5) bc_state=3;
+ battery.chargecontrol(bc_state,&save_flag);
+ pc.printf("Voltage=%f,save_flag=%d\r\n",bt_dec,save_flag);
+ wait(1.0);
+ }
+}
\ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/mbed.bld Fri Dec 09 05:04:37 2016 +0000 @@ -0,0 +1,1 @@ +http://mbed.org/users/mbed_official/code/mbed/builds/6c34061e7c34 \ No newline at end of file