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

core/

Browse Source
This commit is contained in:
Oliver Hahm 2011-12-28 11:37:05 +01:00
commit c3d24e2057
325 changed files with 11675 additions and 2892 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
.gitignore vendored Normal file
View File

@ -0,0 +1,5 @@
*.o
doc/doxygen/html
doc/doxygen/latex
doc/doxygen/man
*bin

2
Jamfile
View File

@ -67,8 +67,8 @@ Debug debug : $(TARGET) ;
ListModules listmodules ; ListModules listmodules ;
ShowFlags showflags : $(TARGET) ; ShowFlags showflags : $(TARGET) ;
SubInclude TOP projects $(PROJECT) ;
SubInclude TOP sys ; SubInclude TOP sys ;
SubInclude TOP core ; SubInclude TOP core ;
SubInclude TOP drivers ; SubInclude TOP drivers ;
SubInclude TOP board ; SubInclude TOP board ;
SubInclude TOP projects $(PROJECT) ;

8
Jamrules
View File

@ -31,15 +31,15 @@
include $(TOP)$(SLASH)Jamrules.common ; include $(TOP)$(SLASH)Jamrules.common ;
# #
# Setup FeuerWare build system configuration (default values for common options) # Setup ukleos build system configuration (default values for common options)
# #
PROJECT = $(PROJECT:E=hello-world) ; PROJECT = $(PROJECT:E=default) ;
BOARD = $(BOARD:E=msba2) ; BOARD = $(BOARD:E=msba2) ;
SUFFIX ?= "" ; # must be at least "" !!! SUFFIX ?= "" ; # must be at least "" !!!
TARGET = "$(BOARD)-$(PROJECT)$(SUFFIX)$(SUFEXE)" ; # main target binary TARGET = "$(BOARD)-$(PROJECT)$(SUFFIX)$(SUFEXE)" ; # main target binary
OPENOCD_IF ?= olimex-jtag-tiny-a ; OPENOCD_IF ?= olimex-jtag-tiny-a ;
TERMINAL ?= board/msba2/tools/bin/pseudoterm ; TERMINAL ?= tools/pyterm/pyterm.py ;
if $(NT) || $(OS) = CYGWIN { if $(NT) || $(OS) = CYGWIN {
PORT = $(PORT:E=1) ; PORT = $(PORT:E=1) ;
@ -53,7 +53,6 @@ CCFLAGS += -DBOARD=BOARD_$(BOARD:U) ;
# core source directories # core source directories
HDRS += $(TOP) ; HDRS += $(TOP) ;
HDRS += [ FPath $(TOP) core include ] ; HDRS += [ FPath $(TOP) core include ] ;
HDRS += [ FPath $(TOP) hal include ] ;
HDRS += [ FPath $(TOP) sys include ] [ FPath $(TOP) sys config ] [ FPath $(TOP) sys drivers include ] [ FPath $(TOP) sys drivers cc110x ] [ FPath $(TOP) sys drivers nanopan5375 ] ; HDRS += [ FPath $(TOP) sys include ] [ FPath $(TOP) sys config ] [ FPath $(TOP) sys drivers include ] [ FPath $(TOP) sys drivers cc110x ] [ FPath $(TOP) sys drivers nanopan5375 ] ;
HDRS += [ FPath $(TOP) sys net ] ; HDRS += [ FPath $(TOP) sys net ] ;
HDRS += [ FPath $(TOP) sys lib ] [ FPath $(TOP) sys lib fat include ] ; HDRS += [ FPath $(TOP) sys lib ] [ FPath $(TOP) sys lib fat include ] ;
@ -74,3 +73,4 @@ HDRS += [ FPath $(TOP) projects $(PROJECT) ] ;
# drivers # drivers
HDRS += [ FPath $(TOP) drivers include ] ; HDRS += [ FPath $(TOP) drivers include ] ;
HDRS += [ FPath $(TOP) drivers cc110x ] ; HDRS += [ FPath $(TOP) drivers cc110x ] ;
HDRS += [ FPath $(TOP) drivers cc110x_ng include ] ;

5
Jamrules.common
View File

@ -125,7 +125,7 @@ actions Cleanall
{ {
echo "> Cleaning binaries" echo "> Cleaning binaries"
$(RM) bin$(SLASH)* $(RM) bin$(SLASH)*
make -C $(TOP)$(SLASH)doc clean # make -C $(TOP)$(SLASH)doc clean
} }
# #
@ -177,7 +177,7 @@ rule Test
} }
actions Test actions Test
{ {
for tst in projects/$(PROJECT)/tests/*; do $tst; done export PORT=$(PORT); for tst in projects/$(PROJECT)/tests/*; do $tst; done
} }
# Reset connected sensor node # Reset connected sensor node
@ -357,4 +357,3 @@ actions ShowFlags {
echo "" | $(CC) -E -dD - echo "" | $(CC) -E -dD -
} }

1
README
View File

@ -7,3 +7,4 @@ License
a separate license. a separate license.
All code files contain licensing information. All code files contain licensing information.

4
board/eZ430-Chronos/Jamfile → board/chronos/Jamfile
View File

@ -1,8 +1,8 @@
SubDir TOP board eZ430-Chronos ; SubDir TOP board chronos ;
HDRS += $(TOP)/board/$(CPU)/include ; HDRS += $(TOP)/board/$(CPU)/include ;
Module board : debug_uart.c board_init.c ; Module board : putchar.c board_init.c ;
UseModule board ; UseModule board ;
SubInclude TOP board $(BOARD) drivers ; SubInclude TOP board $(BOARD) drivers ;

6
board/eZ430-Chronos/Jamrules.eZ430-Chronos → board/chronos/Jamrules.chronos
View File

@ -3,10 +3,12 @@
# ****************************************************************************** # ******************************************************************************
# $Id$ # $Id$
BOARD = eZ430-Chronos ; BOARD = chronos ;
CPU = msp430 ; CPU = cc430 ;
MCU = cc430x6137 ; MCU = cc430x6137 ;
HDRS += [ FPath $(TOP) board chronos drivers include ] ;
FLASHER ?= mspdebug ; FLASHER ?= mspdebug ;
FLASHFLAGS ?= rf2500 ; FLASHFLAGS ?= rf2500 ;

74
board/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();
}

11
board/chronos/drivers/Jamfile Normal file
View File

@ -0,0 +1,11 @@
SubDir TOP board chronos drivers ;
HDRS += $(TOP)/board/$(CPU)/drivers/include ;
Module board_display : display.c display1.c ;
Module board_cc110x : cc430-cc110x.c : cc110x_cc430 ;
Module board_buzzer : buzzer.c : hwtimer ;
Module battery : battery.c : adc hwtimer ;
Module vti_ps_twi : vti_ps_twi.c : hwtimer ;
Module display_putchar : display_putchar.c : board_display ;

13
board/chronos/drivers/battery.c Normal file
View File

@ -0,0 +1,13 @@
#include <stdint.h>
#include <cc430x613x.h>
#include <cc430-adc.h>
uint32_t battery_get_voltage(void) {
uint32_t voltage;
voltage = adc12_single_conversion(REFVSEL_1, ADC12SHT0_10, ADC12INCH_11);
/* Ideally we have A11=0->AVCC=0V ... A11=4095(2^12-1)->AVCC=4V
* --> (A11/4095)*4V=AVCC --> AVCC=(A11*4)/4095 */
voltage = (voltage * 2 * 2 * 1000) / 4095;
return voltage;
}

28
board/chronos/drivers/buzzer.c Normal file
View File

@ -0,0 +1,28 @@
#include <stdint.h>
#include <buzzer.h>
#include <hwtimer.h>
#include <cc430x613x.h>
void buzzer_beep(uint8_t pitch, uint16_t duration) {
// Reset TA1R, set up mode, TA1 runs from 32768Hz ACLK
TA1CTL = TACLR | MC_1 | TASSEL__ACLK;
// Set PWM frequency
TA1CCR0 = pitch;
// Enable IRQ, set output mode "toggle"
TA1CCTL0 = OUTMOD_4;
// Allow buzzer PWM output on P2.7
P2SEL |= BIT7;
hwtimer_wait(duration);
// Stop PWM timer
TA1CTL &= ~(BIT4 | BIT5);
// Reset and disable buzzer PWM output
P2OUT &= ~BIT7;
P2SEL &= ~BIT7;
TA1CCTL0 &= ~CCIE;
}

81
board/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
board/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_t 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++;
}
}

207
board/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",
};

42
board/chronos/drivers/display_putchar.c Normal file
View File

@ -0,0 +1,42 @@
#include <stdio.h>
#include <display.h>
#include <string.h>
extern int toupper(int c);
extern void (*_putchar)(int c);
static char display_buf[11];
void putchar_to_display();
void init_display_putchar() {
memset(display_buf, '\0', 11);
_putchar = putchar_to_display;
}
void putchar_to_display(int c) {
if (c == '\n') {
display_buf[4] = 1;
return;
}
if (display_buf[4]) {
memset(display_buf, '\0', 11);
} else {
display_buf[0] = display_buf[1];
display_buf[1] = display_buf[2];
display_buf[2] = display_buf[3];
display_buf[3] = display_buf[5];
display_buf[5] = display_buf[6];
display_buf[6] = display_buf[7];
display_buf[7] = display_buf[8];
display_buf[8] = display_buf[9];
}
display_buf[9] = toupper(c);
clear_display_all();
display_chars(LCD_SEG_L1_3_0, display_buf, SEG_ON);
display_chars(LCD_SEG_L2_5_0, display_buf+4, SEG_ON);
}

6
board/chronos/drivers/include/battery.h Normal file
View File

@ -0,0 +1,6 @@
#ifndef BATTERY_H
#define BATTERY_H
uint32_t battery_get_voltage(void);
#endif /* BATTERY_H */

6
board/chronos/drivers/include/buzzer.h Normal file
View File

@ -0,0 +1,6 @@
#ifndef BUZZER_H
#define BUZZER_H
void buzzer_beep(uint8_t pitch, uint16_t duration);
#endif /* BUZZER_H */

458
board/chronos/drivers/include/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_t;
extern volatile s_display_flags_t 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_ */

6
board/chronos/drivers/include/display_putchar.h Normal file
View File

@ -0,0 +1,6 @@
#ifndef __DISPLAY_PUTCHAR_H
#define __DISPLAY_PUTCHAR_H
void init_display_putchar();
#endif /* __DISPLAY_PUTCHAR_H */

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

11
board/chronos/include/buttons.h Normal file
View File

@ -0,0 +1,11 @@
#ifndef BUTTONS_H
#define BUTTONS_H
// Button ports
#define BUTTON_STAR_PIN (BIT2)
#define BUTTON_NUM_PIN (BIT1)
#define BUTTON_UP_PIN (BIT4)
#define BUTTON_DOWN_PIN (BIT0)
#define BUTTON_BACKLIGHT_PIN (BIT3)
#endif

11
board/chronos/putchar.c Normal file
View File

@ -0,0 +1,11 @@
static void _dummy(int c) {
}
void (*_putchar)(int c) = _dummy;
int putchar(int c)
{
_putchar(c);
return c;
}

2
board/eZ430-Chronos/board_init.c
View File

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

21
board/eZ430-Chronos/debug_uart.c
View File

@ -1,21 +0,0 @@
#include <stdio.h>
#include "board.h"
#define UART1_TX TXBUF1
#define UART1_WAIT_TXDONE() while( (UTCTL1 & TXEPT) == 0 ) { _NOP(); }
int putchar(int c)
{
// UART1_TX = c;
// UART1_WAIT_TXDONE();
//
// if (c == 10) {
// UART1_TX = 13;
// UART1_WAIT_TXDONE();
// }
return c;
}

5
board/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
board/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
board/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
board/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",
};

34
board/msb-430-common/Jamfile 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$
SubDir TOP board msb-430-common ;
Module board : board_init.c uart1.c ;
Module board_config : board_config.c : flashrom ;
UseModule board ;
SubInclude TOP cpu $(CPU) ;

38
board/msb-430-common/Jamrules.msb-430-common Normal file
View File

@ -0,0 +1,38 @@
# ******************************************************************************
# 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 = msp430x16x ;
MCU = msp430x1612 ;
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
board/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)));
}

2
board/msb-430h/board_init.c → board/msb-430-common/board_init.c
View File

@ -201,7 +201,7 @@ void board_init() {
msp430_cpu_init(); msp430_cpu_init();
msb_ports_init(); msb_ports_init();
RED_ON; LED_RED_ON;
msp430_set_cpu_speed(7372800uL); msp430_set_cpu_speed(7372800uL);
} }

61
board/msb-430-common/drivers/include/sht11-board.h Normal file
View File

@ -0,0 +1,61 @@
/******************************************************************************
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
*******************************************************************************/
#ifndef SHT11BOARD_H_
#define SHT11BOARD_H_
/**
* @ingroup msb_430h
* @{
*/
/**
* @file
* @brief SHT11 Device Driver Configuration For MSB-430 Platform
*
* @author Freie Universität Berlin, Computer Systems & Telematics, µkleos
* @version $Revision$
*
* @note $Id$
*/
#include <msp430x16x.h>
#include <bitarithm.h>
/* SCK = P3B5
* DATA = P3B4
*/
#define SHT11_SCK_LOW P3OUT &= ~(BIT5); /**< serial clock line low */
#define SHT11_SCK_HIGH P3OUT |= BIT5; /**< serial clock line high */
#define SHT11_DATA (P3IN & BIT5) /**< read serial I/O */
#define SHT11_DATA_LOW P3OUT &= ~(BIT5); /**< serial I/O line low */
#define SHT11_DATA_HIGH P3OUT |= BIT5; /**< serial I/O line high */
#define SHT11_DATA_IN P3DIR &= ~(BIT5); /**< serial I/O as input */
#define SHT11_DATA_OUT P3DIR |= BIT5; /**< serial I/O as output */
#define SHT11_INIT P3DIR |= BIT5; /* FIO1DIR |= BIT25; PINSEL3 &= ~(BIT14|BIT15 | BIT16|BIT17); */
/** @} */
#endif /* SHT11BOARD_H_ */

6
board/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 */

7
board/msb-430-common/putchar.c Normal file
View File

@ -0,0 +1,7 @@
#include <stdio.h>
void (_putchar(int)) = uart1_putchar;
void putchar(int c) {
_putchar(c);
}

0
board/msb-430h/debug_uart.c → board/msb-430-common/uart1.c
View File

32
board/msb-430/Jamfile Normal file
View File

@ -0,0 +1,32 @@
# ******************************************************************************
# 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$
SubDir TOP board msb-430 ;
SubInclude TOP board msb-430-common ;
SubInclude TOP cpu $(CPU) ;

3
board/msb-430/Jamrules.msb-430 Normal file
View File

@ -0,0 +1,3 @@
BOARD = msb-430 ;
include $(TOP)/board/msb-430-common/Jamrules.msb-430-common ;

70
board/msb-430/include/board.h Normal file
View File

@ -0,0 +1,70 @@
/******************************************************************************
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
*******************************************************************************/
#ifndef _MSB_BOARD_H
#define _MSB_BOARD_H
/**
* @defgroup msb_430h ScatterWeb MSB-430H
* @ingroup msp430
*
<h2>Compontents</h2>
\li MSP430
\li CC1100
* @{
*/
/**
* @file
* @brief MSB-430H Board
*
* @author Freie Universität Berlin, Computer Systems & Telematics, FeuerWhere project
* @version $Revision$
*
* @note $Id$
*/
//MSB430 core
#define MSP430_INITIAL_CPU_SPEED 7372800uL
#define MSP430_HAS_DCOR 1
#define MSP430_HAS_EXTERNAL_CRYSTAL 0
/* LEDs ports MSB430 */
#define LEDS_PxDIR P5DIR
#define LEDS_PxOUT P5OUT
#define LEDS_CONF_RED 0x80
#define LEDS_CONF_GREEN 0x00
#define LEDS_CONF_YELLOW 0x00
#define LED_RED_ON LEDS_PxOUT &=~LEDS_CONF_RED
#define LED_RED_OFF LEDS_PxOUT |= LEDS_CONF_RED
#define LED_RED_TOGGLE LEDS_PxOUT ^= LEDS_CONF_RED
#include <msp430x16x.h>
/** @} */
#endif // _MSB_BOARD_H

6
board/msb-430h/Jamfile
View File

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

36
board/msb-430h/Jamrules.msb-430h
View File

@ -1,37 +1,3 @@
# ******************************************************************************
# 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$
BOARD = msb-430h ; BOARD = msb-430h ;
CPU = msp430 ;
MCU = msp430x1612 ;
FLASH_PORT ?= /dev/ttyUSB0 ;
FLASHER ?= mspdebug ;
FLASHFLAGS ?= -d $(FLASH_PORT) -j uif ;
RESET ?= $(FLASHER) $(FLASHFLAGS) reset ;
include $(TOP)/board/msb-430-common/Jamrules.msb-430-common ;

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

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

5
board/msb-430h/include/board.h
View File

@ -60,8 +60,9 @@ and the mailinglist (subscription via web site)
#define LEDS_CONF_GREEN 0x00 #define LEDS_CONF_GREEN 0x00
#define LEDS_CONF_YELLOW 0x00 #define LEDS_CONF_YELLOW 0x00
#define RED_ON LEDS_PxOUT &=~LEDS_CONF_RED #define LED_RED_ON LEDS_PxOUT &=~LEDS_CONF_RED
#define RED_OFF LEDS_PxOUT |= LEDS_CONF_RED #define LED_RED_OFF LEDS_PxOUT |= LEDS_CONF_RED
#define LED_RED_TOGGLE LEDS_PxOUT ^= LEDS_CONF_RED
#include <msp430x16x.h> #include <msp430x16x.h>

7
board/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
board/msba2/Jamfile.msba2 → board/msba2-common/Jamfile.msba2
View File

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

34
board/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
board/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
board/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
board/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 ;

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

@ -54,10 +54,5 @@ and the mailinglist (subscription via web site)
#define SHT11_DATA_OUT (FIO1DIR |= BIT26) // serial I/O as output #define SHT11_DATA_OUT (FIO1DIR |= BIT26) // serial I/O as output
#define SHT11_INIT FIO1DIR |= BIT25; PINSEL3 &= ~(BIT14|BIT15 | BIT16|BIT17); #define SHT11_INIT FIO1DIR |= BIT25; PINSEL3 &= ~(BIT14|BIT15 | BIT16|BIT17);
/* time to wait after toggling the data line */
#define SHT11_DATA_WAIT (50)
/* time to wait after toggling the clock line */
#define SHT11_CLK_WAIT (10)
/** @} */ /** @} */
#endif /* SHT11BOARD_H_ */ #endif /* SHT11BOARD_H_ */

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

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

8
board/msba2/drivers/msba2-ltc4150.c → board/msba2-common/drivers/msba2-ltc4150.c
View File

@ -45,19 +45,19 @@ and the mailinglist (subscription via web site)
#include "ltc4150_arch.h" #include "ltc4150_arch.h"
#include "gpioint.h" #include "gpioint.h"
void ltc4150_disable_int(void) { void __attribute__((__no_instrument_function__)) ltc4150_disable_int(void) {
gpioint_set(0, BIT4, GPIOINT_DISABLE, NULL); gpioint_set(0, BIT4, GPIOINT_DISABLE, NULL);
} }
void ltc4150_enable_int(void) { void __attribute__((__no_instrument_function__)) ltc4150_enable_int(void) {
gpioint_set(0, BIT4, GPIOINT_FALLING_EDGE, &ltc4150_interrupt); gpioint_set(0, BIT4, GPIOINT_FALLING_EDGE, &ltc4150_interrupt);
} }
void ltc4150_sync_blocking(void) { void __attribute__((__no_instrument_function__)) ltc4150_sync_blocking(void) {
while(!(FIO0PIN & BIT4)) {}; while(!(FIO0PIN & BIT4)) {};
} }
void ltc4150_arch_init() { void __attribute__((__no_instrument_function__)) ltc4150_arch_init() {
FIO0DIR |= BIT5; FIO0DIR |= BIT5;
FIO0SET = BIT5; FIO0SET = BIT5;
} }

11
board/msba2/drivers/msba2-uart0.c → board/msba2-common/drivers/msba2-uart0.c
View File

@ -35,6 +35,7 @@ and the mailinglist (subscription via web site)
#include <stdio.h> #include <stdio.h>
#include "lpc23xx.h" #include "lpc23xx.h"
#include "VIC.h" #include "VIC.h"
#include <kernel.h>
#include <board_uart0.h> #include <board_uart0.h>
@ -48,13 +49,13 @@ and the mailinglist (subscription via web site)
* @note $Id$ * @note $Id$
*/ */
typedef struct toprint { typedef struct toprint_t {
unsigned int len; unsigned int len;
char content[]; char content[];
}toprint; }toprint_t;
#define QUEUESIZE 255 #define QUEUESIZE 255
static volatile toprint* queue[QUEUESIZE]; static volatile toprint_t* queue[QUEUESIZE];
static volatile unsigned char queue_head = 0; static volatile unsigned char queue_head = 0;
static volatile unsigned char queue_tail = 0; static volatile unsigned char queue_tail = 0;
static volatile unsigned char queue_items = 0; static volatile unsigned char queue_items = 0;
@ -63,7 +64,7 @@ static volatile unsigned int actual_pos = 0;
static volatile unsigned int running = 0; static volatile unsigned int running = 0;
static volatile unsigned int fifo = 0; static volatile unsigned int fifo = 0;
static volatile toprint* actual = NULL; static volatile toprint_t* actual = NULL;
static inline void enqueue(void) { static inline void enqueue(void) {
queue_items++; queue_items++;
@ -78,12 +79,14 @@ static inline void dequeue(void) {
static void push_queue(void) { static void push_queue(void) {
running = 1; running = 1;
lpm_prevent_sleep |= LPM_PREVENT_SLEEP_UART;
start: start:
if (!actual) { if (!actual) {
if (queue_items) { if (queue_items) {
dequeue(); dequeue();
} else { } else {
running = 0; running = 0;
lpm_prevent_sleep &= ~LPM_PREVENT_SLEEP_UART;
if (!fifo) if (!fifo)
while(!(U0LSR & BIT6)){}; while(!(U0LSR & BIT6)){};
return; return;

33
board/msba2/drivers/include/hal-board.h → board/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 scatterweb@lists.spline.inf.fu-berlin.de
*******************************************************************************/ *******************************************************************************/
#ifndef HALPLATFORM_H_ #ifndef __MSBA2_COMMON_H
#define HALPLATFORM_H_ #define __MSBA2_COMMON_H
/** /**
* @ingroup msba2 * @ingroup msb_a2
* @{ * @{
*/ */
/** /**
* @file * @file
* @brief * @brief MSB-A2 Common Board Definitions
* *
* @author Freie Universität Berlin, Computer Systems & Telematics, FeuerWhere project * @author Freie Universität Berlin, Computer Systems & Telematics, FeuerWhere project
* @author baar * @author Kaspar Schleiser <kaspar@schleiser.de>
* @version $Revision$ * @version $Revision$
* *
* @note $Id$ * @note $Id$
*/ */
#include "vdevice.h" #include <lpc2387.h>
#include "device-gpio.h"
#include "device-rs232.h"
#include "device-serial.h"
VDEVICE_NAME(vdevice_gpio, gpio_led_green); #define VICIntEnClear VICIntEnClr
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);
/** @} */ /** @} */
#endif /* HALPLATFORM_H_ */ #endif // __MSBA2_COMMON_H

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

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

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

2
board/msba2/tools/Makefile → board/msba2-common/tools/Makefile
View File

@ -12,9 +12,11 @@ PSEUDOTERM_OBJS = ${addprefix obj/,${patsubst %.c,%.o,$(PSEUDOTERM_SRC)}}
TARGETDIR = bin TARGETDIR = bin
lpc2k_pgm: $(OBJS) lpc2k_pgm: $(OBJS)
mkdir -p $(TARGETDIR)
$(CC) -o $(TARGETDIR)/lpc2k_pgm $(OBJS) $(CC) -o $(TARGETDIR)/lpc2k_pgm $(OBJS)
pseudoterm: $(PSEUDOTERM_OBJS) pseudoterm: $(PSEUDOTERM_OBJS)
mkdir -p $(TARGETDIR)
$(CC) -lpthread -o $(TARGETDIR)/pseudoterm $(PSEUDOTERM_OBJS) $(CC) -lpthread -o $(TARGETDIR)/pseudoterm $(PSEUDOTERM_OBJS)
chipinfo.o: boot_2xxx.h boot_23xx.h chipinfo.o: boot_2xxx.h boot_23xx.h

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@ -78,8 +78,6 @@ int main(int argc, char **argv)
char* port_name = argv[1]; char* port_name = argv[1];
char* file_name = argv[2]; char* file_name = argv[2];
sleep(1);
if (open_serial_port(port_name) < 0) { if (open_serial_port(port_name) < 0) {
return(1); return(1);
} }

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

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

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

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

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

Some files were not shown because too many files have changed in this diff Show More