/**
* Send int value to serial output in ASCII code. Removes unused zeros.
* @param val value to print
*/
void send_rs_int(int val)
{
char dat[8];
int i;
int pom = 0;
for(i = 0; i < 8; i++)
{
dat[i] = (val & 0xF) + 0x30;
if(dat[i] > '9')
dat[i] += 7;
val >>= 4;
}
for(i = 0; i < 8; i++)
{
if((pom == 0) & (dat[7-i] == '0'))
{
if((i == 6) | (i == 7))
uart_send_char('0');
continue;
}
pom = 1;
uart_send_char(dat[7-i]);
}
}
void send_message(char name[], const char *attr[], uint8_t attr_length) {
//EXAMPLE COMMAND
//const char * attr[] = {"DATA1", "DATA2"};
//send_message("ROTATE", attr, 2)
int i;
uart_send_char('#');
uart_send_string(name);
for(i = 0; i < attr_length; ++i){
uart_send_char(':');
uart_send_string(attr[i]);
}
uart_send_char(';');
}
void uart_send_str ( char * str )
{
if ( str != NULL )
{
char * end = str + UART_OUT_BUFFER_SIZE;
while ( str != end )
{
if ( *str == '\0' ) break;
uart_send_char ( *str );
str++;
}
if( str == end )
{
#if( FEATURE_RED_LED )
led_red_on();
#endif
}
}
else
{
#if( FEATURE_RED_LED )
led_red_on();
#endif
}
}
int auswertung()
{
int result = -1;
switch(uart_string[0])
{
case 's':
result=set();
break;
case 'g':
result=get();
break;
case 'c':
send_time_sync();
break;
#if funk == 1
case 'p':
packet();
break;
#endif
#if testing == 1
case 't':
test();
break;
#endif
default:
uart_send_pgm_string(cmd_not_fnd);
uart_send_char(uart_string[0]);
uart_send_string("\n\r\0");
}
return result;
}
//-------------------------------------------------------Funktionen fuer das auslesen von Werten------------------------------------------------------
int get()
{
static const char get_help[] PROGMEM = "Usage: g\n\rt for get time\n\rc for geting color\n\r";
if(uart_string[1] == 'h')
{
uart_send_pgm_string(get_help);
}
else
#if rgb == 1
if(uart_string[1] == 'c')
{
uart_send_string("R: ");
uart_send_var(match[0]);
uart_send_string(", G: ");
uart_send_var(match[1]);
uart_send_string(", B: ");
uart_send_var(match[2]);
uart_send_string("R: ");
uart_send_var(match_tmp[0]);
uart_send_string(", G: ");
uart_send_var(match_tmp[1]);
uart_send_string(", B: ");
uart_send_var(match_tmp[2]);
}
else
#endif
#if time == 1
if(uart_string[1] == 't')
{
uart_send_var_zero_dec(stunde, 2);
uart_send_char(':');
uart_send_var_zero_dec(minute, 2);
uart_send_char(':');
uart_send_var_zero_dec(sekunde, 2);
uart_send_char('\n');
uart_send_char('\r');
}
else
#endif
{
uart_send_pgm_string(get_help);
return -1;
}
return 0;
}
int clock_main(void) {
char ch;
WDTCTL = WDTPW | WDTHOLD; // Stop watchdog timer
P1DIR = 0b00000011;
P1OUT = 0x00;
// Enable P2 interrupts for buttons.
P2OUT = BUTTON_BITS;
P2DIR &= ~BUTTON_BITS;
P2REN = BUTTON_BITS;
P2SEL &= ~BUTTON_BITS;
P2IE = BUTTON_BITS;
P2IES = BUTTON_BITS;
P2IFG &= ~(BUTTON_BITS);
load_and_reset();
uart_init();
lcd_init();
// Setup timer B0 to count exactly each second.
TB0CCTL0 = CCIE;
TB0CCR0 = 32758;
TB0CTL = TBSSEL_1 // Input source: ACLK.
+ MC_1
+ TBCLR;
__bis_SR_register(GIE);
while (1) {
__delay_cycles(0x47FF);
while (receiveBufferSize > 0) {
ch = rcvbuff[--receiveBufferSize];
cmdbuff[cmdbuff_size++] = ch;
uart_send_char(ch);
if (ch == 0x0D) {
//uart_send_char('\r');
uart_send_char('\n');
parse_time(cmdbuff);
cmdbuff_size = 0;
}
}
}
}
inline void uart_send_str(const char* str)
{
while (*str != '\0')
{
uart_send_char(*str);
++str;
}
}
void uart_send(unsigned char *data, unsigned char length) {
unsigned int j;
for (j = 0 ; j < length ; j++) {
uart_send_char(data[j]);
if (data[j] == '\0') break;
}
}
void uart_send(void)
{
if (uart0_flags.txing == false) {
// is some data in buffer ?
if (!(uart0_flags.txing)) {
uart0_flags.txing = true;
uart0_tx_timeout = UART0_TX_TIMEOUT;
UART0_TX_ENA; // tx mode
uart0_buf_tx_ptr = 0; // send first byte from buffer
UART0_PROC_UDR = uart_send_char();
}
}
}
int set_rgb()
{
unsigned char color;
unsigned char i;
color = uart_string[2];
if(color == 'R')
match[0] = (uart_string[3] - 0x30) * 100 + (uart_string[4] - 0x30) * 10 + (uart_string[5] - 0x30);
else if(color == 'G')
match[1] = (uart_string[3] - 0x30) * 100 + (uart_string[4] - 0x30) * 10 + (uart_string[5] - 0x30);
else if(color == 'B')
match[2] = (uart_string[3] - 0x30) * 100 + (uart_string[4] - 0x30) * 10 + (uart_string[5] - 0x30);
else
{
uart_send_string("Fehler\n\r");
return -1;
}
i = 6;
uart_send_char(uart_string[i]);
uart_send_char(uart_string[i+1]);
uart_send_char(uart_string[i+2]);
uart_send_char(uart_string[i+3]);
uart_send_var((uart_string[i+1] - 0x30) * 100 + (uart_string[i+2] - 0x30) * 10 + (uart_string[i+3] - 0x30));
if(uart_string[i] == 'R' || uart_string[i] == 'G' || uart_string[i] == 'B')
{
uart_send_char('r');
if(uart_string[i] == 'R')
{
match[0] = (uart_string[i+1] - 0x30) * 100 + (uart_string[i+2] - 0x30) * 10 + (uart_string[i+3] - 0x30);
uart_send_var((uart_string[i+1] - 0x30) * 100 + (uart_string[i+2] - 0x30) * 10 + (uart_string[i+3] - 0x30));
}
else if(uart_string[i] == 'G')
match[1] = (uart_string[i+1] - 0x30) * 100 + (uart_string[i+2] - 0x30) * 10 + (uart_string[i+3] - 0x30);
else
match[2] = (uart_string[i+1] - 0x30) * 100 + (uart_string[i+2] - 0x30) * 10 + (uart_string[i+3] - 0x30);
i=i+4;
}
sort_matches();
}
int main(void) {
uart_init();
char c = '.';
while(1) {
uart_send_char(c); // Send a character to UART
_delay_ms(1000); // Wait 1000ms
}
return(0);
}
/**
* Send string to serial output in ASCII code. .
* @param data[] string to print
*/
void send_rs_str(const char data[])
{
int i = 0;
int j = 0;
for (j = 0; j < 255; j++)
{
if(data[j] == 0) break;
}
for (i= 0 ; i < j; i++)
{
uart_send_char(data[i]);
}
}
// Transmits a single character
void USART_Transmit_char()
{
// A nice hint: With interrupts, you can send bytes whenever the register UDR0
// is free. And there is an interrupt called USART_UDRE_vect that *tells you*
// whenever UDR0 is free.
// This requires you to have some bytes in the buffer that you would like to
// send, of course. You have a buffer, don't you?
char ch;
if (!rb_get_char(tx_buf, &ch))
{
uart_send_char(ch);
}
else
{
uart_disable_empty_register_interrupt();
}
}
int main(void)
{
uint8_t i;
struct light_packet lp;
uint8_t src;
uint8_t taille;
unsigned char datas[16];
uart_init();
init_mac();
_delay_ms(10000);
while (1)
{
if( recv(&src, &taille, datas) > 0)
{
for (i = 0 ; i < taille ; i++)
{
uart_send_char(datas[i]);
}
}
print("\r\n");
}
return 0;
}
void cmd_dataHandler(u08 input)
{
uart_send_char (input);
if (command)
{
parameter[paramIndex++] = input;
paramsRemaining--;
if (paramsRemaining == 0)
{
u08 which = (parameter[0] == '0' ? 0 : 1);
switch (command)
{
/* Set display 0 character - a<char> */
case 'a': dm_setChar(0, parameter[0]); break;
/* Set display 1 character - A<char> */
case 'A': dm_setChar(1, parameter[0]); break;
/* Blank character - b<01> */
case 'b': dm_blank(which); break;
/* Unblank character - b<01> */
case 'B': dm_unBlank(which); break;
/* Enable Custom character - c<01> */
case 'c': dm_displayProgrammed(which, 1); break;
/* Disable Custom character - C<01> */
case 'C': dm_displayProgrammed(which, 0); break;
/* Dim display - d<01> */
case 'd': dm_setDim(which, 1); break;
/* Undim display - D<01> */
case 'D': dm_setDim(which, 0); break;
/* Flip display - f<01> */
case 'f': dm_setFlip(which, 1); break;
/* Unflip display - F<01> */
case 'F': dm_setFlip(which, 0); break;
/* Invert display bits - i<01> */
case 'i': dm_setReverse(which, 1); break;
/* Uninvert display bits - I<01> */
case 'I': dm_setReverse(which, 0); break;
/* Set Pallete Index for display 0- l<index> */
/* This is ignored for single-color displays */
case 'l': dm_setPalette(0,
asciiToHex(parameter[0], parameter[1]));
break;
/* Set Pallete Index for display 1- L<HH> */
/* This is ignored for single-color displays */
case 'L': dm_setPalette(1,
asciiToHex(parameter[0], parameter[1]));
break;
/* Mirror display - m<01> */
case 'm': dm_setMirror(which, 1); break;
/* Unmirror display M<01> */
case 'M': dm_setMirror(which, 0); break;
/* Copy character to custom character 0 - p<hex> */
case 'p':
dm_copyToCustom(0, asciiToHex(parameter[0], parameter[1])); break;
/* Copy character to custom character 1 - P<hex> */
case 'P':
dm_copyToCustom(1, asciiToHex(parameter[0], parameter[1])); break;
/* Roll matrix n row<s> - r<01><udlr><n> */
case 'r': dm_roll(which,
parameter[1],
parameter[2] - '0');
break;
/* Shift matrix <n> rows - s<01><udlr><n> */
case 's': dm_shift(which,
parameter[1],
parameter[2] - '0');
break;
/* Turn on pixel in custom character - t<01><row><column> */
case 't':
dm_pixel(which, 1, parameter[1] - '0', parameter[2] - '0');
break;
/* Turn off pixel in custom character - T<01><row><column> */
case 'T':
dm_pixel(which, 0, parameter[1] - '0', parameter[2] - '0');
break;
/* Reset all transforms - !<01> */
case '!': dm_reset(which); break;
/* Program custom character columns, display 0 - [01234]<HexHex> */
case '0':
case '1':
case '2':
case '3':
case '4':
dm_progColumn(0, command - '0', asciiToHex(parameter[0], parameter[1]));
break;
/* Program custom character columns, display 1 - [56789]<data> */
case '5':
case '6':
case '7':
case '8':
case '9':
dm_progColumn(1, command -'5', asciiToHex(parameter[0], parameter[1]));
break;
}
command = 0;
paramIndex = 0;
}
return;
}
paramsRemaining = 0;
paramIndex = 0;
switch (input)
{
case 'a':
case 'A':
case 'b':
case 'B':
case 'c':
case 'C':
case 'd':
case 'D':
case 'f':
case 'F':
case 'i':
case 'I':
case 'm':
case 'M':
case 'R':
case '!':
command = input;
paramsRemaining = 1;
break;
case 'p':
case 'P':
case 'l':
case 'L':
command = input;
paramsRemaining = 2;
break;
case 'r':
case 's':
case 't':
case 'T':
command = input;
paramsRemaining = 3;
break;
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
command = input;
paramsRemaining = 2;
break;
case '*':
_wdt_write(1);
break;
case '?':
dm_dumpdisp(0);
dm_dumpdisp(1);
break;
default:
command = 0;
break;
}
}
void mops_trap_writeC_handler(uint32_t character)
{
uart_send_char((char)character);
}
void uart_send_string(const char *s){
int i;
for(i = 0; s[i] != '\0'; ++i){
uart_send_char(s[i]);
}
}
