int avr_run_thread(void *ptr) {
avr_t* avr = (avr_t*) ptr;
int state = cpu_Running;
int old_keys = 0;
rate.last_avr_ticks = avr->cycle;
rate.last_timer = SDL_GetTicks();
uint32_t last_display_timer = rate.last_timer;
avr_cycle_count_t last_display_avr_ticks = avr->cycle;
do {
int count = 10000;
while (( state != cpu_Done ) && ( state != cpu_Crashed ) && --count > 0 )
state = avr_run(avr);
check_simulation_rate(avr);
// Update the display rate if necessary
uint32_t timer = SDL_GetTicks();
if (timer - last_display_timer > 1000) {
// How many kcycles should have elapsed
uint32_t calculated = (timer - last_display_timer) * 16000;
uint32_t actual = avr->cycle - last_display_avr_ticks;
int percent_rate = 100 * actual / calculated;
display_rate(percent_rate);
last_display_timer = timer;
last_display_avr_ticks = avr->cycle;
}
SDL_LockMutex(lcd_ram_mutex);
if (lcd.updated) {
memcpy(lcd_ram, lcd.ram, sizeof(lcd_ram));
lcd_updated = 1;
lcd.updated = 0;
}
if (quit_flag) {
SDL_UnlockMutex(lcd_ram_mutex);
break;
}
int k = keys;
SDL_UnlockMutex(lcd_ram_mutex);
for (int i = 0; i < keydefs_length; i++) {
if ((old_keys & (1<<i)) != (k & (1<<i))) {
const keydef_t* kd = keydefs + i;
if (k & (1<<i))
*key_io[i].pull_value &= ~key_io[i].pin_mask;
else
*key_io[i].pull_value |= key_io[i].pin_mask;
gb_keypad_press(&keypad, kd->keypad_key, (k & (1<<i)) ? 0 : 1);
}
}
old_keys = k;
} while (state != cpu_Done && state != cpu_Crashed);
return 0;
}
int main(int argc, char *argv[])
{
// elf_firmware_t f;
const char * pwd = dirname(argv[0]);
avr = avr_make_mcu_by_name("at90usb162");
if (!avr) {
fprintf(stderr, "%s: Error creating the AVR core\n", argv[0]);
exit(1);
}
strcpy(avr_flash_path, "simusb_flash.bin");
// register our own functions
avr->special_init = avr_special_init;
avr->special_deinit = avr_special_deinit;
//avr->reset = NULL;
avr_init(avr);
avr->frequency = 8000000;
// this trick creates a file that contains /and keep/ the flash
// in the same state as it was before. This allow the bootloader
// app to be kept, and re-run if the bootloader doesn't get a
// new one
{
char path[1024];
uint32_t base, size;
snprintf(path, sizeof(path), "%s/../%s", pwd, "at90usb162_cdc_loopback.hex");
uint8_t * boot = read_ihex_file(path, &size, &base);
if (!boot) {
fprintf(stderr, "%s: Unable to load %s\n", argv[0], path);
exit(1);
}
printf("Booloader %04x: %d\n", base, size);
memcpy(avr->flash + base, boot, size);
free(boot);
avr->pc = base;
avr->codeend = avr->flashend;
}
// even if not setup at startup, activate gdb if crashing
avr->gdb_port = 1234;
if (0) {
//avr->state = cpu_Stopped;
avr_gdb_init(avr);
}
vhci_usb_init(avr, &vhci_usb);
vhci_usb_connect(&vhci_usb, '0');
while (1) {
avr_run(avr);
}
}
static void * avr_run_thread(void * oaram)
{
int b_press = do_button_press;
while (1) {
avr_run(avr);
if (do_button_press != b_press) {
b_press = do_button_press;
printf("Button pressed\n");
button_press(&button, 1000000);
}
}
}
static void *
avr_run_thread (void *oaram)
{
while (1)
{
int state = avr_run (avr);
if (state == cpu_Done || state == cpu_Crashed)
break;
}
avr_terminate (avr);
return NULL;
}
int main(int argc, char *argv[])
{
elf_firmware_t f;
const char * fname = "atmega1280_i2ctest.axf";
printf("Firmware pathname is %s\n", fname);
elf_read_firmware(fname, &f);
printf("firmware %s f=%d mmcu=%s\n", fname, (int)f.frequency, f.mmcu);
avr = avr_make_mcu_by_name(f.mmcu);
if (!avr) {
fprintf(stderr, "%s: AVR '%s' not known\n", argv[0], f.mmcu);
exit(1);
}
avr_init(avr);
avr_load_firmware(avr, &f);
// initialize our 'peripheral', setting the mask to allow read and write
i2c_eeprom_init(avr, &ee, 0xa0, 0x01, NULL, 1024);
i2c_eeprom_attach(avr, &ee, AVR_IOCTL_TWI_GETIRQ(0));
ee.verbose = 1;
// even if not setup at startup, activate gdb if crashing
avr->gdb_port = 1234;
if (0) {
//avr->state = cpu_Stopped;
avr_gdb_init(avr);
}
/*
* VCD file initialization
*
* This will allow you to create a "wave" file and display it in gtkwave
* Pressing "r" and "s" during the demo will start and stop recording
* the pin changes
*/
// avr_vcd_init(avr, "gtkwave_output.vcd", &vcd_file, 100000 /* usec */);
// avr_vcd_add_signal(&vcd_file,
// avr_io_getirq(avr, AVR_IOCTL_TWI_GETIRQ(0), TWI_IRQ_STATUS), 8 /* bits */ ,
// "TWSR" );
printf( "\nDemo launching:\n");
int state = cpu_Running;
while ((state != cpu_Done) && (state != cpu_Crashed))
state = avr_run(avr);
}
static void * avr_run_thread(void * ignore)
{
int b_press[3] = {0};
while (1) {
avr_run(avr);
for (int i = 0; i < 3; i++) {
if (do_button_press[i] != b_press[i]) {
b_press[i] = do_button_press[i];
printf("Button pressed %d\n", i);
button_press(&button[i], 100000);
}
}
}
return NULL;
}
int main(int argc, char *argv[])
{
elf_firmware_t f = {{0}};
long f_cpu = 0;
int trace = 0;
int gdb = 0;
int log = 1;
char name[16] = "";
uint32_t loadBase = AVR_SEGMENT_OFFSET_FLASH;
int trace_vectors[8] = {0};
int trace_vectors_count = 0;
if (argc == 1)
display_usage(basename(argv[0]));
for (int pi = 1; pi < argc; pi++) {
if (!strcmp(argv[pi], "--list-cores")) {
list_cores();
} else if (!strcmp(argv[pi], "-h") || !strcmp(argv[pi], "--help")) {
display_usage(basename(argv[0]));
} else if (!strcmp(argv[pi], "-m") || !strcmp(argv[pi], "-mcu")) {
if (pi < argc-1)
strcpy(name, argv[++pi]);
else
display_usage(basename(argv[0]));
} else if (!strcmp(argv[pi], "-f") || !strcmp(argv[pi], "-freq")) {
if (pi < argc-1)
f_cpu = atoi(argv[++pi]);
else
display_usage(basename(argv[0]));
} else if (!strcmp(argv[pi], "-t") || !strcmp(argv[pi], "-trace")) {
trace++;
} else if (!strcmp(argv[pi], "-ti")) {
if (pi < argc-1)
trace_vectors[trace_vectors_count++] = atoi(argv[++pi]);
} else if (!strcmp(argv[pi], "-g") || !strcmp(argv[pi], "-gdb")) {
gdb++;
} else if (!strcmp(argv[pi], "-v")) {
log++;
} else if (!strcmp(argv[pi], "-ee")) {
loadBase = AVR_SEGMENT_OFFSET_EEPROM;
} else if (!strcmp(argv[pi], "-ff")) {
loadBase = AVR_SEGMENT_OFFSET_FLASH;
} else if (argv[pi][0] != '-') {
char * filename = argv[pi];
char * suffix = strrchr(filename, '.');
if (suffix && !strcasecmp(suffix, ".hex")) {
if (!name[0] || !f_cpu) {
fprintf(stderr, "%s: -mcu and -freq are mandatory to load .hex files\n", argv[0]);
exit(1);
}
ihex_chunk_p chunk = NULL;
int cnt = read_ihex_chunks(filename, &chunk);
if (cnt <= 0) {
fprintf(stderr, "%s: Unable to load IHEX file %s\n",
argv[0], argv[pi]);
exit(1);
}
printf("Loaded %d section of ihex\n", cnt);
for (int ci = 0; ci < cnt; ci++) {
if (chunk[ci].baseaddr < (1*1024*1024)) {
f.flash = chunk[ci].data;
f.flashsize = chunk[ci].size;
f.flashbase = chunk[ci].baseaddr;
printf("Load HEX flash %08x, %d\n", f.flashbase, f.flashsize);
} else if (chunk[ci].baseaddr >= AVR_SEGMENT_OFFSET_EEPROM ||
chunk[ci].baseaddr + loadBase >= AVR_SEGMENT_OFFSET_EEPROM) {
// eeprom!
f.eeprom = chunk[ci].data;
f.eesize = chunk[ci].size;
printf("Load HEX eeprom %08x, %d\n", chunk[ci].baseaddr, f.eesize);
}
}
} else {
if (elf_read_firmware(filename, &f) == -1) {
fprintf(stderr, "%s: Unable to load firmware from file %s\n",
argv[0], filename);
exit(1);
}
}
}
}
if (strlen(name))
strcpy(f.mmcu, name);
if (f_cpu)
f.frequency = f_cpu;
avr = avr_make_mcu_by_name(f.mmcu);
if (!avr) {
fprintf(stderr, "%s: AVR '%s' not known\n", argv[0], f.mmcu);
exit(1);
}
avr_init(avr);
avr_load_firmware(avr, &f);
if (f.flashbase) {
printf("Attempted to load a bootloader at %04x\n", f.flashbase);
avr->pc = f.flashbase;
}
avr->log = (log > LOG_TRACE ? LOG_TRACE : log);
avr->trace = trace;
for (int ti = 0; ti < trace_vectors_count; ti++) {
for (int vi = 0; vi < avr->interrupts.vector_count; vi++)
if (avr->interrupts.vector[vi]->vector == trace_vectors[ti])
avr->interrupts.vector[vi]->trace = 1;
}
// even if not setup at startup, activate gdb if crashing
avr->gdb_port = 1234;
if (gdb) {
avr->state = cpu_Stopped;
avr_gdb_init(avr);
}
signal(SIGINT, sig_int);
signal(SIGTERM, sig_int);
for (;;) {
int state = avr_run(avr);
if ( state == cpu_Done || state == cpu_Crashed)
break;
}
avr_terminate(avr);
}
int
main(int argc, char *argv[])
{
const char *argv0 = argv[0];
int exit_state = EXIT_FAILURE;
char *env;
struct drumfish_cfg config;
struct sigaction act;
int state = cpu_Limbo;
int opt;
char **flash_file = NULL;
size_t flash_file_len = 0;
long port;
config.mac = NULL;
config.pflash = NULL;
config.foreground = 1;
config.verbose = 0;
config.gdb = 0;
config.erase_pflash = 0;
config.peripherals[DF_PERIPHERAL_UART0] = strdup("off");
config.peripherals[DF_PERIPHERAL_UART1] = strdup("on");
while ((opt = getopt(argc, argv, "ef:p:m:vg:s:h")) != -1) {
switch (opt) {
case 'e':
config.erase_pflash = 1;
break;
case 'f':
/* Increment how many file names we need to keep track of */
flash_file_len++;
/* Set a reasonable max which is less than 2^30 to avoid
* overflowing realloc().
*/
if (flash_file_len > MAX_FLASH_FILES) {
fprintf(stderr, "Unable to load more than %d "
"firmware images at once.\n", MAX_FLASH_FILES);
exit(EXIT_FAILURE);
}
/* Make room for our next pointer */
flash_file = realloc(flash_file,
sizeof(void *) * flash_file_len);
if (!flash_file) {
fprintf(stderr, "Failed to allocate memory for "
"flash file list.\n");
exit(EXIT_FAILURE);
}
/* Now let's store our file name */
flash_file[flash_file_len - 1] = strdup(optarg);
if (!flash_file[flash_file_len - 1]) {
fprintf(stderr, "Failed to allocate memory for "
"flash file.\n");
exit(EXIT_FAILURE);
}
break;
case 's':
/* path to storage for flash */
config.pflash = strdup(optarg);
if (!config.pflash) {
fprintf(stderr, "Failed to allocate memory for "
"programmable flashh.\n");
exit(EXIT_FAILURE);
}
break;
case 'm':
config.mac = strdup(optarg);
if (!config.mac) {
fprintf(stderr, "Failed to allocate memory for MAC.\n");
exit(EXIT_FAILURE);
}
break;
case 'v':
config.verbose++;
break;
case 'g':
errno = 0;
port = strtol(optarg, NULL, 10);
if (errno != 0) {
fprintf(stderr, "Invalid supplied GDB port '%s': %s\n",
optarg, strerror(errno));
exit(EXIT_FAILURE);
}
if (port <= 1024 && port > UINT16_MAX) {
fprintf(stderr, "Invalid supplied GDB port %ld. "
"Must be 1024 < port <= %d\n", port, UINT16_MAX);
exit(EXIT_FAILURE);
}
config.gdb = port;
break;
case 'p':
/* store requested port (UART) path */
df_peripheral_parse(&config, optarg);
break;
case 'V':
/* print version */
break;
case 'h':
usage(argv0);
exit(EXIT_SUCCESS);
break;
default: /* '?' */
usage(argv0);
exit(EXIT_FAILURE);
}
}
/* Initialize our logging support */
df_log_init(&config);
/* If the user did not override the default location of the
* programmable flash storage, then set the default
*/
env = getenv("HOME");
if (!env || !env[0]) {
fprintf(stderr, "Unable to determine your HOME.\n");
exit(EXIT_FAILURE);
}
if (asprintf(&config.pflash, "%s%s", env, DEFAULT_PFLASH_PATH) < 0) {
fprintf(stderr, "Failed to allocate memory for pflash filename.\n");
exit(EXIT_FAILURE);
}
printf("Programmable Flash Storage: %s\n", config.pflash);
/* Handle the bare minimum signals */
/* Yes I should use sigset_t here and use sigemptyset() */
memset(&act, 0, sizeof(act));
act.sa_handler = handler;
if (sigaction(SIGHUP, &act, NULL) < 0) {
fprintf(stderr, "Failed to install SIGHUP handler\n");
exit(EXIT_FAILURE);
}
if (sigaction(SIGINT, &act, NULL) < 0) {
fprintf(stderr, "Failed to install SIGINT handler\n");
exit(EXIT_FAILURE);
}
if (sigaction(SIGTERM, &act, NULL) < 0) {
fprintf(stderr, "Failed to install SIGTERM handler\n");
exit(EXIT_FAILURE);
}
avr = m128rfa1_create(&config);
if (!avr) {
fprintf(stderr, "Unable to initialize requested board.\n");
exit(EXIT_FAILURE);
}
/* Flash in any requested firmware, while cleaning up our memory */
for (size_t i = 0; i < flash_file_len; i++) {
if (flash_load(flash_file[i], avr->flash, avr->flashend + 1)) {
fprintf(stderr, "Failed to load '%s' into flash.\n", flash_file[i]);
exit(EXIT_FAILURE);
}
/* Don't need this memory anymore */
free(flash_file[i]);
}
free(flash_file);
/* Ensure the instruction we're about to execute is legit */
if (avr->flash[avr->pc] == 0xff) {
fprintf(stderr, "No firmware loaded in programmable flash, unable "
"to boot.\n");
fprintf(stderr, "Try using '-f firmware.hex' to supply one.\n");
exit(EXIT_FAILURE);
}
/* If the user wants to run the core with GDB server enabled,
* set that up.
*/
if (config.gdb) {
avr->gdb_port = config.gdb;
/* Normally starting the CPU should be in limbo, but the
* GDB code of simavr wants it to be stopped.
*/
state = cpu_Stopped;
avr_gdb_init(avr);
}
/* Capture the current time to be used as when our CPU started */
df_log_start_time();
df_log_msg(DF_LOG_INFO, "Booting CPU from 0x%x.\n", avr->pc);
/* Our main event loop */
for (;;) {
state = avr_run(avr);
if (state == cpu_Done) {
exit_state = EXIT_SUCCESS;
break;
} else if (state == cpu_Crashed) {
/* many firmwares disable interrupts and enable the watchdog
* to cause the MCU to reboot. simavr treats that state as
* cpu_Crashed
*/
df_log_msg(DF_LOG_INFO, "CPU rebooted\n");
avr_reset(avr);
}
}
avr_terminate(avr);
df_log_msg(DF_LOG_INFO, "Terminated.\n");
free(config.pflash);
return exit_state;
}
int main(int argc, char *argv[])
{
struct avr_flash flash_data;
char boot_path[1024] = "ATmegaBOOT_168_atmega328.ihex";
uint32_t boot_base, boot_size;
char * mmcu = "atmega328p";
uint32_t freq = 16000000;
int debug = 0;
int verbose = 0;
/*
* To allow other programs to know that the model is
* online and ready for programming, we create a file
* called emu_online.txt
*
* At the beginning we clean up the file and then write
* to it later on once the emulator is running.
*/
char * emu_online_file = "emu_online.txt";
int emu_online_flag = 0;
for (int i = 1; i < argc; i++) {
if (!strcmp(argv[i] + strlen(argv[i]) - 4, ".hex"))
strncpy(boot_path, argv[i], sizeof(boot_path));
else if (!strcmp(argv[i], "-d"))
debug++;
else if (!strcmp(argv[i], "-v"))
verbose++;
else if (strstr(argv[i], ".ihex") != NULL)
strcpy( boot_path, argv[1] );
else {
fprintf(stderr, "%s: invalid argument %s\n", argv[0], argv[i]);
exit(1);
}
}
if( access(emu_online_file, F_OK) != -1 ){
remove(emu_online_file);
}
avr = avr_make_mcu_by_name(mmcu); if (!avr) { fprintf(stderr, "%s: Error creating the AVR core\n", argv[0]);
exit(1);
}
uint8_t * boot = read_ihex_file(boot_path, &boot_size, &boot_base);
if (!boot) {
fprintf(stderr, "%s: Unable to load %s\n", argv[0], boot_path);
exit(1);
}
if (boot_base > 32*1024*1024) {
mmcu = "atmega2560";
freq = 20000000;
}
printf("%s booloader 0x%05x: %d bytes\n", mmcu, boot_base, boot_size);
snprintf(flash_data.avr_flash_path, sizeof(flash_data.avr_flash_path),
"simduino_%s_flash.bin", mmcu);
flash_data.avr_flash_fd = 0;
// register our own functions
avr->custom.init = avr_special_init;
avr->custom.deinit = avr_special_deinit;
avr->custom.data = &flash_data;
avr_init(avr);
avr->frequency = freq;
memcpy(avr->flash + boot_base, boot, boot_size);
free(boot);
avr->pc = boot_base;
/* end of flash, remember we are writing /code/ */
avr->codeend = avr->flashend;
avr->log = 1 + verbose;
// even if not setup at startup, activate gdb if crashing
avr->gdb_port = 1234;
if (debug) {
avr->state = cpu_Stopped;
avr_gdb_init(avr);
}
uart_pty_init(avr, &uart_pty);
uart_pty_connect(&uart_pty, '0');
while (1) {
int state = avr_run(avr);
if ( state == cpu_Done || state == cpu_Crashed)
break;
if( emu_online_flag == 0){
fopen(emu_online_file, "w+");
emu_online_flag = 1;
}
}
}
int main(int argc, char *argv[])
{
int state;
elf_firmware_t f;
const char *fname = "../BasicMotorControl.elf";
const char *mmcu = "atmega328p";
if (elf_read_firmware(fname, &f) != 0)
{
exit(1);
}
f.frequency = 16000000;
printf("firmware %s f=%d mmcu=%s\n", fname, (int)f.frequency, mmcu);
avr = avr_make_mcu_by_name(mmcu);
if (!avr)
{
fprintf(stderr, "%s: AVR '%s' not known\n", argv[0], mmcu);
exit(1);
}
avr_init(avr);
avr_load_firmware(avr, &f);
#if 0
/* even if not setup at startup, activate gdb if crashing */
avr->gdb_port = 1234;
avr->state = cpu_Stopped;
avr_gdb_init(avr);
#endif
/* VCD file initialization */
avr_vcd_init(avr, "wave.vcd", &vcd_file, 10000 /* usec */);
avr_vcd_add_signal(&vcd_file, avr_io_getirq(avr, AVR_IOCTL_IOPORT_GETIRQ('B'), 0), 1, "B0" );
avr_vcd_add_signal(&vcd_file, avr_io_getirq(avr, AVR_IOCTL_IOPORT_GETIRQ('B'), 1), 1, "B1" );
avr_vcd_add_signal(&vcd_file, avr_io_getirq(avr, AVR_IOCTL_IOPORT_GETIRQ('B'), 2), 1, "B2" );
avr_vcd_add_signal(&vcd_file, avr_io_getirq(avr, AVR_IOCTL_IOPORT_GETIRQ('B'), 3), 1, "B3" );
avr_vcd_start(&vcd_file);
/* IRQ callback hooks */
avr_irq_register_notify( avr_io_getirq(avr, AVR_IOCTL_IOPORT_GETIRQ('B'), 0), pin_changed_hook, NULL);
avr_irq_register_notify( avr_io_getirq(avr, AVR_IOCTL_IOPORT_GETIRQ('B'), 1), pin_changed_hook, NULL);
avr_irq_register_notify( avr_io_getirq(avr, AVR_IOCTL_IOPORT_GETIRQ('B'), 2), pin_changed_hook, NULL);
avr_irq_register_notify( avr_io_getirq(avr, AVR_IOCTL_IOPORT_GETIRQ('B'), 3), pin_changed_hook, NULL);
/* show some info */
show_ports(avr);
/* install signal handlers */
signal(SIGINT, sig_int);
signal(SIGTERM, sig_int);
/* main loop */
printf("*** Entering main loop ***\n");
while (1)
{
state = avr_run(avr);
if (state == cpu_Done || state == cpu_Crashed)
{
printf("CPU State %d\n", state);
break;
}
}
avr_vcd_stop(&vcd_file);
avr_terminate(avr);
return 0;
}