EPSIAE » eneraptor

		<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" />

/*

* 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;

}

#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 doseže 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);

}

/**/

/*

* 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

#ifndef GENERATOR_H_INCLUDED

#define GENERATOR_H_INCLUDED

int generate_value();

char *int_to_str(int nbr);

#endif // GENERATOR_H_INCLUDED

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

/*

* 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);

	/**/

}

/*

* 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

/*

* 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);

}

    //printf( "getPowerPercentage(%d, %d, %d, %.2f, %d)\n",a,b,o,*val,func);

            if(*val >= a)

                pwr=100;

            else

                pwr=(int)((*val-o)/(b-o)*100);

            if(*val <= a)

                pwr=0;

            else

                pwr=(int)((1-(*val-a)/(o-a))*100);

    else if(func == FUNCTION_LOGARITHMIC) //TODO implement log func

    else if(func == FUNCTION_QUADRATIC)  //implement square func

#include "../drv_comm/drv_comm.h"

// devices

const char *dev1="/dev/dev_thermometer_01";

    /** //DAEMON

    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);

        printf("scen->buf %.2f\n", 1.0f*scen->buf);

        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))

            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);

                /// 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);

                    execl(scen->action, power);

                    printf("Zaganjam napravo %s z mocjo %d\n", scen->scen_id, power);

                    shutDownLogic();

                }

                printf("Scenario %s not updated, additional conditions false!\n", scen->scen_id);

        else

            active = 0;

        dev->buf=get_device_value(dev1);

        //dev->buf=random()%10+20;// random 20-30