void avr_spi_init(avr_t * avr, avr_spi_t * p)
{
p->io = _io;
avr_register_io(avr, &p->io);
avr_register_vector(avr, &p->spi);
// allocate this module's IRQ
avr_io_setirqs(&p->io, AVR_IOCTL_SPI_GETIRQ(p->name), SPI_IRQ_COUNT, NULL);
avr_register_io_write(avr, p->r_spdr, avr_spi_write, p);
avr_register_io_read(avr, p->r_spdr, avr_spi_read, p);
}
int main(int argc, char *argv[])
{
elf_firmware_t f;
const char * fname = "wordClock-erl";
char path[256];
// sprintf(path, "%s/%s", dirname(argv[0]), fname);
// printf("Firmware pathname is %s\n", path);
elf_read_firmware(fname, &f);
strcpy( f.mmcu, "atmega168" ); // hack
f.frequency = 16000000;
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' now known\n", argv[0], f.mmcu);
exit(1);
}
avr_init(avr);
avr_load_firmware(avr, &f);
// initialize our 'peripheral'
// button_init(avr, &button, "button");
// "connect" the output irw of the button to the port pin of the AVR
/*
avr_connect_irq(
button.irq + IRQ_BUTTON_OUT,
avr_io_getirq(avr, AVR_IOCTL_IOPORT_GETIRQ('C'), 0));
*/
// connect all the pins on port B to our callback
#if 0
for (int i = 0; i < 8; i++)
avr_irq_register_notify(
avr_io_getirq(avr, AVR_IOCTL_IOPORT_GETIRQ('B'), i),
pin_changed_hook,
NULL);
#endif
// 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
*
* Initially set to 100 000 usec = 100 ms. I think it is how often
* to flush its' log.
*/
avr_vcd_init(avr, "gtkwave_output.vcd", &vcd_file, 100 /* usec */);
/* want MOSI, SCLK, XLAT, BLANK */
avr_vcd_add_signal( &vcd_file,
avr_io_getirq(avr, AVR_IOCTL_SPI_GETIRQ(0),
SPI_IRQ_OUTPUT),
8, "MOSI" );
avr_vcd_add_signal(&vcd_file,
avr_io_getirq(avr, AVR_IOCTL_IOPORT_GETIRQ('B'), 1 ),
1, "XLAT" );
avr_vcd_add_signal(&vcd_file,
avr_io_getirq(avr, AVR_IOCTL_IOPORT_GETIRQ('B'), 2 ),
1, "BLANK" );
avr_vcd_add_signal(&vcd_file,
avr_io_getirq(avr, AVR_IOCTL_IOPORT_GETIRQ('B'), 5 ),
1, "SCLK" );
#if 0
avr_vcd_add_signal(&vcd_file,
button.irq + IRQ_BUTTON_OUT, 1 /* bits */ ,
"button" );
// 'raise' it, it's a "pullup"
avr_raise_irq(button.irq + IRQ_BUTTON_OUT, 1);
#endif
avr_vcd_start( &vcd_file );
printf( "Demo launching. " );
#if 0
/*
* OpenGL init, can be ignored
*/
glutInit(&argc, argv); /* initialize GLUT system */
glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE);
glutInitWindowSize(8 * pixsize, 1 * pixsize); /* width=400pixels height=500pixels */
window = glutCreateWindow("Glut"); /* create window */
// Set up projection matrix
glMatrixMode(GL_PROJECTION); // Select projection matrix
glLoadIdentity(); // Start with an identity matrix
glOrtho(0, 8 * pixsize, 0, 1 * pixsize, 0, 10);
glScalef(1,-1,1);
glTranslatef(0, -1 * pixsize, 0);
glutDisplayFunc(displayCB); /* set window's display callback */
glutKeyboardFunc(keyCB); /* set window's key callback */
glutTimerFunc(1000 / 24, timerCB, 0);
#endif
// the AVR run on it's own thread. it even allows for debugging!
pthread_t run;
pthread_create(&run, NULL, avr_run_thread, NULL);
sleep( 60 ); // wait 5 seconds, then exit.
avr_vcd_stop(&vcd_file);
/* glutMainLoop(); */
}
int main(int argc, char* argv[]) {
int r = 0;
char* elf_file = NULL;
int gdb_port = 0;
for (char** arg = &argv[1]; *arg != NULL; ++arg) {
if (strcmp("-d", *arg) == 0)
gdb_port = atoi(*(++arg));
else
elf_file = *arg;
}
if (elf_file == NULL) {
fprintf(stderr, "Give me a .elf file to load\n");
return 1;
}
elf_firmware_t f;
elf_read_firmware(elf_file, &f);
avr_t* avr = avr_make_mcu_by_name("atmega328p");
if (!avr) {
fprintf(stderr, "Unsupported cpu atmega328p\n");
return 1;
}
avr_init(avr);
if (gdb_port != 0) {
avr->gdb_port = gdb_port;
avr_gdb_init(avr);
}
avr->frequency = 16000000;
avr_load_firmware(avr, &f);
pcd8544_init(avr, &lcd);
avr_connect_irq(avr_io_getirq(avr, AVR_IOCTL_IOPORT_GETIRQ('C'), 2),
lcd.irq + IRQ_PCD8544_DC);
avr_connect_irq(avr_io_getirq(avr, AVR_IOCTL_IOPORT_GETIRQ('C'), 1),
lcd.irq + IRQ_PCD8544_CS);
avr_connect_irq(avr_io_getirq(avr, AVR_IOCTL_IOPORT_GETIRQ('C'), 0),
lcd.irq + IRQ_PCD8544_RST);
avr_connect_irq(avr_io_getirq(avr, AVR_IOCTL_SPI_GETIRQ(0), SPI_IRQ_OUTPUT),
lcd.irq + IRQ_PCD8544_SPI_IN);
gb_keypad_init(avr, &keypad);
for (int i = 0; i < keydefs_length; i++) {
const keydef_t *k = keydefs + i;
avr_connect_irq(keypad.irq + k->keypad_key,
avr_io_getirq(avr, AVR_IOCTL_IOPORT_GETIRQ(k->port), k->pin));
// Start with the pin high
avr_ioport_t* port = (avr_ioport_t*) avr->io[k->avr_port].w.param;
key_io[i].pin_mask = (1<<k->pin);
key_io[i].pull_value = &port->external.pull_value;
port->external.pull_mask |= key_io[i].pin_mask;
port->external.pull_value |= key_io[i].pin_mask;
gb_keypad_press(&keypad, k->keypad_key, 1);
}
if (display_init()) {
lcd_ram_mutex = SDL_CreateMutex();
SDL_Thread* avr_thread = SDL_CreateThread(avr_run_thread, "avr-thread", avr);
main_loop();
SDL_LockMutex(lcd_ram_mutex);
quit_flag = 1;
SDL_UnlockMutex(lcd_ram_mutex);
int avr_thread_return;
SDL_WaitThread(avr_thread, &avr_thread_return);
SDL_DestroyMutex(lcd_ram_mutex);
} else {
r = 1;
fprintf(stderr, "%s\n", display_error_message());
}
display_destroy();
return r;
}
int main(int argc, char *argv[])
{
elf_firmware_t f;
const char * fname = "atmega168_timer_64led.axf";
//char path[256];
// sprintf(path, "%s/%s", dirname(argv[0]), fname);
//printf("Firmware pathname is %s\n", path);
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' now known\n", argv[0], f.mmcu);
exit(1);
}
avr_init(avr);
avr_load_firmware(avr, &f);
//
// initialize our 'peripherals'
//
hc595_init(avr, &shifter);
button_init(avr, &button[B_START], "button.start");
avr_connect_irq(
button[B_START].irq + IRQ_BUTTON_OUT,
avr_io_getirq(avr, AVR_IOCTL_IOPORT_GETIRQ('C'), 0));
button_init(avr, &button[B_STOP], "button.stop");
avr_connect_irq(
button[B_STOP].irq + IRQ_BUTTON_OUT,
avr_io_getirq(avr, AVR_IOCTL_IOPORT_GETIRQ('B'), 1));
button_init(avr, &button[B_RESET], "button.reset");
avr_connect_irq(
button[B_RESET].irq + IRQ_BUTTON_OUT,
avr_io_getirq(avr, AVR_IOCTL_IOPORT_GETIRQ('B'), 0));
// connects the fake 74HC595 array to the pins
avr_irq_t * i_mosi = avr_io_getirq(avr, AVR_IOCTL_SPI_GETIRQ(0), SPI_IRQ_OUTPUT),
* i_reset = avr_io_getirq(avr, AVR_IOCTL_IOPORT_GETIRQ('D'), 4),
* i_latch = avr_io_getirq(avr, AVR_IOCTL_IOPORT_GETIRQ('D'), 7);
avr_connect_irq(i_mosi, shifter.irq + IRQ_HC595_SPI_BYTE_IN);
avr_connect_irq(i_reset, shifter.irq + IRQ_HC595_IN_RESET);
avr_connect_irq(i_latch, shifter.irq + IRQ_HC595_IN_LATCH);
avr_irq_t * i_pwm = avr_io_getirq(avr, AVR_IOCTL_TIMER_GETIRQ('0'), TIMER_IRQ_OUT_PWM0);
avr_irq_register_notify(
i_pwm,
pwm_changed_hook,
NULL);
avr_irq_register_notify(
shifter.irq + IRQ_HC595_OUT,
hc595_changed_hook,
NULL);
// 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, 10000 /* usec */);
avr_vcd_add_signal(&vcd_file,
avr_get_interrupt_irq(avr, 7), 1 /* bit */ ,
"TIMER2_COMPA" );
avr_vcd_add_signal(&vcd_file,
avr_get_interrupt_irq(avr, 17), 1 /* bit */ ,
"SPI_INT" );
avr_vcd_add_signal(&vcd_file,
i_mosi, 8 /* bits */ ,
"MOSI" );
avr_vcd_add_signal(&vcd_file,
i_reset, 1 /* bit */ ,
"595_RESET" );
avr_vcd_add_signal(&vcd_file,
i_latch, 1 /* bit */ ,
"595_LATCH" );
avr_vcd_add_signal(&vcd_file,
button[B_START].irq + IRQ_BUTTON_OUT, 1 /* bits */ ,
"start" );
avr_vcd_add_signal(&vcd_file,
button[B_STOP].irq + IRQ_BUTTON_OUT, 1 /* bits */ ,
"stop" );
avr_vcd_add_signal(&vcd_file,
button[B_RESET].irq + IRQ_BUTTON_OUT, 1 /* bits */ ,
"reset" );
avr_vcd_add_signal(&vcd_file,
shifter.irq + IRQ_HC595_OUT, 32 /* bits */ ,
"HC595" );
avr_vcd_add_signal(&vcd_file,
i_pwm, 8 /* bits */ ,
"PWM" );
// 'raise' it, it's a "pullup"
avr_raise_irq(button[B_START].irq + IRQ_BUTTON_OUT, 1);
avr_raise_irq(button[B_STOP].irq + IRQ_BUTTON_OUT, 1);
avr_raise_irq(button[B_RESET].irq + IRQ_BUTTON_OUT, 1);
printf( "Demo : This is a real world firmware, a 'stopwatch'\n"
" timer that can count up to 99 days. It features a PWM control of the\n"
" brightness, blinks the dots, displays the number of days spent and so on.\n\n"
" Press '0' to press the 'start' button\n"
" Press '1' to press the 'stop' button\n"
" Press '2' to press the 'reset' button\n"
" Press 'q' to quit\n\n"
" Press 'r' to start recording a 'wave' file - with a LOT of data\n"
" Press 's' to stop recording\n"
" + Make sure to watch the brightness dim once you stop the timer\n\n"
);
/*
* OpenGL init, can be ignored
*/
glutInit(&argc, argv); /* initialize GLUT system */
int w = 22, h = 8;
glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE);
glutInitWindowSize(w * pixsize, h * pixsize); /* width=400pixels height=500pixels */
window = glutCreateWindow("Press 0, 1, 2 or q"); /* create window */
// Set up projection matrix
glMatrixMode(GL_PROJECTION); // Select projection matrix
glLoadIdentity(); // Start with an identity matrix
glOrtho(0, w * pixsize, 0, h * pixsize, 0, 10);
glScalef(1,-1,1);
glTranslatef(0, -1 * h * pixsize, 0);
glutDisplayFunc(displayCB); /* set window's display callback */
glutKeyboardFunc(keyCB); /* set window's key callback */
glutTimerFunc(1000 / 24, timerCB, 0);
// the AVR run on it's own thread. it even allows for debugging!
pthread_t run;
pthread_create(&run, NULL, avr_run_thread, NULL);
glutMainLoop();
}
