From 19ff5f54a824d7b3cd7f2683d9e524e446984735 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?IOhannes=20m=20zm=C3=B6lnig?=
 <zmoelnig@users.sourceforge.net>
Date: Tue, 1 Apr 2008 13:44:04 +0000
Subject: an old project - wandering whether it still works

svn path=/trunk/externals/hardware/; revision=9672
---
 MIDIvice/src/motormix.c | 865 ++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 865 insertions(+)
 create mode 100644 MIDIvice/src/motormix.c

(limited to 'MIDIvice/src/motormix.c')

diff --git a/MIDIvice/src/motormix.c b/MIDIvice/src/motormix.c
new file mode 100644
index 0000000..982a268
--- /dev/null
+++ b/MIDIvice/src/motormix.c
@@ -0,0 +1,865 @@
+
+/* 2801:forum::für::umläute:2002 */
+
+/*
+  motormix by CM-labs
+*/
+
+#include "MIDIvice.h"
+#include <string.h>
+#include <ctype.h>
+
+#define LCD_TEXT  0x10
+#define LCD_GRAPH 0x11
+#define SEG7      0x12
+
+static int x_port = 0;
+static t_symbol *ctlin_sym;
+static t_symbol *notein_sym;
+
+void outmidi_noteon(int portno, int channel, int pitch, int velo);
+void outmidi_controlchange(int portno, int channel, int ctlno, int value);
+void sys_putmidibyte(int portno, int byte);
+
+static void outmidi_byte(unsigned char byte)
+{ sys_putmidibyte(x_port, byte); }
+
+
+
+/* ------------------------- LCDtext ------------------------------- */
+
+static t_class *LCDtext_class;
+typedef struct _LCDtext
+{
+  t_object x_obj;
+
+  int pos;
+  int length;
+  t_binbuf *bbuf;
+} t_LCDtext;
+
+
+static void LCD_header(unsigned char type)
+{
+  outmidi_byte(0xF0);
+  outmidi_byte(0x00);
+  outmidi_byte(0x01);
+  outmidi_byte(0x0F);
+  outmidi_byte(0x00);
+  outmidi_byte(0x11);
+  outmidi_byte(0x00);
+  outmidi_byte(type);
+}
+static void LCD_footer(void)
+{
+  outmidi_byte(0xF7);
+}
+
+static void LCDtext_text(t_LCDtext *x)
+{
+  char *c, *str=0;
+  int n, slen;
+  int pos = x->pos;
+  int len = x->length;
+  int rest=0;
+
+  if (!x->bbuf)return;
+
+  binbuf_gettext(x->bbuf, &str, &slen);
+  c=str;
+  if (len>slen){
+    n=slen;
+    rest=len-slen;
+  } else n=len?len:slen;
+
+  if (n>0x50-pos)n=0x50-pos;
+
+  LCD_header(LCD_TEXT);
+  outmidi_byte(pos);
+  while(n--)outmidi_byte(*c++);
+  while(rest--)outmidi_byte(' ');
+  LCD_footer();
+
+  freebytes(str, slen);
+}
+
+static void LCDtext_clear(t_LCDtext *x, t_float fmode)
+{
+  int mode = fmode;
+  int offset = (mode==2)?0x28:0x00;
+  int n = (mode>0)?0x28:0x50;
+
+  post("offset=%d\tn=%d", offset, n);
+
+  LCD_header(LCD_TEXT);
+  outmidi_byte(offset);
+
+  while(n--)outmidi_byte(' ');
+
+  LCD_footer();
+}
+
+static void LCDtext_any(t_LCDtext *x, t_symbol *s, int argc, t_atom *argv)
+{
+  //  t_atom a;
+  binbuf_clear(x->bbuf);
+
+  if ((s != &s_list)&&(s != &s_float)&&(s != &s_symbol)){
+    t_atom a;
+    SETSYMBOL(&a, s);
+    binbuf_add(x->bbuf, 1, &a);
+  }
+  binbuf_add(x->bbuf, argc, argv);
+
+  LCDtext_text(x);
+}
+
+static void LCDtext_pos(t_LCDtext *x, t_float pos, t_float len)
+{
+  if (pos<0 )pos=0;
+  if (pos>80)pos=80;
+  if (len<0 )len=0;
+
+  x->pos=pos;
+  x->length=len;
+}
+
+
+static void *LCDtext_new(t_floatarg f)
+{
+  t_LCDtext *x = (t_LCDtext *)pd_new(LCDtext_class);
+  int pos = f;
+
+  if (pos<0)pos=0;
+  if (pos>0x4f)pos=0x4f;
+  x->pos=pos;
+  //  floatinlet_new(&x->x_obj, &x->pos);
+  inlet_new(&x->x_obj, &x->x_obj.ob_pd, gensym("float"), gensym(""));
+
+  x->bbuf = binbuf_new();
+
+  return (x);
+}
+static void LCDtext_setup(void)
+{
+  LCDtext_class = class_new(gensym("motormix_LCDtext"), (t_newmethod)LCDtext_new, 
+			      0, sizeof(t_LCDtext), 0, A_DEFFLOAT, 0);
+  class_addcreator((t_newmethod)LCDtext_new, gensym("mm_LCDtext"), A_DEFFLOAT, 0);
+
+  class_addmethod(LCDtext_class, (t_method)LCDtext_pos, gensym(""), A_DEFFLOAT, A_DEFFLOAT, 0);
+  class_addmethod(LCDtext_class, (t_method)LCDtext_clear, gensym("clear"), A_DEFFLOAT, 0);
+  class_addbang(LCDtext_class, (t_method)LCDtext_text);
+
+  class_addanything(LCDtext_class, LCDtext_any);
+  class_sethelpsymbol(LCDtext_class, gensym("MIDIvice/motormix"));
+}
+/* ------------------------- LCDgraph ------------------------------- */
+
+static t_class *LCDgraph_class;
+typedef struct _LCDgraph
+{
+  t_object x_obj;
+
+  t_float pos;
+  int type;
+} t_LCDgraph;
+
+static void LCDgraph_valpos(int pos, int val)
+{
+  if ((pos<1)||(pos>8))return;
+  if (val<0)val=0;
+  if (val>127)val=127;
+  outmidi_byte(pos-1);
+  outmidi_byte(val);
+}
+
+static void LCDgraph_float(t_LCDgraph *x, t_float f)
+{
+  if ((x->pos<1)||(x->pos>8))return;
+
+  LCD_header(LCD_GRAPH);
+  outmidi_byte(x->type);
+  LCDgraph_valpos(x->pos, f);
+  LCD_footer();
+}
+
+static void LCDgraph_clear(t_LCDgraph *x)
+{
+  int n = 0x28;
+  int pos=0x28;
+
+  LCD_header(LCD_TEXT);
+  outmidi_byte(pos);
+  while(n--)outmidi_byte(' ');
+  LCD_footer();
+}
+
+
+static void LCDgraph_pos(t_LCDgraph *x, t_float pos)
+{
+  x->pos=pos;
+}
+static void LCDgraph_typ(t_LCDgraph *x, t_float type)
+{
+  if (type<0 )type=0;
+  if (type>7)type=7;
+
+  x->type=type;
+}
+static void *LCDgraph_new(t_float ftype)
+{
+  t_LCDgraph *x = (t_LCDgraph *)pd_new(LCDgraph_class);
+
+  LCDgraph_typ(x, ftype);
+  floatinlet_new(&x->x_obj, &x->pos);
+  inlet_new(&x->x_obj, &x->x_obj.ob_pd, gensym("float"), gensym("type"));
+  x->pos=0;
+
+  return (x);
+}
+static void LCDgraph_setup(void)
+{
+  LCDgraph_class = class_new(gensym("motormix_LCDgraph"), (t_newmethod)LCDgraph_new, 
+			      0, sizeof(t_LCDgraph), 0, A_DEFFLOAT, 0);
+  class_addcreator((t_newmethod)LCDgraph_new, gensym("mm_LCDgraph"), A_DEFFLOAT, 0);
+
+  class_addmethod(LCDgraph_class, (t_method)LCDgraph_typ, gensym("type"), A_DEFFLOAT, 0);
+  class_addmethod(LCDgraph_class, (t_method)LCDgraph_pos, gensym(""), A_DEFFLOAT, 0);
+  class_addmethod(LCDgraph_class, (t_method)LCDgraph_clear, gensym("clear"), 0);
+  class_addfloat (LCDgraph_class, (t_method)LCDgraph_float);
+
+  //  class_addbang(LCDgraph_class, (t_method)LCDgraph_graph);
+  class_sethelpsymbol(LCDgraph_class, gensym("MIDIvice/motormix"));
+}
+
+/* ------------------------- seg7 ------------------------------- */
+
+static t_class *seg7_class;
+typedef struct _seg7
+{
+  t_object x_obj;
+
+  t_float point1, point2;
+  char c1, c2;
+} t_seg7;
+
+static void seg7_nibblebyte(char c, int point)
+{
+  char C = toupper(c);
+  char lo=C&0x0F;
+  char hi=(C>>4)&0x0F;
+  if (point)hi|=0x40;
+  //  post("C=%c=%c", c, C);
+  //  post("hi=%x\tlo=%x", hi, lo);
+
+  outmidi_byte(hi);
+  outmidi_byte(lo);
+}
+
+static void seg7_write(char c1, int pt1, char c2, int pt2)
+{
+  LCD_header(SEG7);
+
+  seg7_nibblebyte(c1, pt1);
+  seg7_nibblebyte(c2, pt2);
+
+  LCD_footer();
+}
+
+static void seg7_clear(t_seg7 *x, t_float fmode)
+{
+  int mode = fmode;
+
+  LCD_header(SEG7);
+  if (mode!=2)seg7_nibblebyte(' ', 0);
+  else seg7_nibblebyte(0, 0);
+  if (mode!=1)seg7_nibblebyte(' ', 0);
+  else seg7_nibblebyte(0, 0);
+
+  LCD_footer();
+}
+
+static void seg7_list(t_seg7 *x, t_symbol *s, int argc, t_atom* argv)
+{
+  char seg1, seg2;
+  int pt1=(x->point1 != 0);
+  int pt2=(x->point2 != 0);
+
+  seg1=(argv->a_type==A_SYMBOL)?
+    *atom_getsymbol(argv)->s_name:
+    (atom_getint(argv)%10+0x30);
+  argv++;
+  if (argc>1)seg2=(argv->a_type==A_SYMBOL)?*atom_getsymbol(argv)->s_name:(atom_getint(argv)%10+0x30);
+  else {
+    seg2=seg1;
+    seg1=' ';
+  }
+  //  post("seg1=%c\tseg2=%c", seg1, seg2);
+  
+  x->c1=seg1;
+  x->c2=seg2;
+
+  seg7_write(seg1, pt1, seg2, pt2);
+}
+static void seg7_symbol(t_seg7 *x, t_symbol *s)
+{
+  int pt1=(x->point1 != 0);
+  int pt2=(x->point2 != 0);
+  char c1=*s->s_name;
+  char c2=x->c2;
+
+  x->c1=c1;
+
+  //  post("c1=%c\tc2=%c", c1, c2);
+
+  seg7_write(c1, pt1, c2, pt2);
+}
+static void seg7_symbol2(t_seg7 *x, t_symbol *s)
+{
+  x->c2=*s->s_name;
+}
+static void seg7_bang(t_seg7 *x)
+{
+  int pt1=(x->point1 != 0);
+  int pt2=(x->point2 != 0);
+  char c1=x->c1;
+  char c2=x->c2;
+
+  seg7_write(c1, pt1, c2, pt2);
+}
+
+static void *seg7_new(void)
+{
+  t_seg7 *x = (t_seg7 *)pd_new(seg7_class);
+ 
+  floatinlet_new(&x->x_obj, &x->point1);
+  inlet_new(&x->x_obj, &x->x_obj.ob_pd, gensym("symbol"), gensym(""));
+  floatinlet_new(&x->x_obj, &x->point2);
+
+  x->point1=x->point2=0;
+  x->c1=x->c2=0;
+
+  return (x);
+}
+static void seg7_setup(void)
+{
+  seg7_class = class_new(gensym("motormix_7seg"), (t_newmethod)seg7_new, 
+			      0, sizeof(t_seg7), 0, A_GIMME, 0);
+  class_addcreator((t_newmethod)seg7_new, gensym("mm_7seg"), A_GIMME, 0);
+  class_addbang(seg7_class, seg7_bang);
+  class_addlist(seg7_class, seg7_list);
+  class_addsymbol(seg7_class, seg7_symbol);
+  class_addmethod(seg7_class, (t_method)seg7_clear, gensym("clear"), A_DEFFLOAT, 0);
+  class_addmethod(seg7_class, (t_method)seg7_symbol2, gensym(""), A_DEFSYMBOL, 0);
+  class_sethelpsymbol(seg7_class, gensym("MIDIvice/motormix"));
+}
+
+/* ------------------------- LED ------------------------------- */
+
+static t_class *LED_class;
+typedef struct _LED
+{
+  t_object x_obj;
+
+  t_float LED;
+  t_float state;
+} t_LED;
+
+static void LED_float(t_LED *x, t_float f)
+{
+  int MSB, LSB;
+  int state = x->state;
+  int offset = 0;
+  int id = f;
+
+  if (id<0)return;
+  LSB=id%8;
+  MSB=id/8;
+
+  x->LED=id;
+
+
+  if (state>0)offset=0x40;
+  else if (state<0)offset=0x50;
+
+  //  if (MSB<8)offset++;
+#if 0
+  post("LED: %x %x %x %x", 0x0C, MSB, 0x2C, LSB+offset);
+  //  post("LED: %d %d %d %d\n", 0x0C, MSB, 0x2C, LSB+offset);
+#endif
+  outmidi_controlchange(x_port>>4, x_port&15, 0x0C, MSB);
+  outmidi_controlchange(x_port>>4, x_port&15, 0x2C, LSB+offset);
+}
+
+static void LED_symbol(t_LED *x, t_symbol *s)
+{
+  post("motormix_LED: no method for symbol");
+}
+
+static void LED_bang(t_LED *x)
+{
+  LED_float(x, x->LED);
+}
+
+static void *LED_new(void)
+{
+  t_LED *x = (t_LED *)pd_new(LED_class);
+
+  x->LED=-1;
+  floatinlet_new(&x->x_obj, &x->state);
+
+  x->state=0;
+
+  return (x);
+}
+static void LED_setup(void)
+{
+  LED_class = class_new(gensym("motormix_LED"), (t_newmethod)LED_new, 
+			      0, sizeof(t_LED), 0, 0);
+  class_addcreator((t_newmethod)LED_new, gensym("mm_LED"), 0);
+ 
+  class_addsymbol(LED_class, LED_symbol);
+  class_addfloat (LED_class, LED_float);
+  class_addbang  (LED_class, LED_bang);
+  class_sethelpsymbol(LED_class, gensym("MIDIvice/motormix"));
+}
+
+
+/* button */
+static t_class *button_class;
+typedef struct _button
+{
+  t_object x_obj;
+  int      o_itsme;      // the fader changed
+  int      o_imtouched;  // the fader was touched
+
+  t_outlet *o_value; // actual fader-value
+  t_outlet *o_touch; // 1=touched; 0=released
+
+  int activefader;
+  int fader;
+  unsigned char MSB, LSB;
+} t_button;
+
+static void button_touch(t_button *x, unsigned char value, unsigned char control)
+{
+  int pressed=0;
+  int MSB=x->MSB;
+  int LSB=0;
+
+  x->o_imtouched=0;
+
+  if (x->MSB<8){
+    if ((value==0x00) || (value==0x40))return;
+  }
+
+  LSB=value;
+
+  if (LSB>=0x40){
+    pressed=1;
+    LSB-=0x40;
+  }
+
+  outlet_float(x->o_touch, pressed);
+  outlet_float(x->o_value, MSB*8+LSB);
+}
+
+static void button_list(t_button *x, t_symbol *s, int argc, t_atom *argv)
+{
+  unsigned char ctl = atom_getfloatarg(0, argc, argv);
+  unsigned char val = atom_getfloatarg(1, argc, argv);
+  //  int channel   = atom_getfloatarg(2, argc, argv);
+
+  if (x->o_imtouched)button_touch(x, val, ctl);
+
+  if (ctl==0x0f){
+	x->o_imtouched=1;
+	x->MSB=val;
+      }
+}
+static void button_free(t_button *x)
+{
+  pd_unbind(&x->x_obj.ob_pd, ctlin_sym);
+}
+static void *button_new()
+{
+  t_button *x = (t_button *)pd_new(button_class);
+
+  x->o_value=outlet_new(&x->x_obj, &s_float);
+  x->o_touch=outlet_new(&x->x_obj, &s_float);
+
+  x->o_imtouched = 0;
+
+  pd_bind(&x->x_obj.ob_pd, ctlin_sym);
+
+  return (x);
+}
+static void button_setup(void)
+{
+  button_class = class_new(gensym("motormix_button"), (t_newmethod)button_new, (t_method)button_free,
+			   sizeof(t_button), CLASS_NOINLET, A_DEFFLOAT,  0);
+  class_addcreator((t_newmethod)button_new, gensym("mm_button"), A_DEFFLOAT, 0);
+ 
+  class_addlist(button_class, button_list);
+  class_sethelpsymbol(button_class, gensym("MIDIvice/motormix"));
+}
+
+/* ------------------------- rotary ------------------------------- */
+
+
+static t_class *rotary_class;
+typedef struct _rotary
+{
+  t_object x_obj;
+
+  t_outlet *o_value; // actual rot-value
+  t_outlet *o_rot; // rot-number
+
+  int rot;
+} t_rotary;
+
+static void rotary_list(t_rotary *x, t_symbol *s, int argc, t_atom *argv)
+{
+  unsigned char ctl = atom_getfloatarg(0, argc, argv);
+  unsigned char val = atom_getfloatarg(1, argc, argv);
+  //  int channel   = atom_getfloatarg(2, argc, argv);
+
+  if ((ctl>=0x40) && (ctl<0x48)) {
+    if (x->rot) {
+      if (ctl+1-0x40==x->rot){
+	//	int value = (val>=64)?val-64:-val;
+	outlet_float(x->o_value, (val>=64)?val-64:-val);
+	  }
+    } else {
+      outlet_float(x->o_rot, (t_float)(ctl-0x40+1));
+      outlet_float(x->o_value, (val>=64)?val-64:-val);  
+    }
+  }
+}
+static void rotary_free(t_rotary *x)
+{
+  pd_unbind(&x->x_obj.ob_pd, ctlin_sym);
+}
+static void *rotary_new(t_floatarg f)
+{
+  t_rotary *x = (t_rotary *)pd_new(rotary_class);
+
+  if ((f<0) || (f>=9)){
+    post("motormix_rotary: rot [%d] specified. only rotariess 1..8(&0) are valid", (int)f);
+    f=0;
+  }
+  x->rot = f;
+
+  x->o_value=outlet_new(&x->x_obj, &s_float);
+  if (!x->rot) x->o_rot=outlet_new(&x->x_obj, &s_float);
+
+  pd_bind(&x->x_obj.ob_pd, ctlin_sym);
+
+  return (x);
+}
+static void rotary_setup(void)
+{
+  rotary_class = class_new(gensym("motormix_rotary"), (t_newmethod)rotary_new,  (t_method)rotary_free,
+			      sizeof(t_rotary), CLASS_NOINLET, A_DEFFLOAT,  0);
+  class_addcreator((t_newmethod)rotary_new, gensym("mm_rotary"), A_DEFFLOAT, 0);
+ 
+  class_addlist(rotary_class, rotary_list);
+  class_sethelpsymbol(rotary_class, gensym("MIDIvice/motormix"));
+}
+
+/* ------------------------- encoder ------------------------------- */
+
+static t_class *encoder_class;
+typedef struct _encoder
+{
+  t_object x_obj;
+
+  t_outlet *o_value; // actual rot-value
+  t_outlet *o_push;  // pushed
+} t_encoder;
+
+static void encoder_list(t_encoder *x, t_symbol *s, int argc, t_atom *argv)
+{
+  unsigned char ctl = atom_getfloatarg(0, argc, argv);
+  unsigned char val = atom_getfloatarg(1, argc, argv);
+  //  int channel   = atom_getfloatarg(2, argc, argv);
+
+  if (ctl==0x48) outlet_float(x->o_value, (val>=64)?val-64:-val);
+  else if (ctl==0x49)outlet_float(x->o_push, (t_float)(val==0x01));
+}
+static void encoder_free(t_encoder *x)
+{
+  pd_unbind(&x->x_obj.ob_pd, ctlin_sym);
+}
+static void *encoder_new(void)
+{
+  t_encoder *x = (t_encoder *)pd_new(encoder_class);
+
+  x->o_value=outlet_new(&x->x_obj, &s_float);
+  x->o_push =outlet_new(&x->x_obj, &s_float);
+
+  pd_bind(&x->x_obj.ob_pd, ctlin_sym);
+
+  return (x);
+}
+static void encoder_setup(void)
+{
+  encoder_class = class_new(gensym("motormix_encoder"), (t_newmethod)encoder_new,  (t_method)encoder_free,
+			    sizeof(t_encoder), CLASS_NOINLET, 0);
+   class_addcreator((t_newmethod)encoder_new, gensym("mm_encoder"), 0);
+
+  class_addlist(encoder_class, encoder_list);
+  class_sethelpsymbol(encoder_class, gensym("MIDIvice/motormix"));
+}
+
+
+/* ------------------------- faderIn ------------------------------- */
+
+static t_class *faderIn_class;
+typedef struct _faderIn
+{
+  t_object x_obj;
+  int      o_itsme;      // the fader changed
+  int      o_imtouched;  // the fader was touched
+
+  t_outlet *o_value; // actual fader-value
+  t_outlet *o_touch; // 1=touched; 0=released
+  t_outlet *o_fader; // fader-number
+
+  int activefader;
+  int fader;
+  unsigned char MSB, LSB;
+} t_faderIn;
+
+static void faderIn_parse(t_faderIn *x, unsigned char value, unsigned char control)
+{
+  unsigned int fader = (x->fader)?x->fader:x->activefader;
+  x->o_itsme=0;
+
+  if (fader+31==control){
+    x->LSB=value;
+    if (!x->fader)outlet_float(x->o_fader, x->activefader);
+    outlet_float(x->o_value, x->MSB+(1./128)*x->LSB);
+  }
+}
+static void faderIn_touch(t_faderIn *x, unsigned char value, unsigned char control)
+{
+  x->o_imtouched=0;
+
+  if (control==0x2F){
+    switch (value) {
+    case 0x00:
+      if (!x->fader)outlet_float(x->o_fader, x->activefader);
+      outlet_float(x->o_touch, 0.);
+      break;
+    case 0x40:
+      if (!x->fader)outlet_float(x->o_fader, x->activefader);
+      outlet_float(x->o_touch, 1.);
+    default:
+      break;
+    }
+  }
+}
+
+static void faderIn_list(t_faderIn *x, t_symbol *s, int argc, t_atom *argv)
+{
+  unsigned char ctl = atom_getfloatarg(0, argc, argv);
+  unsigned char val = atom_getfloatarg(1, argc, argv);
+  //  int channel   = atom_getfloatarg(2, argc, argv);
+
+  if (x->o_itsme)    faderIn_parse(x, val, ctl);
+  if (x->o_imtouched)faderIn_touch(x, val, ctl);
+
+  if (ctl==0x0f){
+    if (x->fader) {
+      if (val+1==x->fader){ // touched me
+	x->o_imtouched=1;
+      }
+    } else {
+      if (val<=7){ // touched us
+	x->o_imtouched=1;
+	x->activefader=val+1;
+      }
+    }
+  } else if (ctl<0x08) {
+    if (x->fader) {
+      if (ctl+1==x->fader){
+	x->o_itsme=1;
+	x->MSB=val;
+      }
+    } else {
+      x->o_itsme=1;
+      x->activefader=ctl+1;
+      x->MSB=val;
+    }
+  }
+}
+static void faderIn_free(t_faderIn *x)
+{
+  pd_unbind(&x->x_obj.ob_pd, ctlin_sym);
+}
+static void *faderIn_new(t_floatarg f)
+{
+  t_faderIn *x = (t_faderIn *)pd_new(faderIn_class);
+
+  if ((f<0) || (f>=9)){
+    post("motormix_fader: fader [%d] specified. only faders 1..8(&0) are valid", (int)f);
+    f=0;
+  }
+  x->fader = f;
+
+  x->o_value=outlet_new(&x->x_obj, &s_float);
+  x->o_touch=outlet_new(&x->x_obj, &s_float);
+  if (!x->fader) x->o_fader=outlet_new(&x->x_obj, &s_float);
+
+  x->o_itsme     = 0;
+  x->o_imtouched = 0;
+  x->activefader = 0;
+
+  pd_bind(&x->x_obj.ob_pd, ctlin_sym);
+
+  return (x);
+}
+static void faderIn_setup(void)
+{
+  faderIn_class = class_new(gensym("motormix_faderIn"), (t_newmethod)faderIn_new,  (t_method)faderIn_free,
+			    sizeof(t_faderIn), CLASS_NOINLET, A_DEFFLOAT,  0);
+  class_addcreator((t_newmethod)faderIn_new, gensym("mm_faderIn"), A_DEFFLOAT, 0);
+ 
+  class_addlist(faderIn_class, faderIn_list);
+  class_sethelpsymbol(faderIn_class, gensym("MIDIvice/motormix"));
+}
+
+/* ------------------------- faderOut ------------------------------- */
+
+static t_class *faderOut_class;
+typedef struct _faderOut
+{
+  t_object x_obj;
+
+  t_float fader;
+} t_faderOut;
+
+static void faderOut_float(t_faderOut *x, t_float f)
+{
+  int fader=x->fader;
+  unsigned char MSB, LSB;
+  if (f>=128)f=128;
+  else if (f<0)f=0;
+  if ((fader<1) || (fader>8))return;    
+
+  MSB=f;
+  LSB=(f-MSB)*128;
+  outmidi_controlchange(x_port>>4, x_port&15, fader-1, MSB);
+  outmidi_controlchange(x_port>>4, x_port&15, fader-1+32, LSB);
+}
+
+static void *faderOut_new(t_floatarg f)
+{
+  t_faderOut *x = (t_faderOut *)pd_new(faderOut_class);
+
+  if ((f<0) || (f>=9)){
+    post("motormix_fader: fader [%d] specified. only faders 1..8(&0) are valid", (int)f);
+    f=0;
+  }
+  x->fader=f;
+  if (!x->fader)floatinlet_new(&x->x_obj, &x->fader);
+
+  return (x);
+}
+static void faderOut_setup(void)
+{
+  faderOut_class = class_new(gensym("motormix_faderOut"), (t_newmethod)faderOut_new, 
+			      0, sizeof(t_faderOut), 0, A_DEFFLOAT,  0);
+  class_addcreator((t_newmethod)faderOut_new, gensym("mm_faderOut"), A_DEFFLOAT, 0);
+ 
+  class_addfloat(faderOut_class, faderOut_float);
+  class_sethelpsymbol(faderOut_class, gensym("MIDIvice/motormix"));
+}
+
+/* ------------------------- motormix ------------------------------- */
+
+static t_class *motormix_class;
+typedef struct _motormix
+{
+  t_object x_obj;
+} t_motormix;
+static void motormix_return(t_motormix *x, t_symbol *s, int argc, t_atom *argv)
+{
+  int p = atom_getfloatarg(0, argc, argv);
+  int v = atom_getfloatarg(1, argc, argv);
+
+  if ((p==0x00) && (v==0x7F))
+    outlet_bang(x->x_obj.ob_outlet);
+}
+
+static void motormix_bang(t_motormix *x)
+{ outmidi_noteon(x_port>>4, x_port&15,0,0); }
+
+static void motormix_help(t_motormix *x)
+{
+  post("MIDIvice - motormix\n===================");
+  post("support for MotorMix (tm) by cm-labs (r)");
+  post("  \tmotormix_faderIn"
+       "\n\tmotormix_rotary"
+       "\n\tmotormix_encoder"
+       "\n\tmotormix_button"
+       "\n\tmotormix_faderOut"
+       "\n\tmotormix_LED"
+       "\n\tmotormix_LCDtext"
+       "\n\tmotormix_LCDgraph"
+       "\n\tmotormix_7seg");
+  post("(l) forum::für::umläute @ IEM, Graz; 2002");
+}
+static void motormix_reset(t_motormix *x)
+{ /* this LOOKs like a reset; i don't know what it really is... */
+  LCD_header(SEG7);
+  LCD_footer(); 
+}
+static void motormix_free(t_motormix *x)
+{
+  pd_unbind(&x->x_obj.ob_pd, notein_sym);
+}
+static void *motormix_new(t_floatarg f)
+{
+  t_motormix *x = (t_motormix *)pd_new(motormix_class);
+  x_port=f;
+  outlet_new(&x->x_obj, &s_float);
+  pd_bind(&x->x_obj.ob_pd, notein_sym);
+  //  outmidi_noteon(x_port>>4,x_port&15,0,0); // isn't this dangerous ???
+  return (x);
+}
+
+void motormix_setup(void)
+{
+  motormix_class = class_new(gensym("motormix"), (t_newmethod)motormix_new, (t_method)motormix_free,
+			     sizeof(t_motormix), 0/*0CLASS_NOINLET*/, /*A_DEFFLOAT,*/  0);
+  
+  class_addcreator((t_newmethod)motormix_new, gensym("MotorMix"), /*A_DEFFLOAT,*/ 0);
+
+  class_addmethod(motormix_class, (t_method)motormix_help, gensym("help"), 0);
+  class_addbang(motormix_class, motormix_bang);
+  class_addmethod(motormix_class, (t_method)motormix_reset, gensym("reset"), 0);
+  class_addlist(motormix_class, motormix_return);
+ 
+  class_sethelpsymbol(motormix_class, gensym("MIDIvice/motormix"));
+
+  ctlin_sym = gensym("#ctlin");
+  notein_sym = gensym("#notein");
+
+  button_setup();
+  faderIn_setup();
+  faderOut_setup();
+  rotary_setup();
+  encoder_setup();
+  LED_setup();
+
+  LCDtext_setup();
+  LCDgraph_setup();
+  seg7_setup();
+
+  /* we have to send a motormix_ping once before it starts reacting.
+   * this seems to be a problem with pd, but i don't have hardware to test it right now
+   */
+  outmidi_noteon(x_port>>4,x_port&15,0,0); 
+}
-- 
cgit v1.2.1