Proto server added for better performance of remote application using a binary protocol;

gpio2spi added which can be used to switch the GPIO pins into SPI mode if necessary;


Former-commit-id: 237f495289ce2f4afae49b36684f464937dbd30f

libsrc/protoserver/ProtoClientConnection.cpp

@@ -0,0 +1,231 @@
+// system includes
+#include <stdexcept>
+#include <cassert>
+
+// stl includes
+#include <iostream>
+#include <sstream>
+#include <iterator>
+
+// Qt includes
+#include <QResource>
+#include <QDateTime>
+
+// hyperion util includes
+#include "hyperion/ImageProcessorFactory.h"
+#include "hyperion/ImageProcessor.h"
+#include "utils/RgbColor.h"
+
+// project includes
+#include "ProtoClientConnection.h"
+
+ProtoClientConnection::ProtoClientConnection(QTcpSocket *socket, Hyperion * hyperion) :
+	QObject(),
+	_socket(socket),
+	_imageProcessor(ImageProcessorFactory::getInstance().newImageProcessor()),
+	_hyperion(hyperion),
+	_receiveBuffer()
+{
+	// connect internal signals and slots
+	connect(_socket, SIGNAL(disconnected()), this, SLOT(socketClosed()));
+	connect(_socket, SIGNAL(readyRead()), this, SLOT(readData()));
+}
+
+ProtoClientConnection::~ProtoClientConnection()
+{
+	delete _socket;
+}
+
+void ProtoClientConnection::readData()
+{
+	_receiveBuffer += _socket->readAll();
+
+	// check if we can read a message size
+	if (_receiveBuffer.size() <= 4)
+	{
+		return;
+	}
+
+	// read the message size
+	uint32_t messageSize =
+			((_receiveBuffer[0]<<24) & 0xFF000000) |
+			((_receiveBuffer[1]<<16) & 0x00FF0000) |
+			((_receiveBuffer[2]<< 8) & 0x0000FF00) |
+			((_receiveBuffer[3]    ) & 0x000000FF);
+
+	// check if we can read a complete message
+	if ((uint32_t) _receiveBuffer.size() < messageSize + 4)
+	{
+		return;
+	}
+
+	// read a message
+	proto::HyperionRequest message;
+	try
+	{
+		message.ParseFromArray(_receiveBuffer.data() + 4, messageSize);
+	}
+	catch(const std::exception & e)
+	{
+		sendErrorReply(std::string("Unable to parse message: ") + e.what());
+	}
+
+	// handle the message
+	handleMessage(message);
+
+	// remove message data from buffer
+	_receiveBuffer = _receiveBuffer.mid(messageSize + 4);
+}
+
+void ProtoClientConnection::socketClosed()
+{
+	emit connectionClosed(this);
+}
+
+void ProtoClientConnection::handleMessage(const proto::HyperionRequest & message)
+{
+	switch (message.command())
+	{
+	case proto::HyperionRequest::COLOR:
+		if (!message.HasExtension(proto::ColorRequest::colorRequest))
+		{
+			sendErrorReply("Received COLOR command without ColorRequest");
+			break;
+		}
+		handleColorCommand(message.GetExtension(proto::ColorRequest::colorRequest));
+		break;
+	case proto::HyperionRequest::IMAGE:
+		if (!message.HasExtension(proto::ImageRequest::imageRequest))
+		{
+			sendErrorReply("Received IMAGE command without ImageRequest");
+			break;
+		}
+		handleImageCommand(message.GetExtension(proto::ImageRequest::imageRequest));
+		break;
+	case proto::HyperionRequest::CLEAR:
+		if (!message.HasExtension(proto::ClearRequest::clearRequest))
+		{
+			sendErrorReply("Received CLEAR command without ClearRequest");
+			break;
+		}
+		handleClearCommand(message.GetExtension(proto::ClearRequest::clearRequest));
+		break;
+	case proto::HyperionRequest::CLEARALL:
+		handleClearallCommand();
+		break;
+	default:
+		handleNotImplemented();
+	}
+}
+
+void ProtoClientConnection::handleColorCommand(const proto::ColorRequest &message)
+{
+	if (message.rgbcolor().size() != 3)
+	{
+		sendErrorReply("The rgbcolor field requires a length of 3");
+		return;
+	}
+
+	// extract parameters
+	int priority = message.priority();
+	int duration = message.has_duration() ? message.duration() : -1;
+	const std::string & rgbColor = message.rgbcolor();
+	RgbColor color = {uint8_t(rgbColor[0]), uint8_t(rgbColor[1]), uint8_t(rgbColor[2])};
+
+	// set output
+	_hyperion->setColor(priority, color, duration);
+
+	// send reply
+	sendSuccessReply();
+}
+
+void ProtoClientConnection::handleImageCommand(const proto::ImageRequest &message)
+{
+	// extract parameters
+	int priority = message.priority();
+	int duration = message.has_duration() ? message.duration() : -1;
+	int width = message.imagewidth();
+	int height = message.imageheight();
+	const std::string & imageData = message.imagedata();
+
+	// check consistency of the size of the received data
+	if ((int) imageData.size() != width*height*3)
+	{
+		sendErrorReply("Size of image data does not match with the width and height");
+		return;
+	}
+
+	// set width and height of the image processor
+	_imageProcessor->setSize(width, height);
+
+	// create RgbImage
+	RgbImage image(width, height);
+	memcpy(image.memptr(), imageData.c_str(), imageData.size());
+
+	// process the image
+	std::vector<RgbColor> ledColors = _imageProcessor->process(image);
+	_hyperion->setColors(priority, ledColors, duration);
+
+	// send reply
+	sendSuccessReply();
+}
+
+
+void ProtoClientConnection::handleClearCommand(const proto::ClearRequest &message)
+{
+	// extract parameters
+	int priority = message.priority();
+
+	// clear priority
+	_hyperion->clear(priority);
+
+	// send reply
+	sendSuccessReply();
+}
+
+void ProtoClientConnection::handleClearallCommand()
+{
+	// clear priority
+	_hyperion->clearall();
+
+	// send reply
+	sendSuccessReply();
+}
+
+
+void ProtoClientConnection::handleNotImplemented()
+{
+	sendErrorReply("Command not implemented");
+}
+
+void ProtoClientConnection::sendMessage(const google::protobuf::Message &message)
+{
+	std::string serializedReply = message.SerializeAsString();
+	uint32_t size = serializedReply.size();
+	uint8_t sizeData[] = {uint8_t(size >> 24), uint8_t(size >> 16), uint8_t(size >> 8), uint8_t(size)};
+	std::cout << sizeData[0] << " " << sizeData[0] << " " << sizeData[0] << " " << sizeData[0] << " <data>" << std::endl;
+	_socket->write((const char *) sizeData, sizeof(sizeData));
+	_socket->write(serializedReply.data(), serializedReply.length());
+	_socket->flush();
+}
+
+void ProtoClientConnection::sendSuccessReply()
+{
+	// create reply
+	proto::HyperionReply reply;
+	reply.set_success(true);
+
+	// send reply
+	sendMessage(reply);
+}
+
+void ProtoClientConnection::sendErrorReply(const std::string &error)
+{
+	// create reply
+	proto::HyperionReply reply;
+	reply.set_success(false);
+	reply.set_error(error);
+
+	// send reply
+	sendMessage(reply);
+}