riot-ci/RIOT
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

[board/chronos/drivers/display]

Browse Source 
* cleaned up code and documentation

[drivers/cc110x_ng]
* fixed include pathes
This commit is contained in:
Oliver Hahm 2010-12-11 13:38:04 +01:00
parent 8f63b18b9f
commit c083928983
5 changed files with 515 additions and 568 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
Jamrules
View File

@ -73,4 +73,4 @@ HDRS += [ FPath $(TOP) projects $(PROJECT) ] ;
# drivers
HDRS += [ FPath $(TOP) drivers include ] ;
HDRS += [ FPath $(TOP) drivers cc110x ] ;
HDRS += [ FPath $(TOP) drivers cc110x_ng ] ;
HDRS += [ FPath $(TOP) drivers cc110x_ng include ] ;

550
board/chronos/drivers/display.c
View File

@ -1,514 +1,382 @@
// *************************************************************************************************
//
// Copyright (C) 2009 Texas Instruments Incorporated - http://www.ti.com/
//
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions
// are met:
//
// Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
//
// Redistributions in binary form must reproduce the above copyright
// notice, this list of conditions and the following disclaimer in the
// documentation and/or other materials provided with the
// distribution.
//
// Neither the name of Texas Instruments Incorporated nor the names of
// its contributors may be used to endorse or promote products derived
// from this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
// *************************************************************************************************
// Display functions.
// *************************************************************************************************
/* *************************************************************************************************
*
* Copyright (C) 2009 Texas Instruments Incorporated - http://www.ti.com/
*
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the
* distribution.
*
* Neither the name of Texas Instruments Incorporated nor the names of
* its contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
* *************************************************************************************************
* Basic display functions.
* ************************************************************************************************/
/* *************************************************************************************************
* Include section
*/
// *************************************************************************************************
// Include section
// system
/* system */
#include <string.h>
// driver
/* driver */
#include <cc430x613x.h>
#include <display.h>
// *************************************************************************************************
// Prototypes section
/**************************************************************************************************
* Prototypes section */
void write_lcd_mem(uint8_t *lcdmem, uint8_t bits, uint8_t bitmask, uint8_t state);
void clear_line(uint8_t line);
void display_symbol(uint8_t symbol, uint8_t mode);
// *************************************************************************************************
// Defines section
/* *************************************************************************************************
* Global Variable section */
// *************************************************************************************************
// Global Variable section
// Display flags
/* Display flags */
volatile s_display_flags display;
// Global return string for itoa function
uint8_t itoa_str[8];
/* Global return string for itoa function */
char itoa_str[8];
// *************************************************************************************************
// @fn lcd_init
// @brief Erase LCD memory. Init LCD peripheral.
// @param none
// @return none
// *************************************************************************************************
void lcd_init(void)
{
// Clear entire display memory
void lcd_init(void) {
/* Clear entire display memory */
LCDBMEMCTL |= LCDCLRBM + LCDCLRM;
// LCD_FREQ = ACLK/16/8 = 256Hz
// Frame frequency = 256Hz/4 = 64Hz, LCD mux 4, LCD on
/* LCD_FREQ = ACLK/16/8 = 256Hz */
/* Frame frequency = 256Hz/4 = 64Hz, LCD mux 4, LCD on */
LCDBCTL0 = (LCDDIV0 + LCDDIV1 + LCDDIV2 + LCDDIV3) | (LCDPRE0 + LCDPRE1) | LCD4MUX | LCDON;
// LCB_BLK_FREQ = ACLK/8/4096 = 1Hz
/* LCB_BLK_FREQ = ACLK/8/4096 = 1Hz */
LCDBBLKCTL = LCDBLKPRE0 | LCDBLKPRE1 | LCDBLKDIV0 | LCDBLKDIV1 | LCDBLKDIV2 | LCDBLKMOD0;
// I/O to COM outputs
/* I/O to COM outputs */
P5SEL |= (BIT5 | BIT6 | BIT7);
P5DIR |= (BIT5 | BIT6 | BIT7);
// Activate LCD output
LCDBPCTL0 = 0xFFFF; // Select LCD segments S0-S15
LCDBPCTL1 = 0x00FF; // Select LCD segments S16-S22
/* Activate LCD output */
LCDBPCTL0 = 0xFFFF; /* Select LCD segments S0-S15 */
LCDBPCTL1 = 0x00FF; /* Select LCD segments S16-S22 */
#ifdef USE_LCD_CHARGE_PUMP
// Charge pump voltage generated internally, internal bias (V2-V4) generation
/* Charge pump voltage generated internally, internal bias (V2-V4) generation */
LCDBVCTL = LCDCPEN | VLCD_2_72;
#endif
}
// *************************************************************************************************
// @fn clear_display_all
// @brief Erase LINE1 and LINE2 segments. Clear also function-specific content.
// @param none
// @return none
// *************************************************************************************************
void clear_display_all(void)
{
void clear_display_all(void) {
// Clear generic content
clear_line(LINE1);
clear_line(LINE2);
}
// *************************************************************************************************
// @fn clear_display
// @brief Erase LINE1 and LINE2 segments. Keep icons.
// @param none
// @return none
// *************************************************************************************************
void clear_display(void)
{
void clear_display(void) {
clear_line(LINE1);
clear_line(LINE2);
}
// *************************************************************************************************
// @fn clear_line
// @brief Erase segments of a given line.
// @param uint8_t line LINE1, LINE2
// @return none
// *************************************************************************************************
void clear_line(uint8_t line)
{
void clear_line(uint8_t line) {
display_chars(switch_seg(line, LCD_SEG_L1_3_0, LCD_SEG_L2_5_0), NULL, SEG_OFF);
if (line == LINE1)
{
if (line == LINE1) {
display_symbol(LCD_SEG_L1_DP1, SEG_OFF);
display_symbol(LCD_SEG_L1_DP0, SEG_OFF);
display_symbol(LCD_SEG_L1_COL, SEG_OFF);
}
else // line == LINE2
{
/* line == LINE2 */
else {
display_symbol(LCD_SEG_L2_DP, SEG_OFF);
display_symbol(LCD_SEG_L2_COL1, SEG_OFF);
display_symbol(LCD_SEG_L2_COL0, SEG_OFF);
}
}
// *************************************************************************************************
// @fn write_segment
// @brief Write to one or multiple LCD segments
// @param lcdmem Pointer to LCD byte memory
// bits Segments to address
// bitmask Bitmask for particular display item
// mode On, off or blink segments
// @return
// *************************************************************************************************
void write_lcd_mem(uint8_t * lcdmem, uint8_t bits, uint8_t bitmask, uint8_t state)
{
if (state == SEG_ON)
{
// Clear segments before writing
void write_lcd_mem(uint8_t *lcdmem, uint8_t bits, uint8_t bitmask, uint8_t state) {
if (state == SEG_ON) {
/* Clear segments before writing */
*lcdmem = (uint8_t)(*lcdmem & ~bitmask);
// Set visible segments
/* Set visible segments */
*lcdmem = (uint8_t)(*lcdmem | bits);
}
else if (state == SEG_OFF)
{
// Clear segments
else if (state == SEG_OFF) {
/* Clear segments */
*lcdmem = (uint8_t)(*lcdmem & ~bitmask);
}
else if (state == SEG_ON_BLINK_ON)
{
// Clear visible / blink segments before writing
else if (state == SEG_ON_BLINK_ON) {
/* Clear visible / blink segments before writing */
*lcdmem = (uint8_t)(*lcdmem & ~bitmask);
*(lcdmem+0x20) = (uint8_t)(*(lcdmem+0x20) & ~bitmask);
// Set visible / blink segments
/* Set visible / blink segments */
*lcdmem = (uint8_t)(*lcdmem | bits);
*(lcdmem+0x20) = (uint8_t)(*(lcdmem+0x20) | bits);
}
else if (state == SEG_ON_BLINK_OFF)
{
// Clear visible segments before writing
else if (state == SEG_ON_BLINK_OFF) {
/* Clear visible segments before writing */
*lcdmem = (uint8_t)(*lcdmem & ~bitmask);
// Set visible segments
/* Set visible segments */
*lcdmem = (uint8_t)(*lcdmem | bits);
// Clear blink segments
/* Clear blink segments */
*(lcdmem+0x20) = (uint8_t)(*(lcdmem+0x20) & ~bitmask);
}
else if (state == SEG_OFF_BLINK_OFF)
{
// Clear segments
else if (state == SEG_OFF_BLINK_OFF) {
/* Clear segments */
*lcdmem = (uint8_t)(*lcdmem & ~bitmask);
// Clear blink segments
/* Clear blink segments */
*(lcdmem+0x20) = (uint8_t)(*(lcdmem+0x20) & ~bitmask);
}
}
// *************************************************************************************************
// @fn itoa
// @brief Generic integer to array routine. Converts integer n to string.
// Default conversion result has leading zeros, e.g. "00123"
// Option to convert leading '0' into whitespace (blanks)
// @param uint32_t n integer to convert
// uint8_t digits number of digits
// uint8_t blanks fill up result string with number of whitespaces instead of leading zeros
// @return uint8_t string
// *************************************************************************************************
uint8_t * itoa(uint32_t n, uint8_t digits, uint8_t blanks)
{
char *itoa(uint32_t n, uint8_t digits, uint8_t blanks) {
uint8_t i;
uint8_t digits1 = digits;
// Preset result string
/* Preset result string */
memcpy(itoa_str, "0000000", 7);
// Return empty string if number of digits is invalid (valid range for digits: 1-7)
if ((digits == 0) || (digits > 7)) return (itoa_str);
/* Return empty string if number of digits is invalid (valid range for digits: 1-7) */
if ((digits == 0) || (digits > 7)) {
return (itoa_str);
}
// Numbers 0 .. 180 can be copied from itoa_conversion_table without conversion
if (n <= 180)
{
if (digits >= 3)
{
/* Numbers 0 .. 180 can be copied from itoa_conversion_table without conversion */
if (n <= 180) {
if (digits >= 3) {
memcpy(itoa_str+(digits-3), itoa_conversion_table[n], 3);
}
else // digits == 1 || 2
{
/* digits == 1 || 2 */
else {
memcpy(itoa_str, itoa_conversion_table[n]+(3-digits), digits);
}
}
else // For n > 180 need to calculate string content
{
// Calculate digits from least to most significant number
do
{
/* For n > 180 need to calculate string content */
else {
/* Calculate digits from least to most significant number */
do {
itoa_str[digits-1] = n % 10 + '0';
n /= 10;
} while (--digits > 0);
}
// Remove specified number of leading '0', always keep last one
/* Remove specified number of leading '0', always keep last one */
i = 0;
while ((itoa_str[i] == '0') && (i < digits1-1))
{
if (blanks > 0)
{
// Convert only specified number of leading '0'
while ((itoa_str[i] == '0') && (i < digits1-1)) {
if (blanks > 0) {
/* Convert only specified number of leading '0' */
itoa_str[i]=' ';
blanks--;
}
i++;
}
return (itoa_str);
}
// *************************************************************************************************
// @fn display_value1
// @brief Generic decimal display routine. Used exclusively by set_value function.
// @param uint8_t segments LCD segments where value is displayed
// uint32_t value Integer value to be displayed
// uint8_t digits Number of digits to convert
// uint8_t blanks Number of leadings blanks in itoa result string
// @return none
// *************************************************************************************************
void display_value1(uint8_t segments, uint32_t value, uint8_t digits, uint8_t blanks, uint8_t disp_mode)
{
uint8_t* str;
void display_value1(uint8_t segments, uint32_t value, uint8_t digits, uint8_t blanks, uint8_t disp_mode) {
char *str;
str = itoa(value, digits, blanks);
// Display string in blink mode
display_chars(segments, (char*) str, disp_mode);
/* Display string in blink mode */
display_chars(segments, str, disp_mode);
}
// *************************************************************************************************
// @fn display_symbol
// @brief Switch symbol on or off on LCD.
// @param uint8_t symbol A valid LCD symbol (index 0..42)
// uint8_t state SEG_ON, SEG_OFF, SEG_BLINK
// @return none
// *************************************************************************************************
void display_symbol(uint8_t symbol, uint8_t mode)
{
uint8_t * lcdmem;
void display_symbol(uint8_t symbol, uint8_t mode) {
uint8_t *lcdmem;
uint8_t bits;
uint8_t bitmask;
if (symbol <= LCD_SEG_L2_DP)
{
// Get LCD memory address for symbol from table
lcdmem = (uint8_t *)segments_lcdmem[symbol];
if (symbol <= LCD_SEG_L2_DP) {
/* Get LCD memory address for symbol from table */
lcdmem = (uint8_t*)segments_lcdmem[symbol];
// Get bits for symbol from table
/* Get bits for symbol from table */
bits = segments_bitmask[symbol];
// Bitmask for symbols equals bits
/* Bitmask for symbols equals bits */
bitmask = bits;
// Write LCD memory
/* Write LCD memory */
write_lcd_mem(lcdmem, bits, bitmask, mode);
}
}
// *************************************************************************************************
// @fn display_char
// @brief Write to 7-segment characters.
// @param uint8_t segment A valid LCD segment
// uint8_t chr Character to display
// uint8_t mode SEG_ON, SEG_OFF, SEG_BLINK
// @return none
// *************************************************************************************************
void display_char(uint8_t segment, char chr, uint8_t mode)
{
uint8_t * lcdmem; // Pointer to LCD memory
uint8_t bitmask; // Bitmask for character
uint8_t bits, bits1; // Bits to write
void display_char(uint8_t segment, char chr, uint8_t mode) {
uint8_t *lcdmem; /* Pointer to LCD memory */
uint8_t bitmask; /* Bitmask for character */
uint8_t bits, bits1; /* Bits to write */
// Write to single 7-segment character
if ((segment >= LCD_SEG_L1_3) && (segment <= LCD_SEG_L2_DP))
{
// Get LCD memory address for segment from table
lcdmem = (uint8_t *)segments_lcdmem[segment];
/* Write to single 7-segment character */
if ((segment >= LCD_SEG_L1_3) && (segment <= LCD_SEG_L2_DP)) {
/* Get LCD memory address for segment from table */
lcdmem = (uint8_t*)segments_lcdmem[segment];
// Get bitmask for character from table
/* Get bitmask for character from table */
bitmask = segments_bitmask[segment];
// Get bits from font set
if ((chr >= 0x30) && (chr <= 0x5A))
{
// Use font set
/* Get bits from font set */
if ((chr >= 0x30) && (chr <= 0x5A)) {
/* Use font set */
bits = lcd_font[chr-0x30];
}
else if (chr == 0x2D)
{
// '-' not in font set
else if (chr == 0x2D) {
/* '-' not in font set */
bits = BIT1;
}
else
{
// Other characters map to ' ' (blank)
else {
/* Other characters map to ' ' (blank) */
bits = 0;
}
// When addressing LINE2 7-segment characters need to swap high- and low-nibble,
// because LCD COM/SEG assignment is mirrored against LINE1
if (segment >= LCD_SEG_L2_5)
{
/* When addressing LINE2 7-segment characters need to swap high- and low-nibble, */
/* because LCD COM/SEG assignment is mirrored against LINE1 */
if (segment >= LCD_SEG_L2_5) {
bits1 = ((bits << 4) & 0xF0) | ((bits >> 4) & 0x0F);
bits = bits1;
// When addressing LCD_SEG_L2_5, need to convert ASCII '1' and 'L' to 1 bit,
// because LCD COM/SEG assignment is special for this incomplete character
if (segment == LCD_SEG_L2_5)
{
/* When addressing LCD_SEG_L2_5, need to convert ASCII '1' and 'L' to 1 bit, */
/* because LCD COM/SEG assignment is special for this incomplete character */
if (segment == LCD_SEG_L2_5) {
if ((chr == '1') || (chr == 'L')) bits = BIT7;
}
}
// Physically write to LCD memory
/* Physically write to LCD memory */
write_lcd_mem(lcdmem, bits, bitmask, mode);
}
}
// *************************************************************************************************
// @fn display_chars
// @brief Write to consecutive 7-segment characters.
// @param uint8_t segments LCD segment array
// uint8_t * str Pointer to a string
// uint8_t mode SEG_ON, SEG_OFF, SEG_BLINK
// @return none
// *************************************************************************************************
void display_chars(uint8_t segments, char *str, uint8_t mode) {
uint8_t i;
uint8_t length = 0; // Write length
uint8_t char_start = 0; // Starting point for consecutive write
uint8_t length = 0; /* Write length */
uint8_t char_start = 0; /* Starting point for consecutive write */
switch (segments)
{
// LINE1
case LCD_SEG_L1_3_0: length=4; char_start=LCD_SEG_L1_3; break;
case LCD_SEG_L1_2_0: length=3; char_start=LCD_SEG_L1_2; break;
case LCD_SEG_L1_1_0: length=2; char_start=LCD_SEG_L1_1; break;
case LCD_SEG_L1_3_1: length=3; char_start=LCD_SEG_L1_3; break;
case LCD_SEG_L1_3_2: length=2; char_start=LCD_SEG_L1_3; break;
switch (segments) {
/* LINE1 */
case LCD_SEG_L1_3_0:
length=4;
char_start=LCD_SEG_L1_3;
break;
case LCD_SEG_L1_2_0:
length=3;
char_start=LCD_SEG_L1_2;
break;
case LCD_SEG_L1_1_0:
length=2;
char_start=LCD_SEG_L1_1;
break;
case LCD_SEG_L1_3_1:
length=3;
char_start=LCD_SEG_L1_3;
break;
case LCD_SEG_L1_3_2:
length=2;
char_start=LCD_SEG_L1_3;
break;
// LINE2
case LCD_SEG_L2_5_0: length=6; char_start=LCD_SEG_L2_5; break;
case LCD_SEG_L2_4_0: length=5; char_start=LCD_SEG_L2_4; break;
case LCD_SEG_L2_3_0: length=4; char_start=LCD_SEG_L2_3; break;
case LCD_SEG_L2_2_0: length=3; char_start=LCD_SEG_L2_2; break;
case LCD_SEG_L2_1_0: length=2; char_start=LCD_SEG_L2_1; break;
case LCD_SEG_L2_5_4: length=2; char_start=LCD_SEG_L2_5; break;
case LCD_SEG_L2_5_2: length=4; char_start=LCD_SEG_L2_5; break;
case LCD_SEG_L2_3_2: length=2; char_start=LCD_SEG_L2_3; break;
case LCD_SEG_L2_4_2: length=3; char_start=LCD_SEG_L2_4; break;
/* LINE2 */
case LCD_SEG_L2_5_0:
length=6;
char_start=LCD_SEG_L2_5;
break;
case LCD_SEG_L2_4_0:
length=5;
char_start=LCD_SEG_L2_4;
break;
case LCD_SEG_L2_3_0:
length=4;
char_start=LCD_SEG_L2_3;
break;
case LCD_SEG_L2_2_0:
length=3;
char_start=LCD_SEG_L2_2;
break;
case LCD_SEG_L2_1_0:
length=2;
char_start=LCD_SEG_L2_1;
break;
case LCD_SEG_L2_5_4:
length=2;
char_start=LCD_SEG_L2_5;
break;
case LCD_SEG_L2_5_2:
length=4;
char_start=LCD_SEG_L2_5;
break;
case LCD_SEG_L2_3_2:
length=2;
char_start=LCD_SEG_L2_3;
break;
case LCD_SEG_L2_4_2:
length=3;
char_start=LCD_SEG_L2_4;
break;
}
// Write to consecutive digits
for(i=0; i<length; i++)
{
// Use single character routine to write display memory
/* Write to consecutive digits */
for(i=0; i<length; i++) {
/* Use single character routine to write display memory */
display_char(char_start+i, *(str+i), mode);
}
}
// *************************************************************************************************
// @fn switch_seg
// @brief Returns index of 7-segment character. Required for display routines that can draw
// information on both lines.
// @param uint8_t line LINE1, LINE2
// uint8_t index1 Index of LINE1
// uint8_t index2 Index of LINE2
// @return uint8
// *************************************************************************************************
uint8_t switch_seg(uint8_t line, uint8_t index1, uint8_t index2)
{
if (line == LINE1)
{
uint8_t switch_seg(uint8_t line, uint8_t index1, uint8_t index2) {
if (line == LINE1) {
return index1;
}
else // line == LINE2
{
/* line == LINE2 */
else {
return index2;
}
}
// *************************************************************************************************
// @fn start_blink
// @brief Start blinking.
// @param none
// @return none
// *************************************************************************************************
void start_blink(void)
{
void start_blink(void) {
LCDBBLKCTL |= LCDBLKMOD0;
}
// *************************************************************************************************
// @fn stop_blink
// @brief Stop blinking.
// @param none
// @return none
// *************************************************************************************************
void stop_blink(void)
{
void stop_blink(void) {
LCDBBLKCTL &= ~LCDBLKMOD0;
}
// *************************************************************************************************
// @fn stop_blink
// @brief Clear blinking memory.
// @param none
// @return none
// *************************************************************************************************
void clear_blink_mem(void)
{
void clear_blink_mem(void) {
LCDBMEMCTL |= LCDCLRBM;
}
// *************************************************************************************************
// @fn set_blink_rate
// @brief Set blink rate register bits.
// @param none
// @return none
// *************************************************************************************************
void set_blink_rate(uint8_t bits)
{
void set_blink_rate(uint8_t bits) {
LCDBBLKCTL &= ~(BIT7 | BIT6 | BIT5);
LCDBBLKCTL |= bits;
}
// *************************************************************************************************
// @fn display_all_off
// @brief Sets everything of on the display
// @param none
// @return none
// *************************************************************************************************
void display_all_off(void)
{
uint8_t * lcdptr = (uint8_t*)0x0A20;
void display_all_off(void) {
uint8_t *lcdptr = (uint8_t*)0x0A20;
uint8_t i;
for (i=1; i<=12; i++)
{
for (i=1; i<=12; i++) {
*lcdptr = 0x00;
lcdptr++;
}

310
board/chronos/drivers/display.h
View File

@ -1,72 +1,55 @@
// *************************************************************************************************
//
// Copyright (C) 2009 Texas Instruments Incorporated - http://www.ti.com/
//
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions
// are met:
//
// Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
//
// Redistributions in binary form must reproduce the above copyright
// notice, this list of conditions and the following disclaimer in the
// documentation and/or other materials provided with the
// distribution.
//
// Neither the name of Texas Instruments Incorporated nor the names of
// its contributors may be used to endorse or promote products derived
// from this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
// *************************************************************************************************
/* *************************************************************************************************
*
* Copyright (C) 2009 Texas Instruments Incorporated - http://www.ti.com/
*
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the
* distribution.
*
* Neither the name of Texas Instruments Incorporated nor the names of
* its contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
* *************************************************************************************************
* Basic display functions.
* ************************************************************************************************/
#ifndef __DISPLAY_H
#define __DISPLAY_H
// *************************************************************************************************
// Include section
/*
* Set some options at compile time for how the time is displayed
* The options are, in order of code space used-
* OPTION_TIME_DISPLAY == CLOCK_24HR
* OPTION_TIME_DISPLAY == CLOCK_AM_PM
* OPTION_TIME_DISPLAY == CLOCK_DISPLAY_SELECT
*/
#define CLOCK_24HR 0
#define CLOCK_AM_PM 1
#define CLOCK_DISPLAY_SELECT 2
#define CLOCK_24HR (0)
#define CLOCK_AM_PM (1)
#define CLOCK_DISPLAY_SELECT (2)
/* *************************************************************************************************
* Global Variable section */
// *************************************************************************************************
// Extern section
// *************************************************************************************************
// Global Variable section
// Set of display flags
typedef union
{
struct
{
// Line1 + Line2 + Icons
/* Set of display flags */
typedef union {
struct {
/* Line1 + Line2 + Icons*/
uint16_t full_update : 1; // 1 = Redraw all content
uint16_t partial_update : 1; // 1 = Update changes
@ -90,7 +73,7 @@ extern volatile s_display_flags display;
// Constants defined in library
extern const uint8_t lcd_font[];
extern const uint8_t * segments_lcdmem[];
extern const uint8_t *segments_lcdmem[];
extern const uint8_t segments_bitmask[];
extern const uint8_t itoa_conversion_table[][3];
@ -127,30 +110,31 @@ extern const uint8_t itoa_conversion_table[][3];
#define SEG_F (BIT0)
#define SEG_G (BIT1)
// ------------------------------------------
// LCD symbols for easier access
//
// xxx_SEG_xxx = Seven-segment character (sequence 5-4-3-2-1-0)
// xxx_SYMB_xxx = Display symbol, e.g. "AM" for ante meridiem
// xxx_UNIT_xxx = Display unit, e.g. "km/h" for kilometers per hour
// xxx_ICON_xxx = Display icon, e.g. heart to indicate reception of heart rate data
// xxx_L1_xxx = Item is part of Line1 information
// xxx_L2_xxx = Item is part of Line2 information
/* ------------------------------------------
* LCD symbols for easier access
*
* xxx_SEG_xxx = Seven-segment character (sequence 5-4-3-2-1-0)
* xxx_SYMB_xxx = Display symbol, e.g. "AM" for ante meridiem
* xxx_UNIT_xxx = Display unit, e.g. "km/h" for kilometers per hour
* xxx_ICON_xxx = Display icon, e.g. heart to indicate reception of heart rate data
* xxx_L1_xxx = Item is part of Line1 information
* xxx_L2_xxx = Item is part of Line2 information
*/
// Symbols for Line1
//* Symbols for Line1 */
#define LCD_SYMB_AM 0
#define LCD_SYMB_PM 1
#define LCD_SYMB_ARROW_UP 2
#define LCD_SYMB_ARROW_DOWN 3
#define LCD_SYMB_PERCENT 4
// Symbols for Line2
/* Symbols for Line2 */
#define LCD_SYMB_TOTAL 5
#define LCD_SYMB_AVERAGE 6
#define LCD_SYMB_MAX 7
#define LCD_SYMB_BATTERY 8
// Units for Line1
/* Units for Line1 */
#define LCD_UNIT_L1_FT 9
#define LCD_UNIT_L1_K 10
#define LCD_UNIT_L1_M 11
@ -159,12 +143,12 @@ extern const uint8_t itoa_conversion_table[][3];
#define LCD_UNIT_L1_PER_H 14
#define LCD_UNIT_L1_DEGREE 15
// Units for Line2
/* Units for Line2 */
#define LCD_UNIT_L2_KCAL 16
#define LCD_UNIT_L2_KM 17
#define LCD_UNIT_L2_MI 18
// Icons
/* Icons */
#define LCD_ICON_HEART 19
#define LCD_ICON_STOPWATCH 20
#define LCD_ICON_RECORD 21
@ -173,7 +157,7 @@ extern const uint8_t itoa_conversion_table[][3];
#define LCD_ICON_BEEPER2 24
#define LCD_ICON_BEEPER3 25
// Line1 7-segments
/* Line1 7-segments */
#define LCD_SEG_L1_3 26
#define LCD_SEG_L1_2 27
#define LCD_SEG_L1_1 28
@ -182,7 +166,7 @@ extern const uint8_t itoa_conversion_table[][3];
#define LCD_SEG_L1_DP1 31
#define LCD_SEG_L1_DP0 32
// Line2 7-segments
/* Line2 7-segments */
#define LCD_SEG_L2_5 33
#define LCD_SEG_L2_4 34
#define LCD_SEG_L2_3 35
@ -193,15 +177,14 @@ extern const uint8_t itoa_conversion_table[][3];
#define LCD_SEG_L2_COL0 40
#define LCD_SEG_L2_DP 41
// Line1 7-segment arrays
/* Line1 7-segment arrays */
#define LCD_SEG_L1_3_0 70
#define LCD_SEG_L1_2_0 71
#define LCD_SEG_L1_1_0 72
#define LCD_SEG_L1_3_1 73
#define LCD_SEG_L1_3_2 74
// Line2 7-segment arrays
/* Line2 7-segment arrays */
#define LCD_SEG_L2_5_0 90
#define LCD_SEG_L2_4_0 91
#define LCD_SEG_L2_3_0 92
@ -212,8 +195,7 @@ extern const uint8_t itoa_conversion_table[][3];
#define LCD_SEG_L2_5_4 97
#define LCD_SEG_L2_4_2 98
// LCD controller memory map
/* LCD controller memory map */
#define LCD_MEM_1 ((uint8_t*)0x0A20)
#define LCD_MEM_2 ((uint8_t*)0x0A21)
#define LCD_MEM_3 ((uint8_t*)0x0A22)
@ -227,8 +209,7 @@ extern const uint8_t itoa_conversion_table[][3];
#define LCD_MEM_11 ((uint8_t*)0x0A2A)
#define LCD_MEM_12 ((uint8_t*)0x0A2B)
// Memory assignment
/* Memory assignment */
#define LCD_SEG_L1_0_MEM (LCD_MEM_6)
#define LCD_SEG_L1_1_MEM (LCD_MEM_4)
#define LCD_SEG_L1_2_MEM (LCD_MEM_3)
@ -272,7 +253,7 @@ extern const uint8_t itoa_conversion_table[][3];
#define LCD_ICON_BEEPER2_MEM (LCD_MEM_6)
#define LCD_ICON_BEEPER3_MEM (LCD_MEM_7)
// Bit masks for write access
/* Bit masks for write access */
#define LCD_SEG_L1_0_MASK (BIT2+BIT1+BIT0+BIT7+BIT6+BIT5+BIT4)
#define LCD_SEG_L1_1_MASK (BIT2+BIT1+BIT0+BIT7+BIT6+BIT5+BIT4)
#define LCD_SEG_L1_2_MASK (BIT2+BIT1+BIT0+BIT7+BIT6+BIT5+BIT4)
@ -317,44 +298,161 @@ extern const uint8_t itoa_conversion_table[][3];
#define LCD_ICON_BEEPER3_MASK (BIT3)
/* *************************************************************************************************
* API section
*/
// *************************************************************************************************
// API section
/* Physical LCD memory write */
/* *************************************************************************************************
* @fn write_segment
* @brief Write to one or multiple LCD segments
* @param lcdmem Pointer to LCD byte memory
* bits Segments to address
* bitmask Bitmask for particular display item
* mode On, off or blink segments
* @return
* ************************************************************************************************/
void write_lcd_mem(uint8_t *lcdmem, uint8_t bits, uint8_t bitmask, uint8_t state);
// Physical LCD memory write
void write_lcd_mem(uint8_t * lcdmem, uint8_t bits, uint8_t bitmask, uint8_t state);
// Display init / clear
/* Display init / clear */
/* *************************************************************************************************
* @fn lcd_init
* @brief Erase LCD memory. Init LCD peripheral.
* @param none
* @return none
* ************************************************************************************************/
void lcd_init(void);
/* *************************************************************************************************
* @fn clear_display
* @brief Erase LINE1 and LINE2 segments. Keep icons.
* @param none
* @return none
* ************************************************************************************************/
void clear_display(void);
/* *************************************************************************************************
* @fn clear_display_all
* @brief Erase LINE1 and LINE2 segments. Clear also function-specific content.
* @param none
* @return none
* ************************************************************************************************/
void clear_display_all(void);
/* *************************************************************************************************
* @fn clear_line
* @brief Erase segments of a given line.
* @param uint8_t line LINE1, LINE2
* @return none
* ************************************************************************************************/
void clear_line(uint8_t line);
// Blinking function
/* Blinking function */
/* *************************************************************************************************
* @fn start_blink
* @brief Start blinking.
* @param none
* @return none
* ************************************************************************************************/
void start_blink(void);
/* *************************************************************************************************
* @fn stop_blink
* @brief Stop blinking.
* @param none
* @return none
* ************************************************************************************************/
void stop_blink(void);
/* *************************************************************************************************
* @fn stop_blink
* @brief Clear blinking memory.
* @param none
* @return none
* ************************************************************************************************/
void clear_blink_mem(void);
/* *************************************************************************************************
* @fn set_blink_rate
* @brief Set blink rate register bits.
* @param none
* @return none
* ************************************************************************************************/
void set_blink_rate(uint8_t bits);
// Character / symbol draw functions
/* Character / symbol draw functions */
/* *************************************************************************************************
* @fn display_char
* @brief Write to 7-segment characters.
* @param uint8_t segment A valid LCD segment
* uint8_t chr Character to display
* uint8_t mode SEG_ON, SEG_OFF, SEG_BLINK
* @return none
* ************************************************************************************************/
void display_char(uint8_t segment, char chr, uint8_t mode);
void display_chars(uint8_t segments, char* str, uint8_t mode);
/* *************************************************************************************************
* @FN display_chars
* @brief Write to consecutive 7-segment characters.
* @param uint8_t segments LCD segment array
* uint8_t * str Pointer to a string
* uint8_t mode SEG_ON, SEG_OFF, SEG_BLINK
* @return none
* ************************************************************************************************/
void display_chars(uint8_t segments, char *str, uint8_t mode);
/* *************************************************************************************************
* @fn display_symbol
* @brief Switch symbol on or off on LCD.
* @param uint8_t symbol A valid LCD symbol (index 0..42)
* uint8_t state SEG_ON, SEG_OFF, SEG_BLINK
* @return none
* ************************************************************************************************/
void display_symbol(uint8_t symbol, uint8_t mode);
// Time display function
void DisplayTime(uint8_t updateMode);
void display_am_pm_symbol(uint8_t timeAM);
// Set_value display functions
/* Set_value display functions */
/* *************************************************************************************************
* @fn display_value1
* @brief Generic decimal display routine. Used exclusively by set_value function.
* @param uint8_t segments LCD segments where value is displayed
* uint32_t value Integer value to be displayed
* uint8_t digits Number of digits to convert
* uint8_t blanks Number of leadings blanks in itoa result string
* @return none
* ************************************************************************************************/
void display_value1(uint8_t segments, uint32_t value, uint8_t digits, uint8_t blanks, uint8_t disp_mode);
void display_hours_12_or_24(uint8_t segments, uint32_t value, uint8_t digits, uint8_t blanks, uint8_t disp_mode);
// Integer to string conversion
uint8_t * itoa(uint32_t n, uint8_t digits, uint8_t blanks);
/* Integer to string conversion */
/* *************************************************************************************************
* @fn itoa
* @brief Generic integer to array routine. Converts integer n to string.
* Default conversion result has leading zeros, e.g. "00123"
* Option to convert leading '0' into whitespace (blanks)
* @param uint32_t n integer to convert
* uint8_t digits number of digits
* uint8_t blanks fill up result string with number of whitespaces instead of leading zeros
* @return uint8_t string
* ************************************************************************************************/
char *itoa(uint32_t n, uint8_t digits, uint8_t blanks);
// Segment index helper function
/* Segment index helper function */
/* *************************************************************************************************
* @fn switch_seg
* @brief Returns index of 7-segment character. Required for display routines that can draw
* information on both lines.
* @param uint8_t line LINE1, LINE2
* uint8_t index1 Index of LINE1
* uint8_t index2 Index of LINE2
* @return uint8
* ************************************************************************************************/
uint8_t switch_seg(uint8_t line, uint8_t index1, uint8_t index2);
/* *************************************************************************************************
* @fn display_all_off
* @brief Sets everything of on the display
* @param none
* @return none
* ************************************************************************************************/
void display_all_off(void);
#endif // __DISPLAY_
#endif /* __DISPLAY_ */

219
board/chronos/drivers/display1.c
View File

@ -1,119 +1,103 @@
// *************************************************************************************************
//
// Copyright (C) 2009 Texas Instruments Incorporated - http://www.ti.com/
//
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions
// are met:
//
// Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
//
// Redistributions in binary form must reproduce the above copyright
// notice, this list of conditions and the following disclaimer in the
// documentation and/or other materials provided with the
// distribution.
//
// Neither the name of Texas Instruments Incorporated nor the names of
// its contributors may be used to endorse or promote products derived
// from this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
// *************************************************************************************************
// Basic display functions.
// *************************************************************************************************
/* *************************************************************************************************
*
* Copyright (C) 2009 Texas Instruments Incorporated - http://www.ti.com/
*
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the
* distribution.
*
* Neither the name of Texas Instruments Incorporated nor the names of
* its contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
* ************************************************************************************************/
/* Basic display functions. */
/* ************************************************************************************************* */
// *************************************************************************************************
// Include section
#include "cc430x613x.h"
/* ************************************************************************************************* */
/* Include section */
#include <cc430x613x.h>
#include <display.h>
/* ************************************************************************************************* */
/* Global Variable section */
// driver
#include "display.h"
// *************************************************************************************************
// Prototypes section
// *************************************************************************************************
// Defines section
// *************************************************************************************************
// Global Variable section
// Table with memory bit assignment for digits "0" to "9" and characters "A" to "Z"
// A
// F B
// G
// E C
// D
const uint8_t lcd_font[] =
{
SEG_A+SEG_B+SEG_C+SEG_D+SEG_E+SEG_F, // Displays "0"
SEG_B+SEG_C, // Displays "1"
SEG_A+SEG_B+ SEG_D+SEG_E+ SEG_G, // Displays "2"
SEG_A+SEG_B+SEG_C+SEG_D+ SEG_G, // Displays "3"
SEG_B+SEG_C+ SEG_F+SEG_G, // Displays "4"
SEG_A+ SEG_C+SEG_D+ SEG_F+SEG_G, // Displays "5"
SEG_A+ SEG_C+SEG_D+SEG_E+SEG_F+SEG_G, // Displays "6"
SEG_A+SEG_B+SEG_C, // Displays "7"
SEG_A+SEG_B+SEG_C+SEG_D+SEG_E+SEG_F+SEG_G, // Displays "8"
SEG_A+SEG_B+SEG_C+SEG_D+ SEG_F+SEG_G, // Displays "9"
0 , // Displays " " (:)
0 , // Displays " " (;)
SEG_A+ SEG_F+SEG_G, // Displays "<" as high c
SEG_D+ SEG_G, // Displays "="
0 , // Displays " " (>)
SEG_A+SEG_B+ SEG_E+ SEG_G, // Displays "?"
0 , // Displays " " (@)
SEG_A+SEG_B+SEG_C+ SEG_E+SEG_F+SEG_G, // Displays "A"
SEG_C+SEG_D+SEG_E+SEG_F+SEG_G, // Displays "b"
SEG_D+SEG_E+ SEG_G, // Displays "c"
SEG_B+SEG_C+SEG_D+SEG_E+ SEG_G, // Displays "d"
SEG_A+ +SEG_D+SEG_E+SEG_F+SEG_G, // Displays "E"
SEG_A+ SEG_E+SEG_F+SEG_G, // Displays "f"
SEG_A+SEG_B+SEG_C+SEG_D+ SEG_F+SEG_G, // Displays "g" same as 9
SEG_C+ SEG_E+SEG_F+SEG_G, // Displays "h"
SEG_E , // Displays "i"
SEG_A+SEG_B+SEG_C+SEG_D , // Displays "J"
SEG_D+ SEG_F+SEG_G, // Displays "k"
SEG_D+SEG_E+SEG_F , // Displays "L"
SEG_A+SEG_B+SEG_C+ SEG_E+SEG_F , // Displays "M"
SEG_C+ SEG_E+ SEG_G, // Displays "n"
SEG_C+SEG_D+SEG_E+ SEG_G, // Displays "o"
SEG_A+SEG_B+ SEG_E+SEG_F+SEG_G, // Displays "P"
SEG_A+SEG_B+SEG_C+ SEG_F+SEG_G, // Displays "q"
SEG_E+ SEG_G, // Displays "r"
SEG_A+ SEG_C+SEG_D+ SEG_F+SEG_G, // Displays "S" same as 5
SEG_D+SEG_E+SEG_F+SEG_G, // Displays "t"
SEG_C+SEG_D+SEG_E , // Displays "u"
SEG_C+SEG_D+SEG_E , // Displays "v" same as u
SEG_B+SEG_C+SEG_D+SEG_E+SEG_F+SEG_G, // Displays "W"
SEG_B+SEG_C+ +SEG_E+SEG_F+SEG_G, // Displays "X" as H
SEG_B+SEG_C+SEG_D+ SEG_F+SEG_G, // Displays "Y"
SEG_A+SEG_B+ SEG_D+SEG_E+ SEG_G, // Displays "Z" same as 2
/* Table with memory bit assignment for digits "0" to "9" and characters "A" to "Z" */
/* A */
/* F B */
/* G */
/* E C */
/* D */
const uint8_t lcd_font[] = {
SEG_A+SEG_B+SEG_C+SEG_D+SEG_E+SEG_F, /* Displays "0" */
SEG_B+SEG_C, /* Displays "1" */
SEG_A+SEG_B+ SEG_D+SEG_E+ SEG_G, /* Displays "2" */
SEG_A+SEG_B+SEG_C+SEG_D+ SEG_G, /* Displays "3" */
SEG_B+SEG_C+ SEG_F+SEG_G, /* Displays "4" */
SEG_A+ SEG_C+SEG_D+ SEG_F+SEG_G, /* Displays "5" */
SEG_A+ SEG_C+SEG_D+SEG_E+SEG_F+SEG_G, /* Displays "6" */
SEG_A+SEG_B+SEG_C, /* Displays "7" */
SEG_A+SEG_B+SEG_C+SEG_D+SEG_E+SEG_F+SEG_G, /* Displays "8" */
SEG_A+SEG_B+SEG_C+SEG_D+ SEG_F+SEG_G, /* Displays "9" */
0 , /* Displays " " (:) */
0 , /* Displays " " (;) */
SEG_A+ SEG_F+SEG_G, /* Displays "<" as high c */
SEG_D+ SEG_G, /* Displays "=" */
0 , /* Displays " " (>) */
SEG_A+SEG_B+ SEG_E+ SEG_G, /* Displays "?" */
0 , /* Displays " " (@) */
SEG_A+SEG_B+SEG_C+ SEG_E+SEG_F+SEG_G, /* Displays "A" */
SEG_C+SEG_D+SEG_E+SEG_F+SEG_G, /* Displays "b" */
SEG_D+SEG_E+ SEG_G, /* Displays "c" */
SEG_B+SEG_C+SEG_D+SEG_E+ SEG_G, /* Displays "d" */
SEG_A+ +SEG_D+SEG_E+SEG_F+SEG_G, /* Displays "E" */
SEG_A+ SEG_E+SEG_F+SEG_G, /* Displays "f" */
SEG_A+SEG_B+SEG_C+SEG_D+ SEG_F+SEG_G, /* Displays "g" same as 9 */
SEG_C+ SEG_E+SEG_F+SEG_G, /* Displays "h" */
SEG_E , /* Displays "i" */
SEG_A+SEG_B+SEG_C+SEG_D , /* Displays "J" */
SEG_D+ SEG_F+SEG_G, /* Displays "k" */
SEG_D+SEG_E+SEG_F , /* Displays "L" */
SEG_A+SEG_B+SEG_C+ SEG_E+SEG_F , /* Displays "M" */
SEG_C+ SEG_E+ SEG_G, /* Displays "n" */
SEG_C+SEG_D+SEG_E+ SEG_G, /* Displays "o" */
SEG_A+SEG_B+ SEG_E+SEG_F+SEG_G, /* Displays "P" */
SEG_A+SEG_B+SEG_C+ SEG_F+SEG_G, /* Displays "q" */
SEG_E+ SEG_G, /* Displays "r" */
SEG_A+ SEG_C+SEG_D+ SEG_F+SEG_G, /* Displays "S" same as 5 */
SEG_D+SEG_E+SEG_F+SEG_G, /* Displays "t" */
SEG_C+SEG_D+SEG_E , /* Displays "u" */
SEG_C+SEG_D+SEG_E , /* Displays "v" same as u */
SEG_B+SEG_C+SEG_D+SEG_E+SEG_F+SEG_G, /* Displays "W" */
SEG_B+SEG_C+ +SEG_E+SEG_F+SEG_G, /* Displays "X" as H */
SEG_B+SEG_C+SEG_D+ SEG_F+SEG_G, /* Displays "Y" */
SEG_A+SEG_B+ SEG_D+SEG_E+ SEG_G, /* Displays "Z" same as 2 */
};
// Table with memory address for each display element
const uint8_t * segments_lcdmem[] =
{
/* Table with memory address for each display element */
const uint8_t * segments_lcdmem[] = {
LCD_SYMB_AM_MEM,
LCD_SYMB_PM_MEM,
LCD_SYMB_ARROW_UP_MEM,
@ -158,10 +142,8 @@ const uint8_t * segments_lcdmem[] =
LCD_SEG_L2_DP_MEM,
};
// Table with bit mask for each display element
const uint8_t segments_bitmask[] =
{
/* Table with bit mask for each display element */
const uint8_t segments_bitmask[] = {
LCD_SYMB_AM_MASK,
LCD_SYMB_PM_MASK,
LCD_SYMB_ARROW_UP_MASK,
@ -206,10 +188,10 @@ const uint8_t segments_bitmask[] =
LCD_SEG_L2_DP_MASK,
};
// Quick integer to array conversion table for most common integer values
const uint8_t itoa_conversion_table[][3] =
{
/* Quick integer to array conversion table for most common integer values
* discarding this would save aprox. 600 bytes codespace but increase cpu time
* for displaying values */
const uint8_t itoa_conversion_table[][3] = {
"000", "001", "002", "003", "004", "005", "006", "007", "008", "009", "010", "011", "012", "013", "014", "015",
"016", "017", "018", "019", "020", "021", "022", "023", "024", "025", "026", "027", "028", "029", "030", "031",
"032", "033", "034", "035", "036", "037", "038", "039", "040", "041", "042", "043", "044", "045", "046", "047",
@ -223,4 +205,3 @@ const uint8_t itoa_conversion_table[][3] =
"160", "161", "162", "163", "164", "165", "166", "167", "168", "169", "170", "171", "172", "173", "174", "175",
"176", "177", "178", "179", "180",
};

2
drivers/cc110x_ng/Jamfile
View File

@ -27,7 +27,7 @@
SubDir TOP drivers cc110x_ng ;
HDRS += $(TOP)/drivers/cc110x_ng ;
HDRS += $(TOP)/drivers/cc110x_ng/include ;
Module cc110x_ng : cc110x.c cc110x-rx.c cc110x-tx.c cc110x-defaultSettings.c : hwtimer board_cc110x ;
Module cc110x_spi : cc110x_spi.c ;