1

/*

     2

 * DMX output.

     3

 *

     4

 * See doc/dmx.txt for the RX-485 bus protocol details...

     5

 */

     6

     7

#include <avr/io.h>

     8

     9

#include "stdlib.h"

    10

#include "timer.c"

    11

#include "serial.c"

    12

#include "dmx.c"

    13

    14

// debug

    15

#define DEBUG_DDR   DDRB

    16

#define DEBUG_PORT  PORTB

    17

#define DEBUG_LED   0

    18

    19

void led_init ()

    20

{

    21

    sbi(&DEBUG_DDR, DEBUG_LED);

    22

}

    23

    24

void led_on ()

    25

{

    26

    sbi(&DEBUG_PORT, DEBUG_LED);

    27

}

    28

    29

void led_off ()

    30

{

    31

    cbi(&DEBUG_PORT, DEBUG_LED);

    32

}

    33

    34

void led_toggle ()

    35

{

    36

    xbi(&DEBUG_PORT, DEBUG_LED);

    37

}

    38

    39

// dmx

    40

#define DMX_COUNT 255

    41

    42

/*

    43

 * DMX state

    44

 */

    45

static struct dmx_state {

    46

    byte out[DMX_COUNT];

    47

    byte count;

    48

} dmx;

    49

    50

enum state {

    51

    START       = '\n',

    52

    CMD         = ';',

    53

    ARG         = ',',

    54

    ERROR       = '!',

    55

};

    56

    57

#define CONSOLE_ARGS 8

    58

    59

/*

    60

 * Console input state.

    61

 */

    62

static struct console {

    63

    byte state;

    64

    byte cmd;

    65

    byte argc;

    66

    byte argv[CONSOLE_ARGS];

    67

} console;

    68

    69

/*

    70

 * Clear output (no state).

    71

 */

    72

int cmd_clear ()

    73

{

    74

    dmx.count = 0;

    75

    76

    return 0;

    77

}

    78

    79

/*

    80

 * Set output to given sequence.

    81

 */

    82

int cmd_out ()

    83

{

    84

    byte i;

    85

    86

    for (i = 0; i < console.argc && i < DMX_COUNT; i++) {

    87

        dmx.out[i] = console.argv[i];

    88

    }

    89

    90

    dmx.count = i;

    91

    92

    return 0;

    93

}

    94

    95

/*

    96

 * Set output at offset.

    97

 */

    98

int cmd_set ()

    99

{

   100

    if (console.argc < 1) {

   101

        return '!';

   102

    }

   103

   104

    if (console.argv[0] == 0) {

   105

        return '!';

   106

    }

   107

   108

    byte i = console.argv[0] - 1;

   109

   110

    for (byte a = 1; a < console.argc && i < DMX_COUNT; a++) {

   111

        dmx.out[i++] = console.argv[a];

   112

    }

   113

   114

    if (i > dmx.count) {

   115

        dmx.count = i;

   116

    }

   117

   118

    return 0;

   119

}

   120

   121

/*

   122

 * Fill output range with values.

   123

 *

   124

 *  r <start> <stop> <value> ...

   125

 */

   126

int cmd_fill ()

   127

{

   128

    if (console.argc < 3) {

   129

        return '!';

   130

    }

   131

   132

    byte start = console.argv[0];

   133

    byte end = console.argv[1];

   134

   135

    if (!start) {

   136

        return '!';

   137

    }

   138

   139

    if (end < start) {

   140

        return '!';

   141

    }

   142

   143

    if (end >= DMX_COUNT) {

   144

        return '!';

   145

    }

   146

   147

    // apply

   148

    // arg is 1..256

   149

    byte c = start - 1;

   150

   151

    // c < end actually means inclusive to end of range, as the index is -1

   152

    for ( ; c < end; ) {

   153

        for (byte a = 2; a < console.argc && c < end; a++) {

   154

            dmx.out[c++] = console.argv[a];

   155

        }

   156

    }

   157

   158

    if (c > dmx.count) {

   159

        dmx.count = c;

   160

    }

   161

   162

    return 0;

   163

}

   164

   165

/*

   166

 * Set output start-stop/step range to value.

   167

 *

   168

 *  r <start> <stop> <step> <value>

   169

 */

   170

int cmd_range ()

   171

{

   172

    if (console.argc != 4) {

   173

        return '!';

   174

    }

   175

   176

    byte start = console.argv[0];

   177

    byte end = console.argv[1];

   178

    byte skip = console.argv[2];

   179

    byte value = console.argv[3];

   180

    byte c;

   181

   182

    if (!start) {

   183

        return '!';

   184

    }

   185

   186

    if (end < start) {

   187

        return '!';

   188

    }

   189

   190

    if (!skip) {

   191

        return '!';

   192

    }

   193

   194

    for (c = start; c <= end && c < DMX_COUNT; c += skip) {

   195

        dmx.out[c - 1] = value;

   196

    }

   197

   198

    // XXX: -1

   199

    if (c > dmx.count) {

   200

        dmx.count = c;

   201

    }

   202

   203

    return 0;

   204

}

   205

/*

   206

 * Set output to max. zeroes

   207

 */

   208

int cmd_zero ()

   209

{

   210

    byte count;

   211

   212

    if (console.argc == 0) {

   213

        count = DMX_COUNT;

   214

    } else if (console.argc == 1) {

   215

        count = console.argv[0];

   216

    } else {

   217

        return '!';

   218

    }

   219

   220

    // set

   221

    byte i;

   222

    for (i = 0; i < count; i++) {

   223

        dmx.out[i] = 0;

   224

    }

   225

    dmx.count = i;

   226

   227

    return 0;

   228

}

   229

   230

/*

   231

 * Process console command.

   232

 */

   233

int command ()

   234

{

   235

    switch (console.cmd) {

   236

        case 'c':       return cmd_clear();

   237

        case 'o':       return cmd_out();

   238

        case 'f':       return cmd_fill();

   239

        case 'r':       return cmd_range();

   240

        case 's':       return cmd_set();

   241

        case 'z':       return cmd_zero();

   242

   243

        default:        return '?';

   244

    }

   245

}

   246

   247

/*

   248

 * Process console input.

   249

 */

   250

char input (char c)

   251

{

   252

    // control

   253

    if (c == '\r') {

   254

        char ret = '?';

   255

   256

        if (console.state == CMD) {

   257

            console.argc = 0;

   258

        } else if (console.state == ARG) {

   259

            console.argc++;

   260

        } else {

   261

            console.state = START;

   262

            return '\n';

   263

        }

   264

   265

        // command

   266

        if ((ret = command(console.cmd))) {

   267

   268

        } else {

   269

            ret = '\n';

   270

        }

   272

        // return to START with response

   273

        console.state = START;

   274

        return '\n'; // XXX: required to delimit command reponses..

   276

    } else if (c == ' ' || c == '\t' || c == ',') {

   277

        // argument

   278

        if (console.state == CMD) {

   279

            console.state = ARG;

   280

            console.argc = 0;

   281

            console.argv[0] = 0;

   282

   283

            return ',';

   284

   285

        } else if (console.state == ARG) {

   286

            if (console.argc++ < CONSOLE_ARGS) {

   287

                console.argv[console.argc] = 0;

   288

   289

                return ',';

   290

            }

   291

        }

   292

   294

    } else if (32 < c && c < 128) {

   295

        // process input char

   296

        if (console.state == START)  {

   297

            console.cmd = c;

   298

            console.state = CMD;

   299

   300

            return c;

   301

   302

        } else if (console.state == ARG) {

   303

            if (c >= '0' && c <= '9') {

   304

                console.argv[console.argc] *= 10;

   305

                console.argv[console.argc] += (c - '0');

   306

   307

                return c;

   308

            }

   309

        }

   310

    } else {

   311

        // ignore

   312

        return ' ';

   313

    }

   315

    // reject

   316

    console.state = ERROR;

   317

    return ERROR;

   318

}

   319

   320

/*

   321

 * Tick output state

   322

 */

   323

void update ()

   324

{

   325

    dmx_packet(dmx.count, dmx.out);

   326

}

   327

   328

void main ()

   329

{

   330

    led_init();

   331

    timer_init();

   332

    serial_init();

   333

    dmx_init();

   334

   335

    // mainloop

   336

    char c = '>';

   337

    unsigned timeout = 8000; // 2Hz

   339

    // start

   340

    sei();

   341

    serial_write(c);

   342

   343

    while (true) {

   344

        // sleep

   345

        //led_on();

   346

        if (timer_sleep(timeout)) {

   347

            led_toggle();

   348

        }

   349

   350

        // input

   351

        while ((c = serial_read())) {

   352

            serial_write(input(c));

   353

        }

   354

   355

        //led_off();

   357

        // output

   358

        update();

   359

    }

   360

}