Skip to content

Commit ff052ae

Browse files
giulcioffigiulcioffi
committed
Make reg_write/read functions private and rename them with camelCase
1 parent 8a1d016 commit ff052ae

File tree

5 files changed

+61
-62
lines changed

5 files changed

+61
-62
lines changed

‎libraries/Camera/src/camera.h

-2
Original file line numberDiff line numberDiff line change
@@ -71,8 +71,6 @@ class ImageSensor {
7171
virtual int setFrameRate(int32_t framerate) = 0;
7272
virtual int setResolution(int32_t resolution) = 0;
7373
virtual int setPixelFormat(int32_t pixelformat) = 0;
74-
virtual int reg_write(uint8_t dev_addr, uint16_t reg_addr, uint8_t reg_data, bool wide_addr) = 0;
75-
virtual uint8_t reg_read(uint8_t dev_addr, uint16_t reg_addr, bool wide_addr) = 0;
7674
virtual int enableMotionDetection(md_callback_t callback) = 0;
7775
virtual int disableMotionDetection() = 0;
7876
virtual int setMotionDetectionWindow(uint32_t x, uint32_t y, uint32_t w, uint32_t h) = 0;

‎libraries/GC2145/gc2145.cpp

+21-21
Original file line numberDiff line numberDiff line change
@@ -721,7 +721,7 @@ int GC2145::init()
721721

722722
// Write default regsiters
723723
for (int i = 0; default_regs[i][0]; i++) {
724-
ret |= reg_write(GC2145_I2C_ADDR, default_regs[i][0], default_regs[i][1]);
724+
ret |= regWrite(GC2145_I2C_ADDR, default_regs[i][0], default_regs[i][1]);
725725
}
726726

727727
return ret;
@@ -732,23 +732,23 @@ int GC2145::setWindow(uint16_t reg, uint16_t x, uint16_t y, uint16_t w, uint16_t
732732
int ret = 0;
733733

734734
// P0 regs
735-
ret |= reg_write(GC2145_I2C_ADDR, 0xFE, 0x00);
735+
ret |= regWrite(GC2145_I2C_ADDR, 0xFE, 0x00);
736736

737737
// Y/row offset
738-
ret |= reg_write(GC2145_I2C_ADDR, reg++, y >> 8);
739-
ret |= reg_write(GC2145_I2C_ADDR, reg++, y & 0xff);
738+
ret |= regWrite(GC2145_I2C_ADDR, reg++, y >> 8);
739+
ret |= regWrite(GC2145_I2C_ADDR, reg++, y & 0xff);
740740

741741
// X/col offset
742-
ret |= reg_write(GC2145_I2C_ADDR, reg++, x >> 8);
743-
ret |= reg_write(GC2145_I2C_ADDR, reg++, x & 0xff);
742+
ret |= regWrite(GC2145_I2C_ADDR, reg++, x >> 8);
743+
ret |= regWrite(GC2145_I2C_ADDR, reg++, x & 0xff);
744744

745745
// Window height
746-
ret |= reg_write(GC2145_I2C_ADDR, reg++, h >> 8);
747-
ret |= reg_write(GC2145_I2C_ADDR, reg++, h & 0xff);
746+
ret |= regWrite(GC2145_I2C_ADDR, reg++, h >> 8);
747+
ret |= regWrite(GC2145_I2C_ADDR, reg++, h & 0xff);
748748

749749
// Window width
750-
ret |= reg_write(GC2145_I2C_ADDR, reg++, w >> 8);
751-
ret |= reg_write(GC2145_I2C_ADDR, reg++, w & 0xff);
750+
ret |= regWrite(GC2145_I2C_ADDR, reg++, w >> 8);
751+
ret |= regWrite(GC2145_I2C_ADDR, reg++, w & 0xff);
752752

753753
return ret;
754754
}
@@ -813,11 +813,11 @@ int GC2145::setResolution(int32_t resolution)
813813
ret |= setWindow(0x91, x, y, w, h);
814814

815815
// Enable crop
816-
ret |= reg_write(GC2145_I2C_ADDR, 0x90, 0x01);
816+
ret |= regWrite(GC2145_I2C_ADDR, 0x90, 0x01);
817817

818818
// Set Sub-sampling ratio and mode
819-
ret |= reg_write(GC2145_I2C_ADDR, 0x99, ((r_ratio << 4) | c_ratio));
820-
ret |= reg_write(GC2145_I2C_ADDR, 0x9A, 0x0E);
819+
ret |= regWrite(GC2145_I2C_ADDR, 0x99, ((r_ratio << 4) | c_ratio));
820+
ret |= regWrite(GC2145_I2C_ADDR, 0x9A, 0x0E);
821821

822822
return ret;
823823

@@ -829,27 +829,27 @@ int GC2145::setPixelFormat(int32_t pixformat)
829829
uint8_t reg;
830830

831831
// P0 regs
832-
ret |= reg_write(GC2145_I2C_ADDR, 0xFE, 0x00);
832+
ret |= regWrite(GC2145_I2C_ADDR, 0xFE, 0x00);
833833

834834
// Read current output format reg
835-
reg = reg_read(GC2145_I2C_ADDR, REG_OUTPUT_FMT);
835+
reg = regRead(GC2145_I2C_ADDR, REG_OUTPUT_FMT);
836836

837837
switch (pixformat) {
838838
case CAMERA_RGB565:
839-
ret |= reg_write(GC2145_I2C_ADDR,
839+
ret |= regWrite(GC2145_I2C_ADDR,
840840
REG_OUTPUT_FMT, REG_OUTPUT_SET_FMT(reg, REG_OUTPUT_FMT_RGB565));
841841
break;
842842
case CAMERA_GRAYSCALE:
843843
// TODO: There's no support for extracting GS from YUV so we use Bayer for 1BPP for now.
844-
//ret |= reg_write(GC2145_I2C_ADDR,
844+
//ret |= regWrite(GC2145_I2C_ADDR,
845845
// REG_OUTPUT_FMT, REG_OUTPUT_SET_FMT(reg, REG_OUTPUT_FMT_YCBYCR));
846846
//break;
847847
case CAMERA_BAYER:
848848
// There's no BAYER support so it will just look off.
849849
// Make sure odd/even row are switched to work with our bayer conversion.
850-
ret |= reg_write(GC2145_I2C_ADDR,
850+
ret |= regWrite(GC2145_I2C_ADDR,
851851
REG_SYNC_MODE, REG_SYNC_MODE_DEF | REG_SYNC_MODE_ROW_SWITCH);
852-
ret |= reg_write(GC2145_I2C_ADDR,
852+
ret |= regWrite(GC2145_I2C_ADDR,
853853
REG_OUTPUT_FMT, REG_OUTPUT_SET_FMT(reg, REG_OUTPUT_FMT_BAYER));
854854
break;
855855
default:
@@ -859,7 +859,7 @@ int GC2145::setPixelFormat(int32_t pixformat)
859859
return ret;
860860
}
861861

862-
int GC2145::reg_write(uint8_t dev_addr, uint16_t reg_addr, uint8_t reg_data, bool wide_addr)
862+
int GC2145::regWrite(uint8_t dev_addr, uint16_t reg_addr, uint8_t reg_data, bool wide_addr)
863863
{
864864
_i2c->beginTransmission(dev_addr);
865865
uint8_t buf[3] = {(uint8_t) (reg_addr >> 8), (uint8_t) (reg_addr & 0xFF), reg_data};
@@ -870,7 +870,7 @@ int GC2145::reg_write(uint8_t dev_addr, uint16_t reg_addr, uint8_t reg_data, boo
870870
return _i2c->endTransmission();
871871
}
872872

873-
uint8_t GC2145::reg_read(uint8_t dev_addr, uint16_t reg_addr, bool wide_addr)
873+
uint8_t GC2145::regRead(uint8_t dev_addr, uint16_t reg_addr, bool wide_addr)
874874
{
875875
uint8_t reg_data = 0;
876876
uint8_t buf[2] = {(uint8_t) (reg_addr >> 8), (uint8_t) (reg_addr & 0xFF)};

‎libraries/GC2145/gc2145.h

+2-2
Original file line numberDiff line numberDiff line change
@@ -26,6 +26,8 @@ class GC2145: public ImageSensor {
2626
int setWindow(uint16_t reg, uint16_t x, uint16_t y, uint16_t w, uint16_t h);
2727
Stream *_debug;
2828
arduino::MbedI2C *_i2c;
29+
int regWrite(uint8_t dev_addr, uint16_t reg_addr, uint8_t reg_data, bool wide_addr = false);
30+
uint8_t regRead(uint8_t dev_addr, uint16_t reg_addr, bool wide_addr = false);
2931

3032
public:
3133
GC2145(arduino::MbedI2C &i2c = CameraWire);
@@ -36,8 +38,6 @@ class GC2145: public ImageSensor {
3638
int setFrameRate(int32_t framerate);
3739
int setResolution(int32_t resolution);
3840
int setPixelFormat(int32_t pixformat);
39-
int reg_write(uint8_t dev_addr, uint16_t reg_addr, uint8_t reg_data, bool wide_addr = false);
40-
uint8_t reg_read(uint8_t dev_addr, uint16_t reg_addr, bool wide_addr = false);
4141
int enableMotionDetection(md_callback_t callback) { return 0; };
4242
int disableMotionDetection() { return 0; };
4343
int setMotionDetectionWindow(uint32_t x, uint32_t y, uint32_t w, uint32_t h) { return 0; };

‎libraries/Himax_HM01B0/himax.cpp

+35-35
Original file line numberDiff line numberDiff line change
@@ -317,12 +317,12 @@ int HM01B0::init()
317317
}
318318

319319
for (uint32_t i=0; himax_default_regs[i][0]; i++) {
320-
reg_write(HM01B0_I2C_ADDR, himax_default_regs[i][0], himax_default_regs[i][1], true);
320+
regWrite(HM01B0_I2C_ADDR, himax_default_regs[i][0], himax_default_regs[i][1], true);
321321
}
322322

323-
reg_write(HM01B0_I2C_ADDR, PCLK_POLARITY, (0x20 | PCLK_FALLING_EDGE), true);
323+
regWrite(HM01B0_I2C_ADDR, PCLK_POLARITY, (0x20 | PCLK_FALLING_EDGE), true);
324324

325-
reg_write(HM01B0_I2C_ADDR, MODE_SELECT, HIMAX_Streaming, true);
325+
regWrite(HM01B0_I2C_ADDR, MODE_SELECT, HIMAX_Streaming, true);
326326

327327
HAL_Delay(200);
328328

@@ -333,9 +333,9 @@ int HM01B0::reset()
333333
{
334334
uint32_t max_timeout=100;
335335
do {
336-
reg_write(HM01B0_I2C_ADDR, SW_RESET, HIMAX_RESET, true);
336+
regWrite(HM01B0_I2C_ADDR, SW_RESET, HIMAX_RESET, true);
337337
delay(1);
338-
} while (reg_read(HM01B0_I2C_ADDR, MODE_SELECT, true) != HIMAX_Standby && ((--max_timeout)>0) );
338+
} while (regRead(HM01B0_I2C_ADDR, MODE_SELECT, true) != HIMAX_Standby && ((--max_timeout)>0) );
339339

340340
return (max_timeout > 0) ? 0 : -1;
341341
}
@@ -347,17 +347,17 @@ int HM01B0::setResolution(int32_t resolution)
347347
switch (resolution) {
348348
case CAMERA_R160x120:
349349
for(uint32_t i = 0; himax_qqvga_regs[i][0]; i++) {
350-
ret |= reg_write(HM01B0_I2C_ADDR, himax_qqvga_regs[i][0], himax_qqvga_regs[i][1], true);
350+
ret |= regWrite(HM01B0_I2C_ADDR, himax_qqvga_regs[i][0], himax_qqvga_regs[i][1], true);
351351
}
352352
break;
353353
case CAMERA_R320x240:
354354
for(uint32_t i = 0; himax_qvga_regs[i][0]; i++) {
355-
ret |= reg_write(HM01B0_I2C_ADDR, himax_qvga_regs[i][0], himax_qvga_regs[i][1], true);
355+
ret |= regWrite(HM01B0_I2C_ADDR, himax_qvga_regs[i][0], himax_qvga_regs[i][1], true);
356356
}
357357
break;
358358
case CAMERA_R320x320:
359359
for(uint32_t i = 0; himax_full_regs[i][0]; i++) {
360-
ret |= reg_write(HM01B0_I2C_ADDR, himax_full_regs[i][0], himax_full_regs[i][1], true);
360+
ret |= regWrite(HM01B0_I2C_ADDR, himax_full_regs[i][0], himax_full_regs[i][1], true);
361361
}
362362
break;
363363
default:
@@ -371,7 +371,7 @@ int HM01B0::setFrameRate(int32_t framerate)
371371
{
372372
uint8_t osc_div = 0;
373373
// binning is enabled for QQVGA
374-
uint8_t binning = reg_read(HM01B0_I2C_ADDR, BINNING_MODE, true) & 0x03;
374+
uint8_t binning = regRead(HM01B0_I2C_ADDR, BINNING_MODE, true) & 0x03;
375375

376376
switch (framerate) {
377377
case 15:
@@ -391,7 +391,7 @@ int HM01B0::setFrameRate(int32_t framerate)
391391
return -1;
392392
}
393393

394-
return reg_write(HM01B0_I2C_ADDR, OSC_CLK_DIV, 0x08 | osc_div, true);
394+
return regWrite(HM01B0_I2C_ADDR, OSC_CLK_DIV, 0x08 | osc_div, true);
395395
}
396396

397397
int HM01B0::setPixelFormat(int32_t pixformat)
@@ -402,19 +402,19 @@ int HM01B0::setPixelFormat(int32_t pixformat)
402402
int HM01B0::setTestPattern(bool enable, bool walking)
403403
{
404404
uint8_t reg = 0;
405-
reg_write(HM01B0_I2C_ADDR, PCLK_POLARITY, (0x20 | PCLK_FALLING_EDGE), true);
406-
reg_write(HM01B0_I2C_ADDR, 0x2100, 0, true); //AE
407-
reg_write(HM01B0_I2C_ADDR, 0x1000, 0, true); //BLC
408-
reg_write(HM01B0_I2C_ADDR, 0x1008, 0, true); //DPC
409-
reg_write(HM01B0_I2C_ADDR, 0x0205, 0, true); //AGAIN
410-
reg_write(HM01B0_I2C_ADDR, 0x020e, 1, true); //DGAINH
411-
reg_write(HM01B0_I2C_ADDR, 0x020f, 0, true); //DGAINL
405+
regWrite(HM01B0_I2C_ADDR, PCLK_POLARITY, (0x20 | PCLK_FALLING_EDGE), true);
406+
regWrite(HM01B0_I2C_ADDR, 0x2100, 0, true); //AE
407+
regWrite(HM01B0_I2C_ADDR, 0x1000, 0, true); //BLC
408+
regWrite(HM01B0_I2C_ADDR, 0x1008, 0, true); //DPC
409+
regWrite(HM01B0_I2C_ADDR, 0x0205, 0, true); //AGAIN
410+
regWrite(HM01B0_I2C_ADDR, 0x020e, 1, true); //DGAINH
411+
regWrite(HM01B0_I2C_ADDR, 0x020f, 0, true); //DGAINL
412412

413413
if (enable) {
414414
reg = 1 | (walking ? (1 << 4) : 0);
415415
}
416-
reg_write(HM01B0_I2C_ADDR, 0x0601, reg, true);
417-
reg_write(HM01B0_I2C_ADDR, 0x0104, 1, true); //group hold
416+
regWrite(HM01B0_I2C_ADDR, 0x0601, reg, true);
417+
regWrite(HM01B0_I2C_ADDR, 0x0104, 1, true); //group hold
418418

419419
HAL_Delay(100);
420420

@@ -431,20 +431,20 @@ int HM01B0::setMotionDetectionThreshold(uint32_t threshold)
431431
//
432432
// In other words, motion is detected if the abs difference of the ROI mean and the
433433
// average ROI mean of the last 8 or 16 frames is higher than (ROI mean * threshold / 64).
434-
return reg_write(HM01B0_I2C_ADDR, MD_THL, (threshold < 3) ? 3 : (threshold > 0xF0) ? 0xF0 : threshold, true);
434+
return regWrite(HM01B0_I2C_ADDR, MD_THL, (threshold < 3) ? 3 : (threshold > 0xF0) ? 0xF0 : threshold, true);
435435
}
436436

437437
int HM01B0::setMotionDetectionWindow(uint32_t x, uint32_t y, uint32_t w, uint32_t h)
438438
{
439439
int ret = 0;
440-
ret |= reg_write(HM01B0_I2C_ADDR, MD_LROI_X_START_H, (x>>8), true);
441-
ret |= reg_write(HM01B0_I2C_ADDR, MD_LROI_X_START_L, (x&0xff), true);
442-
ret |= reg_write(HM01B0_I2C_ADDR, MD_LROI_Y_START_H, (y>>8), true);
443-
ret |= reg_write(HM01B0_I2C_ADDR, MD_LROI_Y_START_L, (y&0xff), true);
444-
ret |= reg_write(HM01B0_I2C_ADDR, MD_LROI_X_END_H, (w>>8), true);
445-
ret |= reg_write(HM01B0_I2C_ADDR, MD_LROI_X_END_L, (w&0xff), true);
446-
ret |= reg_write(HM01B0_I2C_ADDR, MD_LROI_Y_END_H, (h>>8), true);
447-
ret |= reg_write(HM01B0_I2C_ADDR, MD_LROI_Y_END_L, (h&0xff), true);
440+
ret |= regWrite(HM01B0_I2C_ADDR, MD_LROI_X_START_H, (x>>8), true);
441+
ret |= regWrite(HM01B0_I2C_ADDR, MD_LROI_X_START_L, (x&0xff), true);
442+
ret |= regWrite(HM01B0_I2C_ADDR, MD_LROI_Y_START_H, (y>>8), true);
443+
ret |= regWrite(HM01B0_I2C_ADDR, MD_LROI_Y_START_L, (y&0xff), true);
444+
ret |= regWrite(HM01B0_I2C_ADDR, MD_LROI_X_END_H, (w>>8), true);
445+
ret |= regWrite(HM01B0_I2C_ADDR, MD_LROI_X_END_L, (w&0xff), true);
446+
ret |= regWrite(HM01B0_I2C_ADDR, MD_LROI_Y_END_H, (h>>8), true);
447+
ret |= regWrite(HM01B0_I2C_ADDR, MD_LROI_Y_END_L, (h&0xff), true);
448448
return ret;
449449
}
450450

@@ -456,15 +456,15 @@ int HM01B0::enableMotionDetection(md_callback_t callback)
456456
md_irq.enable_irq();
457457

458458
int ret = clearMotionDetection();
459-
ret |= reg_write(HM01B0_I2C_ADDR, MD_CTRL, 1, true);
459+
ret |= regWrite(HM01B0_I2C_ADDR, MD_CTRL, 1, true);
460460
return ret;
461461
}
462462

463463
int HM01B0::disableMotionDetection()
464464
{
465465
_md_callback = NULL;
466466
int ret = clearMotionDetection();
467-
ret |= reg_write(HM01B0_I2C_ADDR, MD_CTRL, 0, true);
467+
ret |= regWrite(HM01B0_I2C_ADDR, MD_CTRL, 0, true);
468468
return ret;
469469
}
470470

@@ -481,12 +481,12 @@ int HM01B0::motionDetected()
481481

482482
int HM01B0::pollMotionDetection()
483483
{
484-
return reg_read(HM01B0_I2C_ADDR, MD_INTERRUPT, true);
484+
return regRead(HM01B0_I2C_ADDR, MD_INTERRUPT, true);
485485
}
486486

487487
int HM01B0::clearMotionDetection()
488488
{
489-
return reg_write(HM01B0_I2C_ADDR, I2C_CLEAR, 0x01, true);
489+
return regWrite(HM01B0_I2C_ADDR, I2C_CLEAR, 0x01, true);
490490
}
491491

492492
uint8_t HM01B0::printRegs()
@@ -495,12 +495,12 @@ uint8_t HM01B0::printRegs()
495495
printf("0x%04X: 0x%02X 0x%02X \n",
496496
himax_default_regs[i][0],
497497
himax_default_regs[i][1],
498-
reg_read(HM01B0_I2C_ADDR, himax_default_regs[i][0], true));
498+
regRead(HM01B0_I2C_ADDR, himax_default_regs[i][0], true));
499499
}
500500
return 0;
501501
}
502502

503-
int HM01B0::reg_write(uint8_t dev_addr, uint16_t reg_addr, uint8_t reg_data, bool wide_addr)
503+
int HM01B0::regWrite(uint8_t dev_addr, uint16_t reg_addr, uint8_t reg_data, bool wide_addr)
504504
{
505505
_i2c->beginTransmission(dev_addr);
506506
uint8_t buf[3] = {(uint8_t) (reg_addr >> 8), (uint8_t) (reg_addr & 0xFF), reg_data};
@@ -511,7 +511,7 @@ int HM01B0::reg_write(uint8_t dev_addr, uint16_t reg_addr, uint8_t reg_data, boo
511511
return _i2c->endTransmission();
512512
}
513513

514-
uint8_t HM01B0::reg_read(uint8_t dev_addr, uint16_t reg_addr, bool wide_addr)
514+
uint8_t HM01B0::regRead(uint8_t dev_addr, uint16_t reg_addr, bool wide_addr)
515515
{
516516
uint8_t reg_data = 0;
517517
uint8_t buf[2] = {(uint8_t) (reg_addr >> 8), (uint8_t) (reg_addr & 0xFF)};

‎libraries/Himax_HM01B0/himax.h

+3-2
Original file line numberDiff line numberDiff line change
@@ -29,6 +29,9 @@ class HM01B0: public ImageSensor {
2929
mbed::InterruptIn md_irq;
3030
md_callback_t _md_callback;
3131
void irqHandler();
32+
int regWrite(uint8_t dev_addr, uint16_t reg_addr, uint8_t reg_data, bool wide_addr = false);
33+
uint8_t regRead(uint8_t dev_addr, uint16_t reg_addr, bool wide_addr = false);
34+
3235
public:
3336
HM01B0(arduino::MbedI2C &i2c = CameraWire);
3437
int init();
@@ -38,8 +41,6 @@ class HM01B0: public ImageSensor {
3841
int setFrameRate(int32_t framerate);
3942
int setResolution(int32_t resolution);
4043
int setPixelFormat(int32_t pixformat);
41-
int reg_write(uint8_t dev_addr, uint16_t reg_addr, uint8_t reg_data, bool wide_addr = false);
42-
uint8_t reg_read(uint8_t dev_addr, uint16_t reg_addr, bool wide_addr = false);
4344
int setTestPattern(bool enable, bool walking);
4445
int enableMotionDetection(md_callback_t callback=NULL);
4546
int disableMotionDetection();

0 commit comments

Comments
 (0)