JuFo/2016_BMS/a00073_source.html

 #include "ili9341.h"
 #include "ili9341_regs.h"
 #include <util/delay.h>

 __always_inline static void ili9341_select_chip ( void )
 {
     IO_SetPinLow ( CONF_ILI9341_CS_PIN );
 }

 __always_inline static void ili9341_deselect_chip ( void )
 {
     IO_SetPinHigh ( CONF_ILI9341_CS_PIN );
 }

 __always_inline static void ili9341_select_command_mode ( void )
 {
     IO_SetPinLow ( CONF_ILI9341_DC_PIN );
 }

 __always_inline static void ili9341_select_data_mode ( void )
 {
     IO_SetPinHigh ( CONF_ILI9341_DC_PIN );
 }

 __always_inline static void ili9341_wait_for_send_done ( void )
 {
 #if defined(CONF_ILI9341_USART_SPI)
     while (!usart_tx_is_complete(CONF_ILI9341_USART_SPI))
     {
         /* Do nothing */
     }
     usart_clear_tx_complete(CONF_ILI9341_USART_SPI);
 #elif defined(CONF_ILI9341_SPI)
     /* Wait for TX to complete */
     while ( !spi_is_tx_empty ( CONF_ILI9341_SPI ) )
     {
         /* Do nothing */
     }
 #endif
 }

 __always_inline static void ili9341_send_byte ( uint8_t data )
 {
 #if defined(CONF_ILI9341_USART_SPI)
     while (!usart_data_register_is_empty(CONF_ILI9341_USART_SPI))
     {
         /* Do nothing */
     }

     irqflags_t flags = cpu_irq_save();
     usart_clear_tx_complete(CONF_ILI9341_USART_SPI);
     usart_put(CONF_ILI9341_USART_SPI, data);
     cpu_irq_restore(flags);
 #elif defined(CONF_ILI9341_SPI)
     /* Wait for any previously running send data */
     ili9341_wait_for_send_done ();

     spi_write_single ( CONF_ILI9341_SPI, data );
 #endif
 }

 __always_inline static uint8_t ili9341_read_byte ( void )
 {
     uint8_t data;

 #if defined(CONF_ILI9341_USART_SPI)
     /* Workaround for clearing the RXCIF for XMEGA */
     usart_rx_enable(CONF_ILI9341_USART_SPI);

     usart_put(CONF_ILI9341_USART_SPI, 0xFF);
     while (!usart_rx_is_complete(CONF_ILI9341_USART_SPI))
     {
         /* Do nothing */
     }
     data = usart_get(CONF_ILI9341_USART_SPI);

     /* Workaround for clearing the RXCIF for XMEGA */
     usart_rx_disable(CONF_ILI9341_USART_SPI);
 #elif defined(CONF_ILI9341_SPI)
     spi_write_single ( CONF_ILI9341_SPI, 0xFF );

     ili9341_wait_for_send_done ();

     /* Wait for RX to complete */
     while ( !spi_is_rx_full ( CONF_ILI9341_SPI ) )
     {
         /* Do nothing */
     }

     spi_read_single ( CONF_ILI9341_SPI, &data );
 #endif

     return data;
 }

 static void ili9341_send_command ( uint8_t command )
 {
     ili9341_select_command_mode ();
     ili9341_select_chip ();
     ili9341_send_byte ( command );
     ili9341_wait_for_send_done ();
     ili9341_select_data_mode ();
 }

 static ili9341_coord_t limit_start_x, limit_start_y;
 static ili9341_coord_t limit_end_x, limit_end_y;

 static void ili9341_send_draw_limits ( const bool send_end_limits )
 {
     ili9341_send_command ( ILI9341_CMD_COLUMN_ADDRESS_SET );
     ili9341_send_byte ( limit_start_x >> 8 );
     ili9341_send_byte ( limit_start_x & 0xFF );
     if ( send_end_limits )
     {
         ili9341_send_byte ( limit_end_x >> 8 );
         ili9341_send_byte ( limit_end_x & 0xFF );
     }
     ili9341_wait_for_send_done ();
     ili9341_deselect_chip ();

     ili9341_send_command ( ILI9341_CMD_PAGE_ADDRESS_SET );
     ili9341_send_byte ( limit_start_y >> 8 );
     ili9341_send_byte ( limit_start_y & 0xFF );
     if ( send_end_limits )
     {
         ili9341_send_byte ( limit_end_y >> 8 );
         ili9341_send_byte ( limit_end_y & 0xFF );
     }
     ili9341_wait_for_send_done ();
     ili9341_deselect_chip ();
 }

 void ili9341_set_top_left_limit ( ili9341_coord_t x, ili9341_coord_t y )
 {
     limit_start_x = x;
     limit_start_y = y;

     ili9341_send_draw_limits ( false );
 }

 void ili9341_set_bottom_right_limit ( ili9341_coord_t x, ili9341_coord_t y )
 {
     limit_end_x = x;
     limit_end_y = y;

     ili9341_send_draw_limits ( true );
 }

 void ili9341_set_limits ( ili9341_coord_t start_x, ili9341_coord_t start_y, ili9341_coord_t end_x, ili9341_coord_t end_y )
 {
     limit_start_x = start_x;
     limit_start_y = start_y;
     limit_end_x = end_x;
     limit_end_y = end_y;

     ili9341_send_draw_limits ( true );
 }

 ili9341_color_t ili9341_read_gram ( void )
 {
     uint8_t red, green, blue;

     ili9341_send_command ( ILI9341_CMD_MEMORY_READ );

     /* No interesting data in the first byte, hence read and discard */
     red = ili9341_read_byte ();

     red = ili9341_read_byte ();
     green = ili9341_read_byte ();
     blue = ili9341_read_byte ();

     ili9341_deselect_chip ();

     return ILI9341_COLOR( red, green, blue );
 }

 void ili9341_write_gram ( ili9341_color_t color )
 {
     /* Only 16-bit color supported */
     Assert( sizeof(color) == 2 );

     ili9341_send_command ( ILI9341_CMD_MEMORY_WRITE );
     ili9341_send_byte ( color );
     ili9341_send_byte ( color >> 8 );
     ili9341_wait_for_send_done ();
     ili9341_deselect_chip ();
 }

 void ili9341_copy_pixels_to_screen ( const ili9341_color_t *pixels, uint32_t count )
 {
     const ili9341_color_t *pixel = pixels;

     /* Sanity check to make sure that the pixel count is not zero */
     Assert( count > 0 );

     ili9341_send_command ( ILI9341_CMD_MEMORY_WRITE );

 #if defined(ILI9341_DMA_ENABLED)
     ili9341_color_t chunk_buf[ILI9341_DMA_CHUNK_SIZE];
     uint32_t chunk_len;

     while (count)
     {
         /* We need to copy out the data to send in chunks into RAM, as the PDC
          * does not allow FLASH->Peripheral transfers */
         chunk_len = min(ILI9341_DMA_CHUNK_SIZE, count);

         /* Wait for pending transfer to complete */
         ili9341_wait_for_send_done();

         for (uint32_t i = 0; i < chunk_len; i++)
         {
             chunk_buf[i] = le16_to_cpu(pixel[i]);
         }

         pixel += chunk_len;
         count -= chunk_len;
     }

     ili9341_wait_for_send_done();
     ili9341_deselect_chip();

 #else
     while ( count-- )
     {
         ili9341_send_byte ( *pixel );
         ili9341_send_byte ( *pixel >> 8 );

         pixel++;
     }

     ili9341_wait_for_send_done ();
     ili9341_deselect_chip ();
 #endif
 }

 void ili9341_copy_progmem_pixels_to_screen ( ili9341_color_t PROGMEM_PTR_T pixels, uint32_t count, uint8_t swap)
 {
     ili9341_color_t color;

     /* Sanity check to make sure that the pixel count is not zero */
     Assert(count > 0);

     ili9341_send_command(ILI9341_CMD_MEMORY_WRITE);

     while (count--)
     {
         color = PROGMEM_READ_WORD(pixels);

         if(swap)
         {
             ili9341_send_byte(color);
             ili9341_send_byte(color >> 8);}
         else
         {
             ili9341_send_byte(color >> 8);
             ili9341_send_byte(color);}

         pixels++;
     }

     ili9341_wait_for_send_done();
     ili9341_deselect_chip();
 }

 void ili9341_duplicate_pixel ( const ili9341_color_t color, uint32_t count )
 {
     /* Sanity check to make sure that the pixel count is not zero */
     Assert( count > 0 );

     ili9341_send_command ( ILI9341_CMD_MEMORY_WRITE );

     while ( count-- )
     {
         ili9341_send_byte ( color );
         ili9341_send_byte ( color >> 8 );
     }

     ili9341_wait_for_send_done ();
     ili9341_deselect_chip ();
 }

 void ili9341_copy_pixels_from_screen ( ili9341_color_t *pixels, uint32_t count )
 {
     uint8_t red, green, blue;

     /* Sanity check to make sure that the pixel count is not zero */
     Assert( count > 0 );

     ili9341_send_command ( ILI9341_CMD_MEMORY_READ );

     /* No interesting data in the first byte, hence read and discard */
     red = ili9341_read_byte ();

     while ( count-- )
     {
         red = ili9341_read_byte ();
         green = ili9341_read_byte ();
         blue = ili9341_read_byte ();

         *pixels = ILI9341_COLOR( red, green, blue );
         pixels++;
     }

     ili9341_deselect_chip ();
 }

 static void ili9341_interface_init ( void )
 {
 #if defined(CONF_ILI9341_USART_SPI) || defined(CONF_ILI9341_SPI)
     spi_flags_t spi_flags = SPI_MODE_0;
     board_spi_select_id_t spi_select_id = 0;
 #else
 #error Interface for ILI9341 has not been selected or interface not supported, please configure component driver using the ili9341.h    file!
 #endif

 #if defined(CONF_ILI9341_USART_SPI)
     struct usart_spi_device device =
     {
         .id = 0,
     };

     usart_spi_init(CONF_ILI9341_USART_SPI);
     usart_spi_setup_device(CONF_ILI9341_USART_SPI, &device, spi_flags, CONF_ILI9341_CLOCK_SPEED, spi_select_id);

 #elif defined(CONF_ILI9341_SPI)
     struct spi_device device = { .id = 0, };

     spi_master_init ( CONF_ILI9341_SPI );
     spi_master_setup_device ( CONF_ILI9341_SPI, &device, spi_flags,
     CONF_ILI9341_CLOCK_SPEED, spi_select_id );
     spi_enable ( CONF_ILI9341_SPI );

     /* Send one dummy byte for the spi_is_tx_ok() to work as expected */
     spi_write_single ( CONF_ILI9341_SPI, 0 );
 #endif
 }

 static void ili9341_controller_init_registers ( void )
 {
     ili9341_send_command ( ILI9341_CMD_POWER_CONTROL_A );
     ili9341_send_byte ( 0x39 );
     ili9341_send_byte ( 0x2C );
     ili9341_send_byte ( 0x00 );
     ili9341_send_byte ( 0x34 );
     ili9341_send_byte ( 0x02 );
     ili9341_wait_for_send_done ();
     ili9341_deselect_chip ();

     ili9341_send_command ( ILI9341_CMD_POWER_CONTROL_B );
     ili9341_send_byte ( 0x00 );
     ili9341_send_byte ( 0xAA );
     ili9341_send_byte ( 0XB0 );
     ili9341_wait_for_send_done ();
     ili9341_deselect_chip ();

     ili9341_send_command ( ILI9341_CMD_PUMP_RATIO_CONTROL );
     ili9341_send_byte ( 0x30 );
     ili9341_wait_for_send_done ();
     ili9341_deselect_chip ();

     ili9341_send_command ( ILI9341_CMD_POWER_CONTROL_1 );
     ili9341_send_byte ( 0x25 );
     ili9341_wait_for_send_done ();
     ili9341_deselect_chip ();

     ili9341_send_command ( ILI9341_CMD_POWER_CONTROL_2 );
     ili9341_send_byte ( 0x11 );
     ili9341_wait_for_send_done ();
     ili9341_deselect_chip ();

     ili9341_send_command ( ILI9341_CMD_VCOM_CONTROL_1 );
     ili9341_send_byte ( 0x5C );
     ili9341_send_byte ( 0x4C );
     ili9341_wait_for_send_done ();
     ili9341_deselect_chip ();

     ili9341_send_command ( ILI9341_CMD_VCOM_CONTROL_2 );
     ili9341_send_byte ( 0x94 );
     ili9341_wait_for_send_done ();
     ili9341_deselect_chip ();

     ili9341_send_command ( ILI9341_CMD_DRIVER_TIMING_CONTROL_A );
     ili9341_send_byte ( 0x85 );
     ili9341_send_byte ( 0x01 );
     ili9341_send_byte ( 0x78 );
     ili9341_wait_for_send_done ();
     ili9341_deselect_chip ();

     ili9341_send_command ( ILI9341_CMD_DRIVER_TIMING_CONTROL_B );
     ili9341_send_byte ( 0x00 );
     ili9341_send_byte ( 0x00 );
     ili9341_wait_for_send_done ();
     ili9341_deselect_chip ();

     ili9341_send_command ( ILI9341_CMD_COLMOD_PIXEL_FORMAT_SET );
     ili9341_send_byte ( 0x05 );
     ili9341_wait_for_send_done ();
     ili9341_deselect_chip ();

     ili9341_set_orientation ( 0 );
     ili9341_set_limits ( 0, 0, ILI9341_DEFAULT_WIDTH,
     ILI9341_DEFAULT_HEIGHT );
 }

 static void ili9341_exit_standby ( void )
 {
     ili9341_send_command ( ILI9341_CMD_SLEEP_OUT );
     ili9341_deselect_chip ();
     _delay_ms ( 150 );
     ili9341_send_command ( ILI9341_CMD_DISPLAY_ON );
     ili9341_deselect_chip ();
 }

 static void ili9341_reset_display ( void )
 {
     IO_SetPinHigh ( CONF_ILI9341_RESET_PIN );
     _delay_ms ( 10 );
     IO_SetPinLow ( CONF_ILI9341_RESET_PIN );
     _delay_ms ( 10 );
     IO_SetPinHigh ( CONF_ILI9341_RESET_PIN );
     _delay_ms ( 150 );
 }

 void ili9341_init ( void )
 {
     /* Initialise the communication interface */
     ili9341_interface_init ();

     /* Reset the display */
     ili9341_reset_display ();

     /* Send commands to exit standby mode */
     ili9341_exit_standby ();

     /* Write all the controller registers with correct values */
     ili9341_controller_init_registers ();
 }

 void ili9341_set_orientation ( uint8_t flags )
 {
     uint8_t madctl = 0x48;

     /* Pretend the display is in landscape mode by default to match other display drivers */
     flags ^= ILI9341_SWITCH_XY | ILI9341_FLIP_X;

     if ( flags & ILI9341_FLIP_X )
     {
         madctl &= ~(1 << 6);
     }

     if ( flags & ILI9341_FLIP_Y )
     {
         madctl |= 1 << 7;
     }

     if ( flags & ILI9341_SWITCH_XY )
     {
         madctl |= 1 << 5;
     }

     ili9341_send_command ( ILI9341_CMD_MEMORY_ACCESS_CONTROL );
     ili9341_send_byte ( madctl );
     ili9341_wait_for_send_done ();
     ili9341_deselect_chip ();
 }
ili9341_select_chip
static __always_inline void ili9341_select_chip(void)
Helper function to select the CS of the controller on the bus.
Definition: ili9341.c:53

spi_is_rx_full
static bool spi_is_rx_full(SPI_t *spi)
Tests if the SPI contains a received character.
Definition: spi_master.h:409

ILI9341_FLIP_Y
#define ILI9341_FLIP_Y
Definition: ili9341.h:157

ili9341_reset_display
static void ili9341_reset_display(void)
Reset the display using the digital control interface.
Definition: ili9341.c:665

ili9341_write_gram
void ili9341_write_gram(ili9341_color_t color)
Write the graphical memory with a single color pixel.
Definition: ili9341.c:335

ili9341_send_byte
static __always_inline void ili9341_send_byte(uint8_t data)
Helper function to send a byte over an arbitrary interface.
Definition: ili9341.c:116

ili9341_select_data_mode
static __always_inline void ili9341_select_data_mode(void)
Helper function to select data byte transmission mode.
Definition: ili9341.c:80

spi_device
Polled SPI device definition.
Definition: spi_master.h:250

CONF_ILI9341_CS_PIN
#define CONF_ILI9341_CS_PIN
Define what MCU pin the ILI9341 chip select pin is connected to.
Definition: ili9341.h:77

ILI9341_SWITCH_XY
#define ILI9341_SWITCH_XY
Definition: ili9341.h:159

spi_device::id
port_pin_t id
Board specific select id.
Definition: spi_master.h:252

Assert
#define Assert(expr)
This macro is used to test fatal errors.
Definition: compiler.h:46

spi_read_single
static void spi_read_single(SPI_t *spi, uint8_t *data)
Receive one byte from a SPI device.
Definition: spi_master.h:359

ili9341_set_orientation
void ili9341_set_orientation(uint8_t flags)
Sets the orientation of the display data.
Definition: ili9341.c:707

spi_master_setup_device
void spi_master_setup_device(SPI_t *spi, struct spi_device *device, spi_flags_t flags, uint32_t baud_rate, board_spi_select_id_t sel_id)
Setup a SPI device.
Definition: spi_master.c:175

spi_master_init
void spi_master_init(SPI_t *spi)
Initializes the SPI in master mode.
Definition: spi_master.c:126

ili9341_init
void ili9341_init(void)
Initialise the controller.
Definition: ili9341.c:683

ili9341_select_command_mode
static __always_inline void ili9341_select_command_mode(void)
Helper function to select command byte transmission mode.
Definition: ili9341.c:71

ili9341_set_limits
void ili9341_set_limits(ili9341_coord_t start_x, ili9341_coord_t start_y, ili9341_coord_t end_x, ili9341_coord_t end_y)
Set the full display drawing limits.
Definition: ili9341.c:278

SPI_MODE_0
#define SPI_MODE_0
SPI mode 0.
Definition: spi_master.h:232

ili9341_coord_t
int16_t ili9341_coord_t
Definition: ili9341.h:147

IO_SetPinHigh
void IO_SetPinHigh(PORT_t *port, uint8_t pinMask)
This function sets a bit in the OUT register of an I/O port or virtual port.
Definition: port_driver.c:108

ILI9341_DEFAULT_HEIGHT
#define ILI9341_DEFAULT_HEIGHT
Definition: ili9341.h:164

ili9341_interface_init
static void ili9341_interface_init(void)
Initialize the hardware interface to the controller.
Definition: ili9341.c:538

ili9341_regs.h
IL9341 Display Controller Register und Bitfield Definitionen aus dem ASF 3.26.0.

spi_enable
static void spi_enable(SPI_t *spi)
Enables the SPI.
Definition: spi_master.h:112

ili9341_copy_progmem_pixels_to_screen
void ili9341_copy_progmem_pixels_to_screen(ili9341_color_t PROGMEM_PTR_T pixels, uint32_t count, uint8_t swap)
Copy pixels from progmem to the screen.
Definition: ili9341.c:426

ILI9341_FLIP_X
#define ILI9341_FLIP_X
Definition: ili9341.h:155

ili9341_read_byte
static __always_inline uint8_t ili9341_read_byte(void)
Helper function to read a byte from an arbitrary interface.
Definition: ili9341.c:146

IO_SetPinLow
void IO_SetPinLow(PORT_t *port, uint8_t pinMask)
This function clears a bit in the OUT register of an I/O port or virtual port.
Definition: port_driver.c:121

ILI9341_DEFAULT_WIDTH
#define ILI9341_DEFAULT_WIDTH
Definition: ili9341.h:167

ili9341_wait_for_send_done
static __always_inline void ili9341_wait_for_send_done(void)
Helper function to wait for the last send operation to complete.
Definition: ili9341.c:89

ili9341_deselect_chip
static __always_inline void ili9341_deselect_chip(void)
Helper function to de-select the CS of the controller on the bus.
Definition: ili9341.c:62

ili9341_set_top_left_limit
void ili9341_set_top_left_limit(ili9341_coord_t x, ili9341_coord_t y)
Set the display top left drawing limit.
Definition: ili9341.c:244

ili9341_copy_pixels_to_screen
void ili9341_copy_pixels_to_screen(const ili9341_color_t *pixels, uint32_t count)
Copy pixels from SRAM to the screen.
Definition: ili9341.c:362

ili9341_send_command
static void ili9341_send_command(uint8_t command)
Sends a command to the controller, and prepares for parameter transfer.
Definition: ili9341.c:190

CONF_ILI9341_CLOCK_SPEED
#define CONF_ILI9341_CLOCK_SPEED
Select the correct hardware interface.
Definition: ili9341.h:74

spi_write_single
static __always_inline void spi_write_single(SPI_t *spi, uint8_t data)
Write one byte to a SPI device.
Definition: spi_master.h:334

CONF_ILI9341_RESET_PIN
#define CONF_ILI9341_RESET_PIN
Define what MCU pin the ILI9341 back light pin is connected to.
Definition: ili9341.h:86

ili9341.h
ILI9341 Display Controller Component Driver aus dem ASF 3.26.0.

ili9341_color_t
uint16_t ili9341_color_t
Definition: ili9341.h:143

ILI9341_COLOR
#define ILI9341_COLOR(r, g, b)
Definition: ili9341.h:140

ili9341_duplicate_pixel
void ili9341_duplicate_pixel(const ili9341_color_t color, uint32_t count)
Set a given number of pixels to the same color.
Definition: ili9341.c:471

ili9341_read_gram
ili9341_color_t ili9341_read_gram(void)
Read a single color from the graphical memory.
Definition: ili9341.c:303

ili9341_controller_init_registers
static void ili9341_controller_init_registers(void)
Initialize all the display registers.
Definition: ili9341.c:576

ili9341_exit_standby
static void ili9341_exit_standby(void)
Send display commands to exit standby mode.
Definition: ili9341.c:650

spi_is_tx_empty
static bool spi_is_tx_empty(SPI_t *spi)
Checks if all transmissions are complete.
Definition: spi_master.h:385

ili9341_send_draw_limits
static void ili9341_send_draw_limits(const bool send_end_limits)
Helper function to send the drawing limits (boundaries) to the display.
Definition: ili9341.c:211

ili9341_copy_pixels_from_screen
void ili9341_copy_pixels_from_screen(ili9341_color_t *pixels, uint32_t count)
Copy pixels from the screen to a pixel buffer.
Definition: ili9341.c:503

CONF_ILI9341_DC_PIN
#define CONF_ILI9341_DC_PIN
Define what MCU pin the ILI9341 DC pin is connected to.
Definition: ili9341.h:80

ili9341_set_bottom_right_limit
void ili9341_set_bottom_right_limit(ili9341_coord_t x, ili9341_coord_t y)
Set the display bottom right drawing limit.
Definition: ili9341.c:260

__always_inline
#define __always_inline
The function should always be inlined.
Definition: compiler.h:127