I2c Implementation is working, but error management is not clear, must chekc writeBuffer & readBuffer functions

developpment/Makefile

@@ -1,11 +1,14 @@
-cpp_src += $(wildcard ./pimpl/*.cpp)
 cpp_src += $(wildcard *.cpp) 
-cpp_src += $(wildcard ./management/*.cpp) $(wildcard ./systems/*.cpp) 
+cpp_src += $(wildcard ./pimpl/*.cpp)
+cpp_src += $(wildcard ./communication/i2c/*.cpp)
+cpp_src += $(wildcard ./management/*.cpp)
+cpp_src += $(wildcard ./drivers/bh1750/*.cpp)
+cpp_src += $(wildcard ./systems/*.cpp) 
 
 c_src += $(wildcard ./algorithms/*.c)
+c_src += $(wildcard ./drivers/pf8574/*.c)
 
 cpp_obj = $(cpp_src:.cpp=.o)
-impl_obj = $(impl_src:.cpp=.o)
 c_obj = $(c_src:.c=.o)
 CC = g++ 
 CFLAGS = -Wall -pedantic -li2c 
@@ -15,7 +18,7 @@ EXEC = runtest
 
 all : $(EXEC)
 
-$(EXEC): $(impl_obj) $(cpp_obj) $(c_obj)
+$(EXEC): $(cpp_obj) $(c_obj)
 	$(CC) -o $@ $^ $(LDFLAGS) 
  
 clean: 

developpment/communication/i2c/$

@@ -0,0 +1,40 @@
+#ifndef _I2C_H_
+#define _I2C_H_
+
+#include <unistd.h>
+#include <stdint.h>
+#include <memory>
+#include <ostream>
+#include <iostream>
+#include "../../config.h"
+
+class I2C
+{
+	public: 
+		enum errors 
+		{
+			noError,
+			writeFailed, 
+			readFailed, 
+			bufferFull, 
+			fasleAddrs, 
+			initFailed
+		}; 
+
+		I2C();
+		~I2C();
+		uint8_t readByte(const uint8_t& address, const uint8_t& reg); 
+		uint16_t readWord(const uint8_t& address, const uint8_t& reg); 
+		uint8_t writeByte(const uint8_t& address, const uint8_t& data); 
+		uint8_t writeWord(const uint8_t& address, const uint8_t& reg, const uint8_t& data);	
+		uint8_t writeBuffer(const uint8_t& address, const uint8_t& buffer, uint8_t len);	
+		uint8_t readBuffer(const uint8_t& address, const uint8_t& buffer, uint8_t len);	
+		int8_t getError(); 	
+
+	private:
+		struct i2cImpl; 
+		std::unique_ptr<i2cImpl> i2cPimpl; 
+
+};
+#endif // _I2C_H_
+#define _I2C_H_

developpment/communication/i2c/i2c.cpp

@@ -0,0 +1,52 @@
+#include "i2c.hpp"
+
+/*
+#if PLATFORM == LINUX
+#include "i2c_linux.hpp"
+#endif
+
+#if PLATFORM == LINUX
+#include "i2c_stm.hpp"
+#endif
+*/
+
+#include "i2c_linux.hpp"
+
+I2C::I2C():i2cPimpl(new i2cImpl()){}
+
+I2C::~I2C(){}
+
+uint8_t I2C::readByte(const uint8_t& address, const uint8_t& reg)
+{
+	return i2cPimpl->readByte(address,reg); 
+} 
+
+uint16_t I2C::readWord(const uint8_t& address, const uint8_t& reg)
+{
+	return i2cPimpl->readWord(address,reg);
+} 
+
+uint8_t I2C::writeByte(const uint8_t& address, const uint8_t& data)
+{
+	return i2cPimpl->writeByte(address,data);
+} 
+
+uint8_t I2C::writeWord(const uint8_t& address, const uint8_t& reg, const uint8_t& data)
+{
+	return i2cPimpl->writeWord(address,reg,data);
+}	
+
+uint8_t I2C::writeBuffer(const uint8_t& address, const uint8_t& buffer, uint8_t len)
+{
+	return i2cPimpl->writeBuffer(address,buffer,len);
+}	
+
+uint8_t I2C::readBuffer(const uint8_t& address, const uint8_t& buffer, uint8_t len)
+{
+	return i2cPimpl->readBuffer(address,buffer,len); 
+}	
+
+int8_t I2C::getError()
+{
+	return i2cPimpl->getError();
+} 	

developpment/communication/i2c/i2c.hpp

@@ -0,0 +1,40 @@
+#ifndef _I2C_H_
+#define _I2C_H_
+
+#include <unistd.h>
+#include <stdint.h>
+#include <memory>
+#include <ostream>
+#include <iostream>
+#include "../../config.h"
+
+class I2C
+{
+	public: 
+		enum errors 
+		{
+			noError,
+			writeFailed, 
+			readFailed, 
+			bufferFull, 
+			falseAddrs, 
+			initFailed
+		}; 
+
+		I2C();
+		~I2C();
+		uint8_t readByte(const uint8_t& address, const uint8_t& reg); 
+		uint16_t readWord(const uint8_t& address, const uint8_t& reg); 
+		uint8_t writeByte(const uint8_t& address, const uint8_t& data); 
+		uint8_t writeWord(const uint8_t& address, const uint8_t& reg, const uint8_t& data);	
+		uint8_t writeBuffer(const uint8_t& address, const uint8_t& buffer, uint8_t len);	
+		uint8_t readBuffer(const uint8_t& address, const uint8_t& buffer, uint8_t len);	
+		int8_t getError(); 	
+
+	private:
+		struct i2cImpl; 
+		std::unique_ptr<i2cImpl> i2cPimpl; 
+
+};
+#endif // _I2C_H_
+#define _I2C_H_

developpment/communication/i2c/i2c_linux.hpp

@@ -0,0 +1,126 @@
+#ifndef _I2C_LINUX_H_
+#define _I2C_LINUX_H_
+#include "i2c.hpp"
+
+#include <linux/i2c-dev.h>
+#include <fcntl.h>
+#include <sys/ioctl.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+
+struct I2C::i2cImpl
+{
+	int16_t deviceDescriptor; 
+	uint8_t device_address;
+	uint8_t send_buffer[32];
+	uint8_t recieve_buffer[32];
+	uint8_t blocks; 
+	uint8_t channel; 
+	uint8_t mode;
+	int8_t error;
+
+	i2cImpl()
+	{
+		char filename[20];
+		errors currentError = noError;
+		snprintf(filename, 19, "/dev/i2c-%d", 1);
+
+		deviceDescriptor = open(filename, O_RDWR);
+		if (deviceDescriptor < 0) {
+			error = initFailed;	
+		}
+	}
+	uint8_t readByte(const uint8_t& address, const uint8_t& reg)
+	{
+		if (ioctl(deviceDescriptor, I2C_SLAVE, address) < 0) 
+		{
+			error = falseAddrs;	
+		}
+		
+		writeByte(address,reg); //Initiate a write to indicate the desired register to read
+
+		if (read(deviceDescriptor, recieve_buffer, 1) != 1)  // An then initare a read request of 1 byte
+		{
+			error = readFailed; 	
+		} 
+		return recieve_buffer[0] ;
+	}
+ 
+	uint16_t readWord(const uint8_t& address, const uint8_t& reg)
+	{
+		uint16_t result = 0 ;
+		if (ioctl(deviceDescriptor, I2C_SLAVE, address) < 0) 
+		{
+			error = falseAddrs;	
+		}
+
+		writeByte(address,reg); //Initiate a write to indicate the desired register to read
+		
+		if (read(deviceDescriptor, recieve_buffer, 2) != 2)  // An then initare a read request of 2 bytes
+		{
+			error = readFailed; 	
+		} 
+		result = (recieve_buffer[0] << 8) + recieve_buffer[1] ;
+		return result ; 
+	}
+ 
+	uint8_t writeByte(const uint8_t& address, const uint8_t& data)
+	{
+		if (ioctl(deviceDescriptor, I2C_SLAVE, address) < 0) 
+		{
+			error = falseAddrs;	
+		}
+		
+		send_buffer[0] = data; 
+
+		if ((write(deviceDescriptor, send_buffer, 1)) != 1)
+		{	
+			error = writeFailed; 	
+		}
+		return 0; 
+	}
+ 
+	uint8_t writeWord(const uint8_t& address, const uint8_t& reg, const uint8_t& data)
+	{
+		if (ioctl(deviceDescriptor, I2C_SLAVE, address) < 0) 
+		{
+			error = falseAddrs;	
+		}
+		
+		send_buffer[0] = reg; 
+		send_buffer[1] = data;
+
+		if ((write(deviceDescriptor, send_buffer, 2)) != 2)
+		{	
+			error = writeFailed; 	
+		}
+		return 0; 
+	}
+	
+	uint8_t writeBuffer(const uint8_t& address, const uint8_t& buffer, uint8_t len)
+	{
+		if (ioctl(deviceDescriptor, I2C_SLAVE, address) < 0) 
+		{
+			error = falseAddrs;	
+		}
+		
+		send_buffer[0] = buffer;
+
+		if ((write(deviceDescriptor, send_buffer, len)) != len)
+		{	
+			error = writeFailed; 	
+		}
+		return 0; 
+	}
+	
+	uint8_t readBuffer(const uint8_t& address, const uint8_t& buffer, uint8_t len)
+	{
+		return 0;
+	}
+	
+	int8_t getError()
+	{
+		return 0;
+	}
+};
+#endif // _I2C_LINUX_H_

developpment/config.h

@@ -1,7 +1,6 @@
 #define STM 0
 #define LINUX 1
 
-
 #define PLATFORM STM
 
 

developpment/drivers/bh1750/bh1750.cpp

@@ -2,7 +2,7 @@
 
 
 
-Bh1750::Bh1750(i2c_ch1_pImpL *i2c)
+Bh1750::Bh1750(I2C *i2c)
 {
 	i2c_bh1750 = i2c;
 	currentMode = 0; // no mode selected

developpment/drivers/bh1750/bh1750.h

@@ -5,7 +5,7 @@
 #include <iostream>
 #include <array>
 #include <string>
-#include "../../periferals/i2c/i2c_ch1_pImpL.hpp"
+#include "../../communication/i2c/i2c.hpp"
 
 
 //Start measurement at 4lx resolution. Time typically 16ms.
@@ -33,14 +33,14 @@
 class Bh1750
 {
 	public: 
-		Bh1750(i2c_ch1_pImpL *i2c); 
+		Bh1750(I2C *i2c); 
 		uint8_t sleep(); // To be testes
 		uint8_t wake(); // To be tested
 		uint8_t reset(); // To be tested 
 		float oneShot(uint8_t mode); // ok  
 		float continious(uint8_t mode, uint8_t delayMs); // IMplment delay or make a delay class ???
 	private: 
-		i2c_ch1_pImpL* i2c_bh1750;
+		I2C* i2c_bh1750;
 		uint8_t high; 
 		uint8_t low; 
 		uint8_t currentMode; 

developpment/drivers/pf8574/pf8574lcd.c

@@ -12,10 +12,10 @@
 
 #include "pf8574lcd.h"
 
-i2c_ch1_pImpL *i2c_pf8574;
+I2C *i2c_pf8574;
 
 // Fonction pour initialiser l'écran vide en mode 4 bits 
-int lcd_init(i2c_ch1_pImpL* i2c)
+int lcd_init(I2C* i2c)
 {
 	i2c_pf8574 = i2c;
 	lcd_write(0x03,CMD_MODE); 		// Mise en mode 4 bit avec 4 essai conssecutif

developpment/drivers/pf8574/pf8574lcd.h

@@ -7,9 +7,7 @@
 #include <errno.h>
 #include <sys/types.h>
 #include <limits.h>
-#include "../../periferals/i2c/i2c_ch1_pImpL.hpp"
+#include "../../communication/i2c/i2c.hpp"
-
-//#include "i2c_ch1_pImpL.cpp"
 
 // commandes
 #define LCD_CLEARDISPLAY			0x01
@@ -70,11 +68,10 @@
 #define TOTAL_CHAR_CAP 				20 
 
 
-int  lcd_init(i2c_ch1_pImpL* i2c); 
+int  lcd_init(I2C *i2c); 
 void lcd_write_char( unsigned char charvalue); 
 void lcd_display_string(unsigned char line, unsigned char pos, char* charvalue, unsigned char lenght); 
 void ldc_pulse_En(unsigned char data); 
 void lcd_write(unsigned char cmd, unsigned char mode); 
 void lcd_write_4bits(unsigned char data); 
 
-

developpment/interfacer.cpp

@@ -13,23 +13,23 @@
 #include <bitset>
 #include "./management/errorHandling.h"
 #include "./management/commandManager.h"
-//#include "./drivers/bh1750/bh1750.h"
+#include "./drivers/bh1750/bh1750.h"
-//#include "./drivers/pf8574/pf8574lcd.h"
+#include "./drivers/pf8574/pf8574lcd.h"
 #include "./algorithms/bitgestion.h"
-//#include "./periferals/i2c/i2c.hpp"
-//#include "./pimpl/implementation.hpp"
 #include "./pimpl/interface.hpp"
-
+#include "./communication/i2c/i2c.hpp"
 
 ErrorHandler errorHandle;
 CommandManager commander; 
 
 Device pimplTest; 
+I2C i2c;
+
+char char_array[TOTAL_CHAR_CAP];
 
 //i2c_ch1_pImpL i2c(1, &errorHandle);
 
 /*
-char char_array[TOTAL_CHAR_CAP];
 int freq = 0; 
 
 int initPlatform()
@@ -106,6 +106,7 @@ int main(int argc, char *argv[])
 */
 int initPlatform()
 {
+	lcd_init(&i2c); 
 	return 0; 
 }
 
@@ -114,12 +115,26 @@ void dummy()
 	pimplTest.printNumber(3); 
 }
 
+void bh1750_test()
+{
+	Bh1750 lightSens(&i2c);
+	while(1)
+	{
+//		std::cout << "value "<< lightSens.continious(BH1750_CONTINUOUS_HIGH_RES_MODE_1,1) << " Lux" <<std::endl; 
+		std::string Msg = std::to_string(lightSens.continious(BH1750_CONTINUOUS_HIGH_RES_MODE_1,1)); 
+		char char_array[TOTAL_CHAR_CAP];
+		strcpy(char_array, Msg.c_str());
+		lcd_display_string(2,0, char_array,5); 
+		usleep(150*1000);
+	}
+}
 int main(int argc, char *argv[])
 {
 	// Init 
 	initPlatform(); 
 	std::cout << "Main Begin" << std::endl;
 	commander.addNewCommand("dummy", "The test command for testing the test", dummy);
+	commander.addNewCommand("bh1750", "The test command for testing the bh1750", bh1750_test);
 	commander(argv[1]); 	
 	std::cout << "Main End" << std::endl;