/** Read a char. */
uint8_t
uart_getc (void)
{
uint8_t c;
if (uart (eof))
return 0xff;
c = *(uint8_t *) 0x20;
if (!c)
{
uart (exit) ();
c = 0xff;
}
return c;
}
int main(void)
{
Utils::SerialPeer::Settings settings;
settings.mode = Utils::SerialPeer::UART_8N1;
settings.flow = Utils::SerialPeer::UART_NO_FLOW_CONTROL;
settings.speed = Utils::SerialPeer::BAUD_115200;
Utils::SerialPeer uart("/dev/pts/8", settings);
std::vector<unsigned char> str;
Iriss::Command cmd;
while(1) {
std::cout << "Waiting on reception of a command\n";
uart.recv(str);
std::cout << "Received something!: " << &(str[0]) << "\n";
if(cmd.get() == Iriss::Command::ACK) {
std::cout << "Got an ACK over serial!\n";
}
std::cout << "Sending an ACK back!\n";
cmd.set(Iriss::Command::ACK);
uart.send(cmd);
std::cout << "Sent an ACK back!\n";
}
}
void selz80_state::selz80(machine_config &config)
{
/* basic machine hardware */
Z80(config, m_maincpu, XTAL(4'000'000)); // it's actually a 5MHz XTAL with a NEC uPD780C-1 cpu
m_maincpu->set_addrmap(AS_PROGRAM, &selz80_state::selz80_mem);
m_maincpu->set_addrmap(AS_IO, &selz80_state::selz80_io);
MCFG_MACHINE_RESET_OVERRIDE(selz80_state, selz80 )
/* video hardware */
config.set_default_layout(layout_selz80);
/* Devices */
CLOCK(config, m_clock, 153600);
m_clock->signal_handler().set("uart", FUNC(i8251_device::write_txc));
m_clock->signal_handler().append("uart", FUNC(i8251_device::write_rxc));
i8251_device &uart(I8251(config, "uart", 0));
uart.txd_handler().set("rs232", FUNC(rs232_port_device::write_txd));
uart.dtr_handler().set("rs232", FUNC(rs232_port_device::write_dtr));
uart.rts_handler().set("rs232", FUNC(rs232_port_device::write_rts));
rs232_port_device &rs232(RS232_PORT(config, "rs232", default_rs232_devices, nullptr));
rs232.rxd_handler().set("uart", FUNC(i8251_device::write_rxd));
rs232.dsr_handler().set("uart", FUNC(i8251_device::write_dsr));
rs232.cts_handler().set("uart", FUNC(i8251_device::write_cts));
i8279_device &kbdc(I8279(config, "i8279", 5000000 / 2)); // based on divider
kbdc.out_sl_callback().set(FUNC(selz80_state::scanlines_w)); // scan SL lines
kbdc.out_disp_callback().set(FUNC(selz80_state::digit_w)); // display A&B
kbdc.in_rl_callback().set(FUNC(selz80_state::kbd_r)); // kbd RL lines
kbdc.in_shift_callback().set_constant(1); // Shift key
kbdc.in_ctrl_callback().set_constant(1);
}
//Initialize the mhTerminal
void Terminal::Init()
{
#ifdef ENABLE_TERMINAL
registeredCallbacks = new SimplePushStack(MAX_TERMINAL_COMMAND_LISTENER_CALLBACKS);
//Start UART communication
log_transport_init();
char versionString[15];
Utility::GetVersionStringFromInt(Config->firmwareVersion, versionString);
if (promptAndEchoMode)
{
//Send Escape sequence
log_transport_put(27); //ESC
log_transport_putstring((const u8*) "[2J"); //Clear Screen
log_transport_put(27); //ESC
log_transport_putstring((const u8*) "[H"); //Cursor to Home
//Send App start header
log_transport_putstring((const u8*) "--------------------------------------------------" EOL);
log_transport_putstring((const u8*) "Terminal started, compile date: ");
log_transport_putstring((const u8*) __DATE__);
log_transport_putstring((const u8*) " ");
log_transport_putstring((const u8*) __TIME__);
log_transport_putstring((const u8*) ", version: ");
log_transport_putstring((const u8*) versionString);
#ifdef NRF52
log_transport_putstring((const u8*) ", nRF52");
#else
log_transport_putstring((const u8*) ", nRF51");
#endif
if(Config->deviceConfigOrigin == Conf::deviceConfigOrigins::RANDOM_CONFIG){
log_transport_putstring((const u8*) ", RANDOM Config");
} else if(Config->deviceConfigOrigin == Conf::deviceConfigOrigins::UICR_CONFIG){
log_transport_putstring((const u8*) ", UICR Config");
} else if(Config->deviceConfigOrigin == Conf::deviceConfigOrigins::TESTDEVICE_CONFIG){
log_transport_putstring((const u8*) ", TESTDEVICE Config");
}
log_transport_putstring((const u8*) EOL "--------------------------------------------------" EOL);
} else {
uart("NODE", "{\"type\":\"reboot\"}" SEP);
}
terminalIsInitialized = true;
#endif
}
IMPLEMENTATION [libuart]:
#include "io_regblock_asi.h"
EXTENSION class Uart
{
L4::Io_register_block_asi _regs;
};
IMPLEMENT inline Uart::Uart() : _regs(base()) {}
PUBLIC bool Uart::startup()
{
return uart()->startup(&_regs);
}
void konin_state::konin(machine_config &config)
{
/* basic machine hardware */
i8080_cpu_device &maincpu(I8080(config, m_maincpu, XTAL(4'000'000)));
maincpu.set_addrmap(AS_PROGRAM, &konin_state::konin_mem);
maincpu.set_addrmap(AS_IO, &konin_state::konin_io);
maincpu.out_inte_func().set(m_picu, FUNC(i8214_device::inte_w));
maincpu.set_irq_acknowledge_callback(device_irq_acknowledge_delegate(FUNC(i8212_device::inta_cb), "intlatch", (i8212_device*)nullptr));
i8212_device &intlatch(I8212(config, "intlatch", 0));
intlatch.md_rd_callback().set_constant(0);
intlatch.di_rd_callback().set(m_picu, FUNC(i8214_device::vector_r));
intlatch.int_wr_callback().set_inputline("maincpu", I8085_INTR_LINE);
I8214(config, m_picu, XTAL(4'000'000));
m_picu->int_wr_callback().set("intlatch", FUNC(i8212_device::stb_w));
pit8253_device &mainpit(PIT8253(config, "mainpit", 0));
// wild guess at UART clock and source
mainpit.set_clk<0>(1536000);
mainpit.out_handler<0>().set("uart", FUNC(i8251_device::write_txc));
mainpit.out_handler<0>().append("uart", FUNC(i8251_device::write_rxc));
I8255(config, "mainppi", 0);
PIT8253(config, m_iopit, 0);
I8255(config, m_ioppi, 0);
i8251_device &uart(I8251(config, "uart", 0));
uart.txd_handler().set("rs232", FUNC(rs232_port_device::write_txd));
uart.dtr_handler().set("rs232", FUNC(rs232_port_device::write_dtr));
uart.rts_handler().set("rs232", FUNC(rs232_port_device::write_rts));
uart.rxrdy_handler().set(FUNC(konin_state::picu_r3_w));
rs232_port_device &rs232(RS232_PORT(config, "rs232", default_rs232_devices, "terminal"));
rs232.rxd_handler().set("uart", FUNC(i8251_device::write_rxd));
rs232.dsr_handler().set("uart", FUNC(i8251_device::write_dsr));
rs232.cts_handler().set("uart", FUNC(i8251_device::write_cts));
}
void ScanningModule::ConnectionPacketReceivedEventHandler(connectionPacket* inPacket, Connection* connection, connPacketHeader* packetHeader, u16 dataLength)
{
//Must call superclass for handling
Module::ConnectionPacketReceivedEventHandler(inPacket, connection, packetHeader, dataLength);
if(packetHeader->messageType == MESSAGE_TYPE_MODULE_TRIGGER_ACTION){
connPacketModuleRequest* packet = (connPacketModuleRequest*)packetHeader;
//Check if our module is meant and we should trigger an action
if(packet->moduleId == moduleId){
//It's a LED message
if(packet->data[0] == ScanModuleMessages::TOTAL_SCANNED_PACKETS){
u32 totalMessages;
i32 totalRSSI;
memcpy(&totalMessages, packet->data+1, 4);
memcpy(&totalRSSI, packet->data+5, 4);
uart("SCANMOD", "{\"module\":%d, \"type\":\"general\", \"msgType\":\"totalpackets\", \"sender\":%d, \"messageSum\":%u, \"rssiSum\":%d}", moduleId, packet->header.sender, totalMessages, totalRSSI);
}
}
}
}
void Node::messageReceivedCallback(connectionPacket* inPacket)
{
Connection* connection = cm->GetConnectionFromHandle(inPacket->connectionHandle);
u8* data = inPacket->data;
u16 dataLength = inPacket->dataLength;
connPacketHeader* packetHeader = (connPacketHeader*) data;
//If the packet is a handshake packet it will not be forwarded to the node but will be
//handled in the connection. All other packets go here for further processing
switch (packetHeader->messageType)
{
case MESSAGE_TYPE_CLUSTER_INFO_UPDATE:
if (dataLength == SIZEOF_CONN_PACKET_CLUSTER_INFO_UPDATE)
{
connPacketClusterInfoUpdate* packet = (connPacketClusterInfoUpdate*) data;
logt("HANDSHAKE", "IN <= %d CLUSTER_INFO_UPDATE clstID:%d, newClstId:%d, sizeChange:%d, hop:%d", connection->partnerId, packet->payload.currentClusterId, packet->payload.newClusterId, packet->payload.clusterSizeChange, packet->payload.hopsToSink);
UpdateClusterInfo(connection, packet);
}
break;
case MESSAGE_TYPE_DATA_1:
if (dataLength >= SIZEOF_CONN_PACKET_DATA_1)
{
connPacketData1* packet = (connPacketData1*) data;
logt("DATA", "IN <= %d ################## Got Data packet %d:%d:%d (len:%d) ##################", connection->partnerId, packet->payload.data[0], packet->payload.data[1], packet->payload.data[2], inPacket->dataLength);
//tracef("data is %u/%u/%u" EOL, packet->payload.data[0], packet->payload.data[1], packet->payload.data[2]);
}
break;
case MESSAGE_TYPE_DATA_2:
if (dataLength == SIZEOF_CONN_PACKET_DATA_2)
{
connPacketData2* packet = (connPacketData2*) data;
//Update our scan response with the data from this campaign
this->UpdateScanResponsePacket(packet->payload.data, packet->payload.length);
logt("DATA", "IN <= %d ################## Got Data 2 packet %c ##################", connection->partnerId, packet->payload.data[0]);
}
break;
case MESSAGE_TYPE_ADVINFO:
if (dataLength == SIZEOF_CONN_PACKET_ADV_INFO)
{
connPacketAdvInfo* packet = (connPacketAdvInfo*) data;
uart("ADVINFO", "{\"sender\":\"%d\",\"addr\":\"%x:%x:%x:%x:%x:%x\",\"count\":%d,\"rssiSum\":%d}", packet->header.sender, packet->payload.peerAddress[0], packet->payload.peerAddress[1], packet->payload.peerAddress[2], packet->payload.peerAddress[3], packet->payload.peerAddress[4], packet->payload.peerAddress[5], packet->payload.packetCount, packet->payload.inverseRssiSum);
}
break;
}
//Now we must pass the message to all of our modules for further processing
for(int i=0; i<MAX_MODULE_COUNT; i++){
if(activeModules[i] != 0){
activeModules[i]->ConnectionPacketReceivedEventHandler(inPacket, connection, packetHeader, dataLength);
}
}
}
bool StatusReporterModule::TerminalCommandHandler(string commandName, vector<string> commandArgs)
{
//Must be called to allow the module to get and set the config
Module::TerminalCommandHandler(commandName, commandArgs);
//React on commands, return true if handled, false otherwise
if(commandName == "UART_GET_CONNECTIONS")
{
//Print own connections
if(Terminal::terminalIsInitialized){
//Print our own data
uart("QOS_CONN", "{\"nodeId\":%d, \"partners\":[%d,%d,%d,%d], \"rssiValues\":[%d,%d,%d,%d]}", node->persistentConfig.nodeId, cm->connections[0]->partnerId, cm->connections[1]->partnerId, cm->connections[2]->partnerId, cm->connections[3]->partnerId, cm->connections[0]->GetAverageRSSI(), cm->connections[1]->GetAverageRSSI(), cm->connections[2]->GetAverageRSSI(), cm->connections[3]->GetAverageRSSI());
}
//Query connection information from all other nodes
connPacketQosRequest packet;
packet.header.messageType = MESSAGE_TYPE_QOS_REQUEST;
packet.header.sender = node->persistentConfig.nodeId;
packet.header.receiver = 0;
packet.payload.nodeId = 0;
packet.payload.type = 0;
cm->SendMessageOverConnections(NULL, (u8*) &packet, SIZEOF_CONN_PACKET_QOS_REQUEST, false);
}
else if(commandName == "UART_MODULE_TRIGGER_ACTION")
{
//Rewrite "this" to our own node id, this will actually build the packet
//But reroute it to our own node
nodeID destinationNode = (commandArgs[0] == "this") ? node->persistentConfig.nodeId : atoi(commandArgs[0].c_str());
if(commandArgs[1] != "STATUS") return false;
//E.g. UART_MODULE_TRIGGER_ACTION 635 STATUS led on
if(commandArgs.size() == 4 && commandArgs[2] == "led")
{
connPacketModuleRequest packet;
packet.header.messageType = MESSAGE_TYPE_MODULE_TRIGGER_ACTION;
packet.header.sender = node->persistentConfig.nodeId;
packet.header.receiver = destinationNode;
packet.moduleId = moduleId;
packet.data[0] = StatusModuleTriggerActionMessages::SET_LED_MESSAGE;
packet.data[1] = commandArgs[3] == "on" ? 1: 0;
cm->SendMessageToReceiver(NULL, (u8*)&packet, SIZEOF_CONN_PACKET_MODULE_REQUEST+2, true);
return true;
}
else if(commandArgs.size() == 3 && commandArgs[2] == "get_status")
{
SendStatusInformation(destinationNode);
return true;
}
else if(commandArgs.size() == 3 && commandArgs[2] == "get_connections")
{
connPacketModuleRequest packet;
packet.header.messageType = MESSAGE_TYPE_MODULE_TRIGGER_ACTION;
packet.header.sender = node->persistentConfig.nodeId;
packet.header.receiver = destinationNode;
packet.moduleId = moduleId;
packet.data[0] = StatusModuleTriggerActionMessages::GET_CONNECTIONS_MESSAGE;
cm->SendMessageToReceiver(NULL, (u8*)&packet, SIZEOF_CONN_PACKET_MODULE_REQUEST+1, true);
return true;
}
return false;
}
else
{
return false;
}
return true;
}
void StatusReporterModule::ConnectionPacketReceivedEventHandler(connectionPacket* inPacket, Connection* connection, connPacketHeader* packetHeader, u16 dataLength)
{
//Must call superclass for handling
Module::ConnectionPacketReceivedEventHandler(inPacket, connection, packetHeader, dataLength);
if(packetHeader->messageType == MESSAGE_TYPE_MODULE_TRIGGER_ACTION){
connPacketModuleRequest* packet = (connPacketModuleRequest*)packetHeader;
//Check if our module is meant and we should trigger an action
if(packet->moduleId == moduleId){
//It's a LED message
if(packet->data[0] == StatusModuleTriggerActionMessages::SET_LED_MESSAGE){
if(packet->data[1])
{
//Switch LED on
node->currentLedMode = Node::ledMode::LED_MODE_OFF;
node->LedRed->On();
node->LedGreen->On();
node->LedBlue->On();
}
else
{
//Switch LEDs back to connection signaling
node->currentLedMode = Node::ledMode::LED_MODE_CONNECTIONS;
}
}
//We were queried for our status
else if(packet->data[0] == StatusModuleTriggerActionMessages::GET_STATUS_MESSAGE)
{
//TODO: Build the status response packet and do not just print st. to the console
node->UartGetStatus();
}
//We were queried for our connections
else if(packet->data[0] == StatusModuleTriggerActionMessages::GET_CONNECTIONS_MESSAGE)
{
//Build response and send
u16 packetSize = SIZEOF_CONN_PACKET_MODULE_REQUEST + 1 + SIZEOF_STATUS_REPORTER_MODULE_CONNECTIONS_MESSAGE;
u8 buffer[packetSize];
connPacketModuleRequest* outPacket = (connPacketModuleRequest*)buffer;
outPacket->header.messageType = MESSAGE_TYPE_MODULE_ACTION_RESPONSE;
outPacket->header.receiver = packetHeader->sender;
outPacket->header.sender = node->persistentConfig.nodeId;
outPacket->moduleId = moduleId;
outPacket->data[0] = StatusModuleActionResponseMessages::CONNECTIONS_MESSAGE;
StatusReporterModuleConnectionsMessage* outPacketData = (StatusReporterModuleConnectionsMessage*)(outPacket->data + 1);
outPacketData->partner1 = cm->connections[0]->partnerId;
outPacketData->partner2 = cm->connections[1]->partnerId;
outPacketData->partner3 = cm->connections[2]->partnerId;
outPacketData->partner4 = cm->connections[3]->partnerId;
outPacketData->rssi1 = cm->connections[0]->GetAverageRSSI();
outPacketData->rssi2 = cm->connections[1]->GetAverageRSSI();
outPacketData->rssi3 = cm->connections[2]->GetAverageRSSI();
outPacketData->rssi4 = cm->connections[3]->GetAverageRSSI();
cm->SendMessageToReceiver(NULL, buffer, packetSize, true);
}
}
}
//Parse Module responses
if(packetHeader->messageType == MESSAGE_TYPE_MODULE_ACTION_RESPONSE){
connPacketModuleRequest* packet = (connPacketModuleRequest*)packetHeader;
//Check if our module is meant and we should trigger an action
if(packet->moduleId == moduleId)
{
//Somebody reported its connections back
if(packet->data[0] == StatusModuleActionResponseMessages::CONNECTIONS_MESSAGE)
{
StatusReporterModuleConnectionsMessage* packetData = (StatusReporterModuleConnectionsMessage*) (packet->data+1);
uart("STATUSMOD", "{\"module\":%d, \"type\":\"response\", \"msgType\":\"connections\", \"nodeId\":%d, \"partners\":[%d,%d,%d,%d], \"rssiValues\":[%d,%d,%d,%d]}", moduleId, packet->header.sender, packetData->partner1, packetData->partner2, packetData->partner3, packetData->partner4, packetData->rssi1, packetData->rssi2, packetData->rssi3, packetData->rssi4);
}
else if(packet->data[0] == StatusModuleActionResponseMessages::STATUS_MESSAGE)
{
logt("STATUSMOD", "STATUSREQUEST");
}
}
/*switch(packetHeader->messageType){
case MESSAGE_TYPE_QOS_REQUEST:
if (dataLength == SIZEOF_CONN_PACKET_QOS_REQUEST)
{
logt("DATA", "IN <= %d QOS_REQUEST", connection->partnerId);
connPacketQosRequest* packet = (connPacketQosRequest*) packetHeader;
//Check if we are requested to send a quality of service packet
if (packet->payload.nodeId == 0 || packet->payload.nodeId == node->persistentConfig.nodeId)
{
if (packet->payload.type == 0)
{
SendConnectionInformation(connection);
}
else if (packet->payload.type == 1)
{
//more
}
}
}
break;
//In case we receive a packet with connection information, we print it
case MESSAGE_TYPE_QOS_CONNECTION_DATA:
if (dataLength == SIZEOF_CONN_PACKET_QOS_CONNECTION_DATA)
{
connPacketQosConnectionData* packet = (connPacketQosConnectionData*) packetHeader;
if (Terminal::terminalIsInitialized)
{
uart("QOS_CONN", "{\"nodeId\":%d, \"partners\":[%d,%d,%d,%d], \"rssiValues\":[%d,%d,%d,%d]}", packet->header.sender, packet->payload.partner1, packet->payload.partner2, packet->payload.partner3, packet->payload.partner4, packet->payload.rssi1, packet->payload.rssi2, packet->payload.rssi3, packet->payload.rssi4);
}
}
break;
}*/
}
}
void StatusReporterModule::ConnectionPacketReceivedEventHandler(connectionPacket* inPacket, Connection* connection, connPacketHeader* packetHeader, u16 dataLength)
{
//Must call superclass for handling
Module::ConnectionPacketReceivedEventHandler(inPacket, connection, packetHeader, dataLength);
if(packetHeader->messageType == MESSAGE_TYPE_MODULE_TRIGGER_ACTION){
connPacketModule* packet = (connPacketModule*)packetHeader;
//Check if our module is meant and we should trigger an action
if(packet->moduleId == moduleId){
//We were queried for our status
if(packet->actionType == StatusModuleTriggerActionMessages::GET_STATUS)
{
SendStatus(packet->header.sender, MESSAGE_TYPE_MODULE_ACTION_RESPONSE);
}//We were queried for our device info
else if(packet->actionType == StatusModuleTriggerActionMessages::GET_DEVICE_INFO)
{
SendDeviceInfo(packet->header.sender, MESSAGE_TYPE_MODULE_ACTION_RESPONSE);
}
//We were queried for our connections
else if(packet->actionType == StatusModuleTriggerActionMessages::GET_ALL_CONNECTIONS)
{
StatusReporterModule::SendAllConnections(packetHeader->sender, MESSAGE_TYPE_MODULE_ACTION_RESPONSE);
}
//We were queried for nearby nodes (nodes in the join_me buffer)
else if(packet->actionType == StatusModuleTriggerActionMessages::GET_NEARBY_NODES)
{
StatusReporterModule::SendNearbyNodes(packetHeader->sender, MESSAGE_TYPE_MODULE_ACTION_RESPONSE);
}
//We should set ourselves initialized
else if(packet->actionType == StatusModuleTriggerActionMessages::SET_INITIALIZED)
{
node->initializedByGateway = true;
SendModuleActionMessage(
MESSAGE_TYPE_MODULE_ACTION_RESPONSE,
packet->header.sender,
StatusModuleActionResponseMessages::SET_INITIALIZED_RESULT,
0,
NULL,
0,
false
);
}
}
}
//Parse Module responses
if(packetHeader->messageType == MESSAGE_TYPE_MODULE_ACTION_RESPONSE){
connPacketModule* packet = (connPacketModule*)packetHeader;
//Check if our module is meant and we should trigger an action
if(packet->moduleId == moduleId)
{
//Somebody reported its connections back
if(packet->actionType == StatusModuleActionResponseMessages::ALL_CONNECTIONS)
{
StatusReporterModuleConnectionsMessage* packetData = (StatusReporterModuleConnectionsMessage*) (packet->data);
uart("STATUSMOD", "{\"type\":\"connections\",\"nodeId\":%d,\"module\":%d,\"partners\":[%d,%d,%d,%d],\"rssiValues\":[%d,%d,%d,%d]}" SEP, packet->header.sender, moduleId, packetData->partner1, packetData->partner2, packetData->partner3, packetData->partner4, packetData->rssi1, packetData->rssi2, packetData->rssi3, packetData->rssi4);
}
else if(packet->actionType == StatusModuleActionResponseMessages::DEVICE_INFO)
{
//Print packet to console
StatusReporterModuleDeviceInfoMessage* data = (StatusReporterModuleDeviceInfoMessage*) (packet->data);
u8* addr = data->accessAddress.addr;
uart("STATUSMOD", "{\"nodeId\":%u,\"type\":\"device_info\",\"module\":%d,", packet->header.sender, moduleId);
uart("STATUSMOD", "\"dBmRX\":%u,\"dBmTX\":%u,", data->dBmRX, data->dBmTX);
uart("STATUSMOD", "\"deviceType\":%u,\"manufacturerId\":%u,", data->deviceType, data->manufacturerId);
uart("STATUSMOD", "\"networkId\":%u,\"nodeVersion\":%u,", data->networkId, data->nodeVersion);
uart("STATUSMOD", "\"chipId\":\"%02X:%02X:%02X:%02X:%02X:%02X:%02X:%02X\",", data->chipId[0], data->chipId[1], data->chipId[2], data->chipId[3], data->chipId[4], data->chipId[5], data->chipId[6], data->chipId[7]);
uart("STATUSMOD", "\"serialNumber\":\"%.*s\",\"accessAddress\":\"%02X:%02X:%02X:%02X:%02X:%02X\"", SERIAL_NUMBER_LENGTH, data->serialNumber, addr[5], addr[4], addr[3], addr[2], addr[1], addr[0]);
uart("STATUSMOD", "}" SEP);
}
else if(packet->actionType == StatusModuleActionResponseMessages::STATUS)
{
//Print packet to console
StatusReporterModuleStatusMessage* data = (StatusReporterModuleStatusMessage*) (packet->data);
uart("STATUSMOD", "{\"nodeId\":%u,\"type\":\"status\",\"module\":%d,", packet->header.sender, moduleId);
uart("STATUSMOD", "\"batteryInfo\":%u,\"clusterSize\":%u,", data->batteryInfo, data->clusterSize);
uart("STATUSMOD", "\"connectionLossCounter\":%u,\"freeIn\":%u,", data->connectionLossCounter, data->freeIn);
uart("STATUSMOD", "\"freeOut\":%u,\"inConnectionPartner\":%u,", data->freeOut, data->inConnectionPartner);
uart("STATUSMOD", "\"inConnectionRSSI\":%d, \"initialized\":%u", data->inConnectionRSSI, data->initializedByGateway);
uart("STATUSMOD", "}" SEP);
}
else if(packet->actionType == StatusModuleActionResponseMessages::NEARBY_NODES)
{
//Print packet to console
uart("STATUSMOD", "{\"nodeId\":%u,\"type\":\"nearby_nodes\",\"module\":%u,\"nodes\":[", packet->header.sender, moduleId);
u16 nodeCount = (dataLength - SIZEOF_CONN_PACKET_MODULE) / 3;
bool first = true;
for(int i=0; i<nodeCount; i++){
u16 nodeId;
i8 rssi;
//TODO: Find a nicer way to access unaligned data in packets
memcpy(&nodeId, packet->data + i*3+0, 2);
memcpy(&rssi, packet->data + i*3+2, 1);
if(!first){
uart("STATUSMOD", ",");
}
uart("STATUSMOD", "{\"nodeId\":%u,\"rssi\":%d}", nodeId, rssi);
first = false;
}
uart("STATUSMOD", "]}" SEP);
}
else if(packet->actionType == StatusModuleActionResponseMessages::SET_INITIALIZED_RESULT)
{
uart("STATUSMOD", "{\"type\":\"set_init_result\",\"nodeId\":%u,\"module\":%u}" SEP, packet->header.sender, moduleId);
}
}
}
}
int
main(void)
{
SystemInit();
xpcc::lpc11::SysTickTimer::enable();
scl::setOutput(xpcc::lpc::OPEN_DRAIN);
sda::setOutput(xpcc::lpc::OPEN_DRAIN);
// Set LED port pin to output
rot::setOutput();
gelb::setOutput();
blau::setOutput();
gruen::setOutput();
weiss::setOutput();
rot::reset();
gelb::reset();
blau::reset();
gruen::reset();
weiss::set();
// Initialize 32-bit timer 0. TIME_INTERVAL is defined as 10mS
// You may also want to use the Cortex SysTick timer to do this
init_timer32(0, TIME_INTERVAL);
// Enable timer 0. Our interrupt handler will begin incrementing
// the TimeTick global each time timer 0 matches and resets.
enable_timer32(0);
xpcc::lpc::Uart1 uart(115200);
xpcc::delay_ms(10); // glitch ?
i2c::initialize();
XPCC_LOG_DEBUG << "TCS3414" << xpcc::endl;
// Initialize colour sensor
const uint8_t address = 0b0111001 << 1;
if(!tcs::initialize()) {
XPCC_LOG_DEBUG << "ERROR WITH INTIALIZING!" << xpcc::endl; }
xpcc::delay_ms(100);
tcs::setGain(xpcc::tcs3414::Gain::X16);
xpcc::delay_ms(100);
tcs::setIntegrationTime(xpcc::tcs3414::IntegrationMode::DEFAULT, xpcc::tcs3414::NominalIntegrationTime::MSEC_100);
while (1)
{
gelb::toggle();
xpcc::delay_ms(150);
const xpcc::tcs3414::Rgb colors = tcs::getNewColors();
xpcc::color::HsvT<xpcc::tcs3414::UnderlyingType> hsv;
colors.toHsv(&hsv);
XPCC_LOG_DEBUG << "RGB: " << colors << ";" << xpcc::endl;
XPCC_LOG_DEBUG << "HSV: " << hsv.hue << "\t" << hsv.saturation << "\t" << hsv.value << "\t" << xpcc::endl;
if(colors.red > 55)
rot::set();
else
rot::reset();
if(colors.red < 45)
blau::set();
else
blau::reset();
}
}
/** Retrieve availlable chars. */
uint8_t
uart_poll (void)
{
return !uart (eof);
}
/** Use this as exit point. */
void
uart (exit) (void)
{
uart (eof) = 1;
}
/** Initialise uart. */
void
uart_init (void)
{
uart (eof) = 0;
}
int main()
{
std::cout << "Aero will be disabled for performance reason!" << std::endl;
DisableAeroTheme();
bool exit = false; //dit is voor later een escape variable
int cap_method = D3D_CAP;
float gamma = 0.6;
GDICap Cap;
Direct3DCap D3DCap; //init directx9
JackFFT JACK;
std::ifstream myinfile;
myinfile.open("./Config.txt");
//Als het bestand is geopend bestaat die al dus sla je het maken over
if (!myinfile.is_open())
{
myinfile.close();
std::ofstream myfile;
myfile.open("./Config.txt");
CreateConfig(myfile, D3DCap);
myfile.close();
myinfile.open("./Config.txt");
}
std::string STRING;
int Config[9] = { -1 };
for (int i = 0; i < 9; i++)
{
if (myinfile.eof())
break;
std::getline(myinfile, STRING);
Config[i] = atoi(STRING.c_str());
}
myinfile.close();
//Check of config laden goed is gelukt
int i = 0;
while (Config[i] != -1 && i < 9)
{
i++;
}
if (i < 9)
{
std::cout << "Config Loading went wrong! Please delete Config.txt and run this software again!" << std::endl;
return 0;
}
std::cout << "Using screen: " << Config[0] << " for capturing" << std::endl;
D3DCap.init(Config[0]);
Cap.init(Config[0]); //
UINT32 *pBits;
switch (cap_method)
{
case GDI_CAP:
pBits = Cap.pBits;
break;
case D3D_CAP:
pBits = D3DCap.pBits;
break;
case JAC_CAP:
pBits = JACK.pBits;
}
ScreenCalc Scherm(105, //init de kleur bereken functies
pBits, //De PixelData
D3DCap.return_hres(), //De Hori Resolutie
D3DCap.return_vres(), //De Verti Resolutie
Config[1], //Hoeveel procent die moet nemen aan de bovenkant/onderkant
Config[2], //Hoeveel procent die aan de zijkant moet nemen
Config[3], //Leds Boven
Config[5], //Leds Onder
Config[4], //Leds Links
Config[6], //Leds Rechts
Config[7]);
Scherm.Bereken_Grid(); //stel de hoeveelheid leds in die worden gebruikt en bereken Grid Grootte
Scherm.set_Gamma(gamma);
//Het programma moet eerst 0xff binnen krijgen als dat het geval is dan mag die beginnen met het oversturen
//van de hoeveelheid leds
//Als die hoeveelheden overeenkomen mag die beginnen met het zenden van led data
std::string String;
String = "\\\\.\\COM";
String += std::to_string(Config[8]);
char *temp = new char[String.size() + 1];
std::copy(String.begin(), String.end(), temp);
temp[String.size()] = '\0';
Serial* SP = new Serial(temp);
delete[] temp;
temp = nullptr;
if (SP->IsConnected())
std::cout << "Connected with COM5" << std::endl;
else
{
std::cout << "Communication Error. Exiting" << std::endl;
return 0;
}
char Rx_buffer[100] = ""; //Dit is de Rx_buffer deze moet een char zijn
//je kan hier op escape drukken om het programma af ste sluiten hier
std::cout << "Waiting for Arduino. Press ESC to quit" << std::endl;
SP->ReadData(Rx_buffer, 2);
while (Rx_buffer[0] != '0') //blijf hier hangen tot de arduino klaar is
{
Sleep(100);
SP->ReadData(Rx_buffer, 2);
if (GetAsyncKeyState(VK_ESCAPE))
{
exit = true;
}
if (exit == true)
{
std::cout << "Something went wrong with communication. Check baudrate settings and COM port" << std::endl;
return 0; //beeindig de software
}
}
Rx_buffer[0] = '0';
std::cout << "Got response from arduino sending amount of leds" << std::endl;
//Stuur de hoeveelheid leds naar de arduino
UINT8 Tx_buffer[600 * 3];
ZeroMemory(Tx_buffer, 600 * 3);
Tx_buffer[0] = Scherm.geefLeds() >> 8 & 0x00FF;
Tx_buffer[1] = Scherm.geefLeds() & 0x00FF;
SP->WriteData((char*)Tx_buffer, 2);
Sleep(1000); //Wacht 1 seconde op de arduino
std::cout << "Press END to quit capturing" << std::endl;
UINT8 *pointer; //Pointer voor de led bitstream
clock_t klok1;
clock_t klok2 = 50;
pointer = Scherm.GeefLedPointer(); //Koppel de led bitstream aan de pointer
// maak een thread die nu nog niks doet
std::thread uart(send_data,SP,Rx_buffer,Scherm,pointer);
while (exit == false)
{
//std::cout << " " << "\r";
//std::cout << "FPS: " << ((1 * CLOCKS_PER_SEC) / (clock() - klok2)) << "\r";
klok2 = clock();
if (GetAsyncKeyState(VK_END)) //Als escape is ingedrukt zet exit true
{
exit = true;
}
else if (GetAsyncKeyState(VK_F8))
{
JACK.stop();
pBits = Cap.pBits;
Scherm.set_data(pBits);
cap_method = GDI_CAP;
std::cout << "Changed capture method to GDI " << std::endl;
Sleep(100);
}
else if (GetAsyncKeyState(VK_F9))
{
JACK.stop();
pBits = D3DCap.pBits;
Scherm.set_data(pBits);
cap_method = D3D_CAP;
std::cout << "Changed capture method to D3D " << std::endl;
Sleep(100);
}
else if (GetAsyncKeyState(VK_F7))
{
cap_method = JAC_CAP;
JACK.init(pointer);
std::cout << "Changed capture method to Jack Audio " << std::endl;
JACK.start();
Sleep(100);
}
else if (GetAsyncKeyState(VK_F12))
{
gamma += 0.01;
Scherm.set_Gamma(gamma);
}
else if (GetAsyncKeyState(VK_F11))
{
gamma -= 0.01;
Scherm.set_Gamma(gamma);
}
else if (GetAsyncKeyState(VK_F10))
{
std::cout << "Gamma : " << gamma << std::endl;
}
//start een thread die de data stuurt
//Scherm.Calc_Aspect_ratio();
//Maak screenshot en sla die op
switch (cap_method)
{
case GDI_CAP:
Cap.capture();
break;
case D3D_CAP:
D3DCap.capture();
break;
case JAC_CAP:
Sleep(10);
//when audio is selected everything will be handled in a different thread
break;
}
if (cap_method != JAC_CAP)
{
Scherm.Bereken();
Scherm.Calc_Aspect_ratio();
}
//wacht tot alle data verzonden is en we weer antwoord hebben gehad dat alles in orde is voordat we weer verder gaan
}
Thread_comm = 0;
uart.join();
return 0;
}
void Terminal::PollUART()
{
#ifdef ENABLE_TERMINAL
if (!terminalIsInitialized)
return;
static char readBuffer[250] = { 0 };
static char testCopy[250] = {0};
readBuffer[0] = 0;
if (simple_uart_get_with_timeout(0, (u8*) readBuffer))
{
//Output query string and typed symbol to terminal
if (promptAndEchoMode)
{
simple_uart_putstring((const u8*) EOL "mhTerm: "); //Display prompt
simple_uart_put(readBuffer[0]); //echo back symbol
}
//Read line from uart
ReadlineUART(readBuffer, 250, 1);
//FIXME: remove after finding problem
memcpy(testCopy, readBuffer, 250);
//Clear previous command
commandName.clear();
commandArgs.clear();
//Tokenize input string into vector
char* token = strtok(readBuffer, " ");
if (token != NULL)
commandName.assign(token);
while (token != NULL)
{
token = strtok(NULL, " ");
if (token != NULL)
commandArgs.push_back(string(token));
}
//Check for clear screen
if (commandName == "cls")
{
//Send Escape sequence
simple_uart_put(27); //ESC
simple_uart_putstring((const u8*) "[2J"); //Clear Screen
simple_uart_put(27); //ESC
simple_uart_putstring((const u8*) "[H"); //Cursor to Home
}
else
{
//Call all callbacks
int handled = 0;
for(u32 i=0; i<registeredCallbacks->size(); i++){
handled += ((TerminalCommandListener*)registeredCallbacks->GetItemAt(i))->TerminalCommandHandler(commandName, commandArgs);
}
if (handled == 0){
if(promptAndEchoMode){
simple_uart_putstring((const u8*)"Command not found" EOL);
} else {
uart_error(Logger::COMMAND_NOT_FOUND);
}
//FIXME: to find problems with uart input
uart("ERROR", "{\"user_input\":\"%s\"}" SEP, testCopy);
}
}
}
#endif
}
void EnrollmentModule::ConnectionPacketReceivedEventHandler(connectionPacket* inPacket, Connection* connection, connPacketHeader* packetHeader, u16 dataLength)
{
//Must call superclass for handling
Module::ConnectionPacketReceivedEventHandler(inPacket, connection, packetHeader, dataLength);
if(packetHeader->messageType == MESSAGE_TYPE_MODULE_TRIGGER_ACTION){
connPacketModule* packet = (connPacketModule*)packetHeader;
//Check if our module is meant and we should trigger an action
if(packet->moduleId == moduleId){
if(packet->actionType == EnrollmentModuleTriggerActionMessages::SET_ENROLLMENT_BY_NODE_ID)
{
EnrollmentModuleSetEnrollmentByNodeIdMessage* data = (EnrollmentModuleSetEnrollmentByNodeIdMessage*)packet->data;
logt("ENROLLMOD", "Enrollment (by nodeId) received nodeId:%u, networkid:%u", data->nodeId, data->networkId);
//Stop all meshing
node->Stop();
//Save values to persistent config
node->persistentConfig.nodeId = data->nodeId;
node->persistentConfig.networkId = data->networkId;
node->SaveConfiguration();
//Switch to green LED, user must now reboot the node
node->currentLedMode = ledMode::LED_MODE_OFF;
LedRed->Off();
LedGreen->On();
LedBlue->Off();
SendEnrollmentResponse(NODE_ID_BROADCAST, enrollmentMethods::BY_NODE_ID, packet->requestHandle, 0, (u8*)Config->serialNumber);
}
else if(packet->actionType == EnrollmentModuleTriggerActionMessages::SET_ENROLLMENT_BY_CHIP_ID)
{
EnrollmentModuleSetEnrollmentByChipIdMessage* data = (EnrollmentModuleSetEnrollmentByChipIdMessage*)packet->data;
if(data->chipIdA == NRF_FICR->DEVICEID[0] && data->chipIdB == NRF_FICR->DEVICEID[1])
{
logt("ENROLLMOD", "Enrollment (by chipId) received nodeId:%u, networkid:%u, key[0]=%u, key[10]=%u, key[15]=%u", data->nodeId, data->networkId, data->networkKey[0], data->networkKey[10], data->networkKey[15]);
//Stop all meshing
node->Stop();
//Save values to persistent config
node->persistentConfig.nodeId = data->nodeId;
node->persistentConfig.networkId = data->networkId;
memcpy(&node->persistentConfig.networkKey, data->networkKey, 16);
node->SaveConfiguration();
//Switch to green LED, user must now reboot the node
node->currentLedMode = ledMode::LED_MODE_OFF;
LedRed->Off();
LedGreen->On();
LedBlue->Off();
SendEnrollmentResponse(NODE_ID_BROADCAST, enrollmentMethods::BY_CHIP_ID, packet->requestHandle, 0, (u8*)Config->serialNumber);
}
}
//If an enrollment by serial is received
else if(packet->actionType == EnrollmentModuleTriggerActionMessages::SET_ENROLLMENT_BY_SERIAL)
{
EnrollmentModuleSetEnrollmentBySerialMessage* data = (EnrollmentModuleSetEnrollmentBySerialMessage*)packet->data;
if(memcmp(data->serialNumber, Config->serialNumber, SERIAL_NUMBER_LENGTH) == 0)
{
logt("ENROLLMOD", "Enrollment (by serial) received nodeId:%u, networkid:%u, key[0]=%u, key[10]=%u, key[15]=%u", data->newNodeId, data->newNetworkId, data->newNetworkKey[0], data->newNetworkKey[10], data->newNetworkKey[15]);
//Stop all meshing
node->Stop();
//Save values to persistent config
node->persistentConfig.nodeId = data->newNodeId;
node->persistentConfig.networkId = data->newNetworkId;
memcpy(&node->persistentConfig.networkKey, data->newNetworkKey, 16);
node->SaveConfiguration();
//Switch to green LED, user must now reboot the node
node->currentLedMode = ledMode::LED_MODE_OFF;
LedRed->On();
LedGreen->On();
LedBlue->On();
//FIXME: Hotfix until NewStorage supports page swapping
//We wait some time until the enrollment is saved
for(int i=0; i<8000000; i++){
}
SendEnrollmentResponse(NODE_ID_BROADCAST, enrollmentMethods::BY_SERIAL, packet->requestHandle, 0, (u8*)Config->serialNumber);
}
}
}
}
//Parse Module responses
if(packetHeader->messageType == MESSAGE_TYPE_MODULE_ACTION_RESPONSE){
connPacketModule* packet = (connPacketModule*)packetHeader;
//Check if our module is meant and we should trigger an action
if(packet->moduleId == moduleId)
{
if(packet->actionType == EnrollmentModuleActionResponseMessages::ENROLLMENT_SUCCESSFUL)
{
EnrollmentModuleEnrollmentResponse* data = (EnrollmentModuleEnrollmentResponse*)packet->data;
const char* enrollmentMethodString = "";
if(data->enrollmentMethod == enrollmentMethods::BY_NODE_ID) enrollmentMethodString = "node_id";
else if(data->enrollmentMethod == enrollmentMethods::BY_CHIP_ID) enrollmentMethodString = "chip_id";
else if(data->enrollmentMethod == enrollmentMethods::BY_SERIAL) enrollmentMethodString = "serial";
//Add null terminator to string
u8 serialNumber[SERIAL_NUMBER_LENGTH+1];
memcpy(serialNumber, data->serialNumber, SERIAL_NUMBER_LENGTH);
serialNumber[SERIAL_NUMBER_LENGTH] = '\0';
uart("ENROLLMOD", "{\"nodeId\":%u,\"type\":\"enroll_response_%s\",\"module\":%d,", packet->header.sender, enrollmentMethodString, moduleId);
uart("ENROLLMOD", "\"requestId\":%u,\"serialNumber\":\"%s\"}" SEP, packet->requestHandle, serialNumber);
}
}
}
}
