			/**
			* \file device/Device.h
			*
			* \date Mar 31, 2012
			* \author Alexandre Tuleu
			*/

			#ifndef LIBSBCP_DEVICE_DEVICE_H_
			#define LIBSBCP_DEVICE_DEVICE_H_


			#include <vector>
			#include <memory>

			#include <libsbcp/device/sbcp_common.h>
			#include "RegisterAccessorBase.h"


			namespace sbcp{

			class Bus;
			/**
			* Represents a generic Device over the Bus.
			*
			* \note Device are not created directly but are rather instantiated using
			* sbcp::Bus::OpenDevice() template function.
			*
			* Please notice, that most of the time you want to get a specific
			* implementation of the device, like sbcp::amarsi::MotorDriver or
			* sbcp::amarsi::Power.
			*
			* A Device as several caracteristics :
			* - It has an UID over the bus made from a sbcp::Class 8-bit Byte and a
			* sbcp::DevID 8-bit Byte.
			* - It has a table of DeviceRegister that hold some cobtrol data.
			* - It has a set of standard instruction that could be performed.
			*
			* Each device has the same sets of StdInstruction and StdRegister. This class
			* Implements basic helper method to perfrom these instructions, like
			* SetRegister(), GetRegister(), UnlockRegister().
			*/
			class Device {
			public:
			/**
			* shared_ptr typedef
			*/
			typedef std::shared_ptr<Device> Ptr;

			typedef std::vector<RegisterWriterBase*> ListOfWriters;
			typedef std::vector<RegisterReaderBase*> ListOfReaders;

			/**
			* Binary 8-bit code for InstructionID
			*/
			enum StdInstruction {
			GET_FIRMWARE = 0, //!< GET_FIRMWARE returns the 16-bit FirmwareVersion code of the device.
			GET_REGISTERS = 1, //!< GET_REGISTERS returns the value of a list of registers.
			SET_REGISTERS = 2, //!< SET_REGISTERS sets the value of a list of registers
			UNLOCK_REGISTER = 3, //!< UNLOCK_REGISTER unlocks a list of register
			GET_LOW_LATENCY_PCK_DEF = 4,
			SET_LOW_LATENCY_PCK_DEF = 5,
			DEVICE_SPECIFIC_INSTRUCTIONS = 8, //!< DEVICE_SPECIFIC_INSTRUCTIONS start of address for device specific instruction
			LOW_LATENCY_INSTRUCTION = 0xff
			};

			/**
			* Binary 8-bit code for DeviceRegister. A Device Register is a 16-bit value.
			*/
			enum StdRegister {
			FIRMWARE_VERSION = 0, //!< FIRMWARE_VERSION FirmwareVersion code
			SBCP_CLASS = 1, //!< SBCP_CLASS sbcp::Class 8-bit value
			SBCP_ID = 2, //!< SBCP_ID sbcp::DevID 8-bit value
			DEVICE_SPECIFIC_REGISTERS = 8//!< DEVICE_SPECIFIC_REGISTERS start for device-specific DeviceRegister
			};


			Device(Bus & bus,
			Class klass ,
			DevID id,
			FirmwareVersion version,
			SBCPVersion comVersion);
			virtual ~Device();

			/**
			* @return the sbcp::Class of the Device.
			*/
			sbcp::Class Klass() const;
			/**
			* @return the sbcp::DevID of the device.
			*/
			DevID ID() const;
			/**
			* @return the FirmwareVersion of the device
			*/
			FirmwareVersion Version() const;

			/**
			* @return the SBCPVersion used by the device.
			*/
			SBCPVersion ComVersion() const;

			//way to handle instruction

			/**
			* Sets the value of one single register.
			* Performs a LazyWorkflow transfer.
			* @param address address of the DeviceRegister.
			* @param data new value of the DeviceRegister
			*/
			void SetRegister(Register::Address address, Data data);

			/**
			* Gets the value of a DeviceRegister.
			* Performs a LazyWorkflow transfer.
			* @param address address of the DeviceRegister.
			* @return the current value of the DeviceRegister
			*/
			Data GetRegister(Register::Address address);

			/**
			* Unlocks the DeviceRegister. Performs a LazyWorkflow Transfer.
			* @param address
			*/
			void UnlockRegister(Register::Address address);

			void SetLowLatencyPacketDefinition(const ListOfWriters & inputs,
			const ListOfReaders & outputs);

			const ListOfWriters & GetLowLatencyInPacket() const;
			const ListOfReaders & GetLowLatencyOutPacket() const;

			bool HasALowLatencyPacketDefinition();
			bool CanHaveALowLatencyPacket();

			void CheckSchedulable() throw (std::exception) ;

			bool IsSchedulable();

			/**
			* Returns the current payload size of the out ll packet.
			* @return
			*/
			PayloadSize LowLatencyOutSize() const;

			/**
			* Returns the current payload size of the in ll packet.
			* @return
			*/
			PayloadSize LowLatencyInSize() const;

			unsigned int MaxLowLatencyInSize() const;
			unsigned int MaxLowLatencyOutSize() const;

			sbcp::Bus & GetBus();

			Register::Flag GetRegisterFlags(Register::Address address);

			class RegisterAddAccessor{
			static void AddRegister(Device & d,
			Register * reg);
			friend class Register;
			};

			class LowLatencyIOAccessor {
			static void WriteLowLatencyBuffer(Device & d,
			Byte * buffer,
			PayloadSize size);

			static void ReadLowLatencyBuffer(Device &d,
			const Byte * buffer,
			PayloadSize size);

			friend class ScheduledWorkflow;
			};



			protected :
			typedef std::vector<Register *> ListOfRegisters;

			ListOfRegisters & Registers();

			void EnablesLowLatencyPacket(const ListOfWriters & inputs,
			const ListOfReaders & outputs);

			private :

			friend class Accessor;

			void AddRegister(Register * base);

			void WriteLowLatencyBuffer(Byte * buffer, PayloadSize size);
			void ReadLowLatencyBuffer(const Byte * buffer, PayloadSize size);

			void CheckReaderOwnership(const ListOfReaders & outputs);
			void CheckWritersOwnership(const ListOfWriters & inputs);

			void GetLowLatencyPacketDefinition();

			void FillStdRegisters();

			sbcp::Class d_class;
			DevID d_id;
			FirmwareVersion d_version;
			SBCPVersion d_comVersion;

			std::vector<Register *> d_registers;

			sbcp::Bus & d_bus;

			ListOfReaders d_llReaders;
			ListOfWriters d_llWriters;

			PayloadSize d_maxllInputSize;
			PayloadSize d_maxllOutputSize;

			std::shared_ptr<Register> d_classReg, d_idReg, d_firmwareReg;
			bool d_fillingStdRegister;
			};


			}


			inline
			void sbcp::Device::RegisterAddAccessor::AddRegister(Device & d,
			Register * reg) {
			d.AddRegister(reg);
			}



			#endif // LIBSBCP_DEVICE_DEVICE_H_

libsbcp/src/libsbcp/device/Device.h
a1f3a42630f0master

Device.h
View Options

libsbcp/src/libsbcp/device/Device.ha1f3a42630f0master

Device.hView Options

libsbcp/src/libsbcp/device/Device.h
a1f3a42630f0master

Device.h
View Options