trennfix/sw/src/trennfix_main.c

   1 /******************************************************************************
   2  *
   3  *  Trennfix firmware - main.c
   4  *
   5  *  Copyright (C) 2017 Philipp Hachtmann
   6  *
   7  *  This program is free software: you can redistribute it and/or modify
   8  *  it under the terms of the GNU General Public License as published by
   9  *  the Free Software Foundation, either version 3 of the License, or
  10  *  (at your option) any later version.
  11  *
  12  *  This program is distributed in the hope that it will be useful,
  13  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  *  GNU General Public License for more details.
  16  *
  17  *  You should have received a copy of the GNU General Public License
  18  *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
  19  *
  20  *****************************************************************************/
  21
  22 #include <stdio.h>
  23 #include <stdlib.h>
  24 #include <string.h>
  25
  26 #include <avr/io.h>
  27 #include <avr/eeprom.h>
  28 #include <avr/interrupt.h>
  29 #include <avr/pgmspace.h>
  30
  31 #include <util/delay.h>
  32 #include <stdint.h>
  33 #include <mm/mm_switch.h>
  34 #include <config/hardware.h>
  35
  36 #define EE_MAGIC 0xab
  37
  38 FUSES = {
  39         .low = FUSE_CKDIV8 & FUSE_SUT0 &\
  40         FUSE_CKSEL3 & FUSE_CKSEL2 & FUSE_CKSEL1,
  41         .high = FUSE_SPIEN & FUSE_BODLEVEL1 & FUSE_BODLEVEL0,
  42         .extended = EFUSE_DEFAULT,
  43 };
  44 enum op_mode {
  45         OM_MOMENTARY,     /* on as long as "key on" pressed   */
  46         OM_DOUBLE,        /* On off with "on" and "off" keys  */
  47         OM_TOGGLE,        /* toggle on "key on" pressed       */
  48         OM_ERASED = 0xff  /* EEPROM erased, need setup        */
  49 };
  50
  51 enum learn_mode {
  52         LM_OFF = 0,
  53         LM_LEARN_ON_KEY,     /* Learn primary key                           */
  54         LM_LEARN_OFF_KEY,    /* Learn secondary key, relevant for OM_DOUBLE */
  55         LM_LEARN_INITIAL,    /* Learn initial pulse length, 10ms steps      */
  56         LM_LEARN_DUTY,       /* Learn duty cycle 0-10                       */
  57         LM_LEARN_OP_MODE,    /* Learn operation mode                        */
  58         LM_EASY_WAIT_PRESS,  /* Wait for key press to enter easy mode       */
  59         LM_EASY_WAIT_UP,     /* Wait for end of key press                   */
  60         LM_EASY_WAIT_TURN,   /* Wait for loco 80 turn end                   */
  61         LM_EASY_MODE,        /* Easy config mode for PWM and initial kick   */
  62         LM_END,              /* Only a label                                */
  63 };
  64
  65 struct config {
  66         uint8_t magic; /* Magic value */
  67         enum op_mode op_mode;
  68         uint8_t decoder_on;
  69         uint8_t key_on;
  70         uint8_t decoder_off;
  71         uint8_t key_off;
  72         uint8_t initial_pulse; /* Lenghth of initial pulse in 10ms steps   */
  73         uint8_t on_duty_cycle; /* Duty cycle for on. 0-10                  */
  74         volatile enum learn_mode  learn_mode;
  75 };
  76
  77 static struct EEMEM config ee_config;
  78 static volatile struct config config;
  79
  80 static volatile uint8_t easy_mode = 0;
  81 static volatile uint8_t easy_mode_possible = 0;
  82
  83 #ifndef USE_REGISTER_VARS
  84 static volatile uint8_t drive_on = 0;
  85 #endif
  86
  87 /******************************************************************************
  88  *
  89  * Some nice sounds to play on your coil
  90  *
  91  */
  92
  93 #define G 180
  94 #define sekunde(g)(quinte((quinte(g)))*2)
  95 #define terz(g) ((g) * 4 / 5)
  96 #define kleine_terz(g) ((g) * 5 / 6)
  97 #define quarte(g) ((g) * 3 / 4)
  98 #define quinte(g) ((g) * 2 / 3)
  99 #define tt(g) ((g) * 32 / 45)
 100 #define septime(g) ((g) * 15 / 8)
 101
 102 #if defined(WITH_SOUND) && defined(WITH_PWM)
 103 void play_tone(uint8_t divisor, uint8_t duration, uint8_t pause)
 104 {
 105         uint16_t c;
 106         TCCR1 = 0x8;
 107         OCR1C = divisor;
 108         c = (divisor * 2) / 3;
 109         OCR1B = c;
 110         for (c = 0; c < duration - pause; c++)
 111                 _delay_ms(2);
 112         TCCR1 = 0x6;
 113         OCR1C = PWM_CYCLE;
 114         OCR1B = 12;
 115         for (c = 0; c < pause; c++)
 116                 _delay_ms(2);
 117         TCCR1 = 0x6;
 118         OCR1C = PWM_CYCLE;
 119         OCR1B = PWM_CYCLE;
 120 }
 121
 122 static void tone_enter(void)
 123 {
 124         play_tone((G), 70, 20);
 125         play_tone(terz(G), 70, 20);
 126         play_tone(quinte(G), 70, 20);
 127         play_tone(G/2, 100, 0);
 128 }
 129
 130 static void tone_good(void)
 131 {
 132         play_tone(G, 150, 120);
 133         play_tone(terz(G), 100, 70);
 134         play_tone(tt(G), 100, 50);
 135         play_tone(quarte(terz((G))), 50, 0);
 136         play_tone(quinte(G), 150, 0);
 137         play_tone(terz(G), 100, 50);
 138 }
 139
 140 static void snd_on(void)
 141 {
 142         TCCR1 = 0x8;
 143         OCR1C = 120;
 144         OCR1B = 60;
 145 }
 146
 147 static void snd_off(void)
 148 {
 149         TCCR1 = 0x6;
 150         OCR1C = PWM_CYCLE;
 151         OCR1B = PWM_CYCLE;
 152 }
 153
 154 #else
 155 #define play_tone(...)
 156 #define tone_enter(...)
 157 #define tone_good(...)
 158 #define snd_on(...)
 159 #define snd_off(...)
 160 #endif
 161
 162 static void load_config(void)
 163 {
 164         eeprom_read_block((uint8_t *)&config, &ee_config, sizeof(config));
 165 }
 166
 167 static void save_config(void)
 168 {
 169 #ifdef WITH_EEPROM_UPDATE
 170         eeprom_update_block((uint8_t *)&config, &ee_config, sizeof(config));
 171 #else
 172         eeprom_write_block((uint8_t *)&config, &ee_config, sizeof(config));
 173 #endif
 174 }
 175
 176 void mm_pinchange_callback(void)
 177 {
 178         static uint8_t btn_last = 0;
 179
 180         if (BTN_PRESSED && !btn_last) {
 181                 config.learn_mode++;
 182                 config.learn_mode %= LM_END;
 183         }
 184         btn_last = BTN_PRESSED;
 185 }
 186
 187 static uint8_t get_speed(uint8_t command)
 188 {
 189         uint8_t b1, b3, b5, b7;
 190
 191         b1 = ((command & 0x80) != 0);
 192         b3 = ((command & 0x20) != 0);
 193         b5 = ((command & 0x8) != 0);
 194         b7 = ((command & 0x2) != 0);
 195
 196         //if ((b1 != b2) || (b2 != b3) || (b3 != b4) || (b5 != b6) || (b7 != b8))
 197         //      return 0xff;
 198         return (b1 + b3 * 2 + b5 * 4 +b7 * 8);
 199 }
 200
 201
 202 void mm_drive_cb(uint8_t loco, uint8_t function, uint8_t command)
 203 {
 204         uint8_t speed;
 205         speed = get_speed(command);
 206         static uint8_t alert_last = 0;
 207
 208         switch(loco) {
 209         case 10:
 210                 switch (config.learn_mode) {
 211                 case LM_OFF:
 212                         if (speed == 1)
 213                                 config.learn_mode = LM_EASY_WAIT_PRESS;
 214                         break;
 215                 case LM_EASY_MODE:
 216                         if ((speed == 1) && (alert_last == 0)) {
 217                                 config.learn_mode = LM_OFF;
 218                                 save_config();
 219                                 tone_good();
 220                         }
 221                         break;
 222
 223                 case LM_EASY_WAIT_PRESS:
 224                         if (speed != 1)
 225                             config.learn_mode = LM_OFF;
 226                         break;
 227
 228                 default:
 229                         break;
 230                 }
 231                 alert_last = (speed == 1);
 232                 break;
 233
 234         case 50:
 235                 if (speed)
 236                         speed = speed - 1;
 237
 238                 if (config.learn_mode == LM_EASY_MODE) {
 239                         config.initial_pulse = speed;
 240                 }
 241                 break;
 242         case 51:
 243                 if (speed)
 244                         speed = speed - 1;
 245
 246                 if (config.learn_mode == LM_EASY_MODE)
 247                         config.on_duty_cycle = speed;
 248                 break;
 249         }
 250 }
 251
 252 void mm_key_cb(uint8_t decoder, uint8_t function, uint8_t command)
 253 {
 254         static uint8_t toggle_lock = 0;
 255
 256         /* We don't listen to F1-F4 secret function codes */
 257         if (function & 0x3)
 258             return;
 259
 260         switch(config.learn_mode) {
 261         case LM_OFF:
 262         default:
 263                 if ((decoder == config.decoder_on) &&
 264                     (command == config.key_on)) { /* Primary key pressed */
 265                         switch(config.op_mode) {
 266                         case OM_MOMENTARY:
 267                         case OM_DOUBLE:
 268                                 drive_on = 1;
 269                                 break;
 270                         case OM_TOGGLE:
 271                                 if (!toggle_lock) {
 272                                         drive_on = ~drive_on;
 273                                         toggle_lock = 1;
 274                                 }
 275                                 break;
 276                         default:
 277                                 break;
 278                         }
 279                 }
 280                 if ((decoder == config.decoder_on) &&
 281                     (command == 0)) {  /* Primary key released */
 282                         switch(config.op_mode) {
 283                         case OM_MOMENTARY:
 284                                 drive_on = 0;
 285                                 break;
 286                         case OM_TOGGLE:
 287                                 toggle_lock = 0;
 288                                 break;
 289                         default:
 290                                 break;
 291                         }
 292                 }
 293                 break;
 294
 295         case LM_EASY_WAIT_PRESS:
 296                 if ((decoder == config.decoder_on) &&
 297                     (command == config.key_on))
 298                         config.learn_mode = LM_EASY_WAIT_UP;
 299                 return;
 300
 301         case LM_EASY_WAIT_UP:
 302                 if ((decoder == config.decoder_on) &&
 303                     (command == 0)) {
 304                         config.learn_mode = LM_EASY_MODE;
 305                         tone_enter();
 306                 }
 307                 return;
 308
 309 #ifdef HANDLE_OFF_KEY
 310
 311                 if ((decoder == config.decoder_off) &&
 312                     (command == config.key_off)) { /* Secondary "off" key pressed */
 313                         switch(config.op_mode) {
 314                         case OM_DOUBLE:
 315                                 drive_on = 0;
 316                                 break;
 317                         case OM_TOGGLE:
 318                         case OM_MOMENTARY:
 319                         default:
 320                                 break;
 321                         }
 322                 }
 323 #endif
 324                 break;
 325
 326         case LM_LEARN_ON_KEY:
 327                 if (command) {
 328                         config.decoder_on = decoder;
 329                         config.key_on     = command;
 330                         if (config.op_mode == OM_DOUBLE)
 331                                 config.learn_mode = LM_LEARN_OFF_KEY;
 332                         else
 333                                 config.learn_mode = LM_OFF;
 334                         save_config();
 335                 }
 336                 break;
 337 #ifdef LEARN_ADVANCED
 338         case LM_LEARN_OFF_KEY:
 339                 if (command) {
 340                         config.decoder_off = decoder;
 341                         config.key_off     = command;
 342                         config.learn_mode = LM_OFF;
 343                         save_config();
 344                 }
 345                 break;
 346
 347         case LM_LEARN_INITIAL:
 348                 if (drive_on) {
 349                         if (command == 0)
 350                                 drive_on = 0;
 351
 352                 } else {
 353                         switch(command) {
 354                         case 1:
 355                                 if (config.initial_pulse >= 10)
 356                                         config.initial_pulse -= 10;
 357                                 else
 358                                         config.initial_pulse = 0;
 359                                 save_config();
 360                                 drive_on = 1;
 361                                 break;
 362                         case 2:
 363                                 if (config.initial_pulse <= 245)
 364                                         config.initial_pulse += 10;
 365                                 else
 366                                         config.initial_pulse = 255;
 367                                 save_config();
 368                                 drive_on = 1;
 369                                 break;
 370                         default:
 371                                 break;
 372                         }
 373                 }
 374                 break;
 375
 376         case LM_LEARN_DUTY:
 377                 if (drive_on) {
 378                         if (command == 0)
 379                                 drive_on = 0;
 380                 } else {
 381                         switch(command) {
 382                         case 1:
 383                                 if (config.on_duty_cycle > 0)
 384                                         config.on_duty_cycle -= 1;
 385                                 save_config();
 386                                 drive_on = 1;
 387                                 break;
 388                         case 2:
 389                                 if (config.on_duty_cycle < 10)
 390                                         config.on_duty_cycle += 1;
 391                                 save_config();
 392                                 drive_on = 1;
 393                                 break;
 394                         default:
 395                                 break;
 396                         }
 397                 }
 398                 break;
 399
 400         case LM_LEARN_OP_MODE:
 401                 switch(command) {
 402                 case 1:
 403                         config.op_mode = OM_MOMENTARY;
 404                         save_config();
 405                         config.learn_mode = LM_OFF;
 406                         break;
 407                 case 3:
 408                         config.op_mode = OM_DOUBLE;
 409                         save_config();
 410                         config.learn_mode = LM_OFF;
 411                         break;
 412                 case 5:
 413                         config.op_mode = OM_TOGGLE;
 414                         save_config();
 415                         config.learn_mode = LM_OFF;
 416                         break;
 417                 default:
 418                         break;
 419                 }
 420                 break;
 421 #endif
 422         }
 423 }
 424
 425
 426 /******************************************************************************
 427  *
 428  * main() - The main routine
 429  *
 430  */
 431 void shift(uint8_t mu);
 432
 433 #ifdef DEBUG_DRIVE_LED
 434 #define MON_LED(val) setpin(PIN_LED, val)
 435 #else
 436 #define MON_LED(val)
 437 #endif
 438
 439 #ifdef WITH_PWM
 440 #define DRIVE_OFF  {OCR1B = PWM_CYCLE; MON_LED(0);}
 441 #define DRIVE_ON   {OCR1B = PWM_CYCLE - config.on_duty_cycle; MON_LED(1);}
 442 #define DRIVE_FULL {OCR1B = 0; MON_LED(1);}
 443 #else
 444 #define DRIVE_OFF  {setpin(PIN_DRIVE, 0); MON_LED(0);}
 445 #define DRIVE_ON   {setpin(PIN_DRIVE, 1); MON_LED(1);}
 446 #define DRIVE_FULL {setpin(PIN_DRIVE, 1); MON_LED(1);}
 447 #endif
 448
 449 int main(void) {
 450         uint16_t i;
 451
 452 #ifdef WITH_INITIAL_PULSE
 453         uint8_t drive_last = 0;
 454         uint8_t drive_slope = 0;
 455 #endif
 456
 457 #ifdef USE_REGISTER_VARS
 458         drive_on = 0;
 459 #endif
 460         mm_init();
 461         load_config();
 462         setup_hw();
 463
 464         while(0) {
 465                 setpin(PIN_LED, 1);
 466                 _delay_ms(2);
 467                 _delay_ms(2);
 468                 trigger();
 469                 sei();
 470         }
 471         if (config.magic != EE_MAGIC) {
 472                 config.magic = EE_MAGIC;
 473                 config.op_mode = OM_MOMENTARY;
 474                 config.decoder_on = 1;
 475                 config.key_on = 1;
 476                 config.decoder_off = 1;
 477                 config.key_off = 2;
 478                 config.initial_pulse = 10;
 479                 config.on_duty_cycle = 5;
 480                 config.learn_mode = LM_LEARN_ON_KEY;
 481         }
 482         sei();
 483         while (1) {
 484         drive_start:
 485
 486 #ifdef WITH_INITIAL_PULSE
 487                 cli();
 488                 if (drive_on && !drive_last)
 489                         drive_slope = 1;
 490                 else
 491                         drive_slope = 0;
 492                 drive_last = drive_on;
 493                 sei();
 494 #endif
 495                 if (drive_on) {
 496
 497 #ifdef WITH_INITIAL_PULSE
 498                         if (drive_slope) {
 499                                 DRIVE_FULL;
 500                                 for (i = 0; i < config.initial_pulse; i++) {
 501                                         _delay_ms(5);
 502                                 }
 503                         }
 504 #endif
 505                         DRIVE_ON;
 506
 507                 } else {
 508                         DRIVE_OFF;
 509
 510                         if (!config.learn_mode ||
 511                             config.learn_mode > LM_LEARN_OP_MODE)
 512                                 continue;
 513
 514                         for (i = 0; i < config.learn_mode; i++) {
 515                                 setpin(PIN_LED, 1);
 516                                 snd_on();
 517                                 _delay_ms(10);
 518                                 setpin(PIN_LED, 0);
 519                                 snd_off();
 520                                 if (drive_on) goto drive_start;
 521                                 _delay_ms(135);
 522                                 if (drive_on) goto drive_start;
 523                         }
 524                         for (i = 0; i < 15 - config.learn_mode; i++) {
 525                                 if (drive_on) goto drive_start;
 526                                 _delay_ms(70);
 527                         }
 528                 }
 529         }
 530         return 0;
 531 }
 532
 533 /******************************************************************************
 534  *                        The end :-)
 535  */