git.rot13.org Git - simavr/blob - examples/board_reprap/src/reprap.c

   1 /*
   2         simduino.c
   3
   4         Copyright 2008, 2009 Michel Pollet <buserror@gmail.com>
   5
   6         This file is part of simavr.
   7
   8         simavr is free software: you can redistribute it and/or modify
   9         it under the terms of the GNU General Public License as published by
  10         the Free Software Foundation, either version 3 of the License, or
  11         (at your option) any later version.
  12
  13         simavr is distributed in the hope that it will be useful,
  14         but WITHOUT ANY WARRANTY; without even the implied warranty of
  15         MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16         GNU General Public License for more details.
  17
  18         You should have received a copy of the GNU General Public License
  19         along with simavr.  If not, see <http://www.gnu.org/licenses/>.
  20  */
  21
  22 #include <unistd.h>
  23 #include <sys/stat.h>
  24 #include <fcntl.h>
  25 #include <stdlib.h>
  26 #include <string.h>
  27 #include <stdio.h>
  28 #include <libgen.h>
  29 #include <pthread.h>
  30
  31 #include "sim_avr.h"
  32 #include "avr_ioport.h"
  33 #include "sim_elf.h"
  34 #include "sim_hex.h"
  35 #include "sim_gdb.h"
  36 #include "sim_vcd_file.h"
  37
  38 #include "mongoose.h"
  39
  40 #include "button.h"
  41 #include "uart_pty.h"
  42 #include "thermistor.h"
  43 #include "thermistor.h"
  44 #include "heatpot.h"
  45 #include "stepper.h"
  46
  47 #define __AVR_ATmega644__
  48 #include "marlin/pins.h"
  49
  50 #define PROGMEM
  51 #define THERMISTORHEATER_0 5
  52 #include "marlin/thermistortables.h"
  53
  54 /*
  55  * these are the sources of heat and cold to register to the heatpots
  56  */
  57 enum {
  58         TALLY_HOTEND_PWM        = 1,
  59         TALLY_HOTBED,
  60         TALLY_HOTEND_FAN,
  61 };
  62
  63 thermistor_t    therm_hotend;
  64 thermistor_t    therm_hotbed;
  65 thermistor_t    therm_spare;
  66 heatpot_t               hotend;
  67 heatpot_t               hotbed;
  68
  69 stepper_t               step_x, step_y, step_z, step_e;
  70
  71 uart_pty_t uart_pty;
  72 avr_t * avr = NULL;
  73 avr_vcd_t vcd_file;
  74
  75 typedef struct ardupin_t {
  76         uint32_t port : 7, pin : 3, analog : 1, adc : 3, pwm : 1, ardupin;
  77 } ardupin_t, *ardupin_p;
  78
  79 ardupin_t arduidiot_644[32] = {
  80         [ 0] = { .ardupin =  0, .port = 'B', .pin =  0 },
  81         [ 1] = { .ardupin =  1, .port = 'B', .pin =  1 },
  82         [ 2] = { .ardupin =  2, .port = 'B', .pin =  2 },
  83         [ 3] = { .ardupin =  3, .port = 'B', .pin =  3 },
  84         [ 4] = { .ardupin =  4, .port = 'B', .pin =  4 },
  85         [ 5] = { .ardupin =  5, .port = 'B', .pin =  5 },
  86         [ 6] = { .ardupin =  6, .port = 'B', .pin =  6 },
  87         [ 7] = { .ardupin =  7, .port = 'B', .pin =  7 },
  88
  89         [ 8] = { .ardupin =  8, .port = 'D', .pin =  0 },
  90         [ 9] = { .ardupin =  9, .port = 'D', .pin =  1 },
  91         [10] = { .ardupin = 10, .port = 'D', .pin =  2 },
  92         [11] = { .ardupin = 11, .port = 'D', .pin =  3 },
  93         [12] = { .ardupin = 12, .port = 'D', .pin =  4 },
  94         [13] = { .ardupin = 13, .port = 'D', .pin =  5 },
  95         [14] = { .ardupin = 14, .port = 'D', .pin =  6 },
  96         [15] = { .ardupin = 15, .port = 'D', .pin =  7 },
  97
  98         [16] = { .ardupin = 16, .port = 'C', .pin =  0 },
  99         [17] = { .ardupin = 17, .port = 'C', .pin =  1 },
 100         [18] = { .ardupin = 18, .port = 'C', .pin =  2 },
 101         [19] = { .ardupin = 19, .port = 'C', .pin =  3 },
 102         [20] = { .ardupin = 20, .port = 'C', .pin =  4 },
 103         [21] = { .ardupin = 21, .port = 'C', .pin =  5 },
 104         [22] = { .ardupin = 22, .port = 'C', .pin =  6 },
 105         [23] = { .ardupin = 23, .port = 'C', .pin =  7 },
 106
 107         [24] = { .ardupin = 24, .port = 'A', .pin =  7, .analog = 1, .adc = 7 },
 108         [25] = { .ardupin = 25, .port = 'A', .pin =  6, .analog = 1, .adc = 6 },
 109         [26] = { .ardupin = 26, .port = 'A', .pin =  5, .analog = 1, .adc = 5 },
 110         [27] = { .ardupin = 27, .port = 'A', .pin =  4, .analog = 1, .adc = 4 },
 111         [28] = { .ardupin = 28, .port = 'A', .pin =  3, .analog = 1, .adc = 3 },
 112         [29] = { .ardupin = 29, .port = 'A', .pin =  2, .analog = 1, .adc = 2 },
 113         [30] = { .ardupin = 30, .port = 'A', .pin =  1, .analog = 1, .adc = 1 },
 114         [31] = { .ardupin = 31, .port = 'A', .pin =  0, .analog = 1, .adc = 0 },
 115 };
 116
 117
 118 struct avr_irq_t *
 119 get_ardu_irq(
 120                 struct avr_t * avr,
 121                 int ardupin,
 122                 ardupin_t pins[])
 123 {
 124         if (pins[ardupin].ardupin != ardupin) {
 125                 printf("%s pin %d isn't correct in table\n", __func__, ardupin);
 126                 return NULL;
 127         }
 128         struct avr_irq_t * irq = avr_io_getirq(avr,
 129                         AVR_IOCTL_IOPORT_GETIRQ(pins[ardupin].port), pins[ardupin].pin);
 130         if (!irq) {
 131                 printf("%s pin %d PORT%C%d not found\n", __func__, ardupin, pins[ardupin].port, pins[ardupin].pin);
 132                 return NULL;
 133         }
 134         return irq;
 135 }
 136
 137 /*
 138  * called when the AVR change any of the pins on port B
 139  * so lets update our buffer
 140  */
 141 void hotbed_change_hook(struct avr_irq_t * irq, uint32_t value, void * param)
 142 {
 143         printf("%s %d\n", __func__, value);
 144 //      pin_state = (pin_state & ~(1 << irq->irq)) | (value << irq->irq);
 145 }
 146
 147
 148 char avr_flash_path[1024];
 149 int avr_flash_fd = 0;
 150
 151 // avr special flash initalization
 152 // here: open and map a file to enable a persistent storage for the flash memory
 153 void avr_special_init( avr_t * avr)
 154 {
 155         // open the file
 156         avr_flash_fd = open(avr_flash_path, O_RDWR|O_CREAT, 0644);
 157         if (avr_flash_fd < 0) {
 158                 perror(avr_flash_path);
 159                 exit(1);
 160         }
 161         // resize and map the file the file
 162         (void)ftruncate(avr_flash_fd, avr->flashend + 1);
 163         ssize_t r = read(avr_flash_fd, avr->flash, avr->flashend + 1);
 164         if (r != avr->flashend + 1) {
 165                 fprintf(stderr, "unable to load flash memory\n");
 166                 perror(avr_flash_path);
 167                 exit(1);
 168         }
 169 }
 170
 171 // avr special flash deinitalization
 172 // here: cleanup the persistent storage
 173 void avr_special_deinit( avr_t* avr)
 174 {
 175         puts(__func__);
 176         lseek(avr_flash_fd, SEEK_SET, 0);
 177         ssize_t r = write(avr_flash_fd, avr->flash, avr->flashend + 1);
 178         if (r != avr->flashend + 1) {
 179                 fprintf(stderr, "unable to load flash memory\n");
 180                 perror(avr_flash_path);
 181         }
 182         close(avr_flash_fd);
 183         uart_pty_stop(&uart_pty);
 184 }
 185
 186 static void *
 187 mongoose_callback(
 188         enum mg_event event,
 189         struct mg_connection *conn,
 190         const struct mg_request_info *request_info)
 191 {
 192         if (event == MG_NEW_REQUEST) {
 193                 // Echo requested URI back to the client
 194                 mg_printf(conn, "HTTP/1.1 200 OK\r\n"
 195                                 "Content-Type: text/plain\r\n\r\n"
 196                                 "%s", request_info->uri);
 197                 return ""; // Mark as processed
 198         } else {
 199                 return NULL;
 200         }
 201 }
 202
 203 #define MEGA644_GPIOR0 0x3e
 204
 205 static void
 206 reprap_relief_callback(
 207                 struct avr_t * avr,
 208                 avr_io_addr_t addr,
 209                 uint8_t v,
 210                 void * param)
 211 {
 212 //      printf("%s write %x\n", __func__, addr);
 213         usleep(1000);
 214 }
 215
 216
 217 int main(int argc, char *argv[])
 218 {
 219         int debug = 0;
 220
 221         for (int i = 1; i < argc; i++)
 222                 if (!strcmp(argv[i], "-d"))
 223                         debug++;
 224         avr = avr_make_mcu_by_name("atmega644");
 225         if (!avr) {
 226                 fprintf(stderr, "%s: Error creating the AVR core\n", argv[0]);
 227                 exit(1);
 228         }
 229 //      snprintf(avr_flash_path, sizeof(avr_flash_path), "%s/%s", pwd, "simduino_flash.bin");
 230         strcpy(avr_flash_path,  "reprap_flash.bin");
 231         // register our own functions
 232         avr->special_init = avr_special_init;
 233         avr->special_deinit = avr_special_deinit;
 234         avr_init(avr);
 235         avr->frequency = 20000000;
 236         avr->aref = avr->avcc = avr->vcc = 5 * 1000;    // needed for ADC
 237
 238         if (1) {
 239                 elf_firmware_t f;
 240                 const char * fname = "/opt/reprap/tvrrug/Marlin.base/Marlin/applet/Marlin.elf";
 241                 elf_read_firmware(fname, &f);
 242
 243                 printf("firmware %s f=%d mmcu=%s\n", fname, (int)f.frequency, f.mmcu);
 244                 avr_load_firmware(avr, &f);
 245         } else {
 246                 char path[1024];
 247                 uint32_t base, size;
 248 //              snprintf(path, sizeof(path), "%s/%s", pwd, "ATmegaBOOT_168_atmega328.ihex");
 249                 strcpy(path, "marlin/Marlin.hex");
 250                 strcpy(path, "marlin/bootloader-644-20MHz.hex");
 251                 uint8_t * boot = read_ihex_file(path, &size, &base);
 252                 if (!boot) {
 253                         fprintf(stderr, "%s: Unable to load %s\n", argv[0], path);
 254                         exit(1);
 255                 }
 256                 printf("Firmware %04x(%04x in AVR talk): %d bytes (%d words)\n", base, base/2, size, size/2);
 257                 memcpy(avr->flash + base, boot, size);
 258                 free(boot);
 259                 avr->pc = base;
 260                 avr->codeend = avr->flashend;
 261         }
 262         //avr->trace = 1;
 263
 264         // even if not setup at startup, activate gdb if crashing
 265         avr->gdb_port = 1234;
 266         if (debug) {
 267                 printf("AVR is stopped, waiting on gdb on port %d. Use 'target remote :%d' in avr-gdb\n",
 268                                 avr->gdb_port, avr->gdb_port);
 269                 avr->state = cpu_Stopped;
 270                 avr_gdb_init(avr);
 271         }
 272
 273         // Marlin doesn't loop, sleep, so we don't know when it's idle
 274         // I changed Marlin to do a spurious write to the GPIOR0 register so we can trap it
 275         avr_register_io_write(avr, MEGA644_GPIOR0, reprap_relief_callback, NULL);
 276
 277         uart_pty_init(avr, &uart_pty);
 278         uart_pty_connect(&uart_pty, '0');
 279
 280         thermistor_init(avr, &therm_hotend, 0,
 281                         (short*)temptable_5, sizeof(temptable_5) / sizeof(short) / 2, OVERSAMPLENR, 25.0f);
 282         thermistor_init(avr, &therm_hotbed, 2,
 283                         (short*)temptable_5, sizeof(temptable_5) / sizeof(short) / 2, OVERSAMPLENR, 30.0f);
 284         thermistor_init(avr, &therm_spare, 1,
 285                         (short*)temptable_5, sizeof(temptable_5) / sizeof(short) / 2, OVERSAMPLENR, 10.0f);
 286
 287         heatpot_init(avr, &hotend, "hotend", 28.0f);
 288         heatpot_init(avr, &hotbed, "hotbed", 25.0f);
 289
 290         /* connect heatpot temp output to thermistors */
 291         avr_connect_irq(hotend.irq + IRQ_HEATPOT_TEMP_OUT, therm_hotend.irq + IRQ_TERM_TEMP_VALUE_IN);
 292         avr_connect_irq(hotbed.irq + IRQ_HEATPOT_TEMP_OUT, therm_hotbed.irq + IRQ_TERM_TEMP_VALUE_IN);
 293
 294         {
 295                 avr_irq_t * e = get_ardu_irq(avr, X_ENABLE_PIN, arduidiot_644);
 296                 avr_irq_t * s = get_ardu_irq(avr, X_STEP_PIN, arduidiot_644);
 297                 avr_irq_t * d = get_ardu_irq(avr, X_DIR_PIN, arduidiot_644);
 298                 avr_irq_t * m = get_ardu_irq(avr, X_MIN_PIN, arduidiot_644);
 299
 300                 stepper_init(avr, &step_x, "X", 80.80, 100, 220, 0);
 301                 stepper_connect(&step_x, s, d, e, m, stepper_endstop_inverted);
 302         }
 303         {
 304                 avr_irq_t * e = get_ardu_irq(avr, Y_ENABLE_PIN, arduidiot_644);
 305                 avr_irq_t * s = get_ardu_irq(avr, Y_STEP_PIN, arduidiot_644);
 306                 avr_irq_t * d = get_ardu_irq(avr, Y_DIR_PIN, arduidiot_644);
 307                 avr_irq_t * m = get_ardu_irq(avr, Y_MIN_PIN, arduidiot_644);
 308
 309                 stepper_init(avr, &step_y, "Y", 79.79, 100, 220, 0);
 310                 stepper_connect(&step_y, s, d, e, m, stepper_endstop_inverted);
 311         }
 312         {
 313                 avr_irq_t * e = get_ardu_irq(avr, Z_ENABLE_PIN, arduidiot_644);
 314                 avr_irq_t * s = get_ardu_irq(avr, Z_STEP_PIN, arduidiot_644);
 315                 avr_irq_t * d = get_ardu_irq(avr, Z_DIR_PIN, arduidiot_644);
 316                 avr_irq_t * m = get_ardu_irq(avr, Z_MIN_PIN, arduidiot_644);
 317
 318                 stepper_init(avr, &step_z, "Z", 2560, 20, 110, 0);
 319                 stepper_connect(&step_z, s, d, e, m, stepper_endstop_inverted);
 320         }
 321         {
 322                 avr_irq_t * e = get_ardu_irq(avr, E0_ENABLE_PIN, arduidiot_644);
 323                 avr_irq_t * s = get_ardu_irq(avr, E0_STEP_PIN, arduidiot_644);
 324                 avr_irq_t * d = get_ardu_irq(avr, E0_DIR_PIN, arduidiot_644);
 325
 326                 stepper_init(avr, &step_e, "E", 599.14, 0, 0, 0);
 327                 stepper_connect(&step_e, s, d, e, NULL, 0);
 328         }
 329
 330         const char *options[] = {"listening_ports", "9090", NULL};
 331
 332         struct mg_context *ctx = mg_start(&mongoose_callback, NULL, options);
 333         printf("mongoose %p\n", ctx);
 334
 335         while (1) {
 336                 int state = avr_run(avr);
 337                 if ( state == cpu_Done || state == cpu_Crashed)
 338                         break;
 339         }
 340         mg_stop(ctx);
 341 }