[avrfbosd] / fbosd.c

#include <avr/io.h>
#include <avr/interrupt.h>
#include <util/delay.h>
#include <stdlib.h>
#include <avr/pgmspace.h>

#include "video_properties.h"
#include "render.h"
#include "draw.h"
#include "font.h"

void (*line_handler)( void );

const int vres_scale = ( SCREEN_LINES / VRES -1 );
const int hres_bytes = HRES / 8;

volatile uint8_t* screen_buffer;

volatile int line;
volatile int buffer_position;

void Delay_ms(int cnt)
{
        while(cnt-->0) _delay_ms(1);
}

void set_busy ( uint8_t busy)
{
        if ( busy )
        {
                // Set busy signal
                PORTB |= (1 << PB1);
                
                // TODO: Disable SPI communication here...
        }
        else
        {
                // Clear Busy signal
                PORTB &= ~(uint8_t)(1 << PB1);

                // TODO: Enable SPI communication here...
        }
}

void active_lines ( void )
{
        static uint8_t rept;

        _delay_us(4);

        // Set Busy signal. Line rendering is time-critical.
        set_busy(1);
        asm_render_line();
        set_busy(0);

        if( !rept )
        {
                if ( buffer_position < ((VRES*hres_bytes)) ) 
                        buffer_position += hres_bytes;
                        rept = vres_scale;
        }
        else rept--;

}

void blank_lines ( void )
{
        // Do nothing on the "lead-in" lines
        if ( line < FIRST_LINE )
                return;

        // Clear Frame Ready signal
        PORTD &= ~(uint8_t)(1 << PD5);

        // Activate rendering
        line_handler = active_lines;
}

ISR (INT1_vect)
{
        line_handler();
        line++;
        if( line > LAST_LINE) 
        {
                line = 0;
                buffer_position = 0;
                line_handler = &blank_lines;
                EIMSK &= ~(uint8_t)(1<<INT1);
                
                // Set Frame Ready signal
                PORTD |= (1 << PD5);
                
        }
}

ISR (INT0_vect) 
{
        // VSync is getting close to done.
        // Set line-handler to blank-handler to count-up the undesired lines,
        // and enable HSync interrupts.

        line_handler = &blank_lines;

        EIMSK |= (1<<INT1);
        
}

//Main Function
int main(void)
{
        // Note: PB0 is used as CLKO outputting 20MHz clock to ATtiny
        
        // Set PB2 as Output for BUSY signal
        DDRB = (1 << PB1);
        
        // Set PD5 as Output for FR signal
        // Set PD6 as Output for Status LED
        // Using pin 7 on PD to clock out pixels \o/
        DDRD = (1<<PD5)|(1<<PD6)|(1<<PD7);
        
        // Clear PORTB and PORTD
        PORTB = 0x0;
        PORTD = 0x0;

        // Allocate the framebuffer :D
        screen_buffer = (uint8_t*) malloc( hres_bytes * VRES * sizeof(uint8_t) );
        // And make sure it's cleared
        fill(c_BLACK);

        /* LM1881 pins are connected to:
        INT0 / PCINT18 / PD2 <- VSYNC
        INT1 / PCINT19 / PD3 <- CSYNC
        PCINT20 / PD4        <- ODD/EVEN
        */
        EICRA |= (1<<ISC01)|(1<<ISC00); // Select Rising-edge interrupt for VSync
        EICRA |= (1<<ISC11)|(1<<ISC10); // Select Rising-edge interrupt for HSync
        EIMSK |= (1<<INT0);                     // Enable VSync-interrupts

        // Enable interrupts globally.
        sei();

/*      
        // Do some static drawing :P
        set_pixel(28, 8, 1);
        set_pixel(92, 82, 1);

        set_pixel(92, 8, 1);
        set_pixel(28, 82, 1);

        draw_line(0, 0, 128, 92, 1);
        draw_line(128, 0, 0, 92, 1);

        draw_rect( 0, 1, 127, 91, 1);

        draw_rect( 34, 21, 60, 50, 1);
        _draw_rect( 24, 11, 80, 70, 1, -1);
        draw_rect( 34, 21, 60, 50, 1);

        fill_circle( 64,46, 45, 1 );
        fill_circle( 64,46, 40, 0 );

        _draw_circle( 64,46, 35, 1, -1 );
        draw_circle( 64,46, 30, 1 );
        fill_rect( 38, 25, 52, 42, 1);
        fill_rect( 41, 28, 46, 36, 0);

        for (;;)
        {
                // Toggle status LED
                PORTD ^= (uint8_t)(1 << PD6);
                
                for ( int j = 0; j < 92; j++ )
                {
                        draw_line(0,0,128,j, 2);
                        draw_line(128,0,0,j, 2);
                        draw_line(0,92,128,92-j, 2);
                        draw_line(128,92,0,92-j, 2);

                        Delay_ms(2);

                }
                for ( int j = 0; j < 92; j++ )
                {
                        draw_line(0,0,128,j, 2);
                        draw_line(128,0,0,j, 2);
                        draw_line(0,92,128,92-j, 2);
                        draw_line(128,92,0,92-j, 2);

                        Delay_ms(2);

                }
                Delay_ms(250);
        }
*/      

        for (int q = 0; q < font_height; q++ )
        {
                //for (int r = 0; r < font_width; r++ )
                //{
                        uint8_t t = pgm_read_byte(&(font[0][q]));
                        screen_buffer[q*hres_bytes+3+hres_bytes] |= t;
                        
                        t = pgm_read_byte(&(font[1][q]));
                        screen_buffer[q*hres_bytes+5+hres_bytes] |= t;

                        t = pgm_read_byte(&(font[2][q]));
                        screen_buffer[q*hres_bytes+6+hres_bytes] |= t;

                //}
        }
        
        for (;;)
        {
        
        }
}