489 lines
16 KiB
C++
489 lines
16 KiB
C++
#include "hardwaresetup.h"
|
|
#include "sys/io.h"
|
|
// filecontrol
|
|
#include <fcntl.h>
|
|
#include <iostream>
|
|
#include <memory>
|
|
#include <stdint.h>
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
#include <termios.h>
|
|
#include <unistd.h>
|
|
#ifdef ATMEGA
|
|
#include <usb.h>
|
|
#endif
|
|
|
|
#define USB_LED_ON 1
|
|
#define USB_LED_OFF 0
|
|
#define USB_DATA_OUT 2
|
|
|
|
#define HARDWARE_VERSION 3
|
|
// V1 Parallelport
|
|
// V2 USB Atmega8
|
|
// V3 STM32F07
|
|
|
|
#define PORT_PATH "/dev/ttyACM0"
|
|
|
|
using namespace std;
|
|
// not needed anymore -> usb
|
|
// #define BASEPORT 0xe050 /* lp1 */
|
|
// #define BASEPORT 0x378
|
|
// #define BASEPORT 0xd000
|
|
|
|
HardwareSetup::HardwareSetup() {
|
|
// if (ioperm(BASEPORT, 3, 1)) {
|
|
// //perror("ioperm");
|
|
// }
|
|
this->stop = 0;
|
|
#ifdef ATMEGA
|
|
this->handle = nullptr;
|
|
#endif
|
|
this->fd = 0;
|
|
}
|
|
void HardwareSetup::setStop() {
|
|
this->stop = 1;
|
|
}
|
|
|
|
HardwareSetup::~HardwareSetup() {
|
|
/*if (ioperm(BASEPORT, 3, 0)) {
|
|
//perror("ioperm");
|
|
}*/
|
|
|
|
std::cout << "Hardware beendet" << std::endl;
|
|
this->stop = 1;
|
|
|
|
if (HARDWARE_VERSION == 2) {
|
|
#ifdef ATMEGA
|
|
if (this->handle) {
|
|
usb_close(this->handle);
|
|
}
|
|
this->handle = NULL;
|
|
#endif
|
|
}
|
|
else if (HARDWARE_VERSION == 3) {
|
|
// close filedescriptor
|
|
if (this->fd < 0) {
|
|
// already closed
|
|
}
|
|
else {
|
|
close(this->fd);
|
|
}
|
|
}
|
|
}
|
|
#ifdef ATMEGA
|
|
|
|
/* Used to get descriptor strings for device identification */
|
|
int HardwareSetup::usbGetDescriptorString(usb_dev_handle * dev, int index,
|
|
int langid, char * buf, int buflen) {
|
|
char buffer[256];
|
|
int rval, i;
|
|
|
|
// make standard request GET_DESCRIPTOR, type string and given index
|
|
// (e.g. dev->iProduct)
|
|
rval = usb_control_msg(
|
|
dev, USB_TYPE_STANDARD | USB_RECIP_DEVICE | USB_ENDPOINT_IN,
|
|
USB_REQ_GET_DESCRIPTOR, (USB_DT_STRING << 8) + index, langid, buffer,
|
|
sizeof(buffer), 1000);
|
|
|
|
if (rval < 0) // error
|
|
return rval;
|
|
|
|
// rval should be bytes read, but buffer[0] contains the actual response
|
|
// size
|
|
if ((unsigned char)buffer[0] < rval)
|
|
rval = (unsigned char)buffer[0]; // string is shorter than bytes read
|
|
|
|
if (buffer[1] != USB_DT_STRING) // second byte is the data type
|
|
return 0; // invalid return type
|
|
|
|
// we're dealing with UTF-16LE here so actual chars is half of rval,
|
|
// and index 0 doesn't count
|
|
rval /= 2;
|
|
|
|
/* lossy conversion to ISO Latin1 */
|
|
for (i = 1; i < rval && i < buflen; i++) {
|
|
if (buffer[2 * i + 1] == 0)
|
|
buf[i - 1] = buffer[2 * i];
|
|
else
|
|
buf[i - 1] = '?'; /* outside of ISO Latin1 range */
|
|
}
|
|
buf[i - 1] = 0;
|
|
|
|
return i - 1;
|
|
}
|
|
|
|
usb_dev_handle * HardwareSetup::usbOpenDevice(int vendor, char * vendorName,
|
|
int product, char * productName) {
|
|
struct usb_bus * bus;
|
|
struct usb_device * dev;
|
|
char devVendor[256], devProduct[256];
|
|
|
|
usb_dev_handle * handle = NULL;
|
|
|
|
usb_init();
|
|
usb_find_busses();
|
|
usb_find_devices();
|
|
|
|
for (bus = usb_get_busses(); bus; bus = bus->next) {
|
|
for (dev = bus->devices; dev; dev = dev->next) {
|
|
if (dev->descriptor.idVendor != vendor ||
|
|
dev->descriptor.idProduct != product)
|
|
continue;
|
|
|
|
/* we need to open the device in order to query strings */
|
|
if (!(handle = usb_open(dev))) {
|
|
fprintf(stderr, "Warning: cannot open USB device: %sn",
|
|
usb_strerror());
|
|
continue;
|
|
}
|
|
|
|
/* get vendor name */
|
|
if (usbGetDescriptorString(handle, dev->descriptor.iManufacturer,
|
|
0x0409, devVendor,
|
|
sizeof(devVendor)) < 0) {
|
|
fprintf(stderr,
|
|
"Warning: cannot query manufacturer for device: %sn",
|
|
usb_strerror());
|
|
usb_close(handle);
|
|
continue;
|
|
}
|
|
|
|
/* get product name */
|
|
if (usbGetDescriptorString(handle, dev->descriptor.iProduct, 0x0409,
|
|
devProduct, sizeof(devVendor)) < 0) {
|
|
fprintf(stderr, "Warning: cannot query product for device: %sn",
|
|
usb_strerror());
|
|
usb_close(handle);
|
|
continue;
|
|
}
|
|
|
|
if (strcmp(devVendor, vendorName) == 0 &&
|
|
strcmp(devProduct, productName) == 0)
|
|
return handle;
|
|
else
|
|
usb_close(handle);
|
|
}
|
|
}
|
|
return NULL;
|
|
}
|
|
#endif
|
|
|
|
void HardwareSetup::run() {
|
|
|
|
if (HARDWARE_VERSION == 2) {
|
|
#ifdef ATMEGA
|
|
struct TransStruct buffer[6];
|
|
int testmode = 0;
|
|
|
|
int nBytes = 0;
|
|
// char buffer[256];
|
|
|
|
// struct TransStruct *buffer = buffer1;
|
|
// cout << "thread started" << endl;
|
|
|
|
// if(argc < 2) {
|
|
// printf("Usage:\n");
|
|
// printf("usbtext.exe on\n");
|
|
// printf("usbtext.exe off\n");
|
|
// exit(1);
|
|
// }
|
|
if (!testmode) {
|
|
while (!this->handle) {
|
|
this->handle =
|
|
usbOpenDevice(0x16C0, "test01", 0x05DC, "USBExample");
|
|
|
|
if (this->handle == NULL) {
|
|
fprintf(stderr, "Could not find USB device!\n");
|
|
}
|
|
sleep(1);
|
|
}
|
|
}
|
|
|
|
int index;
|
|
while (!this->stop) {
|
|
|
|
// test mode
|
|
|
|
if (testmode) {
|
|
while (1) {
|
|
int validTimes = 0;
|
|
if (validTimes) {
|
|
Shell(1100, 1);
|
|
sleep(1);
|
|
Shell(1200, 2);
|
|
sleep(1);
|
|
Shell(1300, 3);
|
|
sleep(1);
|
|
Dea(1100, 1);
|
|
sleep(1);
|
|
Dea(1200, 2);
|
|
sleep(1);
|
|
Dea(1300, 3);
|
|
// this->stop = 0;
|
|
sleep(1);
|
|
}
|
|
else {
|
|
// invalid times
|
|
Shell(30, 1);
|
|
sleep(1);
|
|
Shell(700, 2);
|
|
sleep(1);
|
|
Shell(700, 3);
|
|
sleep(1);
|
|
Dea(500, 1);
|
|
sleep(1);
|
|
Dea(700, 2);
|
|
sleep(1);
|
|
Dea(3000, 3);
|
|
// this->stop = 0;
|
|
sleep(1);
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
// normal mode -> no testmode
|
|
usleep(150000); // 100ms
|
|
|
|
// while(1){
|
|
nBytes = usb_control_msg(
|
|
this->handle,
|
|
USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_ENDPOINT_IN,
|
|
USB_DATA_OUT, 0, 0,
|
|
static_cast<char *>(static_cast<void *>(buffer)),
|
|
sizeof(buffer), 5000);
|
|
|
|
for (int i = 0; i < 6; i++) {
|
|
if (buffer[i].update != 0) {
|
|
switch (buffer[i].id) {
|
|
case 0:
|
|
cout << "Shell Zeit 1: "
|
|
<< static_cast<int>(buffer[i].time) << endl;
|
|
emit Shell(static_cast<int>(buffer[i].time), 1);
|
|
break;
|
|
case 1:
|
|
cout << "Dea Zeit 1: "
|
|
<< static_cast<int>(buffer[i].time) << endl;
|
|
emit Dea(static_cast<int>(buffer[i].time), 1);
|
|
break;
|
|
case 2:
|
|
cout << "Shell Zeit 2: "
|
|
<< static_cast<int>(buffer[i].time) << endl;
|
|
emit Shell(static_cast<int>(buffer[i].time), 2);
|
|
break;
|
|
case 3:
|
|
cout << "Dea Zeit 2: "
|
|
<< static_cast<int>(buffer[i].time) << endl;
|
|
emit Dea(static_cast<int>(buffer[i].time), 2);
|
|
break;
|
|
case 4:
|
|
cout << "Shell Zeit 2: "
|
|
<< static_cast<int>(buffer[i].time) << endl;
|
|
emit Shell(static_cast<int>(buffer[i].time), 3);
|
|
break;
|
|
case 5:
|
|
cout << "Dea Zeit 3: "
|
|
<< static_cast<int>(buffer[i].time) << endl;
|
|
emit Dea(static_cast<int>(buffer[i].time), 3);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if (buffer[0].update != 0) {
|
|
cout << "Got " << nBytes
|
|
<< " bytes: " << static_cast<int>(buffer[2].time)
|
|
<< ", " << static_cast<int>(buffer[2].id) << endl;
|
|
}
|
|
//}
|
|
|
|
if (nBytes < 0) {
|
|
fprintf(stderr, "USB error: %sn", usb_strerror());
|
|
while (!this->handle) {
|
|
this->handle = usbOpenDevice(0x16C0, "test01", 0x05DC,
|
|
"USBExample");
|
|
|
|
if (this->handle == nullptr) {
|
|
fprintf(stderr, "Could not find USB device!\n");
|
|
}
|
|
sleep(1);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
#endif // ATMEGA
|
|
} // end HARDWARE_VERSION 2
|
|
|
|
else if (HARDWARE_VERSION == 3) {
|
|
uint8_t dummy[sizeof(struct TransCheck)] = {0};
|
|
|
|
fd = open(PORT_PATH, O_RDONLY);
|
|
while (this->fd < 0) {
|
|
// wait 1 second
|
|
sleep(1);
|
|
cout << "Port can't be opened" << endl;
|
|
fd = open(PORT_PATH, O_RDONLY);
|
|
if (this->stop) {
|
|
break;
|
|
}
|
|
}
|
|
// prepare buffer
|
|
std::shared_ptr<struct TransCheck> received =
|
|
std::make_shared<struct TransCheck>();
|
|
uint8_t uintBuf[sizeof(struct TransCheck)];
|
|
// void * voidBuf;
|
|
// configure among others non-canonical mode (important)
|
|
struct termios config;
|
|
tcgetattr(fd, &config);
|
|
config.c_lflag = 0; // standard value is bad choosen
|
|
tcsetattr(fd, TCSANOW, &config);
|
|
|
|
// read raw data to buffer
|
|
ssize_t length = read(fd, uintBuf, sizeof(struct TransCheck));
|
|
|
|
if (this->stop == 0) {
|
|
cout << "Port opened" << endl;
|
|
// flush existing data
|
|
if (static_cast<unsigned long>(length) <
|
|
sizeof(struct TransCheck)) {
|
|
tcflush(fd, TCIFLUSH);
|
|
}
|
|
}
|
|
while (!this->stop) {
|
|
|
|
// read data
|
|
cout << "try to read data" << endl;
|
|
read(this->fd, uintBuf, sizeof(struct TransCheck));
|
|
cout << "data read" << endl;
|
|
// voidBuf = static_cast<void *>(uintBuf);
|
|
memcpy(received.get(), uintBuf, sizeof(struct TransCheck));
|
|
// voidBuf = static_cast<void *>(uintBuf);
|
|
|
|
// received = static_cast<struct TransCheck *>(voidBuf);
|
|
|
|
usleep(50000); // 150ms
|
|
|
|
if (received->begin == '#' && received->end == '!') {
|
|
for (int i = 0; i < 6; i++) {
|
|
cout << "i: " << i << " time: "
|
|
<< static_cast<int>(received->data[i].time)
|
|
<< " update: "
|
|
<< static_cast<int>(received->data[i].update) << endl;
|
|
if (received->data[i].update != 0) {
|
|
switch (received->data[i].id) {
|
|
case 0:
|
|
cout << "Shell Zeit 1: "
|
|
<< static_cast<int>(received->data[i].time)
|
|
<< endl;
|
|
emit Shell(static_cast<int>(received->data[i].time),
|
|
1);
|
|
break;
|
|
case 1:
|
|
cout << "Dea Zeit 1: "
|
|
<< static_cast<int>(received->data[i].time)
|
|
<< endl;
|
|
emit Dea(static_cast<int>(received->data[i].time),
|
|
1);
|
|
break;
|
|
case 2:
|
|
cout << "Shell Zeit 2: "
|
|
<< static_cast<int>(received->data[i].time)
|
|
<< endl;
|
|
emit Shell(static_cast<int>(received->data[i].time),
|
|
2);
|
|
break;
|
|
case 3:
|
|
cout << "Dea Zeit 2: "
|
|
<< static_cast<int>(received->data[i].time)
|
|
<< endl;
|
|
emit Dea(static_cast<int>(received->data[i].time),
|
|
2);
|
|
break;
|
|
case 4:
|
|
cout << "Shell Zeit 3: "
|
|
<< static_cast<int>(received->data[i].time)
|
|
<< endl;
|
|
emit Shell(static_cast<int>(received->data[i].time),
|
|
3);
|
|
break;
|
|
case 5:
|
|
cout << "Dea Zeit 3: "
|
|
<< static_cast<int>(received->data[i].time)
|
|
<< endl;
|
|
emit Dea(static_cast<int>(received->data[i].time),
|
|
3);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
} // dataframe ok
|
|
else {
|
|
// dataframe not ok
|
|
tcflush(fd, TCIFLUSH);
|
|
}
|
|
|
|
// overwrite received data to prevent same data gets read one more
|
|
// time; dummy data is array of zeros
|
|
memcpy(received.get(), dummy, sizeof(struct TransCheck));
|
|
}
|
|
}
|
|
else {
|
|
cout << "unknown hardware version" << endl;
|
|
}
|
|
}
|
|
|
|
bool HardwareSetup::getShell() {
|
|
|
|
// int zahl[8] = {0};
|
|
|
|
// if(findBit(zahl, inb(BASEPORT + 1))[7] == 1){
|
|
|
|
// return true;
|
|
// }
|
|
return false;
|
|
}
|
|
bool HardwareSetup::getDea() {
|
|
|
|
// int zahl[8] = {0};
|
|
|
|
// if(findBit(zahl, inb(BASEPORT + 1))[6] == 0 ){
|
|
// return true;
|
|
// }
|
|
return false;
|
|
}
|
|
|
|
int * HardwareSetup::findBit(int * array, int zahl) {
|
|
if (zahl >= 128) {
|
|
array[7] = 1;
|
|
zahl -= 128;
|
|
}
|
|
if (zahl >= 64) {
|
|
array[6] = 1;
|
|
zahl -= 64;
|
|
}
|
|
if (zahl >= 32) {
|
|
array[5] = 1;
|
|
zahl -= 32;
|
|
}
|
|
if (zahl >= 16) {
|
|
array[4] = 1;
|
|
zahl -= 16;
|
|
}
|
|
if (zahl >= 8) {
|
|
array[3] = 1;
|
|
zahl -= 8;
|
|
}
|
|
if (zahl >= 4) {
|
|
array[2] = 1;
|
|
zahl -= 4;
|
|
}
|
|
if (zahl >= 2) {
|
|
array[1] = 1;
|
|
zahl -= 2;
|
|
}
|
|
if (zahl >= 1) {
|
|
array[0] = 1;
|
|
zahl -= 1;
|
|
}
|
|
|
|
return array;
|
|
}
|