Index: logic/trunk/src/kernel_modules/generic/ioctl.c
===================================================================
--- logic/trunk/src/kernel_modules/generic/ioctl.c	(revision 0)
+++ logic/trunk/src/kernel_modules/generic/ioctl.c	(revision 71)
@@ -0,0 +1,84 @@
+/*
+* ioctl.c − the process to use ioctl's to control the kernel module
+*
+* Until now we could have used cat for input and output. But now
+* we need to do ioctl's, which require writing our own process.
+*/
+/*
+* device specifics, such as ioctl numbers and the
+* major device file.
+*/
+#include "chardev.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <fcntl.h>	/* open */
+#include <unistd.h>	/* exit */
+#include <sys/ioctl.h>	/* ioctl */
+/*
+* Functions for the ioctl calls
+*/
+ioctl_set_msg(int file_desc, char *message)
+{
+	int ret_val;
+	ret_val = ioctl(file_desc, IOCTL_SET_MSG, message);
+	if (ret_val < 0) {
+		printf("ioctl_set_msg failed:%d\n", ret_val);
+		exit(-1);
+	}
+}
+
+ioctl_get_msg(int file_desc)
+{
+	int ret_val;
+	char message[100];
+	/*
+	* Warning − this is dangerous because we don't tell
+	* the kernel how far it's allowed to write, so it
+	* might overflow the buffer. In a real production
+	* program, we would have used two ioctls − one to tell
+	* the kernel the buffer length and another to give
+	* it the buffer to fill
+	*/
+	ret_val = ioctl(file_desc, IOCTL_GET_MSG, message);
+	if (ret_val < 0) {
+		printf("ioctl_get_msg failed:%d\n", ret_val);
+		exit(-1);
+	}
+	printf("get_msg message:%s\n", message);
+}
+
+ioctl_get_nth_byte(int file_desc)
+{
+	int i;
+	char c;
+	printf("get_nth_byte message:");
+	i = 0;
+	do {
+		c = ioctl(file_desc, IOCTL_GET_NTH_BYTE, i++);
+		if (c < 0) {
+			printf("ioctl_get_nth_byte failed at the %d'th byte:\n",i);
+			exit(-1);
+		}
+		putchar(c);
+	} while (c != 0);
+	putchar('\n');
+}
+
+/*
+* Main − Call the ioctl functions
+*/
+main()
+{
+	int file_desc, ret_val;
+	char *msg = "Message passed by ioctl\n";
+	file_desc = open(DEVICE_FILE_NAME, 0);
+	if (file_desc < 0) {
+		printf("Can't open device file: %s\n", DEVICE_FILE_NAME);
+		exit(-1);
+	}
+	ioctl_set_msg(file_desc, msg);
+	ioctl_get_nth_byte(file_desc);
+	ioctl_get_msg(file_desc);
+	close(file_desc);
+}
+
Index: logic/trunk/src/kernel_modules/generic/Makefile
===================================================================
--- logic/trunk/src/kernel_modules/generic/Makefile	(revision 0)
+++ logic/trunk/src/kernel_modules/generic/Makefile	(revision 71)
@@ -0,0 +1,18 @@
+ifeq ($(KERNELRELEASE),)
+
+KERNELDIR ?= /lib/modules/$(shell uname -r)/build
+PWD := $(shell pwd)
+
+.PHONY: build clean
+
+build:
+	$(MAKE) -C $(KERNELDIR) M=$(PWD) modules
+
+clean:
+	rm -rf *.o *~ core .depend .*.cmd *.ko *.mod.c
+else
+
+$(info Building with KERNELRELEASE = ${KERNELRELEASE})
+obj-m := chardev.o
+
+endif
Index: logic/trunk/src/kernel_modules/generic/chardev.c
===================================================================
--- logic/trunk/src/kernel_modules/generic/chardev.c	(revision 0)
+++ logic/trunk/src/kernel_modules/generic/chardev.c	(revision 71)
@@ -0,0 +1,268 @@
+/*
+* chardev.c − Create an input/output character device
+*/
+#include <linux/kernel.h> /* We're doing kernel work */
+#include <linux/module.h> /* Specifically, a module */
+#include <linux/fs.h>     /* for get_user and put_user */
+#include <linux/i2c.h>     /* for get_user and put_user */
+#include <linux/hwmon.h>     /* for get_user and put_user */
+#include <linux/err.h>     /* for get_user and put_user */
+#include <asm/uaccess.h>
+#include "chardev.h"
+
+#define SUCCESS 0
+#define DEVICE_NAME "char_dev"
+#define BUF_LEN 80
+/*
+* Is the device open right now? Used to prevent
+* concurent access into the same device
+*/
+static int Device_Open = 0;
+/*
+* The message the device will give when asked
+*/
+static char Message[BUF_LEN];
+/*
+* How far did the process reading the message get?
+* Useful if the message is larger than the size of the
+* buffer we get to fill in device_read.
+*/
+static char *Message_Ptr;
+/*
+* This is called whenever a process attempts to open the device file
+*/
+static int device_open(struct inode *inode, struct file *file)
+{
+	//#ifdef DEBUG
+	printk(KERN_INFO "device_open(%p)\n", file);
+	//#endif
+	/*
+	* We don't want to talk to two processes at the same time
+	*/
+	if (Device_Open)
+		return -EBUSY;
+	Device_Open++;
+	/*
+	* Initialize the message
+	*/
+	Message_Ptr = Message;
+	try_module_get(THIS_MODULE);
+	return SUCCESS;
+}
+
+static int device_release(struct inode *inode, struct file *file)
+{
+	//#ifdef DEBUG
+	printk(KERN_INFO "device_release(%p,%p)\n", inode, file);
+	//#endif
+	/*
+	* We're now ready for our next caller
+	*/
+	Device_Open--;
+	module_put(THIS_MODULE);
+	return SUCCESS;
+}
+
+/*
+* This function is called whenever a process which has already opened the
+* device file attempts to read from it.
+*/
+static ssize_t device_read(struct file *file,
+				/* see include/linux/fs.h*/
+				char __user * buffer,
+				/* buffer to be
+				* filled with data */
+				size_t length,
+				loff_t * offset)
+				/* length of the buffer*/
+{
+	/*
+	* Number of bytes actually written to the buffer
+	*/
+	int bytes_read = 0;
+	//#ifdef DEBUG
+	printk(KERN_INFO "device_read(%p,%p,%d)\n", file, buffer, length);
+	//#endif
+	/*
+	* If we're at the end of the message, return 0
+	* (which signifies end of file)
+	*/
+	if (*Message_Ptr == 0)
+		return 0;
+	/*
+	* Actually put the data into the buffer
+	*/
+	while (length && *Message_Ptr) {
+		/*
+		* Because the buffer is in the user data segment,
+		* not the kernel data segment, assignment wouldn't
+		* work. Instead, we have to use put_user which
+		* copies data from the kernel data segment to the
+		* user data segment.
+		*/
+		put_user(*(Message_Ptr++), buffer++);
+		length--;
+		bytes_read++;
+	}
+	//#ifdef DEBUG
+	printk(KERN_INFO "Read %d bytes, %d left\n", bytes_read, length);
+	//#endif
+	/*
+	* Read functions are supposed to return the number
+	* of bytes actually inserted into the buffer
+	*/
+	return bytes_read;
+}
+
+/*
+* This function is called when somebody tries to
+* write into our device file.
+*/
+static ssize_t
+device_write(struct file *file,
+const char __user * buffer, size_t length, loff_t * offset)
+{
+	int i;
+	//#ifdef DEBUG
+	printk(KERN_INFO "device_write(%p,%s,%d)", file, buffer, length);
+	//#endif
+	for (i = 0; i < length && i < BUF_LEN; i++)
+		get_user(Message[i], buffer + i);
+	Message_Ptr = Message;
+	/*
+	* Again, return the number of input characters used
+	*/
+	return i;
+}
+
+/*
+* This function is called whenever a process tries to do an ioctl on our
+* device file. We get two extra parameters (additional to the inode and file
+* structures, which all device functions get): the number of the ioctl called
+* and the parameter given to the ioctl function.
+*
+* If the ioctl is write or read/write (meaning output is returned to the
+* calling process), the ioctl call returns the output of this function.
+*
+*/
+int device_ioctl(struct inode *inode,
+	/* see include/linux/fs.h */
+	struct file *file,
+	/* ditto */
+	unsigned int ioctl_num,
+	/* number and param for ioctl */
+	unsigned long ioctl_param)
+{
+	int i;
+	char *temp;
+	char ch;
+	/*
+	* Switch according to the ioctl called
+	*/
+	switch (ioctl_num) {
+	case IOCTL_SET_MSG:
+		/*
+		* Receive a pointer to a message (in user space) and set that
+		* to be the device's message. Get the parameter given to
+		* ioctl by the process.
+		*/
+		temp = (char *)ioctl_param;
+		/*
+		* Find the length of the message
+		*/
+		get_user(ch, temp);
+		for (i = 0; ch && i < BUF_LEN; i++, temp++)
+			get_user(ch, temp);
+		device_write(file, (char *)ioctl_param, i, 0);
+		break;
+	case IOCTL_GET_MSG:
+		/*
+		* Give the current message to the calling process −
+		* the parameter we got is a pointer, fill it.
+		*/
+		i = device_read(file, (char *)ioctl_param, 99, 0);
+		/*
+		* Put a zero at the end of the buffer, so it will be
+		* properly terminated
+		*/
+		put_user('\0', (char *)ioctl_param + i);
+		break;
+	case IOCTL_GET_NTH_BYTE:
+		/*
+		* This ioctl is both input (ioctl_param) and
+		* output (the return value of this function)
+		*/
+		return Message[ioctl_param];
+		break;
+	}
+	return SUCCESS;
+}
+
+/* Module Declarations */
+/*
+* This structure will hold the functions to be called
+* when a process does something to the device we
+* created. Since a pointer to this structure is kept in
+* the devices table, it can't be local to
+* init_module. NULL is for unimplemented functions.
+*/
+struct file_operations Fops = {
+	.read = device_read,
+	.write = device_write,
+	.ioctl = device_ioctl,
+	.open = device_open,
+	.release = device_release,
+	/* a.k.a. close */
+};
+
+/*
+* Initialize the module − Register the character device
+*/
+int init_module()
+{
+	int ret_val;
+	/*
+	* Register the character device (atleast try)
+	*/
+	ret_val = register_chrdev(MAJOR_NUM, DEVICE_NAME, &Fops);
+	/*
+	* Negative values signify an error
+	*/
+	if (ret_val < 0) {
+		printk(KERN_ALERT "%s failed with %d\n",
+		"Sorry, registering the character device ", ret_val);
+		return ret_val;
+	}
+	printk(KERN_INFO "%s The major device number is %d.\n",
+	"Registeration is a success", MAJOR_NUM);
+	printk(KERN_INFO "If you want to talk to the device driver,\n");
+	printk(KERN_INFO "you'll have to create a device file. \n");
+	printk(KERN_INFO "We suggest you use:\n");
+	printk(KERN_INFO "mknod %s c %d 0\n", DEVICE_FILE_NAME, MAJOR_NUM);
+	printk(KERN_INFO "The device file name is important, because\n");
+	printk(KERN_INFO "the ioctl program assumes that's the\n");
+	printk(KERN_INFO "file you'll use.\n");
+	return 0;
+}
+
+/*
+* Cleanup − unregister the appropriate file from /proc
+*/
+void cleanup_module()
+{
+	//int ret;
+	/*
+	* Unregister the device
+	*/
+	//ret = unregister_chrdev(MAJOR_NUM, DEVICE_NAME);
+    printk(KERN_INFO "Unregistering module.\n");
+	unregister_chrdev(MAJOR_NUM, DEVICE_NAME);
+	/*
+	* If there's an error, report it
+	*/
+	/*
+	if (ret < 0)
+		printk(KERN_ALERT "Error: unregister_chrdev: %d\n", ret);
+	/**/
+}
+
Index: logic/trunk/src/kernel_modules/generic/chardev.h
===================================================================
--- logic/trunk/src/kernel_modules/generic/chardev.h	(revision 0)
+++ logic/trunk/src/kernel_modules/generic/chardev.h	(revision 71)
@@ -0,0 +1,58 @@
+/*
+* chardev.h − the header file with the ioctl definitions.
+* The declarations here have to be in a header file, because
+* they need to be known both to the kernel module
+* (in chardev.c) and the process calling ioctl (ioctl.c)
+*/
+#ifndef CHARDEV_H
+#define CHARDEV_H
+#include <linux/ioctl.h>
+/*
+* The major device number. We can't rely on dynamic
+* registration any more, because ioctls need to know
+* it.
+*/
+#define MAJOR_NUM 100
+/*
+* Set the message of the device driver
+*/
+#define IOCTL_SET_MSG _IOR(MAJOR_NUM, 0, char *)
+/*
+* _IOR means that we're creating an ioctl command
+* number for passing information from a user process
+* to the kernel module.
+*
+* The first arguments, MAJOR_NUM, is the major device
+* number we're using.
+*
+* The second argument is the number of the command
+* (there could be several with different meanings).
+*
+* The third argument is the type we want to get from
+* the process to the kernel.
+*/
+/*
+* Get the message of the device driver
+*/
+#define IOCTL_GET_MSG _IOR(MAJOR_NUM, 1, char *)
+/*
+* This IOCTL is used for output, to get the message
+* of the device driver. However, we still need the
+* buffer to place the message in to be input,
+* as it is allocated by the process.
+*/
+/*
+* Get the n'th byte of the message
+*/
+#define IOCTL_GET_NTH_BYTE _IOWR(MAJOR_NUM, 2, int)
+/*
+* The IOCTL is used for both input and output. It
+* receives from the user a number, n, and returns
+* Message[n].
+*/
+/*
+* The name of the device file
+*/
+#define DEVICE_FILE_NAME "char_dev"
+#endif
+
Index: logic/trunk/src/logics/conditions.c
===================================================================
--- logic/trunk/src/logics/conditions.c	(revision 70)
+++ logic/trunk/src/logics/conditions.c	(revision 71)
@@ -68,7 +68,8 @@
 int getPowerPercentage(int a, int b, int o, float *val, int func)
 {
     int pwr;
-    printf( "getPowerPercentage(%d, %d, %d, %.2f, %d)\n",a,b,o,*val,func);
+    //printf( "getPowerPercentage(%d, %d, %d, %.2f, %d)\n",a,b,o,*val,func);
+
     if(func == FUNCTION_STATIC)
     {
         if(*val>o) // right
@@ -84,14 +85,20 @@
     {
         if(*val>o) // right
         {
-            pwr=(int)((*val-o)/(b-o)*100);
+            if(*val >= a)
+                pwr=100;
+            else
+                pwr=(int)((*val-o)/(b-o)*100);
         }
         else //left
         {
-            pwr=(int)((1-(*val-a)/(o-a))*100);
+            if(*val <= a)
+                pwr=0;
+            else
+                pwr=(int)((1-(*val-a)/(o-a))*100);
         }
     }
-    else if(func == FUNCTION_LOGARITHMIC)
+    else if(func == FUNCTION_LOGARITHMIC) //TODO implement log func
     {
         if(*val>o) // right
         {
@@ -102,7 +109,7 @@
             pwr=(int)((1-(*val-a)/(o-a))*100);
         }
     }
-    else if(func == FUNCTION_QUADRATIC)
+    else if(func == FUNCTION_QUADRATIC)  //implement square func
     {
         if(*val>o) // right
         {
Index: logic/trunk/src/startup/main.c
===================================================================
--- logic/trunk/src/startup/main.c	(revision 70)
+++ logic/trunk/src/startup/main.c	(revision 71)
@@ -11,6 +11,7 @@
 #include <unistd.h>
 #include "../hci_comm/hciChanged.h"
 #include "../hci_comm/hci_comm.h"
+#include "../drv_comm/drv_comm.h"
 #include "../init/scenariolist.h"
 #include "../init/devicelist.h"
 #include "../logics/device_threads.h"
@@ -55,9 +56,11 @@
 int  reinitialiseLogic(); // on HCI request
 int  shutDownLogic();
 
+// devices
+const char *dev1="/dev/dev_thermometer_01";
 // Application entry point
 int main(int argc, char *argv[]) {
-    //** //DAEMON
+    /** //DAEMON
     pid_t pid, sid;
 
     pid = fork();
@@ -167,7 +170,6 @@
     scenario *scen;
     device   *inDev;
     int      active = 0;
-    float    scenarioBuffer;
     //printf("My scen ID> %ld\n",pthread_self());
 
     /*load scenario*/
@@ -177,8 +179,8 @@
     // TODO add pointer to this device (all of them actually) to scenario structure - problems with segfault
     //indev = scen->inDev;
     inDev = getDevice(hDevice, scen->inDevice_id);
-    scen->buf=inDev->buf;
-    printf("Scenario %s buffer updated to %.2f!\n", scen->scen_id, inDev->buf);
+    scen->buf=inDev->buf/10; //TODO make sure buffer values make sense!
+    //printf("Scenario %s buffer updated to %.2f!\n", scen->scen_id, inDev->buf/10);
     //set its value
     //*
     while(1) //TODO signal == true
@@ -185,53 +187,53 @@
     {
         /// main scenario loop
         //printf("inDev->buf %.2f\n", 1.0f*inDev->buf);
+        printf("scen->buf %.2f\n", 1.0f*scen->buf);
         if(active)
             sleep(scen->actvChkItv);
         else
             sleep(scen->idleChkItv);
+
         //checking primary condition
-        if(scen->buf) // is not null
+        scen->buf = scen->buf*scen->alpha+inDev->buf*(1-scen->alpha)/10;
+        //printf("Scenario %s buffer updated to %.2f, alpha: %.2f!\n", scen->scen_id, scen->buf, scen->alpha);
+        syslog(LOG_MAIL, "%s:%.2f", scen->inDevice_id, scen->buf);
+        active = 1;
+
+        if((scen->buf > scen->optval + scen->tolval) ||
+           (scen->buf < scen->optval - scen->tolval))
         {
-            scen->buf = scen->buf*scen->alpha+inDev->buf*(1-scen->alpha);
-            //printf("Scenario %s buffer updated to %f, alpha: %.2f!\n", scen->scen_id, scenarioBuffer, scen->alpha);
-            syslog(LOG_MAIL, "%s:%.2f", scen->inDevice_id, scen->buf);
-            active = 1;
-
-            if((scen->buf > scen->optval + scen->tolval) ||
-               (scen->buf < scen->optval - scen->tolval))
+            if(evaluateAdditionalConditions(scen->cond_l, hDevice))
             {
-                if(evaluateAdditionalConditions(scen->cond_l, hDevice))
-                {
-                    // TODO syslog - "action:scen_ID:power_percentage"
-                    int power = getPowerPercentage(scen->minval, scen->maxval, scen->optval, &scen->buf, scen->func);
+                // TODO syslog - "action:scen_ID:power_percentage"
+                int power = getPowerPercentage(scen->minval, scen->maxval, scen->optval, &scen->buf, scen->func);
 
-                    /// Forking to execute action!
-                    pid_t pid, sid;
+                /// Forking to execute action!
+                pid_t pid;
 
-                    pid = fork();
-                    if (pid < 0) {
-                            exit(EXIT_FAILURE);
-                    }
-                    // ignore parent
-                    if (pid > 0) {}
-                    else
-                    {
-                        /*TODO execute action with parameter(s)*/
-                        syslog(LOG_MAIL, "%s:%s:%.2f", scen->action, scen->scen_id, power);
+                pid = fork();
+                if (pid < 0) {
+                        exit(EXIT_FAILURE);
+                }
+                // ignore parent
+                if (pid > 0) {
+                }
+                else
+                {
+                    /*TODO execute action with parameter(s)*/
+                    syslog(LOG_MAIL, "%s:%s:%.2f", scen->action, scen->scen_id, power);
 
-                        execl(scen->action, power);
-                        printf("Zaganjam napravo %s z mocjo %d\n", scen->scen_id, power);
+                    execl(scen->action, power);
+                    printf("Zaganjam napravo %s z mocjo %d\n", scen->scen_id, power);
 
-                        shutDownLogic();
-                    }
+                    shutDownLogic();
+                }
 
-                }
-                else
-                    printf("Scenario %s not updated!\n", scen->scen_id);
             }
             else
-                active = 0;
+                printf("Scenario %s not updated, additional conditions false!\n", scen->scen_id);
         }
+        else
+            active = 0;
         /*
         if(active)
             printf("%s main buffer %.2f, sleeping %d\n",scen->scen_id, scen->buf, scen->actvChkItv);
@@ -254,7 +256,8 @@
     //set its value
     while(1) //TODO signal == true
     {
-        dev->buf=random()%10+20;// random 20-30
+        dev->buf=get_device_value(dev1);
+        //dev->buf=random()%10+20;// random 20-30
         //printf("device %s buf = %d\n", dev->id, dev->buf);
         sleep(dev->readitv);
     }
Index: logic/trunk/src/drv_comm/drv_comm.c
===================================================================
--- logic/trunk/src/drv_comm/drv_comm.c	(revision 0)
+++ logic/trunk/src/drv_comm/drv_comm.c	(revision 71)
@@ -0,0 +1,94 @@
+/*
+* ioctl.c − the process to use ioctl's to control the kernel module
+*
+* Until now we could have used cat for input and output. But now
+* we need to do ioctl's, which require writing our own process.
+*/
+/*
+* device specifics, such as ioctl numbers and the
+* major device file.
+*/
+#include "drv_comm.h"
+#include "generator.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <fcntl.h>	    /* open */
+#include <unistd.h>	    /* exit */
+//#include <sys/ioctl.h>  /* ioctl */
+/*
+* Functions for the ioctl calls
+*/
+ioctl_set_msg(int file_desc, char *message)
+{
+	int ret_val;
+	ret_val = ioctl(file_desc, IOCTL_SET_MSG, message);
+	if (ret_val < 0) {
+		printf("ioctl_set_msg failed:%d\n", ret_val);
+		exit(-1);
+	}
+}
+
+ioctl_get_msg(int file_desc)
+{
+	int ret_val;
+	char message[100];
+	/*
+	* Warning − this is dangerous because we don't tell
+	* the kernel how far it's allowed to write, so it
+	* might overflow the buffer. In a real production
+	* program, we would have used two ioctls − one to tell
+	* the kernel the buffer length and another to give
+	* it the buffer to fill
+	*/
+	ret_val = ioctl(file_desc, IOCTL_GET_MSG, message);
+	if (ret_val < 0) {
+		printf("ioctl_get_msg failed:%d\n", ret_val);
+		exit(-1);
+	}
+	//printf("get_msg message:%s\n", message);
+}
+
+int ioctl_get_nth_byte(int file_desc)
+{
+	int i, val;
+	char c;
+
+	val=0;
+	i = 0;
+	do {
+		c = ioctl(file_desc, IOCTL_GET_NTH_BYTE, i++);
+		if (c < 0) {
+			printf("ioctl_get_nth_byte failed at the %d'th byte:\n",i);
+			exit(-1);
+		}
+        val=val*10+atoi(&c);
+	} while (c != 0);
+	return (int)val/10; //because string termination character also gets read in loop we have to divide by 10
+}
+
+int get_device_value(const char *dev)
+{
+    //TODO use mutex?
+    int file_desc, ret_val;
+
+	char *msg = int_to_str(generate_value());
+
+	file_desc = open(dev, 0);
+
+	if (file_desc < 0) {
+		printf("Can't open device file: %s\n", dev);
+		ret_val = generate_value(); // TODO fake value in case driver doesnt work
+	}
+	else{
+		//printf("Open device file: %s\n", dev);
+        //ioctl_set_msg(file_desc, msg);
+        ret_val = ioctl_get_nth_byte(file_desc);
+	}
+
+	close(file_desc);
+	ret_val = ret_val+((random()%3-1)*5); //+- 5 (conversion to fload needed later)
+	printf("Returning val %d\n", ret_val);
+
+    return ret_val;
+}
+
Index: logic/trunk/src/drv_comm/generator.c
===================================================================
--- logic/trunk/src/drv_comm/generator.c	(revision 0)
+++ logic/trunk/src/drv_comm/generator.c	(revision 71)
@@ -0,0 +1,72 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+#include <string.h>
+#include <unistd.h>
+
+#include "generator.h"
+
+//funkcija:
+int generate_value() {
+	// nastavitev, minimalne in maksimalne temperature:
+	//funkcija, torej od ure 00:00 raste od minimalne do maximalne, ki jo dosee pri uri 12:00 in nato spet pada do minimalne pri 24:00
+	double minimum=20;
+	double maximum=27;
+
+	time_t     now;
+    struct tm  *ts;
+    char       buf1[80];
+
+    now = time(NULL);
+
+    ts = localtime(&now);
+    strcpy(buf1, asctime(ts));
+
+	int x1 = buf1[11]-48;
+	int x2 = buf1[12]-48;
+	int m1 = buf1[14]-48;
+	int m2 = buf1[15]-48;
+
+	int minutes = (x1*10+x2)*60 + m1*10+m2;
+	int variable = minutes;
+
+	if(variable>720) {
+        variable= 720-(variable-720);
+	}
+
+	double k = ((double)variable)/((double)720);
+
+    //funkcija vraca vrednost na eno decimalko natancno, podobno kot preproste i2c naprave
+	return (int) (minimum + k * (maximum-minimum))*10;
+}
+//*
+char *int_to_str(int nbr)
+{
+  int   div;
+  int   len;
+  int   i;
+  char  *res;
+
+  res = malloc(4 * sizeof(*res));
+  i = 0;
+  while (i < 3)
+    res[i++] = '\0';
+  res[3] = '\0';
+  i = 0;
+  div = 1;
+  len = 1;
+  while (nbr / div >= 10)
+    {
+      div *= 10;
+      len++;
+    }
+  while (len)
+    {
+      res[i++] = '0' + (nbr / div);
+      len--;
+      nbr %= div;
+      div /= 10;
+    }
+  return (res);
+}
+/**/
Index: logic/trunk/src/drv_comm/drv_comm.h
===================================================================
--- logic/trunk/src/drv_comm/drv_comm.h	(revision 0)
+++ logic/trunk/src/drv_comm/drv_comm.h	(revision 71)
@@ -0,0 +1,63 @@
+/*
+* chardev.h − the header file with the ioctl definitions.
+* The declarations here have to be in a header file, because
+* they need to be known both to the kernel module
+* (in chardev.c) and the process calling ioctl (ioctl.c)
+*/
+#ifndef DRV_COMM_H
+#define DRV_COMM_H
+#include <linux/ioctl.h>
+/*
+* The major device number. We can't rely on dynamic
+* registration any more, because ioctls need to know
+* it.
+*/
+#define MAJOR_NUM 100
+/*
+* Set the message of the device driver
+*/
+#define IOCTL_SET_MSG _IOR(MAJOR_NUM, 0, char *)
+/*
+* _IOR means that we're creating an ioctl command
+* number for passing information from a user process
+* to the kernel module.
+*
+* The first arguments, MAJOR_NUM, is the major device
+* number we're using.
+*
+* The second argument is the number of the command
+* (there could be several with different meanings).
+*
+* The third argument is the type we want to get from
+* the process to the kernel.
+*/
+/*
+* Get the message of the device driver
+*/
+#define IOCTL_GET_MSG _IOR(MAJOR_NUM, 1, char *)
+/*
+* This IOCTL is used for output, to get the message
+* of the device driver. However, we still need the
+* buffer to place the message in to be input,
+* as it is allocated by the process.
+*/
+/*
+* Get the n'th byte of the message
+*/
+#define IOCTL_GET_NTH_BYTE _IOWR(MAJOR_NUM, 2, int)
+/*
+* The IOCTL is used for both input and output. It
+* receives from the user a number, n, and returns
+* Message[n].
+*/
+/*
+* The name of the device file
+*/
+#define DEVICE_FILE_NAME "/dev/dev_thermometer_01"
+
+ioctl_set_msg(int file_desc, char *message);
+ioctl_get_msg(int file_desc);
+int ioctl_get_nth_byte(int file_desc);
+int get_device_value();
+
+#endif //DRV_COMM_H
Index: logic/trunk/src/drv_comm/generator.h
===================================================================
--- logic/trunk/src/drv_comm/generator.h	(revision 0)
+++ logic/trunk/src/drv_comm/generator.h	(revision 71)
@@ -0,0 +1,6 @@
+#ifndef GENERATOR_H_INCLUDED
+#define GENERATOR_H_INCLUDED
+int generate_value();
+char *int_to_str(int nbr);
+
+#endif // GENERATOR_H_INCLUDED
Index: logic/trunk/bin/startup
===================================================================
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream
Index: logic/trunk/bin/eneraptor
===================================================================
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream
Index: logic/trunk/bin/eneraptor
===================================================================
--- logic/trunk/bin/eneraptor	(revision 0)
+++ logic/trunk/bin/eneraptor	(revision 71)

Property changes on: logic/trunk/bin/eneraptor
___________________________________________________________________
Added: svn:mime-type
## -0,0 +1 ##
+application/octet-stream
\ No newline at end of property
Added: svn:executable
## -0,0 +1 ##
+*
\ No newline at end of property
Index: logic/trunk/eneraptor.cbp
===================================================================
--- logic/trunk/eneraptor.cbp	(revision 70)
+++ logic/trunk/eneraptor.cbp	(revision 71)
@@ -38,6 +38,14 @@
 			<Add option="-lmxml" />
 			<Add library="pthread" />
 		</Linker>
+		<Unit filename="src/drv_comm/drv_comm.c">
+			<Option compilerVar="CC" />
+		</Unit>
+		<Unit filename="src/drv_comm/drv_comm.h" />
+		<Unit filename="src/drv_comm/generator.c">
+			<Option compilerVar="CC" />
+		</Unit>
+		<Unit filename="src/drv_comm/generator.h" />
 		<Unit filename="src/hci_comm/hciChanged.h" />
 		<Unit filename="src/hci_comm/hci_comm.h" />
 		<Unit filename="src/hci_comm/hci_comm_listener.c">
