RIOT-OS/RIOT
RIOT-OS/RIOT
1
0
Fork 0
mirror of https://github.com/RIOT-OS/RIOT.git synced 2024-12-29 04:50:03 +01:00
Code Releases Activity

branch merge

Browse Source
This commit is contained in:
Stephan Zeisberg 2010-12-13 11:21:22 +01:00
commit fdc7b764a3
93 changed files with 1540 additions and 1803 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
eZ430-Chronos/Jamfile → chronos/Jamfile
View File

@ -1,4 +1,4 @@
SubDir TOP board eZ430-Chronos ;
SubDir TOP board chronos ;
HDRS += $(TOP)/board/$(CPU)/include ;

4
eZ430-Chronos/Jamrules.eZ430-Chronos → chronos/Jamrules.chronos
View File

@ -3,8 +3,8 @@
# ******************************************************************************
# $Id$
BOARD = eZ430-Chronos ;
CPU = msp430 ;
BOARD = chronos ;
CPU = cc430 ;
MCU = cc430x6137 ;
FLASHER ?= mspdebug ;

74
chronos/board_init.c Normal file
View File

@ -0,0 +1,74 @@
#include <stdint.h>
#include <board.h>
#include <cpu.h>
#include <irq.h>
void cc430_cpu_init(void) {
volatile uint16_t i;
volatile unsigned char *ptr;
/* disable watchdog */
WDTCTL = WDTPW + WDTHOLD;
// ---------------------------------------------------------------------
// Enable 32kHz ACLK
P5SEL |= 0x03; // Select XIN, XOUT on P5.0 and P5.1
UCSCTL6 &= ~XT1OFF; // XT1 On, Highest drive strength
UCSCTL6 |= XCAP_3; // Internal load cap
UCSCTL3 = SELA__XT1CLK; // Select XT1 as FLL reference
UCSCTL4 = SELA__XT1CLK | SELS__DCOCLKDIV | SELM__DCOCLKDIV;
// ---------------------------------------------------------------------
// Configure CPU clock for 12MHz
_BIS_SR(SCG0); // Disable the FLL control loop
UCSCTL0 = 0x0000; // Set lowest possible DCOx, MODx
UCSCTL1 = DCORSEL_5; // Select suitable range
UCSCTL2 = FLLD_1 + 0x16E; // Set DCO Multiplier
_BIC_SR(SCG0); // Enable the FLL control loop
// Worst-case settling time for the DCO when the DCO range bits have been
// changed is n x 32 x 32 x f_MCLK / f_FLL_reference. See UCS chapter in 5xx
// UG for optimization.
// 32 x 32 x 8 MHz / 32,768 Hz = 250000 = MCLK cycles for DCO to settle
for (i = 0xFF; i > 0; i--); // Time for flag to set
// Loop until XT1 & DCO stabilizes, use do-while to insure that
// body is executed at least once
do
{
UCSCTL7 &= ~(XT2OFFG + XT1LFOFFG + XT1HFOFFG + DCOFFG);
SFRIFG1 &= ~OFIFG; // Clear fault flags
} while ((SFRIFG1 & OFIFG));
// Disable all interrupts
__disable_interrupt();
// Get write-access to port mapping registers:
PMAPPWD = 0x02D52;
// Allow reconfiguration during runtime:
PMAPCTL = PMAPRECFG;
// P2.7 = TA0CCR1A or TA1CCR0A output (buzzer output)
ptr = &P2MAP0;
*(ptr+7) = PM_TA1CCR0A;
P2OUT &= ~BIT7;
P2DIR |= BIT7;
// P1.5 = SPI MISO input
ptr = &P1MAP0;
*(ptr+5) = PM_UCA0SOMI;
// P1.6 = SPI MOSI output
*(ptr+6) = PM_UCA0SIMO;
// P1.7 = SPI CLK output
*(ptr+7) = PM_UCA0CLK;
// Disable write-access to port mapping registers:
PMAPPWD = 0;
// Re-enable all interrupts
enableIRQ();
}
void board_init() {
cc430_cpu_init();
}

0
eZ430-Chronos/debug_uart.c → chronos/debug_uart.c
View File

4
chronos/drivers/Jamfile Normal file
View File

@ -0,0 +1,4 @@
SubDir TOP board chronos drivers ;
Module board_display : display.c display1.c ;
Module board_cc110x : cc430-cc110x.c : cc110x_cc430 ;

81
chronos/drivers/cc430-cc110x.c Normal file
View File

@ -0,0 +1,81 @@
#include <stdint.h>
#include <cpu.h>
#include <irq.h>
#include <cc110x_ng.h>
#include <cc110x-arch.h>
//#include <cc430_.h>
#include <cc430x613x.h>
//#include <msp430/rf1a.h>
#define CC1100_GDO0 (RF1AIN & BIT0)
#define CC1100_GDO1 (RF1AIN & BIT1)
#define CC1100_GDO2 (RF1AIN & BIT2)
int cc110x_get_gdo0(void) {
return CC1100_GDO0;
}
int cc110x_get_gdo1(void) {
return CC1100_GDO1;
}
int cc110x_get_gdo2(void) {
return CC1100_GDO2;
}
void cc110x_before_send(void)
{
// Disable GDO2 interrupt before sending packet
cc110x_gdo2_disable();
}
void cc110x_after_send(void)
{
// Enable GDO2 interrupt after sending packet
cc110x_gdo2_enable();
}
void cc110x_gdo0_enable(void) {
RF1AIFG &= ~BIT0;
RF1AIE |= BIT0;
}
void cc110x_gdo0_disable(void) {
RF1AIE &= ~BIT0;
RF1AIFG &= ~BIT0;
}
void cc110x_gdo2_disable(void) {
RF1AIFG &= ~BIT2; // Clear a pending interrupt
RF1AIE &= ~BIT2; // Disable the interrupt
}
void cc110x_gdo2_enable(void) {
RF1AIFG &= ~BIT2; // Clear a pending interrupt
RF1AIE |= BIT2; // Enable the interrupt
}
void cc110x_init_interrupts(void) {
uint8_t state = disableIRQ(); /* Disable all interrupts */
cc110x_gdo2_enable();
cc110x_gdo0_disable();
restoreIRQ(state); /* Enable all interrupts */
}
interrupt (CC1101_VECTOR) __attribute__ ((naked)) cc110x_isr(void){
__enter_isr();
/* Check IFG */
if (RF1AIV == RF1AIV_RFIFG2) {
while (RF1AIN & BIT2);
/* discard all further interrupts */
RF1AIV = 0;
cc110x_gdo2_irq();
}
if (RF1AIV == RF1AIV_RFIFG0) {
cc110x_gdo0_irq();
RF1AIE &= ~BIT0;
}
__exit_isr();
}

383
chronos/drivers/display.c Normal file
View File

@ -0,0 +1,383 @@
/* *************************************************************************************************
*
* 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
*/
/* system */
#include <string.h>
/* driver */
#include <cc430x613x.h>
#include <display.h>
/**************************************************************************************************
* 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);
/* *************************************************************************************************
* Global Variable section */
/* Display flags */
volatile s_display_flags display;
/* Global return string for itoa function */
char itoa_str[8];
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 */
LCDBCTL0 = (LCDDIV0 + LCDDIV1 + LCDDIV2 + LCDDIV3) | (LCDPRE0 + LCDPRE1) | LCD4MUX | LCDON;
/* LCB_BLK_FREQ = ACLK/8/4096 = 1Hz */
LCDBBLKCTL = LCDBLKPRE0 | LCDBLKPRE1 | LCDBLKDIV0 | LCDBLKDIV1 | LCDBLKDIV2 | LCDBLKMOD0;
/* 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 */
#ifdef USE_LCD_CHARGE_PUMP
/* Charge pump voltage generated internally, internal bias (V2-V4) generation */
LCDBVCTL = LCDCPEN | VLCD_2_72;
#endif
}
void clear_display_all(void) {
// Clear generic content
clear_line(LINE1);
clear_line(LINE2);
}
void clear_display(void) {
clear_line(LINE1);
clear_line(LINE2);
}
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) {
display_symbol(LCD_SEG_L1_DP1, SEG_OFF);
display_symbol(LCD_SEG_L1_DP0, SEG_OFF);
display_symbol(LCD_SEG_L1_COL, SEG_OFF);
}
/* 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);
}
}
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 */
*lcdmem = (uint8_t)(*lcdmem | bits);
}
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 */
*lcdmem = (uint8_t)(*lcdmem & ~bitmask);
*(lcdmem+0x20) = (uint8_t)(*(lcdmem+0x20) & ~bitmask);
/* 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 */
*lcdmem = (uint8_t)(*lcdmem & ~bitmask);
/* Set visible segments */
*lcdmem = (uint8_t)(*lcdmem | bits);
/* Clear blink segments */
*(lcdmem+0x20) = (uint8_t)(*(lcdmem+0x20) & ~bitmask);
}
else if (state == SEG_OFF_BLINK_OFF) {
/* Clear segments */
*lcdmem = (uint8_t)(*lcdmem & ~bitmask);
/* Clear blink segments */
*(lcdmem+0x20) = (uint8_t)(*(lcdmem+0x20) & ~bitmask);
}
}
char *itoa(uint32_t n, uint8_t digits, uint8_t blanks) {
uint8_t i;
uint8_t digits1 = digits;
/* 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);
}
/* 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);
}
/* digits == 1 || 2 */
else {
memcpy(itoa_str, itoa_conversion_table[n]+(3-digits), digits);
}
}
/* 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 */
i = 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);
}
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, str, disp_mode);
}
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];
/* Get bits for symbol from table */
bits = segments_bitmask[symbol];
/* Bitmask for symbols equals bits */
bitmask = bits;
/* Write LCD memory */
write_lcd_mem(lcdmem, bits, bitmask, mode);
}
}
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];
/* Get bitmask for character from table */
bitmask = segments_bitmask[segment];
/* 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 */
bits = BIT1;
}
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) {
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) {
if ((chr == '1') || (chr == 'L')) bits = BIT7;
}
}
/* Physically write to LCD memory */
write_lcd_mem(lcdmem, bits, bitmask, mode);
}
}
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 */
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;
}
/* 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);
}
}
uint8_t switch_seg(uint8_t line, uint8_t index1, uint8_t index2) {
if (line == LINE1) {
return index1;
}
/* line == LINE2 */
else {
return index2;
}
}
void start_blink(void) {
LCDBBLKCTL |= LCDBLKMOD0;
}
void stop_blink(void) {
LCDBBLKCTL &= ~LCDBLKMOD0;
}
void clear_blink_mem(void) {
LCDBMEMCTL |= LCDCLRBM;
}
void set_blink_rate(uint8_t bits) {
LCDBBLKCTL &= ~(BIT7 | BIT6 | BIT5);
LCDBBLKCTL |= bits;
}
void display_all_off(void) {
uint8_t *lcdptr = (uint8_t*)0x0A20;
uint8_t i;
for (i=1; i<=12; i++) {
*lcdptr = 0x00;
lcdptr++;
}
}

458
chronos/drivers/display.h Normal file
View File

@ -0,0 +1,458 @@
/* *************************************************************************************************
*
* 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
#define CLOCK_24HR (0)
#define CLOCK_AM_PM (1)
#define CLOCK_DISPLAY_SELECT (2)
/* *************************************************************************************************
* Global Variable section */
/* 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
// Line only
uint16_t line1_full_update : 1; // 1 = Redraw Line1 content
uint16_t line2_full_update : 1; // 1 = Redraw Line2 content
// Logic module data update flags
uint16_t update_time : 1; // 1 = Time was updated
uint16_t update_stopwatch : 1; // 1 = Stopwatch was updated
uint16_t update_temperature : 1; // 1 = Temperature was updated
uint16_t update_battery_voltage : 1; // 1 = Battery voltage was updated
uint16_t update_date : 1; // 1 = Date was updated
uint16_t update_alarm : 1; // 1 = Alarm time was updated
uint16_t update_acceleration : 1; // 1 = Acceleration data was updated
} flag;
uint16_t all_flags; // Shortcut to all display flags (for reset)
} s_display_flags;
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_bitmask[];
extern const uint8_t itoa_conversion_table[][3];
// *************************************************************************************************
// Defines section
// Display function modes
#define DISPLAY_LINE_UPDATE_FULL (BIT0)
#define DISPLAY_LINE_UPDATE_PARTIAL (BIT1)
#define DISPLAY_LINE_CLEAR (BIT2)
// Definitions for line view style
#define DISPLAY_DEFAULT_VIEW (0u)
#define DISPLAY_ALTERNATIVE_VIEW (1u)
#define DISPLAY_ALTERNATIVE2_VIEW (2u)
// Definitions for line access
#define LINE1 (1u)
#define LINE2 (2u)
// LCD display modes
#define SEG_OFF (0u)
#define SEG_ON (1u)
#define SEG_ON_BLINK_ON (2u)
#define SEG_ON_BLINK_OFF (3u)
#define SEG_OFF_BLINK_OFF (4u)
// 7-segment character bit assignments
#define SEG_A (BIT4)
#define SEG_B (BIT5)
#define SEG_C (BIT6)
#define SEG_D (BIT7)
#define SEG_E (BIT2)
#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
*/
//* 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 */
#define LCD_SYMB_TOTAL 5
#define LCD_SYMB_AVERAGE 6
#define LCD_SYMB_MAX 7
#define LCD_SYMB_BATTERY 8
/* Units for Line1 */
#define LCD_UNIT_L1_FT 9
#define LCD_UNIT_L1_K 10
#define LCD_UNIT_L1_M 11
#define LCD_UNIT_L1_I 12
#define LCD_UNIT_L1_PER_S 13
#define LCD_UNIT_L1_PER_H 14
#define LCD_UNIT_L1_DEGREE 15
/* Units for Line2 */
#define LCD_UNIT_L2_KCAL 16
#define LCD_UNIT_L2_KM 17
#define LCD_UNIT_L2_MI 18
/* Icons */
#define LCD_ICON_HEART 19
#define LCD_ICON_STOPWATCH 20
#define LCD_ICON_RECORD 21
#define LCD_ICON_ALARM 22
#define LCD_ICON_BEEPER1 23
#define LCD_ICON_BEEPER2 24
#define LCD_ICON_BEEPER3 25
/* Line1 7-segments */
#define LCD_SEG_L1_3 26
#define LCD_SEG_L1_2 27
#define LCD_SEG_L1_1 28
#define LCD_SEG_L1_0 29
#define LCD_SEG_L1_COL 30
#define LCD_SEG_L1_DP1 31
#define LCD_SEG_L1_DP0 32
/* Line2 7-segments */
#define LCD_SEG_L2_5 33
#define LCD_SEG_L2_4 34
#define LCD_SEG_L2_3 35
#define LCD_SEG_L2_2 36
#define LCD_SEG_L2_1 37
#define LCD_SEG_L2_0 38
#define LCD_SEG_L2_COL1 39
#define LCD_SEG_L2_COL0 40
#define LCD_SEG_L2_DP 41
/* 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 */
#define LCD_SEG_L2_5_0 90
#define LCD_SEG_L2_4_0 91
#define LCD_SEG_L2_3_0 92
#define LCD_SEG_L2_2_0 93
#define LCD_SEG_L2_1_0 94
#define LCD_SEG_L2_5_2 95
#define LCD_SEG_L2_3_2 96
#define LCD_SEG_L2_5_4 97
#define LCD_SEG_L2_4_2 98
/* 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)
#define LCD_MEM_4 ((uint8_t*)0x0A23)
#define LCD_MEM_5 ((uint8_t*)0x0A24)
#define LCD_MEM_6 ((uint8_t*)0x0A25)
#define LCD_MEM_7 ((uint8_t*)0x0A26)
#define LCD_MEM_8 ((uint8_t*)0x0A27)
#define LCD_MEM_9 ((uint8_t*)0x0A28)
#define LCD_MEM_10 ((uint8_t*)0x0A29)
#define LCD_MEM_11 ((uint8_t*)0x0A2A)
#define LCD_MEM_12 ((uint8_t*)0x0A2B)
/* 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)
#define LCD_SEG_L1_3_MEM (LCD_MEM_2)
#define LCD_SEG_L1_COL_MEM (LCD_MEM_1)
#define LCD_SEG_L1_DP1_MEM (LCD_MEM_1)
#define LCD_SEG_L1_DP0_MEM (LCD_MEM_5)
#define LCD_SEG_L2_0_MEM (LCD_MEM_8)
#define LCD_SEG_L2_1_MEM (LCD_MEM_9)
#define LCD_SEG_L2_2_MEM (LCD_MEM_10)
#define LCD_SEG_L2_3_MEM (LCD_MEM_11)
#define LCD_SEG_L2_4_MEM (LCD_MEM_12)
#define LCD_SEG_L2_5_MEM (LCD_MEM_12)
#define LCD_SEG_L2_COL1_MEM (LCD_MEM_1)
#define LCD_SEG_L2_COL0_MEM (LCD_MEM_5)
#define LCD_SEG_L2_DP_MEM (LCD_MEM_9)
#define LCD_SYMB_AM_MEM (LCD_MEM_1)
#define LCD_SYMB_PM_MEM (LCD_MEM_1)
#define LCD_SYMB_ARROW_UP_MEM (LCD_MEM_1)
#define LCD_SYMB_ARROW_DOWN_MEM (LCD_MEM_1)
#define LCD_SYMB_PERCENT_MEM (LCD_MEM_5)
#define LCD_SYMB_TOTAL_MEM (LCD_MEM_11)
#define LCD_SYMB_AVERAGE_MEM (LCD_MEM_10)
#define LCD_SYMB_MAX_MEM (LCD_MEM_8)
#define LCD_SYMB_BATTERY_MEM (LCD_MEM_7)
#define LCD_UNIT_L1_FT_MEM (LCD_MEM_5)
#define LCD_UNIT_L1_K_MEM (LCD_MEM_5)
#define LCD_UNIT_L1_M_MEM (LCD_MEM_7)
#define LCD_UNIT_L1_I_MEM (LCD_MEM_7)
#define LCD_UNIT_L1_PER_S_MEM (LCD_MEM_5)
#define LCD_UNIT_L1_PER_H_MEM (LCD_MEM_7)
#define LCD_UNIT_L1_DEGREE_MEM (LCD_MEM_5)
#define LCD_UNIT_L2_KCAL_MEM (LCD_MEM_7)
#define LCD_UNIT_L2_KM_MEM (LCD_MEM_7)
#define LCD_UNIT_L2_MI_MEM (LCD_MEM_7)
#define LCD_ICON_HEART_MEM (LCD_MEM_2)
#define LCD_ICON_STOPWATCH_MEM (LCD_MEM_3)
#define LCD_ICON_RECORD_MEM (LCD_MEM_1)
#define LCD_ICON_ALARM_MEM (LCD_MEM_4)
#define LCD_ICON_BEEPER1_MEM (LCD_MEM_5)
#define LCD_ICON_BEEPER2_MEM (LCD_MEM_6)
#define LCD_ICON_BEEPER3_MEM (LCD_MEM_7)
/* 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)
#define LCD_SEG_L1_3_MASK (BIT2+BIT1+BIT0+BIT7+BIT6+BIT5+BIT4)
#define LCD_SEG_L1_COL_MASK (BIT5)
#define LCD_SEG_L1_DP1_MASK (BIT6)
#define LCD_SEG_L1_DP0_MASK (BIT2)
#define LCD_SEG_L2_0_MASK (BIT3+BIT2+BIT1+BIT0+BIT6+BIT5+BIT4)
#define LCD_SEG_L2_1_MASK (BIT3+BIT2+BIT1+BIT0+BIT6+BIT5+BIT4)
#define LCD_SEG_L2_2_MASK (BIT3+BIT2+BIT1+BIT0+BIT6+BIT5+BIT4)
#define LCD_SEG_L2_3_MASK (BIT3+BIT2+BIT1+BIT0+BIT6+BIT5+BIT4)
#define LCD_SEG_L2_4_MASK (BIT3+BIT2+BIT1+BIT0+BIT6+BIT5+BIT4)
#define LCD_SEG_L2_5_MASK (BIT7)
#define LCD_SEG_L2_COL1_MASK (BIT4)
#define LCD_SEG_L2_COL0_MASK (BIT0)
#define LCD_SEG_L2_DP_MASK (BIT7)
#define LCD_SYMB_AM_MASK (BIT1+BIT0)
#define LCD_SYMB_PM_MASK (BIT0)
#define LCD_SYMB_ARROW_UP_MASK (BIT2)
#define LCD_SYMB_ARROW_DOWN_MASK (BIT3)
#define LCD_SYMB_PERCENT_MASK (BIT4)
#define LCD_SYMB_TOTAL_MASK (BIT7)
#define LCD_SYMB_AVERAGE_MASK (BIT7)
#define LCD_SYMB_MAX_MASK (BIT7)
#define LCD_SYMB_BATTERY_MASK (BIT7)
#define LCD_UNIT_L1_FT_MASK (BIT5)
#define LCD_UNIT_L1_K_MASK (BIT6)
#define LCD_UNIT_L1_M_MASK (BIT1)
#define LCD_UNIT_L1_I_MASK (BIT0)
#define LCD_UNIT_L1_PER_S_MASK (BIT7)
#define LCD_UNIT_L1_PER_H_MASK (BIT2)
#define LCD_UNIT_L1_DEGREE_MASK (BIT1)
#define LCD_UNIT_L2_KCAL_MASK (BIT4)
#define LCD_UNIT_L2_KM_MASK (BIT5)
#define LCD_UNIT_L2_MI_MASK (BIT6)
#define LCD_ICON_HEART_MASK (BIT3)
#define LCD_ICON_STOPWATCH_MASK (BIT3)
#define LCD_ICON_RECORD_MASK (BIT7)
#define LCD_ICON_ALARM_MASK (BIT3)
#define LCD_ICON_BEEPER1_MASK (BIT3)
#define LCD_ICON_BEEPER2_MASK (BIT3)
#define LCD_ICON_BEEPER3_MASK (BIT3)
/* *************************************************************************************************
* 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);
/* 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 */
/* *************************************************************************************************
* @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 */
/* *************************************************************************************************
* @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);
/* *************************************************************************************************
* @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);
/* 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);
/* 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 */
/* *************************************************************************************************
* @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_ */

207
chronos/drivers/display1.c Normal file
View File

@ -0,0 +1,207 @@
/* *************************************************************************************************
*
* 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 <display.h>
/* ************************************************************************************************* */
/* 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 address for each display element */
const uint8_t * segments_lcdmem[] = {
LCD_SYMB_AM_MEM,
LCD_SYMB_PM_MEM,
LCD_SYMB_ARROW_UP_MEM,
LCD_SYMB_ARROW_DOWN_MEM,
LCD_SYMB_PERCENT_MEM,
LCD_SYMB_TOTAL_MEM,
LCD_SYMB_AVERAGE_MEM,
LCD_SYMB_MAX_MEM,
LCD_SYMB_BATTERY_MEM,
LCD_UNIT_L1_FT_MEM,
LCD_UNIT_L1_K_MEM,
LCD_UNIT_L1_M_MEM,
LCD_UNIT_L1_I_MEM,
LCD_UNIT_L1_PER_S_MEM,
LCD_UNIT_L1_PER_H_MEM,
LCD_UNIT_L1_DEGREE_MEM,
LCD_UNIT_L2_KCAL_MEM,
LCD_UNIT_L2_KM_MEM,
LCD_UNIT_L2_MI_MEM,
LCD_ICON_HEART_MEM,
LCD_ICON_STOPWATCH_MEM,
LCD_ICON_RECORD_MEM,
LCD_ICON_ALARM_MEM,
LCD_ICON_BEEPER1_MEM,
LCD_ICON_BEEPER2_MEM,
LCD_ICON_BEEPER3_MEM,
LCD_SEG_L1_3_MEM,
LCD_SEG_L1_2_MEM,
LCD_SEG_L1_1_MEM,
LCD_SEG_L1_0_MEM,
LCD_SEG_L1_COL_MEM,
LCD_SEG_L1_DP1_MEM,
LCD_SEG_L1_DP0_MEM,
LCD_SEG_L2_5_MEM,
LCD_SEG_L2_4_MEM,
LCD_SEG_L2_3_MEM,
LCD_SEG_L2_2_MEM,
LCD_SEG_L2_1_MEM,
LCD_SEG_L2_0_MEM,
LCD_SEG_L2_COL1_MEM,
LCD_SEG_L2_COL0_MEM,
LCD_SEG_L2_DP_MEM,
};
/* 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,
LCD_SYMB_ARROW_DOWN_MASK,
LCD_SYMB_PERCENT_MASK,
LCD_SYMB_TOTAL_MASK,
LCD_SYMB_AVERAGE_MASK,
LCD_SYMB_MAX_MASK,
LCD_SYMB_BATTERY_MASK,
LCD_UNIT_L1_FT_MASK,
LCD_UNIT_L1_K_MASK,
LCD_UNIT_L1_M_MASK,
LCD_UNIT_L1_I_MASK,
LCD_UNIT_L1_PER_S_MASK,
LCD_UNIT_L1_PER_H_MASK,
LCD_UNIT_L1_DEGREE_MASK,
LCD_UNIT_L2_KCAL_MASK,
LCD_UNIT_L2_KM_MASK,
LCD_UNIT_L2_MI_MASK,
LCD_ICON_HEART_MASK,
LCD_ICON_STOPWATCH_MASK,
LCD_ICON_RECORD_MASK,
LCD_ICON_ALARM_MASK,
LCD_ICON_BEEPER1_MASK,
LCD_ICON_BEEPER2_MASK,
LCD_ICON_BEEPER3_MASK,
LCD_SEG_L1_3_MASK,
LCD_SEG_L1_2_MASK,
LCD_SEG_L1_1_MASK,
LCD_SEG_L1_0_MASK,
LCD_SEG_L1_COL_MASK,
LCD_SEG_L1_DP1_MASK,
LCD_SEG_L1_DP0_MASK,
LCD_SEG_L2_5_MASK,
LCD_SEG_L2_4_MASK,
LCD_SEG_L2_3_MASK,
LCD_SEG_L2_2_MASK,
LCD_SEG_L2_1_MASK,
LCD_SEG_L2_0_MASK,
LCD_SEG_L2_COL1_MASK,
LCD_SEG_L2_COL0_MASK,
LCD_SEG_L2_DP_MASK,
};
/* 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",
"048", "049", "050", "051", "052", "053", "054", "055", "056", "057", "058", "059", "060", "061", "062", "063",
"064", "065", "066", "067", "068", "069", "070", "071", "072", "073", "074", "075", "076", "077", "078", "079",
"080", "081", "082", "083", "084", "085", "086", "087", "088", "089", "090", "091", "092", "093", "094", "095",
"096", "097", "098", "099", "100", "101", "102", "103", "104", "105", "106", "107", "108", "109", "110", "111",
"112", "113", "114", "115", "116", "117", "118", "119", "120", "121", "122", "123", "124", "125", "126", "127",
"128", "129", "130", "131", "132", "133", "134", "135", "136", "137", "138", "139", "140", "141", "142", "143",
"144", "145", "146", "147", "148", "149", "150", "151", "152", "153", "154", "155", "156", "157", "158", "159",
"160", "161", "162", "163", "164", "165", "166", "167", "168", "169", "170", "171", "172", "173", "174", "175",
"176", "177", "178", "179", "180",
};

0
eZ430-Chronos/include/board.h → chronos/include/board.h
View File

2
eZ430-Chronos/board_init.c
View File

@ -1,2 +0,0 @@
void board_init() {
}

5
eZ430-Chronos/drivers/Jamfile
View File

@ -1,5 +0,0 @@
SubDir TOP board eZ430-Chronos drivers ;
UseModule board_common ;
Module board_common : display.c display1.c ;

519
eZ430-Chronos/drivers/display.c
View File

@ -1,519 +0,0 @@
// *************************************************************************************************
//
// 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.
// *************************************************************************************************
// *************************************************************************************************
// Include section
// system
#include <string.h>
// driver
#include "cc430x613x.h"
#include "display.h"
// *************************************************************************************************
// 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);
void display_char(uint8_t segment, uint8_t chr, uint8_t mode);
void display_chars(uint8_t segments, uint8_t * str, uint8_t mode);
// *************************************************************************************************
// Defines section
// *************************************************************************************************
// Global Variable section
// Display flags
volatile s_display_flags display;
// Global return string for itoa function
uint8_t 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
LCDBMEMCTL |= LCDCLRBM + LCDCLRM;
// 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
LCDBBLKCTL = LCDBLKPRE0 | LCDBLKPRE1 | LCDBLKDIV0 | LCDBLKDIV1 | LCDBLKDIV2 | LCDBLKMOD0;
// 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
#ifdef USE_LCD_CHARGE_PUMP
// 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)
{
// 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)
{
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)
{
display_chars(switch_seg(line, LCD_SEG_L1_3_0, LCD_SEG_L2_5_0), NULL, SEG_OFF);
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
{
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
*lcdmem = (uint8_t)(*lcdmem & ~bitmask);
// Set visible segments
*lcdmem = (uint8_t)(*lcdmem | bits);
}
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
*lcdmem = (uint8_t)(*lcdmem & ~bitmask);
*(lcdmem+0x20) = (uint8_t)(*(lcdmem+0x20) & ~bitmask);
// 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
*lcdmem = (uint8_t)(*lcdmem & ~bitmask);
// Set visible segments
*lcdmem = (uint8_t)(*lcdmem | bits);
// Clear blink segments
*(lcdmem+0x20) = (uint8_t)(*(lcdmem+0x20) & ~bitmask);
}
else if (state == SEG_OFF_BLINK_OFF)
{
// Clear segments
*lcdmem = (uint8_t)(*lcdmem & ~bitmask);
// 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)
{
uint8_t i;
uint8_t digits1 = digits;
// 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);
// 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
{
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
{
itoa_str[digits-1] = n % 10 + '0';
n /= 10;
} while (--digits > 0);
}
// 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'
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;
str = itoa(value, digits, blanks);
// 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;
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];
// Get bits for symbol from table
bits = segments_bitmask[symbol];
// Bitmask for symbols equals bits
bitmask = bits;
// 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, uint8_t 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];
// Get bitmask for character from table
bitmask = segments_bitmask[segment];
// 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
bits = BIT1;
}
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)
{
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)
{
if ((chr == '1') || (chr == 'L')) bits = BIT7;
}
}
// 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, uint8_t * str, uint8_t mode)
{
uint8_t i;
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;
// 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
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)
{
return index1;
}
else // line == LINE2
{
return index2;
}
}
// *************************************************************************************************
// @fn start_blink
// @brief Start blinking.
// @param none
// @return none
// *************************************************************************************************
void start_blink(void)
{
LCDBBLKCTL |= LCDBLKMOD0;
}
// *************************************************************************************************
// @fn stop_blink
// @brief Stop blinking.
// @param none
// @return none
// *************************************************************************************************
void stop_blink(void)
{
LCDBBLKCTL &= ~LCDBLKMOD0;
}
// *************************************************************************************************
// @fn stop_blink
// @brief Clear blinking memory.
// @param none
// @return none
// *************************************************************************************************
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)
{
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;
uint8_t i;
for (i=1; i<=12; i++)
{
*lcdptr = 0x00;
lcdptr++;
}
}

360
eZ430-Chronos/drivers/display.h
View File

@ -1,360 +0,0 @@
// *************************************************************************************************
//
// 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.
//
// *************************************************************************************************
#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
// *************************************************************************************************
// Extern section
// *************************************************************************************************
// Global Variable section
// 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
// Line only
uint16_t line1_full_update : 1; // 1 = Redraw Line1 content
uint16_t line2_full_update : 1; // 1 = Redraw Line2 content
// Logic module data update flags
uint16_t update_time : 1; // 1 = Time was updated
uint16_t update_stopwatch : 1; // 1 = Stopwatch was updated
uint16_t update_temperature : 1; // 1 = Temperature was updated
uint16_t update_battery_voltage : 1; // 1 = Battery voltage was updated
uint16_t update_date : 1; // 1 = Date was updated
uint16_t update_alarm : 1; // 1 = Alarm time was updated
uint16_t update_acceleration : 1; // 1 = Acceleration data was updated
} flag;
uint16_t all_flags; // Shortcut to all display flags (for reset)
} s_display_flags;
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_bitmask[];
extern const uint8_t itoa_conversion_table[][3];
// *************************************************************************************************
// Defines section
// Display function modes
#define DISPLAY_LINE_UPDATE_FULL (BIT0)
#define DISPLAY_LINE_UPDATE_PARTIAL (BIT1)
#define DISPLAY_LINE_CLEAR (BIT2)
// Definitions for line view style
#define DISPLAY_DEFAULT_VIEW (0u)
#define DISPLAY_ALTERNATIVE_VIEW (1u)
#define DISPLAY_ALTERNATIVE2_VIEW (2u)
// Definitions for line access
#define LINE1 (1u)
#define LINE2 (2u)
// LCD display modes
#define SEG_OFF (0u)
#define SEG_ON (1u)
#define SEG_ON_BLINK_ON (2u)
#define SEG_ON_BLINK_OFF (3u)
#define SEG_OFF_BLINK_OFF (4u)
// 7-segment character bit assignments
#define SEG_A (BIT4)
#define SEG_B (BIT5)
#define SEG_C (BIT6)
#define SEG_D (BIT7)
#define SEG_E (BIT2)
#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
// 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
#define LCD_SYMB_TOTAL 5
#define LCD_SYMB_AVERAGE 6
#define LCD_SYMB_MAX 7
#define LCD_SYMB_BATTERY 8
// Units for Line1
#define LCD_UNIT_L1_FT 9
#define LCD_UNIT_L1_K 10
#define LCD_UNIT_L1_M 11
#define LCD_UNIT_L1_I 12
#define LCD_UNIT_L1_PER_S 13
#define LCD_UNIT_L1_PER_H 14
#define LCD_UNIT_L1_DEGREE 15
// Units for Line2
#define LCD_UNIT_L2_KCAL 16
#define LCD_UNIT_L2_KM 17
#define LCD_UNIT_L2_MI 18
// Icons
#define LCD_ICON_HEART 19
#define LCD_ICON_STOPWATCH 20
#define LCD_ICON_RECORD 21
#define LCD_ICON_ALARM 22
#define LCD_ICON_BEEPER1 23
#define LCD_ICON_BEEPER2 24
#define LCD_ICON_BEEPER3 25
// Line1 7-segments
#define LCD_SEG_L1_3 26
#define LCD_SEG_L1_2 27
#define LCD_SEG_L1_1 28
#define LCD_SEG_L1_0 29
#define LCD_SEG_L1_COL 30
#define LCD_SEG_L1_DP1 31
#define LCD_SEG_L1_DP0 32
// Line2 7-segments
#define LCD_SEG_L2_5 33
#define LCD_SEG_L2_4 34
#define LCD_SEG_L2_3 35
#define LCD_SEG_L2_2 36
#define LCD_SEG_L2_1 37
#define LCD_SEG_L2_0 38
#define LCD_SEG_L2_COL1 39
#define LCD_SEG_L2_COL0 40
#define LCD_SEG_L2_DP 41
// 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
#define LCD_SEG_L2_5_0 90
#define LCD_SEG_L2_4_0 91
#define LCD_SEG_L2_3_0 92
#define LCD_SEG_L2_2_0 93
#define LCD_SEG_L2_1_0 94
#define LCD_SEG_L2_5_2 95
#define LCD_SEG_L2_3_2 96
#define LCD_SEG_L2_5_4 97
#define LCD_SEG_L2_4_2 98
// 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)
#define LCD_MEM_4 ((uint8_t*)0x0A23)
#define LCD_MEM_5 ((uint8_t*)0x0A24)
#define LCD_MEM_6 ((uint8_t*)0x0A25)
#define LCD_MEM_7 ((uint8_t*)0x0A26)
#define LCD_MEM_8 ((uint8_t*)0x0A27)
#define LCD_MEM_9 ((uint8_t*)0x0A28)
#define LCD_MEM_10 ((uint8_t*)0x0A29)
#define LCD_MEM_11 ((uint8_t*)0x0A2A)
#define LCD_MEM_12 ((uint8_t*)0x0A2B)
// 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)
#define LCD_SEG_L1_3_MEM (LCD_MEM_2)
#define LCD_SEG_L1_COL_MEM (LCD_MEM_1)
#define LCD_SEG_L1_DP1_MEM (LCD_MEM_1)
#define LCD_SEG_L1_DP0_MEM (LCD_MEM_5)
#define LCD_SEG_L2_0_MEM (LCD_MEM_8)
#define LCD_SEG_L2_1_MEM (LCD_MEM_9)
#define LCD_SEG_L2_2_MEM (LCD_MEM_10)
#define LCD_SEG_L2_3_MEM (LCD_MEM_11)
#define LCD_SEG_L2_4_MEM (LCD_MEM_12)
#define LCD_SEG_L2_5_MEM (LCD_MEM_12)
#define LCD_SEG_L2_COL1_MEM (LCD_MEM_1)
#define LCD_SEG_L2_COL0_MEM (LCD_MEM_5)
#define LCD_SEG_L2_DP_MEM (LCD_MEM_9)
#define LCD_SYMB_AM_MEM (LCD_MEM_1)
#define LCD_SYMB_PM_MEM (LCD_MEM_1)
#define LCD_SYMB_ARROW_UP_MEM (LCD_MEM_1)
#define LCD_SYMB_ARROW_DOWN_MEM (LCD_MEM_1)
#define LCD_SYMB_PERCENT_MEM (LCD_MEM_5)
#define LCD_SYMB_TOTAL_MEM (LCD_MEM_11)
#define LCD_SYMB_AVERAGE_MEM (LCD_MEM_10)
#define LCD_SYMB_MAX_MEM (LCD_MEM_8)
#define LCD_SYMB_BATTERY_MEM (LCD_MEM_7)
#define LCD_UNIT_L1_FT_MEM (LCD_MEM_5)
#define LCD_UNIT_L1_K_MEM (LCD_MEM_5)
#define LCD_UNIT_L1_M_MEM (LCD_MEM_7)
#define LCD_UNIT_L1_I_MEM (LCD_MEM_7)
#define LCD_UNIT_L1_PER_S_MEM (LCD_MEM_5)
#define LCD_UNIT_L1_PER_H_MEM (LCD_MEM_7)
#define LCD_UNIT_L1_DEGREE_MEM (LCD_MEM_5)
#define LCD_UNIT_L2_KCAL_MEM (LCD_MEM_7)
#define LCD_UNIT_L2_KM_MEM (LCD_MEM_7)
#define LCD_UNIT_L2_MI_MEM (LCD_MEM_7)
#define LCD_ICON_HEART_MEM (LCD_MEM_2)
#define LCD_ICON_STOPWATCH_MEM (LCD_MEM_3)
#define LCD_ICON_RECORD_MEM (LCD_MEM_1)
#define LCD_ICON_ALARM_MEM (LCD_MEM_4)
#define LCD_ICON_BEEPER1_MEM (LCD_MEM_5)
#define LCD_ICON_BEEPER2_MEM (LCD_MEM_6)
#define LCD_ICON_BEEPER3_MEM (LCD_MEM_7)
// 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)
#define LCD_SEG_L1_3_MASK (BIT2+BIT1+BIT0+BIT7+BIT6+BIT5+BIT4)
#define LCD_SEG_L1_COL_MASK (BIT5)
#define LCD_SEG_L1_DP1_MASK (BIT6)
#define LCD_SEG_L1_DP0_MASK (BIT2)
#define LCD_SEG_L2_0_MASK (BIT3+BIT2+BIT1+BIT0+BIT6+BIT5+BIT4)
#define LCD_SEG_L2_1_MASK (BIT3+BIT2+BIT1+BIT0+BIT6+BIT5+BIT4)
#define LCD_SEG_L2_2_MASK (BIT3+BIT2+BIT1+BIT0+BIT6+BIT5+BIT4)
#define LCD_SEG_L2_3_MASK (BIT3+BIT2+BIT1+BIT0+BIT6+BIT5+BIT4)
#define LCD_SEG_L2_4_MASK (BIT3+BIT2+BIT1+BIT0+BIT6+BIT5+BIT4)
#define LCD_SEG_L2_5_MASK (BIT7)
#define LCD_SEG_L2_COL1_MASK (BIT4)
#define LCD_SEG_L2_COL0_MASK (BIT0)
#define LCD_SEG_L2_DP_MASK (BIT7)
#define LCD_SYMB_AM_MASK (BIT1+BIT0)
#define LCD_SYMB_PM_MASK (BIT0)
#define LCD_SYMB_ARROW_UP_MASK (BIT2)
#define LCD_SYMB_ARROW_DOWN_MASK (BIT3)
#define LCD_SYMB_PERCENT_MASK (BIT4)
#define LCD_SYMB_TOTAL_MASK (BIT7)
#define LCD_SYMB_AVERAGE_MASK (BIT7)
#define LCD_SYMB_MAX_MASK (BIT7)
#define LCD_SYMB_BATTERY_MASK (BIT7)
#define LCD_UNIT_L1_FT_MASK (BIT5)
#define LCD_UNIT_L1_K_MASK (BIT6)
#define LCD_UNIT_L1_M_MASK (BIT1)
#define LCD_UNIT_L1_I_MASK (BIT0)
#define LCD_UNIT_L1_PER_S_MASK (BIT7)
#define LCD_UNIT_L1_PER_H_MASK (BIT2)
#define LCD_UNIT_L1_DEGREE_MASK (BIT1)
#define LCD_UNIT_L2_KCAL_MASK (BIT4)
#define LCD_UNIT_L2_KM_MASK (BIT5)
#define LCD_UNIT_L2_MI_MASK (BIT6)
#define LCD_ICON_HEART_MASK (BIT3)
#define LCD_ICON_STOPWATCH_MASK (BIT3)
#define LCD_ICON_RECORD_MASK (BIT7)
#define LCD_ICON_ALARM_MASK (BIT3)
#define LCD_ICON_BEEPER1_MASK (BIT3)
#define LCD_ICON_BEEPER2_MASK (BIT3)
#define LCD_ICON_BEEPER3_MASK (BIT3)
// *************************************************************************************************
// API section
// Physical LCD memory write
void write_lcd_mem(uint8_t * lcdmem, uint8_t bits, uint8_t bitmask, uint8_t state);
// Display init / clear
void lcd_init(void);
void clear_display(void);
void clear_display_all(void);
void clear_line(uint8_t line);
// Blinking function
void start_blink(void);
void stop_blink(void);
void clear_blink_mem(void);
void set_blink_rate(uint8_t bits);
// Character / symbol draw functions
void display_char(uint8_t segment, uint8_t chr, uint8_t mode);
void display_chars(uint8_t segments, uint8_t * str, uint8_t mode);
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
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);
// Segment index helper function
uint8_t switch_seg(uint8_t line, uint8_t index1, uint8_t index2);
void display_all_off(void);
#endif // __DISPLAY_

226
eZ430-Chronos/drivers/display1.c
View File

@ -1,226 +0,0 @@
// *************************************************************************************************
//
// 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"
// 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 address for each display element
const uint8_t * segments_lcdmem[] =
{
LCD_SYMB_AM_MEM,
LCD_SYMB_PM_MEM,
LCD_SYMB_ARROW_UP_MEM,
LCD_SYMB_ARROW_DOWN_MEM,
LCD_SYMB_PERCENT_MEM,
LCD_SYMB_TOTAL_MEM,
LCD_SYMB_AVERAGE_MEM,
LCD_SYMB_MAX_MEM,
LCD_SYMB_BATTERY_MEM,
LCD_UNIT_L1_FT_MEM,
LCD_UNIT_L1_K_MEM,
LCD_UNIT_L1_M_MEM,
LCD_UNIT_L1_I_MEM,
LCD_UNIT_L1_PER_S_MEM,
LCD_UNIT_L1_PER_H_MEM,
LCD_UNIT_L1_DEGREE_MEM,
LCD_UNIT_L2_KCAL_MEM,
LCD_UNIT_L2_KM_MEM,
LCD_UNIT_L2_MI_MEM,
LCD_ICON_HEART_MEM,
LCD_ICON_STOPWATCH_MEM,
LCD_ICON_RECORD_MEM,
LCD_ICON_ALARM_MEM,
LCD_ICON_BEEPER1_MEM,
LCD_ICON_BEEPER2_MEM,
LCD_ICON_BEEPER3_MEM,
LCD_SEG_L1_3_MEM,
LCD_SEG_L1_2_MEM,
LCD_SEG_L1_1_MEM,
LCD_SEG_L1_0_MEM,
LCD_SEG_L1_COL_MEM,
LCD_SEG_L1_DP1_MEM,
LCD_SEG_L1_DP0_MEM,
LCD_SEG_L2_5_MEM,
LCD_SEG_L2_4_MEM,
LCD_SEG_L2_3_MEM,
LCD_SEG_L2_2_MEM,
LCD_SEG_L2_1_MEM,
LCD_SEG_L2_0_MEM,
LCD_SEG_L2_COL1_MEM,
LCD_SEG_L2_COL0_MEM,
LCD_SEG_L2_DP_MEM,
};
// 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,
LCD_SYMB_ARROW_DOWN_MASK,
LCD_SYMB_PERCENT_MASK,
LCD_SYMB_TOTAL_MASK,
LCD_SYMB_AVERAGE_MASK,
LCD_SYMB_MAX_MASK,
LCD_SYMB_BATTERY_MASK,
LCD_UNIT_L1_FT_MASK,
LCD_UNIT_L1_K_MASK,
LCD_UNIT_L1_M_MASK,
LCD_UNIT_L1_I_MASK,
LCD_UNIT_L1_PER_S_MASK,
LCD_UNIT_L1_PER_H_MASK,
LCD_UNIT_L1_DEGREE_MASK,
LCD_UNIT_L2_KCAL_MASK,
LCD_UNIT_L2_KM_MASK,
LCD_UNIT_L2_MI_MASK,
LCD_ICON_HEART_MASK,
LCD_ICON_STOPWATCH_MASK,
LCD_ICON_RECORD_MASK,
LCD_ICON_ALARM_MASK,
LCD_ICON_BEEPER1_MASK,
LCD_ICON_BEEPER2_MASK,
LCD_ICON_BEEPER3_MASK,
LCD_SEG_L1_3_MASK,
LCD_SEG_L1_2_MASK,
LCD_SEG_L1_1_MASK,
LCD_SEG_L1_0_MASK,
LCD_SEG_L1_COL_MASK,
LCD_SEG_L1_DP1_MASK,
LCD_SEG_L1_DP0_MASK,
LCD_SEG_L2_5_MASK,
LCD_SEG_L2_4_MASK,
LCD_SEG_L2_3_MASK,
LCD_SEG_L2_2_MASK,
LCD_SEG_L2_1_MASK,
LCD_SEG_L2_0_MASK,
LCD_SEG_L2_COL1_MASK,
LCD_SEG_L2_COL0_MASK,
LCD_SEG_L2_DP_MASK,
};
// Quick integer to array conversion table for most common integer 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",
"048", "049", "050", "051", "052", "053", "054", "055", "056", "057", "058", "059", "060", "061", "062", "063",
"064", "065", "066", "067", "068", "069", "070", "071", "072", "073", "074", "075", "076", "077", "078", "079",
"080", "081", "082", "083", "084", "085", "086", "087", "088", "089", "090", "091", "092", "093", "094", "095",
"096", "097", "098", "099", "100", "101", "102", "103", "104", "105", "106", "107", "108", "109", "110", "111",
"112", "113", "114", "115", "116", "117", "118", "119", "120", "121", "122", "123", "124", "125", "126", "127",
"128", "129", "130", "131", "132", "133", "134", "135", "136", "137", "138", "139", "140", "141", "142", "143",
"144", "145", "146", "147", "148", "149", "150", "151", "152", "153", "154", "155", "156", "157", "158", "159",
"160", "161", "162", "163", "164", "165", "166", "167", "168", "169", "170", "171", "172", "173", "174", "175",
"176", "177", "178", "179", "180",
};

1
msb-430-common/Jamfile
View File

@ -28,6 +28,7 @@
SubDir TOP board msb-430-common ;
Module board : board_init.c debug_uart.c ;
Module board_config : board_config.c ;
UseModule board ;
SubInclude TOP cpu $(CPU) ;

5
msb-430-common/Jamrules.msb-430-common
View File

@ -25,13 +25,14 @@
# ******************************************************************************
# $Id$
CPU = msp430 ;
CPU = msp430x16x ;
MCU = msp430x1612 ;
FLASH_PORT ?= /dev/ttyUSB0 ;
FLASH_PORT ?= "$(PORT)" ;
FLASHER ?= mspdebug ;
FLASHFLAGS ?= -d $(FLASH_PORT) -j uif ;
RESET ?= $(FLASHER) $(FLASHFLAGS) reset ;
HDRS += [ FPath $(TOP) board msb-430-common include ] ;
HDRS += [ FPath $(TOP) board msb-430-common drivers include ] ;

19
msb-430-common/board_config.c Normal file
View File

@ -0,0 +1,19 @@
#include <stdint.h>
#include <string.h>
#include <board-conf.h>
#include <config.h>
#include <flashrom.h>
void config_load(void) {
if (*((uint16_t*) INFOMEM) == CONFIG_KEY) {
memcpy(&sysconfig, (char*) (INFOMEM + sizeof(CONFIG_KEY)), sizeof(sysconfig));
}
else {
config_save();
}
}
uint8_t config_save(void) {
configmem_t mem = { CONFIG_KEY, sysconfig };
return (flashrom_erase((uint8_t*) INFOMEM) && flashrom_write((uint8_t*) INFOMEM, (char*) &mem, sizeof(mem)));
}

6
msb-430-common/include/board-conf.h Normal file
View File

@ -0,0 +1,6 @@
#ifndef BOARD_CONF_H
#define BOARD_CONF_H
#define INFOMEM (0x1000)
#endif /* BOARD-CONF_H */

3
msb-430h/Jamfile
View File

@ -27,8 +27,7 @@
SubDir TOP board msb-430h ;
Module board_cc1100 : driver_cc1100.c ;
Module board_cc110x : driver_cc110x.c : cc110x_spi ;
SubInclude TOP board msb-430-common ;
SubInclude TOP cpu $(CPU) ;

79
msb-430h/driver_cc1100.c → msb-430h/driver_cc110x.c
View File

@ -23,8 +23,8 @@ Boston, MA 02111-1307, USA. */
#include <cpu.h>
#include <irq.h>
#include <cc1100.h>
#include <arch_cc1100.h>
#include <cc110x_ng.h>
#include <cc110x-arch.h>
#define CC1100_GDO0 (P2IN & 0x02) // read serial I/O (GDO0)
#define CC1100_GDO1 (P3IN & 0x04) // read serial I/O (GDO1)
@ -39,61 +39,61 @@ Boston, MA 02111-1307, USA. */
volatile int abort_count;
volatile int retry_count = 0;
void cc1100_gdo0_enable(void)
void cc110x_gdo0_enable(void)
{
P2IFG &= ~0x02; /* Clear IFG for GDO0 */
P2IE |= 0x02; /* Enable interrupt for GDO0 */
}
void cc1100_gdo0_disable(void)
void cc110x_gdo0_disable(void)
{
P2IE &= ~0x02; /* Disable interrupt for GDO0 */
P2IFG &= ~0x02; /* Clear IFG for GDO0 */
}
void cc1100_gdo2_enable(void)
void cc110x_gdo2_enable(void)
{
P2IFG &= ~0x01; /* Clear IFG for GDO2 */
P2IE |= 0x01; /* Enable interrupt for GDO2 */
}
void cc1100_gdo2_disable(void)
void cc110x_gdo2_disable(void)
{
P2IE &= ~0x01; /* Disable interrupt for GDO2 */
P2IFG &= ~0x01; /* Clear IFG for GDO2 */
}
void cc1100_before_send(void)
void cc110x_before_send(void)
{
// Disable GDO2 interrupt before sending packet
cc1100_gdo2_disable();
cc110x_gdo2_disable();
}
void cc1100_after_send(void)
void cc110x_after_send(void)
{
// Enable GDO2 interrupt after sending packet
cc1100_gdo2_enable();
cc110x_gdo2_enable();
}
int cc1100_get_gdo0(void) {
int cc110x_get_gdo0(void) {
return CC1100_GDO0;
}
int cc1100_get_gdo1(void) {
int cc110x_get_gdo1(void) {
return CC1100_GDO1;
}
int cc1100_get_gdo2(void) {
int cc110x_get_gdo2(void) {
return CC1100_GDO2;
}
void cc1100_spi_cs(void)
void cc110x_spi_cs(void)
{
CC1100_CS_LOW;
}
uint8_t cc1100_txrx(uint8_t data)
uint8_t cc110x_txrx(uint8_t data)
{
/* Ensure TX Buf is empty */
long c = 0;
@ -103,20 +103,20 @@ uint8_t cc1100_txrx(uint8_t data)
while(!(IFG1 & UTXIFG0))
{
if (c++ == 1000000)
puts("cc1100_txrx alarm()");
puts("cc110x_txrx alarm()");
}
/* Wait for Byte received */
c = 0;
while(!(IFG1 & URXIFG0))
{
if (c++ == 1000000)
puts("cc1100_txrx alarm()");
puts("cc110x_txrx alarm()");
}
return RXBUF0;
}
void cc1100_spi_select(void)
void cc110x_spi_select(void)
{
// Switch to GDO mode
P3SEL &= ~0x04;
@ -147,11 +147,11 @@ void cc1100_spi_select(void)
P3SEL |= 0x04;
}
void cc1100_spi_unselect(void) {
void cc110x_spi_unselect(void) {
CC1100_CS_HIGH;
}
void cc1100_init_interrupts(void)
void cc110x_init_interrupts(void)
{
unsigned int state = disableIRQ(); /* Disable all interrupts */
P2SEL = 0x00; /* must be <> 1 to use interrupts */
@ -163,7 +163,7 @@ void cc1100_init_interrupts(void)
restoreIRQ(state); /* Enable all interrupts */
}
void cc1100_spi_init(uint8_t clockrate)
void cc110x_spi_init(uint8_t clockrate)
{
// Switch off async UART
while(!(UTCTL0 & TXEPT)); // Wait for empty UxTXBUF register
@ -197,8 +197,8 @@ void cc1100_spi_init(uint8_t clockrate)
// #include <msp430x16x.h>
// #include <signal.h>
// #include "type.h"
// #include "cc1100_defines.h"
// #include "driver_cc1100.h"
// #include "cc110x_defines.h"
// #include "driver_cc110x.h"
// #include "driver_system.h"
// #include "spi0.h"
//
@ -213,17 +213,17 @@ void cc1100_spi_init(uint8_t clockrate)
// // void spiInitTrx(void)
// //
// // DESCRIPTION:
// // This function puts the cc1100 into spi mode. You have to call this bevore every spi transaction.
// // This function puts the cc110x into spi mode. You have to call this bevore every spi transaction.
// //
// //-------------------------------------------------------------------------------------------------------
//
//
// void drivercc1100_spiwriteburstreg(uint8_t addr, unsigned char *buffer, uint8_t count)
// void drivercc110x_spiwriteburstreg(uint8_t addr, unsigned char *buffer, uint8_t count)
// {
// uint8_t i;
// long c;
// drivercc1100_spiinittrx();
// drivercc1100_trxspi(addr | CC1100_WRITE_BURST);
// drivercc110x_spiinittrx();
// drivercc110x_trxspi(addr | CC1100_WRITE_BURST);
// for (i = 0; i < count; i++)
// {
// c = 0;
@ -247,11 +247,11 @@ void cc1100_spi_init(uint8_t clockrate)
// CC1100_CS_HIGH;
// }
//
// void drivercc1100_spireadburstreg(uint8_t addr, char *buffer, uint8_t count)
// void drivercc110x_spireadburstreg(uint8_t addr, char *buffer, uint8_t count)
// {
// uint8_t i;
// drivercc1100_spiinittrx();
// drivercc1100_trxspi(addr | CC1100_READ_BURST);
// drivercc110x_spiinittrx();
// drivercc110x_trxspi(addr | CC1100_READ_BURST);
// for (i = 0; i < count; i++)
// {
// long c = 0;
@ -275,21 +275,21 @@ void cc1100_spi_init(uint8_t clockrate)
// CC1100_CS_HIGH;
// }
//
// void drivercc1100_load(callback_t cs_cb,callback_t paket_cb)
// void drivercc110x_load(callback_t cs_cb,callback_t paket_cb)
// {
// _paket_cb = paket_cb;
// _cs_cb = cs_cb;
// spi0_init(0);
// }
//
// void drivercc1100_aftersend(void)
// void drivercc110x_aftersend(void)
// {
// CLEAR(P2IFG, 0x01);
// SET(P2IE, 0x01); /* Enable interrupts on port 2 pin 0 */
// CLEAR(P4OUT, 0x08); /* Turn off Sending Led*/
// }
//
// void drivercc1100_initinterrupts(void)
// void drivercc110x_initinterrupts(void)
// {
// _DINT(); /* Disable all interrupts */
// P2SEL = 0x00; /* must be <> 1 to use interrupts */
@ -301,7 +301,7 @@ void cc1100_spi_init(uint8_t clockrate)
// _EINT(); /* Enable all interrupts */
// }
//
// void drivercc1100_beforesend(void)
// void drivercc110x_beforesend(void)
// {
// /* Turn on Led while sending paket for debug reasons */
// SET(P4OUT, 0x08);
@ -319,25 +319,24 @@ void cc1100_spi_init(uint8_t clockrate)
/*
* CC1100 receive interrupt
*/
interrupt (PORT2_VECTOR) __attribute__ ((naked)) cc1100_isr(void){
interrupt (PORT2_VECTOR) __attribute__ ((naked)) cc110x_isr(void){
__enter_isr();
puts("cc1100_isr()");
puts("cc110x_isr()");
// if (system_state.POWERDOWN) SPI_INIT; /* Initialize SPI after wakeup */
/* Check IFG */
if ((P2IFG & 0x01) != 0) {
P2IFG &= ~0x01;
cc1100_gdo2_irq();
cc110x_gdo2_irq();
}
else if ((P2IFG & 0x02) != 0) {
cc1100_gdo0_irq();
cc110x_gdo0_irq();
P2IE &= ~0x02; // Disable interrupt for GDO0
P2IFG &= ~0x02; // Clear IFG for GDO0
} else {
puts("cc1100_isr(): unexpected IFG!");
puts("cc110x_isr(): unexpected IFG!");
/* Should not occur - only Port 2 Pin 0 interrupts are enabled */
// CLEAR(P2IFG, 0xFF); /* Clear all flags */
}
// if (system_state.POWERDOWN != 0) END_LPM3;
__exit_isr();
}

7
msba2-common/Jamfile Normal file
View File

@ -0,0 +1,7 @@
SubDir TOP board msba2-common ;
Module board_common : board_common_init.c ;
Module board_config : board_config.c ;
SubInclude TOP board msba2-common drivers ;

3
msba2/Jamfile.msba2 → msba2-common/Jamfile.msba2
View File

@ -25,7 +25,6 @@
# ******************************************************************************
# $Id$
#LinkLibraries $(BOARD).elf : sys-drivers.a net_mm.a sys-lib.a fat-lib.a
# cpu_drivers.a board_drivers.a cc110x.a hal.a hal_drivers.a lpc2387_hal.a ;
Module msba2_common : board_init.c ;
include [ FPath $(TOP) cpu arm_common Jamfile.arm_common ] ;

34
msba2-common/Jamrules.msba2 Normal file
View File

@ -0,0 +1,34 @@
# ******************************************************************************
# Copyright 2009, Freie Universitaet Berlin (FUB). All rights reserved.
#
# These sources were developed at the Freie Universitaet Berlin, Computer
# Systems and Telematics group (http://cst.mi.fu-berlin.de).
# ------------------------------------------------------------------------------
# This file is part of FeuerWare.
#
# This program is free software: you can redistribute it and/or modify it under
# the terms of the GNU General Public License as published by the Free Software
# Foundation, either version 3 of the License, or (at your option) any later
# version.
#
# FeuerWare is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License along with
# this program. If not, see http://www.gnu.org/licenses/ .
# ------------------------------------------------------------------------------
# For further information and questions please use the web site
# http://scatterweb.mi.fu-berlin.de
# and the mailinglist (subscription via web site)
# scatterweb@lists.spline.inf.fu-berlin.de
# ******************************************************************************
# $Id$
CPU = lpc2387 ;
HDRS += [ FPath $(TOP) board msba2-common include ] ;
HDRS += [ FPath $(TOP) board msba2-common drivers include ] ;
FLASHER ?= $(POSIXSHELL) lpc2k_pgm ;
FLASHFLAGS ?= "$(PORT)" ;

125
msba2-common/board_common_init.c Normal file
View File

@ -0,0 +1,125 @@
/******************************************************************************
Copyright 2008-2009, Freie Universitaet Berlin (FUB). All rights reserved.
These sources were developed at the Freie Universitaet Berlin, Computer Systems
and Telematics group (http://cst.mi.fu-berlin.de).
-------------------------------------------------------------------------------
This file is part of FeuerWare.
This program is free software: you can redistribute it and/or modify it under
the terms of the GNU General Public License as published by the Free Software
Foundation, either version 3 of the License, or (at your option) any later
version.
FeuerWare is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
You should have received a copy of the GNU General Public License along with
this program. If not, see http://www.gnu.org/licenses/ .
--------------------------------------------------------------------------------
For further information and questions please use the web site
http://scatterweb.mi.fu-berlin.de
and the mailinglist (subscription via web site)
scatterweb@lists.spline.inf.fu-berlin.de
*******************************************************************************/
/**
* @ingroup msba2
* @{
*/
/**
* @file
* @brief MSB-A2 board initialization
*
* @author Freie Universität Berlin, Computer Systems & Telematics, FeuerWhere project
* @author Heiko Will
* @author Kaspar Schleiser
* @author Michael Baar <baar@inf.fu-berlin.de>
*
* @note $Id$
*/
#include <board.h>
#include <lpc23xx.h>
#include <VIC.h>
#include <cpu.h>
#include <config.h>
#include <string.h>
#include <flashrom.h>
#define PCRTC BIT9
#define CL_CPU_DIV 4
/*---------------------------------------------------------------------------*/
/**
* @brief Enabling MAM and setting number of clocks used for Flash memory fetch
* @internal
*/
static void
init_mam(void)
{
MAMCR = 0x0000;
MAMTIM = 0x0003;
MAMCR = 0x0002;
}
/*---------------------------------------------------------------------------*/
static inline void
pllfeed(void)
{
PLLFEED = 0xAA;
PLLFEED = 0x55;
}
/*---------------------------------------------------------------------------*/
void init_clks1(void)
{
// Disconnect PLL
PLLCON &= ~0x0002;
pllfeed();
// Disable PLL
PLLCON &= ~0x0001;
pllfeed();
SCS |= 0x20; // Enable main OSC
while( !(SCS & 0x40) ); // Wait until main OSC is usable
/* select main OSC, 16MHz, as the PLL clock source */
CLKSRCSEL = 0x0001;
// Setting Multiplier and Divider values
PLLCFG = 0x0008; // M=9 N=1 Fcco = 288 MHz
pllfeed();
// Enabling the PLL */
PLLCON = 0x0001;
pllfeed();
/* Set clock divider to 4 (value+1) */
CCLKCFG = CL_CPU_DIV - 1; // Fcpu = 72 MHz
#if USE_USB
USBCLKCFG = USBCLKDivValue; /* usbclk = 288 MHz/6 = 48 MHz */
#endif
}
void init_clks2(void){
// Wait for the PLL to lock to set frequency
while(!(PLLSTAT & BIT26));
// Connect the PLL as the clock source
PLLCON = 0x0003;
pllfeed();
/* Check connect bit status */
while (!(PLLSTAT & BIT25));
}
void bl_init_clks(void)
{
PCONP = PCRTC; // switch off everything except RTC
init_clks1();
init_clks2();
init_mam();
}

19
msba2-common/board_config.c Normal file
View File

@ -0,0 +1,19 @@
#include <stdint.h>
#include <string.h>
#include <config.h>
#include <flashrom.h>
void config_load(void) {
extern char configmem[];
if (*((uint16_t*) configmem) == CONFIG_KEY) {
memcpy(&sysconfig, (configmem + sizeof(CONFIG_KEY)), sizeof(sysconfig));
}
else {
config_save();
}
}
uint8_t config_save(void) {
configmem_t mem = { CONFIG_KEY, sysconfig };
return (flashrom_erase((uint8_t*) &configmem) && flashrom_write((uint8_t*) &configmem, (char*) &mem, sizeof(mem)));
}

6
msba2-common/drivers/Jamfile Normal file
View File

@ -0,0 +1,6 @@
SubDir TOP board msba2-common drivers ;
Module board_cc110x : msba2-cc110x.c : cc110x_spi gpioint ;
Module board_ltc4150 : msba2-ltc4150.c : gpioint ;
Module board_uart : msba2-uart0.c : chardev_thread ringbuffer ;

0
msba2/drivers/include/sht11-board.h → msba2-common/drivers/include/sht11-board.h
View File

0
msba2/drivers/include/uart0.h → msba2-common/drivers/include/uart0.h
View File

51
msba2/drivers/msba2-cc1100.c → msba2-common/drivers/msba2-cc110x.c
View File

@ -34,7 +34,7 @@ and the mailinglist (subscription via web site)
* @author Thomas Hillebrandt <hillebra@inf.fu-berlin.de>
* @version $Revision: 1781 $
*
* @note $Id: msba2-cc1100.c 1781 2010-01-26 13:39:36Z hillebra $
* @note $Id: msba2-cc110x.c 1781 2010-01-26 13:39:36Z hillebra $
*/
#include <stdio.h>
@ -43,10 +43,10 @@ and the mailinglist (subscription via web site)
#include <cpu.h>
#include <irq.h>
// sys
#include "cc1100.h"
#include "arch_cc1100.h"
#include "cc1100_spi.h"
#include "gpioint.h"
#include <cc110x_ng.h>
#include <cc110x-arch.h>
#include <cc110x_spi.h>
#include <gpioint.h>
#define CC1100_GDO0 (FIO0PIN & BIT27) // read serial I/O (GDO0)
#define CC1100_GDO1 (FIO1PIN & BIT23) // read serial I/O (GDO1)
@ -82,19 +82,19 @@ static int test_time(int code) {
}
#endif
int cc1100_get_gdo0(void) {
int cc110x_get_gdo0(void) {
return CC1100_GDO0;
}
int cc1100_get_gdo1(void) {
int cc110x_get_gdo1(void) {
return CC1100_GDO1;
}
int cc1100_get_gdo2(void) {
int cc110x_get_gdo2(void) {
return CC1100_GDO2;
}
void cc1100_spi_init(void)
void cc110x_spi_init(void)
{
// configure chip-select
FIO1DIR |= BIT21;
@ -128,8 +128,7 @@ void cc1100_spi_init(void)
}
}
uint8_t
cc1100_txrx(uint8_t c) {
uint8_t cc110x_txrx(uint8_t c) {
uint8_t result;
SSP0DR = c;
#ifdef DEBUG
@ -160,13 +159,13 @@ cc1100_txrx(uint8_t c) {
return result;
}
void cc1100_spi_cs(void)
void cc110x_spi_cs(void)
{
FIO1CLR = BIT21;
}
void
cc1100_spi_select(void)
cc110x_spi_select(void)
{
volatile int retry_count = 0;
volatile int abort_count;
@ -200,44 +199,44 @@ cc1100_spi_select(void)
}
void
cc1100_spi_unselect(void)
cc110x_spi_unselect(void)
{
FIO1SET = BIT21;
}
void cc1100_before_send(void)
void cc110x_before_send(void)
{
// Disable GDO2 interrupt before sending packet
cc1100_gdo2_disable();
cc110x_gdo2_disable();
}
void cc1100_after_send(void)
void cc110x_after_send(void)
{
// Enable GDO2 interrupt after sending packet
cc1100_gdo2_enable();
cc110x_gdo2_enable();
}
void cc1100_gdo0_enable(void) {
gpioint_set(0, BIT27, GPIOINT_RISING_EDGE, &cc1100_gdo0_irq);
void cc110x_gdo0_enable(void) {
gpioint_set(0, BIT27, GPIOINT_RISING_EDGE, &cc110x_gdo0_irq);
}
void cc1100_gdo0_disable(void) {
void cc110x_gdo0_disable(void) {
gpioint_set(0, BIT27, GPIOINT_DISABLE, NULL);
}
void cc1100_gdo2_disable(void) {
void cc110x_gdo2_disable(void) {
gpioint_set(0, BIT28, GPIOINT_DISABLE, NULL);
}
void cc1100_gdo2_enable(void) {
gpioint_set(0, BIT28, GPIOINT_FALLING_EDGE, &cc1100_gdo2_irq);
void cc110x_gdo2_enable(void) {
gpioint_set(0, BIT28, GPIOINT_FALLING_EDGE, &cc110x_gdo2_irq);
}
void cc1100_init_interrupts(void)
void cc110x_init_interrupts(void)
{
// Enable external interrupt on low edge (for GDO2)
FIO0DIR &= ~BIT28;
cc1100_gdo2_enable();
cc110x_gdo2_enable();
// Enable external interrupt on low edge (for GDO0)
FIO0DIR &= ~BIT27;
}

0
msba2/drivers/msba2-ltc4150.c → msba2-common/drivers/msba2-ltc4150.c
View File

0
msba2/drivers/msba2-uart0.c → msba2-common/drivers/msba2-uart0.c
View File

33
msba2/drivers/include/hal-board.h → msba2-common/include/msba2_common.h
View File

@ -24,45 +24,28 @@ and the mailinglist (subscription via web site)
scatterweb@lists.spline.inf.fu-berlin.de
*******************************************************************************/
#ifndef HALPLATFORM_H_
#define HALPLATFORM_H_
#ifndef __BOARD_H
#define __BOARD_H
/**
* @ingroup msba2
* @ingroup msb_a2
* @{
*/
/**
* @file
* @brief
* @brief MSB-A2 Common Board Definitions
*
* @author Freie Universität Berlin, Computer Systems & Telematics, FeuerWhere project
* @author baar
* @author Kaspar Schleiser <kaspar@schleiser.de>
* @version $Revision$
*
* @note $Id$
*/
#include "vdevice.h"
#include "device-gpio.h"
#include "device-rs232.h"
#include "device-serial.h"
#include <lpc2387.h>
VDEVICE_NAME(vdevice_gpio, gpio_led_green);
VDEVICE_NAME(vdevice_gpio, gpio_led_red);
VDEVICE_NAME(vdevice_gpio, gpio_led_usb);
/**
* @var tty0
* @brief RS232 TTY0 device on UART0
*/
VDEVICE_NAME(vdevice_rs232, tty0);
/**
* @var console0
* @brief console device on tty0
*/
VDEVICE_NAME(vdevice_serial, console0);
#define VICIntEnClear VICIntEnClr
/** @} */
#endif /* HALPLATFORM_H_ */
#endif // __BOARD_H

0
msba2/lpc2387-timer3.c → msba2-common/lpc2387-timer3.c
View File

0
msba2/tools/CHANGES → msba2-common/tools/CHANGES
View File

0
msba2/tools/COPYING → msba2-common/tools/COPYING
View File

0
msba2/tools/Makefile → msba2-common/tools/Makefile
View File

0
msba2/tools/README.txt → msba2-common/tools/README.txt
View File

0
msba2/tools/armtools.txt → msba2-common/tools/armtools.txt
View File

0
msba2/tools/flash.cmd → msba2-common/tools/flash.cmd
View File

0
msba2/tools/flashutil.sh → msba2-common/tools/flashutil.sh
View File

0
msba2/tools/mkbootc → msba2-common/tools/mkbootc
View File

0
msba2/tools/mkstaticlist → msba2-common/tools/mkstaticlist
View File

0
msba2/tools/obj/boot_23xx.d → msba2-common/tools/obj/boot_23xx.d
View File

0
msba2/tools/obj/boot_2xxx.d → msba2-common/tools/obj/boot_2xxx.d
View File

0
msba2/tools/obj/chipinfo.d → msba2-common/tools/obj/chipinfo.d
View File

0
msba2/tools/obj/control_2xxx.d → msba2-common/tools/obj/control_2xxx.d
View File

0
msba2/tools/obj/download.d → msba2-common/tools/obj/download.d
View File

0
msba2/tools/obj/ihex.d → msba2-common/tools/obj/ihex.d
View File

0
msba2/tools/obj/lpc2k_pgm.d → msba2-common/tools/obj/lpc2k_pgm.d
View File

0
msba2/tools/obj/pseudoterm.d → msba2-common/tools/obj/pseudoterm.d
View File

0
msba2/tools/obj/serial.d → msba2-common/tools/obj/serial.d
View File

0
msba2/tools/obj/uuencode.d → msba2-common/tools/obj/uuencode.d
View File

0
msba2/tools/src/Jamfile → msba2-common/tools/src/Jamfile
View File

0
msba2/tools/src/boot.h → msba2-common/tools/src/boot.h
View File

0
msba2/tools/src/boot_23xx.armasm → msba2-common/tools/src/boot_23xx.armasm
View File

0
msba2/tools/src/boot_23xx.c → msba2-common/tools/src/boot_23xx.c
View File

0
msba2/tools/src/boot_23xx.h → msba2-common/tools/src/boot_23xx.h
View File

0
msba2/tools/src/boot_2xxx.armasm → msba2-common/tools/src/boot_2xxx.armasm
View File

0
msba2/tools/src/boot_2xxx.c → msba2-common/tools/src/boot_2xxx.c
View File

0
msba2/tools/src/boot_2xxx.h → msba2-common/tools/src/boot_2xxx.h
View File

0
msba2/tools/src/chipinfo.c → msba2-common/tools/src/chipinfo.c
View File

0
msba2/tools/src/chipinfo.h → msba2-common/tools/src/chipinfo.h
View File

0
msba2/tools/src/cksum_test.c → msba2-common/tools/src/cksum_test.c
View File

0
msba2/tools/src/control_2xxx.c → msba2-common/tools/src/control_2xxx.c
View File

0
msba2/tools/src/control_2xxx.h → msba2-common/tools/src/control_2xxx.h
View File

0
msba2/tools/src/download.c → msba2-common/tools/src/download.c
View File

0
msba2/tools/src/download.h → msba2-common/tools/src/download.h
View File

0
msba2/tools/src/gui.c → msba2-common/tools/src/gui.c
View File

0
msba2/tools/src/gui.h → msba2-common/tools/src/gui.h
View File

0
msba2/tools/src/ihex.c → msba2-common/tools/src/ihex.c
View File

0
msba2/tools/src/ihex.h → msba2-common/tools/src/ihex.h
View File

0
msba2/tools/src/lpc2k_pgm.c → msba2-common/tools/src/lpc2k_pgm.c
View File

0
msba2/tools/src/lpc2k_pgm.h → msba2-common/tools/src/lpc2k_pgm.h
View File

0
msba2/tools/src/pseudoterm.c → msba2-common/tools/src/pseudoterm.c
View File

0
msba2/tools/src/serial.c → msba2-common/tools/src/serial.c
View File

0
msba2/tools/src/serial.h → msba2-common/tools/src/serial.h
View File

0
msba2/tools/src/settings.c → msba2-common/tools/src/settings.c
View File

0
msba2/tools/src/settings.h → msba2-common/tools/src/settings.h
View File

0
msba2/tools/src/uuencode.c → msba2-common/tools/src/uuencode.c
View File

0
msba2/tools/src/uuencode.h → msba2-common/tools/src/uuencode.h
View File

0
msba2/tools/termctrl.sh → msba2-common/tools/termctrl.sh
View File

7
msba2/Jamfile
View File

@ -25,11 +25,10 @@
# ******************************************************************************
# $Id$
SubDir TOP board msba2 ;
SubDir TOP board $(BOARD) ;
Module board : board_init.c ;
Module board : board_init.c : board_common board_uart ;
UseModule board ;
UseModule board_common ;
SubInclude TOP board $(BOARD) drivers ;
SubInclude TOP board $(BOARD)-common ;
SubInclude TOP cpu $(CPU) ;

34
msba2/Jamrules.msba2
View File

@ -1,33 +1 @@
# ******************************************************************************
# Copyright 2009, Freie Universitaet Berlin (FUB). All rights reserved.
#
# These sources were developed at the Freie Universitaet Berlin, Computer
# Systems and Telematics group (http://cst.mi.fu-berlin.de).
# ------------------------------------------------------------------------------
# This file is part of FeuerWare.
#
# This program is free software: you can redistribute it and/or modify it under
# the terms of the GNU General Public License as published by the Free Software
# Foundation, either version 3 of the License, or (at your option) any later
# version.
#
# FeuerWare is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License along with
# this program. If not, see http://www.gnu.org/licenses/ .
# ------------------------------------------------------------------------------
# For further information and questions please use the web site
# http://scatterweb.mi.fu-berlin.de
# and the mailinglist (subscription via web site)
# scatterweb@lists.spline.inf.fu-berlin.de
# ******************************************************************************
# $Id$
CPU = lpc2387 ;
HDRS += [ FPath $(TOP) board $(BOARD) drivers include ] ;
FLASHER ?= $(POSIXSHELL) lpc2k_pgm ;
FLASHFLAGS ?= "$(PORT)" ;
include board/msba2-common/Jamrules.msba2 ;

154
msba2/board_init.c
View File

@ -1,139 +1,5 @@
/******************************************************************************
Copyright 2008-2009, Freie Universitaet Berlin (FUB). All rights reserved.
These sources were developed at the Freie Universitaet Berlin, Computer Systems
and Telematics group (http://cst.mi.fu-berlin.de).
-------------------------------------------------------------------------------
This file is part of FeuerWare.
This program is free software: you can redistribute it and/or modify it under
the terms of the GNU General Public License as published by the Free Software
Foundation, either version 3 of the License, or (at your option) any later
version.
FeuerWare is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
You should have received a copy of the GNU General Public License along with
this program. If not, see http://www.gnu.org/licenses/ .
--------------------------------------------------------------------------------
For further information and questions please use the web site
http://scatterweb.mi.fu-berlin.de
and the mailinglist (subscription via web site)
scatterweb@lists.spline.inf.fu-berlin.de
*******************************************************************************/
/**
* @ingroup msba2
* @{
*/
/**
* @file
* @brief MSB-A2 board initialization
*
* @author Freie Universität Berlin, Computer Systems & Telematics, FeuerWhere project
* @author Heiko Will
* @author Kaspar Schleiser
* @author Michael Baar <baar@inf.fu-berlin.de>
*
* @note $Id$
*/
#include <board.h>
#include <lpc23xx.h>
#include "VIC.h"
#include "cpu.h"
#define PCRTC BIT9
#define CL_CPU_DIV 4
/*---------------------------------------------------------------------------*/
/**
* @brief Enabling MAM and setting number of clocks used for Flash memory fetch
* @internal
*/
static void
init_mam(void)
{
MAMCR = 0x0000;
MAMTIM = 0x0003;
MAMCR = 0x0002;
}
/*---------------------------------------------------------------------------*/
static inline void
pllfeed(void)
{
PLLFEED = 0xAA;
PLLFEED = 0x55;
}
/*---------------------------------------------------------------------------*/
void init_clks1(void)
{
// Disconnect PLL
PLLCON &= ~0x0002;
pllfeed();
// Disable PLL
PLLCON &= ~0x0001;
pllfeed();
SCS |= 0x20; // Enable main OSC
while( !(SCS & 0x40) ); // Wait until main OSC is usable
/* select main OSC, 16MHz, as the PLL clock source */
CLKSRCSEL = 0x0001;
// Setting Multiplier and Divider values
PLLCFG = 0x0008; // M=9 N=1 Fcco = 288 MHz
pllfeed();
// Enabling the PLL */
PLLCON = 0x0001;
pllfeed();
/* Set clock divider to 4 (value+1) */
CCLKCFG = CL_CPU_DIV - 1; // Fcpu = 72 MHz
#if USE_USB
USBCLKCFG = USBCLKDivValue; /* usbclk = 288 MHz/6 = 48 MHz */
#endif
}
void init_clks2(void){
// Wait for the PLL to lock to set frequency
while(!(PLLSTAT & BIT26));
// Connect the PLL as the clock source
PLLCON = 0x0003;
pllfeed();
/* Check connect bit status */
while (!(PLLSTAT & BIT25));
}
void bl_init_clks(void)
{
PCONP = PCRTC; // switch off everything except RTC
init_clks1();
init_clks2();
init_mam();
}
void bl_init_ports(void)
{
SCS |= BIT0; // Set IO Ports to fast switching mode
/* UART0 */
PINSEL0 |= BIT4 + BIT6; // RxD0 and TxD0
PINSEL0 &= ~(BIT5 + BIT7);
/* LEDS */
FIO3DIR |= LED_RED_PIN;
FIO3DIR |= LED_GREEN_PIN;
LED_RED_OFF;
LED_GREEN_OFF;
}
#include <cpu.h>
void loop_delay(void) {
volatile uint16_t i, j;
@ -154,3 +20,21 @@ void bl_blink(void) {
LED_GREEN_OFF;
}
void bl_init_ports(void)
{
SCS |= BIT0; // Set IO Ports to fast switching mode
/* UART0 */
PINSEL0 |= BIT4 + BIT6; // RxD0 and TxD0
PINSEL0 &= ~(BIT5 + BIT7);
/* LEDS */
FIO3DIR |= LED_RED_PIN;
FIO3DIR |= LED_GREEN_PIN;
LED_RED_OFF;
LED_GREEN_OFF;
/* short blinking of both of the LEDs on startup */
bl_blink();
}

7
msba2/drivers/Jamfile
View File

@ -1,7 +0,0 @@
SubDir TOP board msba2 drivers ;
Module board_cc1100 : msba2-cc1100.c ;
Module board_hal : msba2-hal.c ;
Module board_ltc4150 : msba2-ltc4150.c : gpioint ;
Module board_common : msba2-uart0.c : ringbuffer ;
Module board_uart : msba2-uart0_thread.c : chardev_thread ringbuffer ;

68
msba2/include/board-conf.h
View File

@ -1,68 +0,0 @@
/******************************************************************************
Copyright 2008, Freie Universitaet Berlin (FUB). All rights reserved.
These sources were developed at the Freie Universitaet Berlin, Computer Systems
and Telematics group (http://cst.mi.fu-berlin.de).
-------------------------------------------------------------------------------
This file is part of FeuerWare.
This program is free software: you can redistribute it and/or modify it under
the terms of the GNU General Public License as published by the Free Software
Foundation, either version 3 of the License, or (at your option) any later
version.
FeuerWare is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
You should have received a copy of the GNU General Public License along with
this program. If not, see http://www.gnu.org/licenses/ .
--------------------------------------------------------------------------------
For further information and questions please use the web site
http://scatterweb.mi.fu-berlin.de
and the mailinglist (subscription via web site)
scatterweb@lists.spline.inf.fu-berlin.de
*******************************************************************************/
#ifndef BOARDCONF_H_
#define BOARDCONF_H_
/**
* @ingroup conf
* @ingroup msba2
*
* @{
*/
/**
* @file
* @brief MSB-A2 board configuration
*
* @author Freie Universität Berlin, Computer Systems & Telematics, FeuerWhere project
* @author baar
* @version $Revision$
*
* @note $Id$
*/
#define FEUERWARE_CONF_BOARD_NAME "FU Berlin MSB-A2"
#ifdef MODULE_CC110X
#define FEUERWARE_CONF_NUM_RADIOS 1
#else
#define FEUERWARE_CONF_NUM_RADIOS 0
#endif
// if FAT is enabled this board supports files
#define FEUERWARE_CONF_CORE_SUPPORTS_FILES defined(MODULE_FAT)
#ifdef MODULE_FAT
#define CFG_CONF_MEM_SIZE 0x7FFFFFFF
#define SYSLOG_CONF_NUM_INTERFACES 2
#else
#define SYSLOG_CONF_NUM_INTERFACES 1
#endif
/** @} */
#endif /* BOARDCONF_H_ */

49
msba2/include/board.h
View File

@ -1,51 +1,7 @@
/******************************************************************************
Copyright 2008, Freie Universitaet Berlin (FUB). All rights reserved.
These sources were developed at the Freie Universitaet Berlin, Computer Systems
and Telematics group (http://cst.mi.fu-berlin.de).
-------------------------------------------------------------------------------
This file is part of FeuerWare.
This program is free software: you can redistribute it and/or modify it under
the terms of the GNU General Public License as published by the Free Software
Foundation, either version 3 of the License, or (at your option) any later
version.
FeuerWare is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
You should have received a copy of the GNU General Public License along with
this program. If not, see http://www.gnu.org/licenses/ .
--------------------------------------------------------------------------------
For further information and questions please use the web site
http://scatterweb.mi.fu-berlin.de
and the mailinglist (subscription via web site)
scatterweb@lists.spline.inf.fu-berlin.de
*******************************************************************************/
#ifndef __BOARD_H
#define __BOARD_H
/**
* @ingroup msb_a2
* @{
*/
/**
* @file
* @brief MSB-A2 Board
*
* @author Freie Universität Berlin, Computer Systems & Telematics, FeuerWhere project
* @author Kaspar Schleiser <kaspar@schleiser.de>
* @version $Revision$
*
* @note $Id$
*/
#include <lpc2387.h>
#define VICIntEnClear VICIntEnClr
#include <msba2_common.h>
#define LED_RED_PIN (BIT25)
#define LED_GREEN_PIN (BIT26)
@ -58,5 +14,4 @@ and the mailinglist (subscription via web site)
#define LED_RED_ON (FIO3CLR = LED_RED_PIN)
#define LED_RED_TOGGLE (FIO3PIN ^= LED_RED_PIN)
/** @} */
#endif // __BOARD_H
#endif /* __BOARD_H */

9
pttu/Jamfile
View File

@ -23,13 +23,12 @@
# and the mailinglist (subscription via web site)
# scatterweb@lists.spline.inf.fu-berlin.de
# ******************************************************************************
# $Id: Jamfile 922 2009-03-26 12:52:27Z baar $
# $Id$
SubDir TOP board pttu ;
SubDir TOP board $(BOARD) ;
Module board : board_init.c ;
Module board : board_init.c : board_common board_uart ;
UseModule board ;
UseModule board_common ;
SubInclude TOP board $(BOARD) drivers ;
SubInclude TOP board msba2-common ;
SubInclude TOP cpu $(CPU) ;

5
pttu/Jamrules.pttu
View File

@ -25,13 +25,10 @@
# ******************************************************************************
# $Id: Jamrules.msba2 881 2009-03-20 12:24:58Z kaspar $
CPU = lpc2387 ;
include board/msba2-common/Jamrules.msba2 ;
HDRS += [ FPath $(TOP) board $(BOARD) drivers include ] ;
FLASHER = $(POSIXSHELL) $(TOP)/board/msba2/tools/flashutil.sh ;
FLASHFLAGS = --basedir $(TOP)/board/msba2/tools --id PTTU --ports "$(PORT)" --openocd $(TOP)/board/pttu/tools/openocd-pttu.sh --openocd-if $(OPENOCD_IF) ;
GDB = arm-elf-gdb ;
GDBFLAGS = -x board/pttu/tools/pttu_debug.gdb ;

86
pttu/board_init.c
View File

@ -33,94 +33,18 @@ and the mailinglist (subscription via web site)
* @file
* @brief PTTU board initialization
*
* @author Freie Universit<EFBFBD>t Berlin, Computer Systems & Telematics, FeuerWhere project
* @author Freie Universität Berlin, Computer Systems & Telematics, FeuerWhere project
* @author Heiko Will
* @author Kaspar Schleise
* @author Michael Baar <baar@inf.fu-berlin.de>
* @author Kaspar Schleiser
*
* @note $Id: cmdengine-out.c 971 2009-04-07 13:41:36Z baar $
*/
#include "lpc23xx.h"
#include "VIC.h"
#include "cpu.h"
#include <board.h>
#include <VIC.h>
#include <cpu.h>
#define PCRTC BIT9
#define CL_CPU_DIV 4
/*---------------------------------------------------------------------------*/
/**
* @brief Enabling MAM and setting number of clocks used for Flash memory fetch
* @internal
*/
void
init_mam(void)
{
MAMCR = 0x0000;
MAMTIM = 0x0003;
MAMCR = 0x0002;
}
/*---------------------------------------------------------------------------*/
static inline void
pllfeed(void)
{
PLLFEED = 0xAA;
PLLFEED = 0x55;
}
/*---------------------------------------------------------------------------*/
void init_clks1(void)
{
// Disconnect PLL
PLLCON &= ~0x0002;
pllfeed();
// Disable PLL
PLLCON &= ~0x0001;
pllfeed();
SCS |= 0x20; // Enable main OSC
while( !(SCS & 0x40) ); // Wait until main OSC is usable
/* select main OSC, 16MHz, as the PLL clock source */
CLKSRCSEL = 0x0001;
// Setting Multiplier and Divider values
PLLCFG = 0x0008; // M=9 N=1 Fcco = 288 MHz
pllfeed();
// Enabling the PLL */
PLLCON = 0x0001;
pllfeed();
/* Set clock divider to 4 (value+1) */
CCLKCFG = CL_CPU_DIV - 1; // Fcpu = 72 MHz
#if USE_USB
USBCLKCFG = USBCLKDivValue; /* usbclk = 288 MHz/6 = 48 MHz */
#endif
}
void init_clks2(void){
// Wait for the PLL to lock to set frequency
while(!(PLLSTAT & BIT26));
// Connect the PLL as the clock source
PLLCON = 0x0003;
pllfeed();
/* Check connect bit status */
while (!(PLLSTAT & BIT25));
}
void bl_init_clks(void)
{
PCONP = PCRTC; // switch off everything except RTC
init_clks1();
init_clks2();
init_mam();
}
// Michael, Do not change anything here! even not the redundant parts!
void bl_init_ports(void)
{
SCS |= BIT0; // Set IO Ports to fast switching mode

2
pttu/drivers/Jamfile
View File

@ -1,4 +1,2 @@
SubDir TOP board pttu drivers ;
Module board_common : pttu-uart0.c ;

204
pttu/drivers/pttu-uart0.c
View File

@ -1,204 +0,0 @@
/******************************************************************************
Copyright 2008-2009, Freie Universitaet Berlin (FUB). All rights reserved.
These sources were developed at the Freie Universitaet Berlin, Computer Systems
and Telematics group (http://cst.mi.fu-berlin.de).
-------------------------------------------------------------------------------
This file is part of FeuerWare.
This program is free software: you can redistribute it and/or modify it under
the terms of the GNU General Public License as published by the Free Software
Foundation, either version 3 of the License, or (at your option) any later
version.
FeuerWare is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
You should have received a copy of the GNU General Public License along with
this program. If not, see http://www.gnu.org/licenses/ .
--------------------------------------------------------------------------------
For further information and questions please use the web site
http://scatterweb.mi.fu-berlin.de
and the mailinglist (subscription via web site)
scatterweb@lists.spline.inf.fu-berlin.de
*******************************************************************************/
/*
* debug_uart.c: provides initial serial debug output
*
* Copyright (C) 2008, 2009 Kaspar Schleiser <kaspar@schleiser.de>
* Heiko Will <hwill@inf.fu-berlin.de>
*/
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include "lpc23xx.h"
#include "VIC.h"
/**
* @file
* @ingroup lpc2387
*
* @author Freie Universität Berlin, Computer Systems & Telematics, FeuerWhere project
* @version $Revision$
*
* @note $Id$
*/
typedef struct toprint {
unsigned int len;
char content[];
}toprint;
#define QUEUESIZE 255
static volatile toprint* queue[QUEUESIZE];
static volatile unsigned char queue_head = 0;
static volatile unsigned char queue_tail = 0;
static volatile unsigned char queue_items = 0;
static volatile unsigned int actual_pos = 0;
static volatile unsigned int running = 0;
static volatile unsigned int fifo = 0;
static volatile toprint* actual = NULL;
void (*uart0_callback)(int);
static inline void enqueue(void) {
queue_items++;
queue_tail++;
}
static inline void dequeue(void) {
actual = (queue[queue_head]);
queue_items--;
queue_head++;
}
static void push_queue(void) {
running = 1;
start:
if (!actual) {
if (queue_items) {
dequeue();
} else {
running = 0;
if (!fifo)
while(!(U0LSR & BIT6)){};
return;
}
}
while ((actual_pos < actual->len) && (fifo++ < 16)){
U0THR = actual->content[actual_pos++];
}
if (actual_pos == actual->len) {
free((void*)actual);
actual = NULL;
actual_pos = 0;
goto start;
}
}
int uart_active(void){
return (running || fifo);
}
static inline void receive(int c)
{
if (uart0_callback != NULL) uart0_callback(c);
}
void stdio_flush(void)
{
U0IER &= ~BIT1; // disable THRE interrupt
while(running) {
while(!(U0LSR & (BIT5|BIT6))){}; // transmit fifo
fifo=0;
push_queue(); // dequeue to fifo
}
U0IER |= BIT1; // enable THRE interrupt
}
void UART0_IRQHandler(void) __attribute__((interrupt("IRQ")));
void UART0_IRQHandler(void)
{
int iir;
iir = U0IIR;
switch(iir & UIIR_ID_MASK) {
case UIIR_THRE_INT: // Transmit Holding Register Empty
fifo=0;
push_queue();
break;
case UIIR_CTI_INT: // Character Timeout Indicator
case UIIR_RDA_INT: // Receive Data Available
do {
int c = U0RBR;
receive(c);
} while (U0LSR & ULSR_RDR);
break;
default:
U0LSR;
U0RBR;
break;
} // switch
VICVectAddr = 0; // Acknowledge Interrupt
}
static inline int uart0_puts(char *astring,int length)
{
while (queue_items == (QUEUESIZE-1)) {} ;
U0IER = 0;
queue[queue_tail] = malloc(length+sizeof(unsigned int));
queue[queue_tail]->len = length;
memcpy(&queue[queue_tail]->content,astring,length);
enqueue();
if (!running)
push_queue();
U0IER |= BIT0 | BIT1; // enable RX irq
// alternative without queue:
// int i;
// for (i=0;i<length;i++) {
// while (!(U0LSR & BIT5));
// U0THR = astring[i];
// }
return length;
}
int fw_puts(char *astring,int length)
{
return uart0_puts(astring, length);
}
int
bl_uart_init(void)
{
PCONP |= PCUART0; // power on
// UART0 clock divider is CCLK/8
PCLKSEL0 |= BIT6 + BIT7;
U0LCR = 0x83; // 8 bits, no Parity, 1 Stop bit
// TODO: UART Baudrate calculation using uart->config->speed
/*
* Baudrate calculation
* BR = PCLK (9 MHz) / (16 x 256 x DLM + DLL) x (1/(DIVADDVAL/MULVAL))
*/
U0FDR = 0x92; // DIVADDVAL = 0010 = 2, MULVAL = 1001 = 9
U0DLM = 0x00;
U0DLL = 0x04;
U0LCR = 0x03; // DLAB = 0
U0FCR = 0x07; // Enable and reset TX and RX FIFO
/* irq */
install_irq(UART0_INT, UART0_IRQHandler, 6);
U0IER |= BIT0 | BIT1; // enable RX+TX irq
return 1;
}