zakladna komunikacia, broadcast

Core/Inc/NbusBridge.h

@@ -18,18 +18,30 @@
 #define SENSOR_ADDRESS(packet)  packet[1]
 #define FUNCTION_CODE(packet)   packet[2]
 
+#define BROADCAST_ADDRESS	0
+#define RX_META	4
+
 /* DEFINES END */
 
+typedef enum {
+	STATE_STOPPED,
+	STATE_RUNNING,
+}RunState_e;
+
 class NbusBridge {
 
 private:
 	NbusCommunicator *_communicator;
 	NbusSlave _slaves[MAX_SLAVES];
+	uint8_t _slave_adress[MAX_SLAVES];
 	uint8_t _num_slaves;
-
+	RunState_e _run_state;
+	DataFrame *_workerFrame;
 
 	void transmit(DataFrame *packet);
+	void process_broadcast(uint8_t *rxFrame);
 	DataFrame *_frame_nbus_internal;
+	Nbus_pdu _pdu;
 
 public:
 	NbusBridge(NbusCommunicator *);
@@ -41,6 +53,10 @@ public:
 	NbusSlave * getSlave(uint8_t index);
 	void sendResponseToMaster(DataFrame *response_frame);
 	void processRequest(uint8_t *rxFrame, uint8_t size);
+	void broadcastStart();
+	void broadcastStop();
+	void processRunningState();
+
 };
 
 #endif /* SRC_NBUSBRIDGE_H_ */

Core/Inc/NbusCommunicator.h

@@ -34,11 +34,12 @@ private:
 	void _receive();
 public:
 	NbusCommunicator(UART_HandleTypeDef*, UART_HandleTypeDef*);
-	void transmit(uint8_t *, uint8_t);
+//	void transmit(uint8_t *, uint8_t);
 	void sendToMaster(DataFrame *master_frame);
 	virtual ~NbusCommunicator();
 
-	DataFrame* send(Nbus_pdu *pdu, uint8_t *data, uint8_t data_len);
+	DataFrame* sendAndReceive(Nbus_pdu *pdu, uint8_t *data, uint8_t data_len);
+	void send(Nbus_pdu *pdu, uint8_t *data, uint8_t data_len);
 };
 
 

Core/Inc/NbusSlave.h

@@ -35,11 +35,13 @@ public:
 	DataFrame* nbus_echo();
 	DataFrame* nbus_sensor_count();
 	DataFrame* nbus_sensor_type(uint8_t);
-	DataFrame* nbus_sensor_parameters(uint8_t);
-	DataFrame* nbus_sensors_parameters();
+	DataFrame* nbus_sensor_format(uint8_t);
+//	DataFrame* nbus_sensors_formats();
+//	DataFrame* nbus_sensor_format(uint8_t, uint8_t);
 	DataFrame* nbus_module_info();
-	DataFrame* nbus_sensor_parameter(uint8_t, uint8_t);
 	DataFrame* nbus_sensor_getData(uint8_t sensor_address);
+	DataFrame* nbus_sensor_parameter(uint8_t, uint8_t);
+	DataFrame* nbus_sensor_parameters(uint8_t);
 
 	uint8_t nbus_get_sensor_count(bool check_hw = false);
 

Core/Src/AppBridge.cpp

@@ -43,15 +43,8 @@ void app(UART_HandleTypeDef *uartNbus, UART_HandleTypeDef *uartMaster){
 
 
 	while(1){
-/*
-		for(uint32_t i=0; i<bridge.getNumSlaves() ; i++){
-			for(uint32_t k = 0 ; k <= bridge.getSlave(i)->nbus_get_sensor_count(false) ; k++){
-				frameTX = bridge.getSlave(i)->nbus_sensor_getData(k);
-				bridge.sendResponseToMaster(frameTX);
-			}
+		bridge.processRunningState();
 
-		}
-*/
 		if(flagUartMasterDataReady > 0){
 			bridge.processRequest(pMasterUartFrame, flagUartMasterDataReady);
 			flagUartMasterDataReady = 0;

Core/Src/NbusBridge.cpp

@@ -45,6 +45,8 @@ NbusBridge::NbusBridge(NbusCommunicator *nc) {
 	}
 	_communicator = nc;
 	_num_slaves = 0;
+	_run_state = STATE_STOPPED;
+	_pdu.sa = BROADCAST_ADDRESS;
 }
 
 NbusBridge::~NbusBridge() {
@@ -60,18 +62,21 @@ void NbusBridge::scan(){
 	Nbus_pdu pdu;
 	pdu.fc = FC_ECHO;
 	pdu.sa = SLAVE_ADDRESS_MODULE;
+	_pdu.ma = SLAVE_ADDRESS_MODULE;
 	uint8_t data[4] = {110, 66, 117, 115};	// nBus
 	const uint8_t data_offset = 4;
+	uint8_t slave_index = 0;
 
 	for(uint32_t i = 1 ; i < MAX_SLAVES; i++){
 		pdu.ma = i;
-		frame = _communicator->send(&pdu, data, 4);
+		frame = _communicator->sendAndReceive(&pdu, data, 4);
 		if (!frame->IsEmpty()){
 			response = frame->GetFrame();
 			if(response[0+data_offset] == 110 && response[1+data_offset] == 66 && response[2+data_offset] == 117 && response[3+data_offset] == 115) {
 				_num_slaves++;
 				_slaves[i].setAddress(i);
 				_slaves[i].setCommunicator(_communicator);
+				_slave_adress[slave_index++] = i;
 			}
 		}
 	}
@@ -110,7 +115,41 @@ void NbusBridge::sendResponseToMaster(DataFrame *response_frame){
 	}
 }
 
+void NbusBridge::broadcastStart(){
+	_pdu.fc = FC_START;
+	_pdu.ma = BROADCAST_ADDRESS;
+	_communicator->send(&_pdu, NULL, 0);
+	_run_state = STATE_RUNNING;
+}
+
+void NbusBridge::broadcastStop(){
+	_pdu.fc = FC_STOP;
+	_pdu.ma = BROADCAST_ADDRESS;
+	_communicator->send(&_pdu, NULL, 0);
+	_run_state = STATE_STOPPED;
+}
+
+void NbusBridge::process_broadcast(uint8_t *rxFrame){
+	switch(FUNCTION_CODE(rxFrame)) {
+
+	case FC_STOP:			/* 2 */
+		this->broadcastStop();
+		break;
+
+	case FC_START:			/* 3 */
+		this->broadcastStart();
+		break;
+
+	}
+}
+
+
 void NbusBridge::processRequest(uint8_t *rxFrame, uint8_t size){
+	if (MODULE_ADDRESS(rxFrame) == 0){
+		process_broadcast(rxFrame);
+		return;
+	}
+
 	uint8_t send_reponse = 1;
 	NbusSlave *selected_slave = getSlave(MODULE_ADDRESS(rxFrame));
 	if (selected_slave == NULL){
@@ -137,13 +176,12 @@ void NbusBridge::processRequest(uint8_t *rxFrame, uint8_t size){
 		_frame_nbus_internal = selected_slave->nbus_echo();
 		break;
 
-	case FC_STOP:			/* 2 */
-		break;
-
-	case FC_START:			/* 3 */
-		break;
-
 	case FC_PARAM:			/* 4 */
+		if(size == RX_META){
+			_frame_nbus_internal = selected_slave->nbus_sensor_parameters(SENSOR_ADDRESS(rxFrame));
+		} else{
+			_frame_nbus_internal = selected_slave->nbus_sensor_parameter(SENSOR_ADDRESS(rxFrame), rxFrame[RX_META-1]);
+		}
 		break;
 
 	case FC_SENSOR_CNT:		/* 5 */
@@ -180,7 +218,7 @@ void NbusBridge::processRequest(uint8_t *rxFrame, uint8_t size){
 		break;
 
 	case FC_SENSOR_FORMAT: 	/* 0xF => 15 */
-		_frame_nbus_internal = selected_slave->nbus_sensor_parameters(SENSOR_ADDRESS(rxFrame));
+		_frame_nbus_internal = selected_slave->nbus_sensor_format(SENSOR_ADDRESS(rxFrame));
 		break;
 	default:
 		send_reponse = 0;
@@ -191,3 +229,24 @@ void NbusBridge::processRequest(uint8_t *rxFrame, uint8_t size){
 	}
 
 }
+
+void NbusBridge::processRunningState(){
+	if (_run_state == STATE_STOPPED ){
+		HAL_GPIO_WritePin(GPIOB, GPIO_PIN_3, GPIO_PIN_RESET);
+		return;
+	}
+
+	HAL_GPIO_WritePin(GPIOB, GPIO_PIN_3, GPIO_PIN_SET);
+	NbusSlave *slave;
+	for(uint32_t i=0; i< _num_slaves; i++){
+		slave = getSlave(_slave_adress[i]);
+		if(slave != NULL && slave->isActive()){
+			for(uint32_t k = 0 ; k <= slave->nbus_get_sensor_count(false) ; k++){
+				_workerFrame = slave->nbus_sensor_getData(k);
+				sendResponseToMaster(_workerFrame);
+			}
+		}
+
+	}
+	HAL_Delay(1);	// TREBA VYSKUSAT
+}

Core/Src/NbusCommunicator.cpp

@@ -52,7 +52,7 @@ void NbusCommunicator::_receive(){
 	HAL_GPIO_WritePin(GPIOB, GPIO_PIN_3, GPIO_PIN_SET);
 
 	// komunikacia v DMA musi byt spracovana aj tak ako blokujuca
-	// takto je tu menej rezie
+	// takto je tu menej rezie. Timeout je 2ms
 	HAL_UARTEx_ReceiveToIdle(_uart_nbus, _data_packet_comm, NBUS_MAX_FRAME_SIZE, &received_size, 2);
 
 	HAL_GPIO_WritePin(GPIOB, GPIO_PIN_3, GPIO_PIN_RESET);
@@ -65,13 +65,20 @@ void NbusCommunicator::_receive(){
 
 }
 
-void NbusCommunicator::transmit(uint8_t *frame, uint8_t length){
-	HAL_UART_Transmit(_uart_nbus, frame, length, 100);
+//void NbusCommunicator::transmit(uint8_t *frame, uint8_t length){
+//	HAL_UART_Transmit(_uart_nbus, frame, length, 100);
+//
+//	HAL_UARTEx_ReceiveToIdle_DMA(_uart_nbus, _data_packet_rx, 64);
+//}
+
+DataFrame* NbusCommunicator::sendAndReceive(Nbus_pdu *pdu, uint8_t *data, uint8_t data_len){
+	this->send(pdu, data, data_len);
+	this->_receive();
+	return _packet_rx;
 
-	HAL_UARTEx_ReceiveToIdle_DMA(_uart_nbus, _data_packet_rx, 64);
 }
 
-DataFrame* NbusCommunicator::send(Nbus_pdu *pdu, uint8_t *data, uint8_t data_len){
+void NbusCommunicator::send(Nbus_pdu *pdu, uint8_t *data, uint8_t data_len){
 	_packet_tx->Init();
 	_packet_tx->AddInt8(pdu->ma);	// Module address
 	_packet_tx->AddInt8(pdu->sa);	// Slave address
@@ -85,9 +92,6 @@ DataFrame* NbusCommunicator::send(Nbus_pdu *pdu, uint8_t *data, uint8_t data_len
 	HAL_UART_Transmit_DMA(_uart_nbus, _packet_tx->GetFrame(), length);
 	HAL_GPIO_WritePin(GPIOB, GPIO_PIN_3, GPIO_PIN_RESET);
 
-	this->_receive();
-	return _packet_rx;
-
 }
 
 void NbusCommunicator::sendToMaster(DataFrame *master_frame){

Core/Src/NbusSlave.cpp

@@ -45,7 +45,7 @@ DataFrame* NbusSlave::nbus_echo() {
 	_sensor_cache[2] = 62 + _pdu.ma;
 	_sensor_cache[3] = 63 + _pdu.ma;
 	_sensor_count = 0;
-	return _communicator->send(&_pdu, _sensor_cache, 4);
+	return _communicator->sendAndReceive(&_pdu, _sensor_cache, 4);
 }
 
 uint8_t NbusSlave::nbus_get_sensor_count(bool check_hw) {
@@ -58,44 +58,59 @@ uint8_t NbusSlave::nbus_get_sensor_count(bool check_hw) {
 DataFrame* NbusSlave::nbus_sensor_count() {
 	_pdu.sa = SLAVE_ADDRESS_MODULE;
 	_pdu.fc = FC_SENSOR_CNT;
-	DataFrame* df = _communicator->send(&_pdu, _sensor_cache, 0);
+	DataFrame* df = _communicator->sendAndReceive(&_pdu, _sensor_cache, 0);
 	_sensor_count = df->GetFrame()[3];
 	return df;
 
 }
 
-DataFrame* NbusSlave::nbus_sensor_type(uint8_t sensor_address) {
-	_pdu.sa = sensor_address;
+DataFrame* NbusSlave::nbus_sensor_type(uint8_t sensor_index) {
+	_pdu.sa = sensor_index;
 	_pdu.fc = FC_SENSOR_TYPE;
-	return _communicator->send(&_pdu, _sensor_cache, 0);
+	return _communicator->sendAndReceive(&_pdu, _sensor_cache, 0);
 }
 
 
 DataFrame* NbusSlave::nbus_module_info() {
 	_pdu.sa = SLAVE_ADDRESS_MODULE;
 	_pdu.fc = FC_INFO;
-	return _communicator->send(&_pdu, _sensor_cache, 0);
+	return _communicator->sendAndReceive(&_pdu, _sensor_cache, 0);
 }
 
-DataFrame* NbusSlave::nbus_sensors_parameters() {
-	return nbus_sensor_parameters(0);
+//DataFrame* NbusSlave::nbus_sensors_formats() {
+//	return nbus_sensor_formats(0);
+//}
+
+DataFrame* NbusSlave::nbus_sensor_format(uint8_t sensor_index) {
+	_pdu.sa = sensor_index;
+	_pdu.fc = FC_SENSOR_FORMAT;
+	return _communicator->sendAndReceive(&_pdu, _sensor_cache, 0);
 }
 
-DataFrame* NbusSlave::nbus_sensor_parameters(uint8_t sensor_address) {
+//DataFrame* NbusSlave::nbus_sensor_format(uint8_t sensor_address, uint8_t  sensor_index) {
+//	_pdu.sa = sensor_address;
+//	_pdu.fc = FC_SENSOR_FORMAT;
+//	_sensor_cache[0] = sensor_index;
+//	return _communicator->sendAndReceive(&_pdu, _sensor_cache, 1);
+//}
+
+DataFrame* NbusSlave::nbus_sensor_getData(uint8_t sensor_address) {
 	_pdu.sa = sensor_address;
-	_pdu.fc = FC_SENSOR_FORMAT;
-	return _communicator->send(&_pdu, _sensor_cache, 0);
+	_pdu.fc = FC_DATA;
+	return _communicator->sendAndReceive(&_pdu, _sensor_cache, 0);
 }
 
 DataFrame* NbusSlave::nbus_sensor_parameter(uint8_t sensor_address, uint8_t  parameter) {
 	_pdu.sa = sensor_address;
-	_pdu.fc = FC_SENSOR_FORMAT;
+	_pdu.fc = FC_PARAM;
 	_sensor_cache[0] = parameter;
-	return _communicator->send(&_pdu, _sensor_cache, 1);
+	return _communicator->sendAndReceive(&_pdu, _sensor_cache, 1);
 }
 
-DataFrame* NbusSlave::nbus_sensor_getData(uint8_t sensor_address) {
+DataFrame* NbusSlave::nbus_sensor_parameters(uint8_t sensor_address) {
 	_pdu.sa = sensor_address;
-	_pdu.fc = FC_DATA;
-	return _communicator->send(&_pdu, _sensor_cache, 0);
+	_pdu.fc = FC_PARAM;
+	return _communicator->sendAndReceive(&_pdu, _sensor_cache, 0);
 }
+
+