void uart0_gets(char *buf, int len)
{
int i;
for (i = 0; i < len - 1; i++)
{
buf[i] = uart0_getc();
if (buf[i] == '\r')
{
break;
}
//abc‘back'
//0123
//'back'
if (buf[i] == '\b' || buf[i] == 127)
{
i--;
if (i < 0)
{
continue;
}
uart0_putc('\b');
uart0_putc(' ');
uart0_putc('\b');
i--;
continue;
}
uart0_putc(buf[i]);
}
buf[i] = 0;
}
int uart0_putchar (int ch) { /* Write Character to Serial Port */
if (ch == '\n') { /* Check for LF */
uart0_putc( '\r' ); /* Output CR */
}
return uart0_putc( ch ); /* Transmit Character */
}
void send_msg(uint8_t code, uint16_t msg)
{
uint8_t *msg_ar = (uint8_t*)&msg;
uart0_putc(code);
for(int i=0; i<2; i++)
uart0_putc(msg_ar[i]);
}
void dreh_task(INT8U my_id, INT8U my_state, INT8U event, INT8U data)
{
static INT8S enc_states[] = { 0, -1, 1, 0, 1, 0, 0, -1, -1, 0, 0, 1, 0, 1, -1, 0 };
static INT8U old_ab = 0;
static INT8U countTwo = 0;
old_ab <<= 2;
old_ab |= (((DREH_A) << 1) | (DREH_B));
INT8S val = enc_states[(old_ab & 0x0F)];
if (val != 0)
{
if (countTwo)
{
if (val == 1)
{
uart0_putc('R');
}
else if (val == -1)
{
uart0_putc('L');
}
countTwo = 0;
}
else
{
countTwo++;
}
}
}
int writepacket(uint8_t *packet_buf, size_t size)
{
uint8_t *byte_ptr = packet_buf;
while ((size_t)(byte_ptr - packet_buf) < size) {
if ((size_t)(byte_ptr - packet_buf) > BORDER_BUFFER_SIZE) {
return -1;
}
switch (*byte_ptr) {
case (END): {
*byte_ptr = END_ESC;
uart0_putc(ESC);
break;
}
case (ESC): {
*byte_ptr = ESC_ESC;
uart0_putc(ESC);
break;
}
default: {
break;
}
}
uart0_putc(*byte_ptr);
byte_ptr++;
}
uart0_putc(END);
return (byte_ptr - packet_buf);
}
void println(char* s) {
for (;;) {
char c = *s++;
if (c == 0)
break;
uart0_putc(c);
}
uart0_putc('\n');
}
static int __dbg_putchar(char c, FILE *stream)
{
static char p = 0;
(void) stream;
if (c == '\n' && p != '\r')
uart0_putc('\r');
p = c;
uart0_putc(c);
return 0;
}
_ssize_t _read_r(
struct _reent *r,
int file,
void *ptr,
size_t len)
{
char c;
int i;
unsigned char *p;
p = (unsigned char*)ptr;
for (i = 0; i < len; i++) {
// c = uart0Getch();
// c = uart0GetchW();
while ( !iFdvUart_kbhit() ) ;
c = (char) uart0_getc();
if (c == 0x0D) {
*p='\0';
break;
}
*p++ = c;
uart0_putc(c);
}
return len - i;
}
void cmd_boot_linux(void){
//1.从nand flash 0x600000读取内核到内存0x20008000，读取大小0xC00000
//特殊情况：板子的nand flash有坏块
//nand_page_read(test_buf,0);
uart0_puts("\nloading kernel...");
unsigned int *ptr = (unsigned int *)0x20008000;
unsigned int page = 0x600000/NF_PAGE_SIZE;
int i ;
for(i = 0;i < 6000;i++){
uart0_putc('.');
uart0_puts("^_^");
nand_page_read(ptr,page);
ptr += NF_PAGE_SIZE/4;//偏移NF_PAGE_SIZE
page++;//加1页
}
uart0_puts("\nrun linux ...");
//2.调用0x20008000处的程序(函数指针)
func_t kernel_start;
kernel_start = (func_t)0x20008000;
kernel_start(0,2456,0);
//第一个参数0，内核已经不使用了
//第二个参数，当编译内核时为开发板指定的一个号，
//内核启动时会判断引导程序传给内核的参数和编译内核时指定的值是否一样；
//如果一样内核继续执行，如果不一样，内核停止执行；
//第三个参数，引导程序和内核传递参数 的 内存地址；内核根据给定地址找参数；该内存地址是引导和内核共享的内存；
//给0是因为Image是使用默认参数的，不需要引导程序传递；
//uart0_puts("\nkernel run end");
}
static int uartstream_putchar(char c, FILE *stream)
{
if ('\n' == c)
uartstream_putchar('\r', stream);
uart0_putc((uint8_t) c);
return 0;
}
void uart0_puts(const char *s )
{
while (*s) {
uart0_putc(*s++);
}
} /* uart0_puts */
//------------------------------------------------------------------------------------------------//
//---------------------------- Function for send string via UART1---------------------------------//
//------------------------------------------------------------------------------------------------//
void uart0_puts(char *p)
{
while(*p) // Point to character
{
uart0_putc(*p++); // Send character then point to next character
}
}
void debug_char(char c){
static char initialised = 0;
if (!initialised){
uart0_init();
initialised=1;
}
uart0_putc(c);
}
int uart0_putc_stream( char c, FILE *stream )
{
if( c == '\n' )
uart0_putc_stream( '\r', stream );
uart0_putc(c);
return 0;
}
void uart0_puts(const char *str)
{
if (0 == str)
{
return ;
}
while(*str)
{
uart0_putc(*str);
if (*str == '\n')
{
uart0_putc('\r');
}
str++;
}
}
_ssize_t _write_r (
struct _reent *r,
int file,
const void *ptr,
size_t len)
{
int i;
const unsigned char *p;
p = (const unsigned char*) ptr;
for (i = 0; i < len; i++) {
if (*p == '\n' ) uart0_putc('\r');
uart0_putc(*p++);
}
return len;
}
int main(void)
{
timeCount = 0;
hardwareInit();
uart0_init(BAUD_SETTING);
/* Initialise timer to divide by 1025, giving 32ms time tick */
timer0Init(0,5);
rfm12_init();
wdtInit();
sei();
indx = 0;
for(;;)
{
wdt_reset();
uint8_t sendMessage = false;
uint16_t character = uart0_getc();
/* Wait for a serial incoming message to be built. */
if (character != UART_NO_DATA)
{
inBuf[indx++] = (uint8_t)(character & 0xFF);
/* Signal to transmit if a CR was received, or string too long. */
sendMessage = ((indx > MAX_MESSAGE) || (character == 0x0D));
}
/* Send a transmission if message is ready to send, or something was
received and time waited is too long. */
if (sendMessage || (timeCount++ > TIMEOUT))
{
/* Wait for the transmit buffer to be freed and message loaded. */
if ((indx > 0) && (rfm12_tx(indx, 0, inBuf) != RFM12_TX_OCCUPIED))
indx = 0;
timeCount = 0;
}
rfm12_tick();
/* If an RF incoming message has been received, take it from the buffer one
character at a time and transmit via the serial port. */
if (rfm12_rx_status() == STATUS_COMPLETE)
{
uint8_t *bufferContents = rfm12_rx_buffer();
uint8_t messageLength = rfm12_rx_len();
uint8_t i;
for (i=0;i<messageLength;i++)
{
uart0_putc(bufferContents[i]);
}
/* Clear the "in use" status of the receive buffer to be available for
rfm12lib. */
rfm12_rx_clear();
}
}
}
int uart0_puts ( char* s )
{
int i = 0;
while ( *s ) {
uart0_putc( *s++ );
i++;
}
return i;
}
/*===========================================================================
U A R T 0 _ P U T C
---------------------------------------------------------------------------*/
static int uart0_putc(char ch, FILE *f)
{
if(ch == '\n') {
uart0_putc('\r', f);
}
while ( !( UCSR0A & (1<<UDRE0)) );
UDR0 = ch;
return (ch);
}
int
_write (int file,
char * ptr,
int len)
{
int r;
for(r=0;r<len;r++){
uart0_putc(ptr[r]);
}
return len;
}
void ccRx(void) {
PORTC &= ~_BV(PC2);
_delay_ms(20);
uint8_t receiver_buf[7];
command(SFRX); // command to flush RX FIFO
_delay_ms(1);
command(SRX); // command to receive data wirelessly
while( (MASK_MARCSTATE(cc2500_get_status(CC2500_MARCSTATE)) != MARCSTATE_IDLE_STATE) ) { //ждать пока не закончится прием пакета
cc2500_get_status(CC2500_PKTSTATUS);
}
if ( cc2500_get_status(CC2500_RXBYTES) == 0 ) { //exit if rx fifo empty(autoflush)
PORTC |= _BV(PC3) | _BV(PC5);
_delay_ms(200);
PORTC &= ~(_BV(PC3) | _BV(PC5));
return;
}
cc2500_fifo_read(receiver_buf, 7);
command(SFRX); // flush receiver FIFO if owerflow state
command(SIDLE); // turn CC2500 into idle mode
command(SFRX); // flush receiver FIFO in IDDLE mode
receiver_buf[2] = *(uint8_t *)&freq;
receiver_buf[3] = *(((uint8_t *)&freq)+1);
receiver_buf[4] = cc2500_get_status(CC2500_RSSI);
receiver_buf[5] = cc2500_get_rssi();
RS485_DE_HIGH;
for(uint8_t i=0; i<7; i++) {
uart0_putc(receiver_buf[i]);
}
//uart0_puts((const char *)receiver_buf);
_delay_ms(10);
RS485_DE_LOW;
//test LED ON if packet received and data correct
// if (receiver_buf[0] == 0x6A) {
// PORTC |= _BV(PC3);
// _delay_ms(200);
// }
// if (receiver_buf[1] == 0x6A) {
// PORTC |= _BV(PC4);
// _delay_ms(200);
// }
// if (receiver_buf[2] == 0x6A) {
// PORTC |= _BV(PC5);
// _delay_ms(200);
// }
// PORTC &= ~( _BV(PC3) | _BV(PC4) | _BV(PC5) );//LED OFF
// _delay_ms(100);
//receive();
//send();
CC_state=CC_IDLE;
}
// wait a few milliseconds for proper ACK, return true if received
static bool waitForAck() {
millis_t now = millis();
while (millis() - now <= ACK_TIME){
if (rf12_recvDone() && rf12_crc == 0 &&
// see http://talk.jeelabs.net/topic/811#post-4712
rf12_hdr == (RF12_HDR_DST | RF12_HDR_CTL | NODEID))
return true; uart0_putc(rf12_hdr);
set_sleep_mode(SLEEP_MODE_IDLE);
sleep_mode();
}
return false;
}
/**
@brief Network receive callback function
@param[in] *arg: unused
@param[in] *data: Data received
@param[in] length: Length of data received
@return void
*/
MEMSPACE
static void tcp_data_receive_callback(void *arg, char *data, uint16_t length)
{
uint16_t current;
uint8_t byte;
// Echo debug
#if 0
for(current = 0; current < length; current++)
uart0_putc(data[current]);
#endif
// FIXME NOT WORKING
//
for(current = 0; (current < length) && queue_space(uart_send_queue); current++)
{
byte = (uint8_t)data[current];
queue_pushc(uart_send_queue, byte);
}
if(queue_empty(uart_send_queue) && tx_fifo_empty(0))
uart_tx_disable(0);
else
uart_tx_enable(0);
}
void callback_uart0_putc(uint8_t value)
{
uart0_putc(value);
}
void numpad_task(void *pvParameters)
/*****************************************************************************
* Input : -
* Output : -
* Function : Disable global interrupt
******************************************************************************/
{
numpad_init();
while (1) {
static INT16U button_prev = 0;
volatile INT16U button_state = 0;
volatile INT8U temp = 0;
INT8U btn;
//Clear column pins and set column 1 high
GPIO_PORTA_DATA_R &= !((1 << NUMPAD_COLUMN_1) | (1 << NUMPAD_COLUMN_2)
| (1 << NUMPAD_COLUMN_3));
GPIO_PORTA_DATA_R |= (1 << NUMPAD_COLUMN_1);
//Read in the entire row port
temp = GPIO_PORTE_DATA_R;
//Clear column pins and set column 2 high
GPIO_PORTA_DATA_R &= !((1 << NUMPAD_COLUMN_1) | (1 << NUMPAD_COLUMN_2)
| (1 << NUMPAD_COLUMN_3));
GPIO_PORTA_DATA_R |= (1 << NUMPAD_COLUMN_2);
//Mask out all bits that aren't row data
temp &= (1 << NUMPAD_ROW_1) | (1 << NUMPAD_ROW_2) | (1 << NUMPAD_ROW_3)
| (1 << NUMPAD_ROW_4);
button_state = temp;
//Read in the entire row port
temp = GPIO_PORTE_DATA_R;
//Clear column pins and set column 3 high
GPIO_PORTA_DATA_R &= !((1 << NUMPAD_COLUMN_1) | (1 << NUMPAD_COLUMN_2)
| (1 << NUMPAD_COLUMN_3));
GPIO_PORTA_DATA_R |= (1 << NUMPAD_COLUMN_3);
//Mask out all bits that aren't row data
temp &= (1 << NUMPAD_ROW_1) | (1 << NUMPAD_ROW_2) | (1 << NUMPAD_ROW_3)
| (1 << NUMPAD_ROW_4);
button_state |= (temp << 4);
//Read in the entire row port
temp = GPIO_PORTE_DATA_R;
//Mask out all bits that aren't row data
temp &= (1 << NUMPAD_ROW_1) | (1 << NUMPAD_ROW_2) | (1 << NUMPAD_ROW_3)
| (1 << NUMPAD_ROW_4);
button_state |= (temp << 8);
if (button_prev != button_state) {
for (int i = 0; i < 12; i++) {
if ((button_state & (1 << i)) != (button_prev & (1 << i))) {
if (button_state & (1 << i)) {
switch (i) {
case NUMPAD_ZERO:
btn = '0';
uart0_putc('0');
//put_queue(Q_INPUT,'0',0);
//queue_put(&numpad_input_queue,'0');
break;
case NUMPAD_ONE:
btn = '1';
uart0_putc('1');
//put_queue(Q_INPUT,'1',0);
//queue_put(&numpad_input_queue,'1');
break;
case NUMPAD_TWO:
btn = '2';
uart0_putc('2');
//put_queue(Q_INPUT,'2',0);
//queue_put(&numpad_input_queue,'2');
break;
case NUMPAD_THREE:
btn = '3';
uart0_putc('3');
//put_queue(Q_INPUT,'3',0);
//queue_put(&numpad_input_queue,'3');
break;
case NUMPAD_FOUR:
btn = '4';
uart0_putc('4');
//put_queue(Q_INPUT,'4',0);
//queue_put(&numpad_input_queue,'4');
break;
case NUMPAD_FIVE:
btn = '5';
uart0_putc('5');
//put_queue(Q_INPUT,'5',0);
//queue_put(&numpad_input_queue,'5');
break;
case NUMPAD_SIX:
btn = '6';
uart0_putc('6');
//put_queue(Q_INPUT,'6',0);
//queue_put(&numpad_input_queue,'6');
break;
case NUMPAD_SEVEN:
btn = '7';
uart0_putc('7');
//put_queue(Q_INPUT,'7',0);
//queue_put(&numpad_input_queue,'7');
break;
case NUMPAD_EIGHT:
btn = '8';
uart0_putc('8');
//put_queue(Q_INPUT,'8',0);
//queue_put(&numpad_input_queue,'8');
break;
case NUMPAD_NINE:
btn = '9';
uart0_putc('9');
//put_queue(Q_INPUT,'9',0);
//queue_put(&numpad_input_queue,'9');
break;
case NUMPAD_HASH:
btn = '#';
uart0_putc('#');
//put_queue(Q_INPUT,'#',0);
//queue_put(&numpad_input_queue,'#');
break;
case NUMPAD_STAR:
btn = '*';
uart0_putc('*');
//put_queue(Q_INPUT,'*',0);
//queue_put(&numpad_input_queue,'*');
break;
default:
break;
}
xQueueSend(GUI_queue,&btn,10000);
}
}
}
button_prev = button_state;
}
vTaskDelay(30 / portTICK_RATE_MS);
}
//wait( NUMPAD_DEBOUNCE_TIME); //
}
int main(void)
{
//STATIC_ASSERT(sizeof(uint16_t) == 2);
InitGPIO();
InitSPI_soft();
InitI2C_soft();
InitADC();
InitSystemTimer();
InitTimers();
InitMessages();
InitCC2500(preferredSettings); //(const uint8_t **)conf(+6bytes of code), preferredSettings
uart0_init( UART_BAUD_SELECT(RS485_BAUDRATE, F_CPU) );
//_delay_ms(5000);
//InitEXTI();
//MCUCR |= (_BV(ISC11) | _BV(ISC01));
/*check Watchdog reset flag*/
if(bit_is_set(MCUCSR, WDRF)) {
//increase wathcdog reset counter and save in eeprom
}
set_sleep_mode(SLEEP_MODE_IDLE); //варианты SLEEP_MODE_PWR_SAVE SLEEP_MODE_IDLE SLEEP_MODE_ADC
//wdt_enable(WDTO_2S);
sei(); //enable interrupts
for (uint8_t i = 0; i<0x05; i++) {
//_spi_start();
//spi_TxRx(0x9D);
//_spi_stop();
_delay_ms(100);
PORTC |= _BV(PC2); //blink for test
_delay_ms(100);
PORTC &= ~_BV(PC2);
_delay_ms(100);
RS485_DE_HIGH;
uart0_putc(0xba);
_delay_ms(2);
RS485_DE_LOW;
}
RS485_DE_LOW;
while(1) {
cc_table_state[CC_state]();
ProcessTimers(&sys_timer);
ProcessMessages();
wdt_reset();
/*enter in sleep mode until interrupts occured*/
// cli(); //disable interrupts
// if (some_condition)
// {
// sleep_enable();
// sei();
// sleep_cpu();
// sleep_disable();
// }
// sei();
}
return 0;
}
