tTh/DD2-monitor
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

les affaires reprennent !

Browse Source
This commit is contained in:
tth 2021-04-12 20:10:15 +02:00
parent 140cbd47d8
commit 1f2755d894
17 changed files with 809 additions and 120 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
.gitignore vendored
View File

@ -35,3 +35,5 @@ audio/*.wav
ui/log.*
ui/t
Beep/alguabeep

34
Beep/Makefile Normal file
View File

@ -0,0 +1,34 @@
CC = gcc
CCOPT = -Wall -O3 -g -DDEBUG_LEVEL=0
# -------------------------------------------------------
all: alguabeep
# -------------------------------------------------------
process.o: process.c process.h Makefile
$(CC) $(CCOPT) -c $<
funcs.o: funcs.c funcs.h Makefile
$(CC) $(CCOPT) -c $<
display.o: display.c funcs.h Makefile
$(CC) $(CCOPT) -c $<
controls.o: controls.c controls.h Makefile
$(CC) $(CCOPT) -c $<
alguabeep.o: alguabeep.c process.h controls.h Makefile
$(CC) $(CCOPT) -c $<
alguabeep: process.o alguabeep.o funcs.o display.o controls.o
$(CC) $(CCOPT) $^ -lao -lv4l2 -lcurses -lm -lpthread -o $@
# -------------------------------------------------------

275
Beep/alguabeep.c Normal file
View File

@ -0,0 +1,275 @@
/* V4L2 video picture grabber
Copyright (C) 2009 Mauro Carvalho Chehab <mchehab@infradead.org>
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation version 2 of the License.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
#include <errno.h>
#include <curses.h>
#include <sys/ioctl.h>
#include <sys/types.h>
#include <sys/time.h>
#include <sys/mman.h>
#include <linux/videodev2.h>
#include <libv4l2.h>
#define CLEAR(x) memset(&(x), 0, sizeof(x))
#include "process.h"
#include "funcs.h"
#include "controls.h"
struct buffer {
void *start;
size_t length;
};
int verbosity;
/* --------------------------------------------------------------------- */
double dtime(void)
{
struct timeval tv;
int foo;
foo = gettimeofday(&tv, NULL);
if (foo) fprintf(stderr, "got %d in %s\n", foo, __func__);
return (double)tv.tv_sec + (double)tv.tv_usec / 1e6;
}
/* --------------------------------------------------------------- */
static void xioctl(int fh, int request, void *arg)
{
int r;
do {
r = v4l2_ioctl(fh, request, arg);
} while (r == -1 && ((errno == EINTR) || (errno == EAGAIN)));
if (r == -1) {
fprintf(stderr, "error %d, %s\n", errno, strerror(errno));
exit(EXIT_FAILURE);
}
}
/* --------------------------------------------------------------------- */
void help(int v)
{
puts("options :");
puts("\t-d /dev/?\tselect video device");
puts("\t-I\t\ttake pictures");
puts("\t-K\t\tset the K parameter");
puts("\t-n NNN\t\thow many frames ?");
puts("\t-p NNN\t\tperiod in seconds");
puts("\t-s WxH\t\tset capture size");
puts("\t-v\t\tincrease verbosity");
exit(0);
}
/* --------------------------------------------------------------------- */
int main(int argc, char **argv)
{
struct v4l2_format fmt;
struct v4l2_buffer buf;
struct v4l2_requestbuffers req;
enum v4l2_buf_type type;
fd_set fds;
struct timeval tv;
int r, fd = -1;
unsigned int i, n_buffers;
char *dev_name = "/dev/video0";
char out_name[256], chaine[100];
FILE *fout;
struct buffer *buffers;
int period = 0; /* delai entre les captures */
int nbre_capt = 1; /* nombre de captures */
int opt, foo;
int K = 100;
int mk_img = 0;
int width=640, height=480;
double t_debut, t_fin;
while ((opt = getopt(argc, argv, "d:hIK:n:p:v")) != -1) {
switch(opt) {
case 'd': dev_name = optarg; break;
case 'h': help(0); break;
case 'I': mk_img = 1; break;
case 'K': K = atoi(optarg); break;
case 'n': nbre_capt = atoi(optarg); break;
case 'p': period = atoi(optarg); break;
case 'v': verbosity++; break;
}
}
fprintf(stderr, "pid of %s is %d\n", argv[0], getpid());
fd = v4l2_open(dev_name, O_RDWR | O_NONBLOCK, 0);
if (fd < 0) {
perror("Cannot open device");
exit(EXIT_FAILURE);
}
foo = set_controls(fd, 127, 127);
fprintf(stderr, "reset controls -> %d\n", foo);
foo = init_process(K);
fprintf(stderr, "init process -> %d\n", foo);
CLEAR(fmt);
fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
fmt.fmt.pix.width = 1920;
fmt.fmt.pix.height = 1080;
fmt.fmt.pix.pixelformat = V4L2_PIX_FMT_RGB24;
fmt.fmt.pix.field = V4L2_FIELD_INTERLACED;
xioctl(fd, VIDIOC_S_FMT, &fmt);
if (fmt.fmt.pix.pixelformat != V4L2_PIX_FMT_RGB24) {
printf("Libv4l didn't accept RGB24 format. Can't proceed.\n");
exit(EXIT_FAILURE);
}
if ((fmt.fmt.pix.width != 640) || (fmt.fmt.pix.height != 480)) {
fprintf(stderr, "Warning: driver is sending image at %dx%d\n",
fmt.fmt.pix.width, fmt.fmt.pix.height);
}
CLEAR(req);
req.count = 2;
req.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
req.memory = V4L2_MEMORY_MMAP;
xioctl(fd, VIDIOC_REQBUFS, &req);
buffers = calloc(req.count, sizeof(*buffers));
for (n_buffers = 0; n_buffers < req.count; ++n_buffers) {
CLEAR(buf);
buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
buf.memory = V4L2_MEMORY_MMAP;
buf.index = n_buffers;
xioctl(fd, VIDIOC_QUERYBUF, &buf);
buffers[n_buffers].length = buf.length;
buffers[n_buffers].start = v4l2_mmap(NULL, buf.length,
PROT_READ | PROT_WRITE, MAP_SHARED,
fd, buf.m.offset);
if (MAP_FAILED == buffers[n_buffers].start) {
perror("mmap");
exit(EXIT_FAILURE);
}
}
for (i = 0; i < n_buffers; ++i) {
CLEAR(buf);
buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
buf.memory = V4L2_MEMORY_MMAP;
buf.index = i;
xioctl(fd, VIDIOC_QBUF, &buf);
}
if (nbre_capt) fprintf(stderr, "running for %d frames\n", nbre_capt);
else fprintf(stderr, "just one shoot...\n");
t_debut = dtime();
foo = lancement_thread_son(0);
initialise_ecran(0);
type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
xioctl(fd, VIDIOC_STREAMON, &type);
sprintf(chaine, "entering main loop, %d iters\n", nbre_capt);
mvaddstr(1, 0, chaine);
refresh();
fprintf(stderr, "%s\n", chaine);
for (i = 0; i < nbre_capt; i++) {
do {
FD_ZERO(&fds);
FD_SET(fd, &fds);
/* Timeout. */
tv.tv_sec = 2;
tv.tv_usec = 0;
r = select(fd + 1, &fds, NULL, NULL, &tv);
} while ((r == -1 && (errno = EINTR)));
if (r == -1) {
perror("select");
return errno;
}
CLEAR(buf);
buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
buf.memory = V4L2_MEMORY_MMAP;
xioctl(fd, VIDIOC_DQBUF, &buf);
#if DEBUG_LEVEL > 1
fprintf(stderr, "buf.bytesused %d\n", buf.bytesused);
#endif
if ( period!=0 || 0==(i%10) ) {
sprintf(chaine, "frame %d %8.1fs", i, dtime()-t_debut);
mvaddstr(1, 50, chaine);
}
foo = charcuteur(buffers[buf.index].start,
fmt.fmt.pix.width, fmt.fmt.pix.height, K);
// foo = process(buffers[buf.index].start,
// fmt.fmt.pix.width, fmt.fmt.pix.height, K);
if (mk_img) {
sprintf(out_name, "i/out%04d.ppm", i);
if (verbosity) fprintf(stderr, "--> %s\n", out_name);
fout = fopen(out_name, "w");
if (!fout) {
perror(out_name);
exit(EXIT_FAILURE);
}
fprintf(fout, "P6\n%d %d 255\n",
fmt.fmt.pix.width, fmt.fmt.pix.height);
fwrite(buffers[buf.index].start, buf.bytesused, 1, fout);
fclose(fout);
}
if (nbre_capt > 1 && period) {
sleep(period);
}
xioctl(fd, VIDIOC_QBUF, &buf);
}
t_fin = dtime();
if (nbre_capt > 0) {
fprintf(stderr, "%f frames per second\n",
(double)nbre_capt/(t_fin-t_debut));
}
type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
xioctl(fd, VIDIOC_STREAMOFF, &type);
for (i = 0; i < n_buffers; ++i) {
v4l2_munmap(buffers[i].start, buffers[i].length);
}
endwin();
v4l2_close(fd);
return 0;
}

71
Beep/controls.c Normal file
View File

@ -0,0 +1,71 @@
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>
#include <sys/ioctl.h>
#include <string.h>
#include <linux/videodev2.h>
#include <libv4l2.h>
#include "controls.h"
extern int verbosity;
int set_controls(int fd, int brightness, int contrast)
{
struct v4l2_queryctrl queryctrl;
struct v4l2_control control;
memset (&queryctrl, 0, sizeof (queryctrl));
queryctrl.id = V4L2_CID_BRIGHTNESS;
if (-1 == ioctl (fd, VIDIOC_QUERYCTRL, &queryctrl)) {
if (errno != EINVAL) {
perror ("VIDIOC_QUERYCTRL");
exit (EXIT_FAILURE);
} else {
printf ("V4L2_CID_BRIGHTNESS is not supported\n");
}
} else if (queryctrl.flags & V4L2_CTRL_FLAG_DISABLED) {
printf ("V4L2_CID_BRIGHTNESS is not supported\n");
} else {
memset (&control, 0, sizeof (control));
control.id = V4L2_CID_BRIGHTNESS;
control.value = queryctrl.default_value;
if (-1 == ioctl (fd, VIDIOC_S_CTRL, &control)) {
perror ("VIDIOC_S_CTRL");
exit (EXIT_FAILURE);
}
}
memset (&control, 0, sizeof (control));
control.id = V4L2_CID_CONTRAST;
if (0 == ioctl (fd, VIDIOC_G_CTRL, &control)) {
control.value += 1;
/* The driver may clamp the value or return ERANGE, ignored here */
if (-1 == ioctl (fd, VIDIOC_S_CTRL, &control)
&& errno != ERANGE) {
perror ("VIDIOC_S_CTRL");
exit (EXIT_FAILURE);
}
/* Ignore if V4L2_CID_CONTRAST is unsupported */
} else if (errno != EINVAL) {
perror ("VIDIOC_G_CTRL");
exit (EXIT_FAILURE);
}
control.id = V4L2_CID_AUDIO_MUTE;
control.value = 1; /* silence */
/* Errors ignored */
ioctl (fd, VIDIOC_S_CTRL, &control);
return 0;
}

6
Beep/controls.h Normal file
View File

@ -0,0 +1,6 @@
/*
* various V4L2 functions
*/
/* not very tested */
int set_controls(int fd, int brightness, int contrast);

38
Beep/display.c Normal file
View File

@ -0,0 +1,38 @@
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <curses.h>
#include "funcs.h"
/* ---------------------------------------------------------------- */
int initialise_ecran(int type)
{
char chaine[100];
initscr();
nonl(); cbreak(); noecho();
keypad(stdscr, TRUE); /* acces aux touches 'curseur' */
atexit(finish);
sprintf(chaine, " alguabeep (%s %s) pid=%d \n", __DATE__, __TIME__,
getpid());
standout(); mvaddstr(0, 0, chaine); standend();
refresh();
return 0;
}
/* ---------------------------------------------------------------- */
void finish(void)
{
endwin();
fprintf(stderr, "end of pid %d\n", getpid());
exit(0);
}
/* ---------------------------------------------------------------- */
/* ---------------------------------------------------------------- */

48
Beep/funcs.c Normal file
View File

@ -0,0 +1,48 @@
/*
* algua beep module
*/
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include "funcs.h"
/* --------------------------------------------------------------------- */
/*
*
* valeur retournee entre 0 et 255
*/
double niveau_zone(unsigned char *datas, int w, int h, Rect *rp)
{
unsigned char *bptr;
int niveau = 0;
int lig, col;
int l2, c2, off;
#if DEBUG_LEVEL
fprintf(stderr, ">>> %s ( %p %d %d %p )\n", __func__, datas, w, h, rp);
fprintf(stderr, " > x %d y %d w %d h %d\n", rp->x, rp->y, rp->w, rp->h);
#endif
l2 = (rp->y+rp->h);
c2 = (rp->x+rp->w);
for (lig=rp->y; lig<l2; lig++) {
off = (3*w*lig) + (3*rp->x); /* WTF ? */
bptr = datas + off;
for (col=rp->x; col<c2; col++) {
niveau += *(bptr+2); /* add value to sum */
bptr += 3; /* next pixel */
}
}
return (double)niveau / (double)(rp->w * rp->h);
}
/* --------------------------------------------------------------------- */

20
Beep/funcs.h Normal file
View File

@ -0,0 +1,20 @@
/* --------------------------------------------------------------------- */
typedef struct {
int x, y, w, h;
} Rect;
/* --------------------------------------------------------------------- */
/* image processing */
double niveau_zone(unsigned char *datas, int w, int h, Rect *rp);
/* --------------------------------------------------------------------- */
/* display module */
int initialise_ecran(int type);
void finish(void);
/* --------------------------------------------------------------------- */

302
Beep/process.c Normal file
View File

@ -0,0 +1,302 @@
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <math.h>
#include <pthread.h>
#include <curses.h>
#include <ao/ao.h>
#include "process.h"
#include "funcs.h"
/* --------------------------------------------------------------------- */
#define IMG_W 32
#define NB_SLICES 32
#define TBUFFER IMG_W*NB_SLICES
extern int verbosity;
short samples[TBUFFER*2];
static ao_device *device;
static ao_sample_format format;
static double debut;
/* --------------------------------------------------------------------- */
int init_process(int K)
{
// int foo;
int default_driver;
#if DEBUG_LEVEL
fprintf(stderr, ">>> %s ( %d )\n", __func__, K);
#endif
ao_initialize();
default_driver = ao_default_driver_id();
#if DEBUG_LEVEL
fprintf(stderr, "%s : ao default driver #%d\n", __func__, default_driver);
#endif
memset(&format, 0, sizeof(format));
format.bits = 16;
format.channels = 2;
format.rate = 44100;
format.byte_format = AO_FMT_LITTLE;
device = ao_open_live(default_driver, &format, NULL);
if (device == NULL) {
fprintf(stderr, "Error opening AO device.\n");
return -1;
}
memset(samples, 0, sizeof(samples));
return 0;
}
/* --------------------------------------------------------------------- */
/* recherche de zones
*/
typedef struct {
int x, y;
double v;
} Datum;
static int cmp_datums(const void *a, const void *b)
{
Datum *pa = (Datum *)a;
Datum *pb = (Datum *)b;
return pa->v < pb->v;
}
static void pr_idx(int idx, int stand)
{
char chaine[100];
if (stand) standout();
sprintf(chaine, "[%03d]", idx);
addstr(chaine);
if (stand) standend();
}
static double i2freq(int i)
{
i = 333+i*42;
if (0==i) abort();
return 30.0* (1.0 / (double)i);
}
static int generate_samples(short *where, int size, Datum *datas)
{
int loop;
short value;
double vol;
char chaine[100];
#if DEBUG_LEVEL > 1
fprintf(stderr, ">>> %s ( %p %d %p )\n", __func__,
where, size, datas);
#endif
for (loop=0; loop<size; loop++) {
/* LEFT */
vol = 10000.0 * pow(datas[0].v / 256.0, 2.0);
value = (short)(sin((double)loop*i2freq(datas[0].y)) * vol);
*where++ = value;
/* RIGHT */
vol = 10000.0 * pow(datas[1].v / 256.0, 2.0);
value = (short)(sin((double)loop*i2freq(datas[1].y)) * vol);
*where++ = value;
}
sprintf(chaine, "sample %6.3f = %7d", vol, value);
mvaddstr(35, 0, chaine);
return 0;
}
int charcuteur(unsigned char *datas, int w, int h, int K)
{
int bigR, bigC, idx;
int nbR, nbC;
double value;
Rect rect;
Datum vals[5000];
char chaine[100];
#define W 80 /* size of rectangular AOIs */
#define H 40
#define SL 4 /* position of display */
#define SC 2
#define DL 1 /* displacement factor */
#define DC 5
idx = 0;
rect.h = H; rect.w = W;
nbR = h / H; nbC = w / W;
#if DEBUG_LEVEL
sprintf(chaine, "%s %4d %4d %3d %3d\n", __func__, w, h, nbC, nbR);
mvaddstr(2, 0, chaine);
#endif
for (bigR=0; bigR<nbR; bigR++) {
rect.y = bigR * H;
for (bigC=0; bigC<nbC; bigC++) {
rect.x = bigC * W;
value = niveau_zone(datas, w, h, &rect);
vals[idx].x = bigC; vals[idx].y = bigR;
vals[idx].v = value;
sprintf(chaine, "%4.0f", value);
mvaddstr(SL+1+bigR*DL, SC+bigC*DC, chaine);
idx++;
#if DEBUG_LEVEL
fprintf(stderr, "%s %6d %6d %6d\n", __func__, bigR, bigC, idx);
#endif
}
}
qsort(vals, nbR*nbC, sizeof(Datum), cmp_datums);
for (idx=0; idx<16; idx++) {
sprintf(chaine, "%2d %2d %6.2f", vals[idx].x, vals[idx].y,
vals[idx].v);
mvaddstr(5+idx, 130, chaine);
}
/* *** sound generator ***/
generate_samples(samples, TBUFFER, vals);
/* marquer les points les plus brillants */
standout();
sprintf(chaine, "%4.0f", vals[0].v);
mvaddstr(SL+1+vals[0].y*DL, SC+vals[0].x*DC, chaine);
sprintf(chaine, "%4.0f", vals[1].v);
mvaddstr(SL+1+vals[1].y*DL, SC+vals[1].x*DC, chaine);
standend(); move(0, 0); refresh();
return -1;
}
/* --------------------------------------------------------------------- */
/*
* extraction de ligne - to be continued
*/
/* --------------------------------------------------------------------- */
/*
* entry point from the main loop
*/
int process(unsigned char *datas, int w, int h, int K)
{
short *ptr, value;
int sl, foo, minv, maxv;
unsigned int idata;
double kv;
double v_left, v_right;
Rect z_left, z_right;
char ligne[200];
#if DEBUG_LEVEL
fprintf(stderr, ">>> %s ( %p %dx%d %d )\n", __func__, datas, w, h, K);
#endif
minv = maxv = 0;
kv = (double)K;
z_left.x = 50; z_left.y = 30;
z_left.w = 500; z_left.h = 100;
v_left = kv * pow((niveau_zone(datas, w, h, &z_left) / 256.0), 2.0);
z_right.x = 50; z_right.y = 300;
z_right.w = 500; z_right.h = 100;
v_right = kv * pow((niveau_zone(datas, w, h, &z_right) / 256.0), 2.0);
sprintf(ligne, "values %10.3f %10.3f", v_left, v_right);
mvaddstr(1, 43, ligne);
refresh();
ptr = samples;
for (sl=0; sl<NB_SLICES; sl++) {
for (foo=0; foo<IMG_W; foo+=2)
{
/* calcul position dans l'image */
idata = (foo*3) + (w*3*100);
value = (short)(v_left * ((double)datas[idata+1]-127.0));
if (value < minv) minv = value;
else if (value > maxv) maxv = value;
*ptr++ = value;
value = (short)(v_right * ((double)datas[idata+2]-127.0));
if (value < minv) minv = value;
else if (value > maxv) maxv = value;
*ptr++ = value;
}
}
// puts("");
if (verbosity) {
sprintf(ligne, " min %6d max %6d\n", minv, maxv);
mvaddstr(11, 3, ligne);
refresh();
}
return 0;
}
/* --------------------------------------------------------------------- */
void * thr_action(void *ptr)
{
long idx;
// int foo;
// #if DEBUG_LEVEL
fprintf(stderr, ">>> %s ( %p )\n", __func__, ptr);
fprintf(stderr, " value is %d\n", *(int *)ptr);
// #endif
while(1) {
if (verbosity > 1) {
fprintf(stderr, "%s t=%g\n", __func__, dtime() - debut);
}
for (idx=0; idx<100; idx++) {
ao_play(device, (char *)samples, TBUFFER*2);
}
}
return NULL;
}
/* --------------------------------------------------------------------- */
int lancement_thread_son(int k)
{
static pthread_t thread;
static int pid;
int foo;
#if DEBUG_LEVEL
fprintf(stderr, ">>> %s ( %d )\n", __func__, k);
#endif
debut = dtime();
/* lancement du thread de rendu sonore */
pid = getpid();
foo = pthread_create(&thread, NULL, thr_action, &pid);
fprintf(stderr, "thread creation -> %d\n", foo);
return 0;
}
/* --------------------------------------------------------------------- */

12
Beep/process.h Normal file
View File

@ -0,0 +1,12 @@
double dtime(void);
int init_process(int K);
int charcuteur(unsigned char *datas, int w, int h, int K);
int process(unsigned char *datas, int w, int h, int K);
int lancement_thread_son(int k);

22
gnocchi/README.md
View File

@ -1,22 +0,0 @@
# Gnocchi
## blabla commercial
<<<<<<< HEAD
_The problem that [Gnocchi](https://gnocchi.xyz/) solves is the storage and indexing of
time series data and resources at a large scale.
=======
_The problem that [Gnocchi](https://gnocchi.xyz/) solves is the storage and
indexing of time series data and resources at a large scale.
>>>>>>> b47e467d21cec6ee688b4407d3ec54fa33e67ba6
This is useful in modern cloud platforms which are not only huge
but also are dynamic and potentially multi-tenant.
Gnocchi takes all of that into account._
Bref, il faut essayer ce truc. Un de ces jours...
`pip install gnocchi[postgresql,ceph,keystone]`
bon, on va peut-être attendre :)

25
influxdb/README.md
View File

@ -1,25 +0,0 @@
## InfluxDB
# Blabla commercial
_Time Series Databases have to deal with specific workloads and requirements.
They need to ingest millions of data points per second; to perform real-time
queries across these large data sets in a non-blocking manner; to downsample
and evict high-precision low-value data; to optimize data storage to reduce
storage costs; and to perform complex time-bound queries to extract meaningful
insight from the data. It is possible to meet these requirements only with a
purpose-built platform that InfluxData provides._
# On essaye ?
Ok, c'est parti. Premier souci, la documentation est assez légère.
On va tenter d'écrire un injecteur en Perl. Puis enchainer sur
une visualisation dynamique des données en lancer de rayon.
Projet ambitieux ? Non, la suite sera bien pire.

13
influxdb/create.sh
View File

@ -1,13 +0,0 @@
#!/bin/bash
#
# create an inflix databasse
#
influx -host localhost -port 8086 << __EOC__
settings
CREATE DATABASE tests
__EOC__
lynx -head -dump http://localhost:8086/ping?verbose=true

11
influxdb/injecteur.pl
View File

@ -1,11 +0,0 @@
#!/usr/bin/perl
use strict;
my $host = "localhost";
my $port = 8086;
print "injecteur v 0\n";
0;

2
plot.sh
View File

@ -18,7 +18,7 @@ wc -l ${DATAFILE}
tail -${nbsamp} < ${DATAFILE} > ${TMPFILE}
gnuplot << __EOC__
set term png size 1600,800
set term png size 1000,600
set output "${IMAGE}"
set ytics 2
set xtics

4
storage/Makefile
View File

@ -1,4 +0,0 @@
t: t.c Makefile
gcc -Wall $< -o $@

44
storage/t.c
View File

@ -1,44 +0,0 @@
/*
* phytotron - outil de gestion des datas
*/
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
int verbosity;
/* --------------------------------------------------------------- */
void help(int k)
{
puts("options : ");
puts("\t-K\tset the K parameter.");
puts("\t-v\tincrease verbosity.");
exit(0);
}
/* --------------------------------------------------------------- */
int main(int argc, char *argv[])
{
int opt, foo;
int K = 0;
// char ligne[100];
while ((opt = getopt(argc, argv, "hKv")) != -1) {
switch (opt) {
case 'h': help(0); break;
case 'K': K = atoi(optarg); break;
case 'v': verbosity++; break;
default: break;
}
}
fprintf(stderr, "*** storage tool %s %s\n", __DATE__, __TIME__);
return 0;
}
/* --------------------------------------------------------------- */