void packet_do_handle()
{
if(packet_receive(&inp, PACKET_INBOUND_START) == PACKET_STAT_OK) {
if(packet_process_received(&packet_handlers, &inp) == PACKET_STAT_ERR_UNKPACK) {
send_status_packet(PACKET_RETURN_INVALID_PACKET);
}
}
else {
send_status_packet(PACKET_RETURN_BAD_PACKET);
}
}
int handle_packet_device_control(unsigned char length, unsigned char *data)
{
// TODO define + implement
send_status_packet(PACKET_RETURN_UNKNOWN);
return PACKET_STAT_OK;
}
int handle_packet_serial_function(unsigned char length, unsigned char *data)
{
// TODO define + implement
send_status_packet(PACKET_RETURN_UNKNOWN);
return PACKET_STAT_OK;
}
// ----------------------
// ---------------------- This will eventually be used for "overtemperature" events/etc.
// ----------------------
static void alarm_handler (int alarm_sig) {
static int count;
count++;
syslog(LOG_NOTICE, "Alarm Handler Called With Signal %d %d START times\n", alarm_sig,count);
send_status_packet(cp_ptr->mode,kd_ptr);
sleep(1);
get_status_packet(sp_ptr);
sem_post(sp_sem);
syslog(LOG_NOTICE, "Alarm Handler Called With Signal %d %d times FINISHED \n", alarm_sig,count);
}
static void* update_thread(void* ptr) {
int j = 0;
while (j == 0) {
send_status_packet(cp_ptr->mode,kd_ptr);
sleep(1);
get_status_packet(sp_ptr);
update_histogram(sp_ptr);
//sem_post(sp_sem);
sleep(10);
}
}
int handle_packet_pin_function(unsigned char length, unsigned char *data)
{
int s;
// check if length matches for packet-data
if(length != 2) {
send_status_packet(PACKET_RETURN_INAVLID_DATA);
return PACKET_STAT_ERR_DATA;
}
packet_data_in_pin_function *pd = (packet_data_in_pin_function *)&data[0];
if((s = pin_setup(pd->pin, pd->function)) != PACKET_STAT_OK) {
send_status_packet(PACKET_RETURN_INVALID_PIN_COMMAND);
}
else {
send_status_packet(PACKET_RETURN_ACK);
}
return s;
}
int handle_packet_pwm_function(unsigned char length, unsigned char *data)
{
int s;
// check if length matches for packet-data
if(length != 3) {
send_status_packet(PACKET_RETURN_INAVLID_DATA);
return PACKET_STAT_ERR_DATA;
}
packet_data_in_pwm_function *pd = (packet_data_in_pwm_function *)&data[0];
int p = (0x00FF & pd->period_lsb) | (0xFF00 & (pd->period_msb << 8));
if((s = pin_pwm_function(pd->pin, p)) != PACKET_STAT_OK) {
send_status_packet(PACKET_RETURN_INVALID_PIN_COMMAND);
}
else {
send_status_packet(PACKET_RETURN_ACK);
}
return s;
}
int handle_packet_reset(unsigned char length, unsigned char *data)
{
send_status_packet(PACKET_RETURN_ACK);
// give send packet some time before we reset ...
volatile unsigned long i = 10000;
do (i--);
while (i != 0);
// make watchdog bite ...
WDTCTL = 0;
return PACKET_STAT_OK;
}
int main(int argc, char** argv)
{
struct kuhler_data kd1;
kd1.usb_mode_control_packet[silent] = (char[0x20]) silent_mode_control;
kd1.usb_mode_control_packet[extreme] = (char[0x20]) extreme_mode_control;
kd1.usb_mode_control_packet[custom] = (char[0x20]) custom_mode_control;
kd1.usb_status_packet[silent] = (char[0x20]) silent_status_control;
kd1.usb_status_packet[extreme] = (char[0x20]) extreme_status_control;
kd1.usb_status_packet[custom] = (char[0x20]) custom_status_control;
// MUTEX Lock
pthread_mutex_init(&kuhler_mutex,NULL);
int c;
int debug_level;
int update_thread_enable = 1;
while ((c = getopt(argc,argv,"d:hn")) != -1) {
switch (c) {
case 'h' :
printargs();
exit(0);
break;
case 'd' :
debug_level = 1;
break;
case 'n' :
update_thread_enable = 0;
break;
default :
debug_level = 0;
}
}
// Init Log Factiity
// EMERG,ALRT,CRIT,ERR,WARNING,NOTICE,INFO,DEBUG
if (debug_level == 1) {
setlogmask (LOG_UPTO(LOG_DEBUG));
printf ("Debug Mode Enabled!\n");
} else {
setlogmask (LOG_UPTO(LOG_NOTICE));
}
openlog ("kuhlerd", LOG_CONS | LOG_PID | LOG_NDELAY , LOG_LOCAL1);
syslog (LOG_NOTICE, "kuhlerd version %s Started",version_string);
// Init kd_ptr
kd_ptr = &kd1;
struct control_packet cp;
struct status_packet sp;
shm_id_cp = shmget(shm_key_cp,sizeof(cp),IPC_CREAT | 0666); //rw-,rw-,rw-
shm_id_sp = shmget(shm_key_sp,sizeof(sp),IPC_CREAT | 0666); //rw,r--,r--
if (shm_id_cp < 0 || shm_id_sp < 0) {
syslog (LOG_ERR, "Failed to Allocate Shared Memory Segment \n");
printf ("Kuhlerd : Failed to Allocate Shared Memory Segment\n");
exit(1);
}
syslog (LOG_DEBUG, "Allocated Shared Memory Segment %d %d \n", shm_id_sp,shm_id_cp);
cp_ptr = shmat(shm_id_cp,NULL,0);
sp_ptr = shmat(shm_id_sp,NULL,0);
if (cp_ptr == NULL || sp_ptr == NULL) {
syslog (LOG_ERR, "Failed to Attach to Shared Memory Segment \n");
printf ("Kuhlerd : Failed to Attach Shared Memory Segment\n");
exit(1);
}
int r = 1;
r = libusb_init(NULL);
if (r < 0) {
syslog (LOG_ERR, "Failed to Initialized libusb \n");
fprintf(stderr, "Kuhlerd : failed to initialise libusb\n");
exit(1);
}
r = find_kuhler920();
if (r < 0) {
syslog (LOG_ERR, "Could not find Kuhler 920/960 or open device \n");
fprintf(stderr, "Kuhlerd : Could not find/open device\n");
exit(1);
}
r = libusb_claim_interface(devh, 0);
if (r < 0) {
syslog (LOG_ERR, "Could not claim exclusive use of usb device \n");
fprintf(stderr, "Kuhlerd : usb_claim_interface error %d\n", r);
exit(1);
}
syslog (LOG_DEBUG,"Claimed Interface \n");
printf("Kuhlerd : claimed interface\n");
syslog (LOG_DEBUG,"Sending Init Packet\n");
printf("Kuhlerd : Sending Init Packet\n");
r = init_kuhler920();
syslog (LOG_DEBUG,"Init Packet Sent, returned with status %d \n",r);
printf("Kuhlerd : Init Packet Sent, returned with status %d \n",r);
//init_signals();
syslog (LOG_DEBUG,"Creating Histogram Entries %d \n",r);
init_histogram(sp_ptr);
syslog (LOG_DEBUG,"Created Histogram Entries %d \n",r);
int i=0;
int current_mode = silent;
cp_sem = sem_open(cp_sem_name, O_CREAT , 0666,0); // 1 = unlocked , 0 = locked
sp_sem = sem_open(sp_sem_name, O_CREAT , 0666,0); // 1 = unlocked , 0 = locked
// v0.5 -- HW BUSY Semaphore - IPC
kuhler_hw_busy_sem = sem_open(kuhler_hw_busy_sem_name,O_CREAT,0666,0);
//if (cp_sem == NULL || sp_sem == NULL) {
if (cp_sem == NULL || sp_sem == NULL || kuhler_hw_busy_sem == NULL) {
syslog (LOG_ERR, "Failed to Create semaphores \n");
printf ("Kuhlerd : failed to create semaphores\n");
exit(1);
}
// Initialize Shared Memory For Safety
cp_ptr->mode = silent;
cp_ptr->cmd = 0;
cp_ptr->led_r = (uint8_t) 0;
cp_ptr->led_g = (uint8_t) 0;
cp_ptr->led_b = (uint8_t) 0;
cp_ptr->start_temp = 40;
cp_ptr->full_temp = 55;
change_mode(silent,kd_ptr);
get_status_packet(sp_ptr);
syslog (LOG_NOTICE, "Entering Main Loop\n");
printf ("Kuhlerd : Entering Main Loop\n");
int rv=-99;
// Fork Off and Exit
pid_t pidd;
pidd = fork();
//if (pidd == 0) {
init_signals();
// create pthreads
pthread_t upd;
// new for V5 - update thread
if (update_thread_enable == 1) {
int pthread_val = pthread_create(&upd,NULL,update_thread,NULL);
syslog(LOG_NOTICE, "Creating Update Thread \n");
printf ("Kuhlerd : Creating Update Thread \n");
} else {
syslog(LOG_NOTICE, "Update thread disabled \n");
printf ("Kuhlerd : Disabling Update Thread \n");
}
if (pidd !=0) {
syslog(LOG_NOTICE, "Entering Daemon Mode, exiting \n");
printf ("Kuhlerd : Entering Daemon Mode, exiting \n");
exit (0);
}
while (i==0) {
// wait for the semaphore to be unlocked - written to 1 by ctl program
//printf ("Waiting for Semaphore Unlock %i\n",rv);
// hw busy control semaphore initially LOCKED
sem_post(kuhler_hw_busy_sem);
rv = sem_wait(cp_sem); // set to 0 -- blocking call
// hw busy control semaphore initially LOCKED
//sem_post(kuhler_hw_busy_sem);
if (cp_ptr->cmd == 1 ) {
change_led_color(cp_ptr->led_r,cp_ptr->led_g,cp_ptr->led_b,cp_ptr->mode,kd_ptr);
if (cp_ptr->mode == custom) {
change_temp_threshold(cp_ptr->start_temp,cp_ptr->full_temp,kd_ptr);
}
change_mode(cp_ptr->mode,kd_ptr);
get_status_packet(sp_ptr); // required after mode change
} else {
send_status_packet(cp_ptr->mode,kd_ptr);
sleep(1);
get_status_packet(sp_ptr);
// unlock status packet semaphore
sem_post(sp_sem);
}
} // end while
}
int handle_packet_pin_control(unsigned char length, unsigned char *data)
{
int s = PACKET_STAT_OK;
// check if length matches for packet-data
if(length != 2) {
send_status_packet(PACKET_RETURN_INAVLID_DATA);
return PACKET_STAT_ERR_DATA;
}
packet_data_in_pin_control *pd = (packet_data_in_pin_control *)&data[0];
switch(pd->control) {
case PIN_CONTROL_CLEAR:
if((s = pin_clear(pd->pin)) != PACKET_STAT_OK) {
send_status_packet(PACKET_RETURN_INVALID_PIN_COMMAND);
}
else {
send_status_packet(PACKET_RETURN_ACK);
}
break;
case PIN_CONTROL_SET:
if((s = pin_set(pd->pin)) != PACKET_STAT_OK) {
send_status_packet(PACKET_RETURN_INVALID_PIN_COMMAND);
}
else {
send_status_packet(PACKET_RETURN_ACK);
}
break;
case PIN_CONTROL_TOGGLE:
if((s = pin_toggle(pd->pin)) != PACKET_STAT_OK) {
send_status_packet(PACKET_RETURN_INVALID_PIN_COMMAND);
}
else {
send_status_packet(PACKET_RETURN_ACK);
}
break;
case PIN_CONTROL_DIGITAL_READ:
if((s = pin_digital_read(pd->pin)) < 0) {
send_status_packet(PACKET_RETURN_INVALID_PIN_COMMAND);
}
else {
packet_data_out_digital_pin_read *pdo = (packet_data_out_digital_pin_read *)&outp.data[0];
outp.start = PACKET_OUTBOUND_START;
outp.length = 6;
outp.type = PACKET_OUT_DIGITAL_PIN_READ;
pdo->pin = pd->pin;
pdo->state = s;
outp.crc = packet_calc_crc(&outp);
packet_send(&outp);
}
break;
case PIN_CONTROL_ANALOG_READ:
if((s = pin_analog_read(pd->pin)) < 0) {
send_status_packet(PACKET_RETURN_INVALID_PIN_COMMAND);
}
else {
packet_data_out_analog_pin_read *pdo = (packet_data_out_analog_pin_read *)&outp.data[0];
outp.start = PACKET_OUTBOUND_START;
outp.length = 7;
outp.type = PACKET_OUT_ANALOG_PIN_READ;
pdo->pin = pd->pin;
pdo->value_lsb = (0x00FF & s);
pdo->value_msb = (0x0F00 & s) >> 8;
outp.crc = packet_calc_crc(&outp);
packet_send(&outp);
}
break;
case PIN_CONTROL_PULSELENGTH_READ:
if((s = pin_pulselength_read(pd->pin)) < 0) {
send_status_packet(PACKET_RETURN_INVALID_PIN_COMMAND);
}
else {
packet_data_out_pulselength_read *pdo =
( packet_data_out_pulselength_read *)&outp.data[0];
outp.start = PACKET_OUTBOUND_START;
outp.length = 7;
outp.type = PACKET_OUT_PULSELENGHT_READ;
pdo->pin = pd->pin;
pdo->value_lsb = (0x00FF & s);
pdo->value_msb = (0x7F00 & s) >> 8;
outp.crc = packet_calc_crc(&outp);
packet_send(&outp);
}
break;
default:
send_status_packet(PACKET_RETURN_INVALID_PIN_COMMAND);
s = PACKET_STAT_ERR_DATA;
}
return s;
}
int handle_packet_null(unsigned char length, unsigned char *data)
{
send_status_packet(PACKET_RETURN_ACK);
return PACKET_STAT_OK;
}
