/**
* Run diagnostic on IR: continuously display the current value.
*/
void diag_ir(void)
{
int i;
u32 data;
/* Set IR sampling frequency */
rct_set_ir_pll();
/* config IR GPIO */
gpio_config_hw(IR_IN);
uart_putstr("running IR diagnostics...\r\n");
uart_putstr("press any key to quit!\r\n");
writel(IR_CONTROL_REG, IR_CONTROL_RESET);
writel(IR_CONTROL_REG, IR_CONTROL_ENB);
for (i = 0; ; i++) {
if (uart_poll())
break;
while (readl(IR_STATUS_REG) == 0x0);
data = readl(IR_DATA_REG);
uart_putdec(data);
uart_putchar(' ');
if (i == 8) {
uart_putstr("\r\n");
i = 0;
}
}
writel(IR_CONTROL_REG, 0x0);
uart_putstr("\r\ndone!\r\n");
}
static int cmd_nand_erase(int argc, char *argv[])
{
u32 start_block, block, blocks, total_blocks;
int i, rval;
total_blocks = flnand.blocks_per_bank * flnand.banks;
if (argc != 3) {
uart_putstr("nand_erase [block] [blocks]!\r\n");
uart_putstr("Total blocks: ");
uart_putdec(total_blocks);
uart_putstr("\r\n");
return -1;
}
putstr("erase nand blocks including any bad blocks...\r\n");
putstr("press enter to start!\r\n");
putstr("press any key to terminate!\r\n");
rval = uart_wait_escape(0xffffffff);
if (rval == 0)
return -1;
strtou32(argv[1], &start_block);
strtou32(argv[2], &blocks);
for (i = 0, block = start_block; i < blocks; i++, block++) {
if (uart_poll())
break;
if (block >= total_blocks)
break;
rval = nand_erase_block(block);
putchar('.');
if ((i & 0xf) == 0xf) {
putchar(' ');
putdec(i);
putchar('/');
putdec(blocks);
putstr(" (");
putdec(i * 100 / blocks);
putstr("%)\t\t\r");
}
if (rval < 0) {
putstr("\r\nfailed at block ");
putdec(block);
putstr("\r\n");
}
}
putstr("\r\ndone!\r\n");
return 0;
}
/**
* Run diagnostic on DRAM: test all regions pass the R/W test. The 1st 1MB
* of DRAM is skipped since the bootloader can't run without it being usable!
*/
void diag_mem(void)
{
int rval;
u32 addr;
uart_putstr("running memory test ...\r\n");
#if (CHIP_REV == I1)
uart_putstr("region 0x00000000 - 0x000fffff skipped\r\n");
#else
uart_putstr("region 0xc0000000 - 0xc00fffff skipped\r\n");
#endif
for (addr = (DRAM_START_ADDR + 0x00100000);
addr <= DRAM_END_ADDR; addr += 0x00100000) {
uart_putstr("testing 0x");
uart_puthex(addr);
uart_putstr(" - 0x");
uart_puthex(addr | 0x000fffff);
uart_putstr(" ... ");
rval = testram3(addr, 0x00100000);
if (rval != 0) {
uart_putstr("\r\nmemory failure at 0x");
uart_puthex(addr);
uart_putstr("!\r\n");
break;
}
uart_putstr("done\r\n");
}
}
int main (void){
DEBUG_INIT();
uart_putstr("\r\n");
cli_rx = uart_getc;
cli_tx = uart_putc;
for(;;){
uart_putstr_P(PSTR("\r\n\r\nCrypto-VS ("));
uart_putstr(algo_name);
uart_putstr_P(PSTR(")\r\nloaded and running\r\n"));
cmd_interface(cmdlist);
}
}
int main (void){
DEBUG_INIT();
uart_putstr("\r\n");
cli_rx = uart_getc;
cli_tx = uart_putc;
shavs_algolist=(hfdesc_t**)algolist;
shavs_algo=(hfdesc_t*)&sha256_desc;
for(;;){
uart_putstr_P(PSTR("\r\n\r\nCrypto-VS ("));
uart_putstr(algo_name);
uart_putstr_P(PSTR(")\r\nloaded and running\r\n"));
cmd_interface(cmdlist);
}
}
void testrun_twister512(void){
twister512_hash_t hash;
char* testv[]={
"",
"a",
"abc",
"message digest",
"abcdefghijklmnopqrstuvwxyz",
"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789",
"12345678901234567890123456789012345678901234567890123456789012345678901234567890"};
uint32_t i;
uart_putstr_P(PSTR("\r\n=== TWISTER-512 test suit (MD5 test values) ==="));
for(i=0; i<7; ++i){
uart_putstr_P(PSTR("\r\n TWISTER-512 (\""));
uart_putstr(testv[i]);
uart_putstr_P(PSTR("\") = \r\n\t"));
twister512(&hash, testv[i], strlen(testv[i])*8);
print_hash(hash);
// return;
}
uart_putstr_P(PSTR("\r\n\r\n=== TWISTER-512 test suit (short test values) ==="));
uint8_t stestv[]= {0x00, 0x00, 0xC0, 0xC0, 0x80, 0x48, 0x50};
uint8_t stestl[]= { 0, 1, 2, 3, 4, 5, 6};
for(i=0; i<7; ++i){
uart_putstr_P(PSTR("\r\n TWISTER-512 (\""));
uart_hexdump(&(stestv[i]), 1);
uart_putstr_P(PSTR("\") = \r\n\t"));
twister512(hash, &(stestv[i]), stestl[i]);
print_hash(hash);
}
#ifdef TWISTER_LONGTEST
uart_putstr_P(PSTR("\r\n\r\n=== TWISTER-512 test suit (long test) ==="));
char* ltest= "abcdefghbcdefghicdefghijdefghijk"
"efghijklfghijklmghijklmnhijklmno";
twister512_ctx_t ctx;
twister512_init(&ctx);
uart_putstr_P(PSTR("\r\n TWISTER-512 ( 16777216 x \""));
uart_putstr(ltest);
uart_putstr_P(PSTR("\") = \r\n\t"));
for(i=0; i<16777216; ++i){
twister512_nextBlock(&ctx, ltest);
}
twister512_ctx2hash(hash, &ctx);
print_hash(hash);
#endif
}
static void RadCalc_EVENT(void) {
if (!Timer_1s) { // Every 1s (1Hz)
Timer_1s = 1000;
if ( _FLAG.LCDExist == _Set ) lcd_ctrl(_FLAG.LCDControl);
static uint16_t table[Ilosc_pomiarow];
static uint8_t index;
uint32_t sr1=0;
ldiv_t result;
table[index++] = pulse_counter;
pulse_counter=0;
if ( index >= Ilosc_pomiarow ) index=0;
for (uint8_t i=0;i<Ilosc_pomiarow;i++) sr1 += table[i];
result = ldiv(sr1,100);
sprintf(SecondLine, " %lu.%02lu uSv/h", result.quot, result.rem);
uart_putnum(sr1,10);
uart_putstr("\r\n");
}
}
bufferStruct receiveSendData(bufferStruct buffer){
bufferStruct result;
if(getAck(buffer.bufferLength, buffer.buffer) & NEED_ACK > 0){
#if STATE_UART_DEBUG >= 2
uart_putstr ("seAck\r\n");
#endif
state = STATE_SENDING_ACK;
backupData.bufferLength = buffer.bufferLength;
memcpy(backupData.buffer, buffer.buffer, buffer.bufferLength);
sendAck(buffer);
} else {
result.bufferLength = getPayloadLength(buffer.bufferLength, buffer.buffer);
memcpy(result.buffer, getPayload(buffer.bufferLength, buffer.buffer), result.bufferLength);
#if STATE_UART_DEBUG >= 3
uart_putc('%');
uart_putc(result.bufferLength);
uart_putc('%');
for(uint8_t i = 0; i < result.bufferLength; ++i){
uart_putc(result.buffer[i]);
}
uart_putc('%');
#endif
}
return result;
}
int main(int argc, char **argv)
{
int8_t *p;
uint8_t c;
// Initialize UART
c = '*'; // print msg on first iteration
for(;;) {
uint32_t start, size;
switch (c) {
case 'u': // upload
start = read_uint32();
size = read_uint32();
for (p = (int8_t *) start; p < (int8_t *) (start+size); p++)
*p = uart_getchar();
break;
case 'd': // download
start = read_uint32();
size = read_uint32();
for (p = (int8_t *) start; p < (int8_t *) (start+size); p++)
uart_putchar( *p );
break;
case 'g': // goto
start = read_uint32();
jump(start);
break;
default:
uart_putstr("**SAKC/bootloader** > \r\n");
break;
};
c = uart_getchar();
}
}
void
#else
uint8_t
#endif
rfm12_tx(uint8_t len, uint8_t type, uint8_t *data)
{
#if RFM12_UART_DEBUG
uart_putstr ("rfm12_tx\r\n");
#endif
if (len > RFM12_TX_BUFFER_SIZE) return TXRETURN(RFM12_TX_ERROR);
//exit if the buffer isn't free
if (ctrl.txstate != STATUS_FREE)
{
return TXRETURN(RFM12_TX_OCCUPIED);
}
memcpy ( rf_tx_buffer.buffer, data, len );
#if (!(RFM12_NORETURNS))
return rfm12_start_tx (type, len);
#else
rfm12_start_tx (type, len);
#endif
}
/**
* @brief AC task to communicate to air-condition by alternating current
* @param None
* @retval None
*/
void AC_task(void * pvParameters)
{
while(1)
{
vTaskDelay(2000);
uart_putstr("AC_task start.");
}
}
/*-----------*/
int main(void) {
uint8_t x;
_INIT();
wdt_enable(WDTO_1S);
usbInit();
usbDeviceDisconnect(); // enforce re-enumeration, do this while interrupts are disabled!
x = 25;
while(--x) { // fake USB disconnect for > 250 ms
wdt_reset();
_delay_ms(10);
}
usbDeviceConnect();
pulse_counter = 0;
sei();
DisplayRefresh(1);
x = 100;
while(--x) {
wdt_reset();
_delay_ms(10);
}
ClearLine(SecondLine);
DisplayRefresh(1);
uart_init(__UBRR);
uart_putstr("\r\n");
uart_putstr("Radioactive@Home V2.60\r\n");
uart_putstr("Firmware 1.0 (27.03.14)\r\n");
while(1) {
wdt_reset();
usbPoll();
HV_Supply_EVENT();
BeepIfChange_EVENT();
Switch_EVENT();
RadCalc_EVENT();
DisplayRefresh_EVENT();
}
return 0;
}
void sendData(bufferStruct buffer, uint8_t ack){
#if STATE_UART_DEBUG >=2
uart_putstr("seData\r\n");
#endif
state = STATE_SENDING_DATA;
memcpy(backupData.buffer, buffer.buffer, buffer.bufferLength);
backupData.bufferLength = buffer.bufferLength;
backupType = ack;
rfm12_tx (buffer.bufferLength+OVERHEAD, encode(ack, SEND_DATA, 0x05, buffer.bufferLength, buffer.buffer));
if(ack & NEED_ACK){
#if STATE_UART_DEBUG >=2
uart_putstr("expAck\r\n");
#endif
state = STATE_EXPECKT_ACK;
startTimer();
}
}
/**
* @brief DC task to communicate to air-condition by direct current
* @param None
* @retval None
*/
void DC_task(void * pvParameters)
{
while(1)
{
vTaskDelay(1500);
uart_putstr("DC_task start.");
xQueueSend(DCSendQueue, (void*)&air_condition_current, 0 );
}
}
void testrun_performance_twister512(void){
uint64_t t;
char str[16];
uint8_t data[64];
twister_big_ctx_t ctx;
calibrateTimer();
print_overhead();
memset(data, 0, 64);
startTimer(1);
twister_big_init(&ctx, 512);
t = stopTimer();
uart_putstr_P(PSTR("\r\n\tctx-gen time: "));
ultoa((unsigned long)t, str, 10);
uart_putstr(str);
startTimer(1);
twister_big_nextBlock(&ctx, data);
t = stopTimer();
uart_putstr_P(PSTR("\r\n\tone-block time: "));
ultoa((unsigned long)t, str, 10);
uart_putstr(str);
startTimer(1);
twister_big_lastBlock(&ctx, data, 0);
t = stopTimer();
uart_putstr_P(PSTR("\r\n\tlast block time: "));
ultoa((unsigned long)t, str, 10);
uart_putstr(str);
startTimer(1);
twister_big_ctx2hash(data, &ctx, 512);
t = stopTimer();
uart_putstr_P(PSTR("\r\n\tctx2hash time: "));
ultoa((unsigned long)t, str, 10);
uart_putstr(str);
uart_putstr_P(PSTR("\r\n"));
}
/**
* @brief Main task run in the background all the time
* @param None
* @retval None
*/
void Main_task(void * pvParameters)
{
struct air_condition air_condition_main;
while(1)
{
//vTaskDelay(2000);
uart_putstr("Main_task start.");
if(xQueueReceive(DCSendQueue,&air_condition_main, 100/portTICK_RATE_MS )==pdPASS)
{
if(air_condition_main.air_fault==1)
{
//иб╔Щ╣╩Н¤
}
else
{
air_condition_main.month=RTC_DateStruct_get.RTC_Month;
air_condition_main.day=RTC_DateStruct_get.RTC_Date;
air_condition_main.week=RTC_DateStruct_get.RTC_WeekDay;
air_condition_main.hour=RTC_TimeStruct_get.RTC_Hours;
air_condition_main.minute=RTC_TimeStruct_get.RTC_Minutes;
Flash_Write_UserData(air_condition_main);
}
}
else if(xQueueReceive(ACSendQueue,&air_condition_main, 100/portTICK_RATE_MS )==pdPASS)
{
if(air_condition_main.air_fault==1)
{
//иб╔Щ╣╩Н¤
}
else
{
air_condition_main.month=RTC_DateStruct_get.RTC_Month;
air_condition_main.day=RTC_DateStruct_get.RTC_Date;
air_condition_main.week=RTC_DateStruct_get.RTC_WeekDay;
air_condition_main.hour=RTC_TimeStruct_get.RTC_Hours;
air_condition_main.minute=RTC_TimeStruct_get.RTC_Minutes;
Flash_Write_UserData(air_condition_main);
}
}
else if(xQueueReceive(WifiSendQueue,&air_condition_main, 100/portTICK_RATE_MS )==pdPASS)
{
}
else if(xQueueReceive(TouchSendQueue,&air_condition_main, 100/portTICK_RATE_MS )==pdPASS)
{
}
else if(RTC_TimeStruct_get.RTC_Minutes==30||RTC_TimeStruct_get.RTC_Minutes==0)
{
}
}
}
int parse_command(char *cmdline)
{
cmdlist_t *cmd;
int argc, num_commands, len;
char buf[MAX_CMD_ARGS][MAX_ARG_LEN];
char *argv[MAX_CMD_ARGS];
for (argc = 0; argc < MAX_CMD_ARGS; argc++)
argv[argc] = &buf[argc][0];
parse_args(cmdline, &argc, argv);
if (argc == 0)
return 0;
num_commands = get_num_command_matches(argv[0]);
if (num_commands < 0)
return num_commands;
if (num_commands != 1) {
uart_putstr("'");
uart_putstr(argv[0]);
uart_putstr("' is not a recognized command! ");
uart_putstr("Type 'help' for help...\r\n");
return -1;
}
len = strlen(argv[0]);
for (cmd = commands; cmd != NULL; cmd = cmd->next) {
if (cmd->magic != COMMAND_MAGIC) {
return -2;
}
if (strncmp(cmd->name, argv[0], len) == 0) {
return cmd->fn(argc, argv);
}
}
return -3;
}
int main()
{
//uint32_t x=1;
//uint8_t c;
//uint8_t flag;
// Initialize UART
//c='u';
uart_putchar('i');
//gpio0->dir=0x0F;
uint32_t tiempo;
uint32_t hbe=0; //el enable ha sido activado
gpio0->dir=0x0F;
uint32_t flag;
while(1)
{
uart_putstr("Entró al while");
flag=gpio0->read;
if(hbe==0 && (flag & 0x40)){
medir_flancopos();
hbe=1;
uart_putstr("Entró al primer if");
}
if(hbe==1 && !(flag & 0x40)){
tiempo=medir_flanconeg();
hbe=0;
uart_putstr("Entró al segundo if");
}
uart_putstr("La duración del pulso es" + tiempo);
}
}
int8_t hh10d_read(struct packet_t *packet) {
int RH;
char buf[6];
uart_putstr_P(PSTR("hh10d read\r\n"));
RH = (offset - (double)old_cnt) * sens / 4096.0;
#ifdef DEBUG
itoa(old_cnt,buf,10);
uart_putstr(buf);
uart_putstr_P(PSTR("\r\n"));
itoa(RH,buf,10);
uart_putstr(buf);
uart_putstr_P(PSTR("\r\n"));
#endif
if (get_remaining_length(packet) < 2) return -1;
return set_data_int16(packet,RH);
}
static int cmd_exec(int argc, char *argv[])
{
u32 addr;
void (*jump_to_img)(void) = NULL;
if (argc != 2 || strtou32(argv[1], &addr) < 0) {
uart_putstr("address (eg. 0x");
uart_puthex(DRAM_START_ADDR + 0x00100000);
uart_putstr(") is required\r\n");
return -1;
}
if (addr < (DRAM_START_ADDR + 0x00100000) ||
addr > (DRAM_START_ADDR + DRAM_SIZE - 1)) {
uart_putstr("address out of range!\r\n");
return -1;
}
jump_to_img = (void *) addr;
if (jump_to_img != 0x0) {
uart_putstr("jumping to 0x");
uart_puthex(addr);
uart_putstr(" ...\r\n");
_clean_flush_all_cache();
_disable_icache();
_disable_dcache();
disable_interrupts();
__asm__ __volatile__ ("nop");
__asm__ __volatile__ ("nop");
__asm__ __volatile__ ("nop");
__asm__ __volatile__ ("nop");
jump_to_img();
}
return 0;
}
/**
* @brief Touch task to display the UI and communicate with the users
* @param None
* @retval None
*/
void Touch_task(void * pvParameters)
{
while(1)
{
vTaskDelay(2000);
uart_putstr("Touch_task start.");
RTC_GetTime(RTC_Format_BCD, &RTC_TimeStruct_get);
RTC_GetDate(RTC_Format_BCD, &RTC_DateStruct_get);
uart_putchar(RTC_TimeStruct_get.RTC_Hours);
uart_putchar(RTC_TimeStruct_get.RTC_Minutes);
uart_putchar(RTC_TimeStruct_get.RTC_Seconds);
}
}
void process_cmd(void)
{
uart_putstr("Processing command: ");
uart_putstr(cmdbuf);
UART_PUTS("\r\n");
if ((cmdbuf[0] == 'w') && (strlen(cmdbuf) == 5))
{
if (enable_write_eeprom)
{
uint16_t adr = hex_to_byte((uint8_t)cmdbuf[1]) * 16 + hex_to_byte((uint8_t)cmdbuf[2]);
uint8_t val = hex_to_uint8((uint8_t *)cmdbuf, 3);
UART_PUTF2("Writing data 0x%x to EEPROM pos 0x%x.\r\n", val, adr);
eeprom_write_byte((uint8_t *)adr, val);
}
else
{
UART_PUTS("Ignoring EEPROM write, since write mode is DISABLED.\r\n");
}
}
else if ((cmdbuf[0] == 'r') && (strlen(cmdbuf) == 3))
{
uint16_t adr = hex_to_byte((uint8_t)cmdbuf[1]) * 16 + hex_to_byte((uint8_t)cmdbuf[2]);
uint8_t val = eeprom_read_byte((uint8_t *)adr);
UART_PUTF2("EEPROM value at position 0x%x is 0x%x.\r\n", adr, val);
}
else if ((cmdbuf[0] == 's') && (strlen(cmdbuf) > 4))
{
strcpy(sendbuf, cmdbuf + 1);
send_data_avail = true;
}
else
{
UART_PUTS("Unknown command.\r\n");
}
}
void testrun_performance_sha256(void){
uint64_t t;
char str[16];
uint8_t data[32];
sha256_ctx_t ctx;
calibrateTimer();
print_overhead();
memset(data, 0, 32);
startTimer(1);
sha256_init(&ctx);
t = stopTimer();
uart_putstr_P(PSTR("\r\n\tctx-gen time: "));
ultoa((unsigned long)t, str, 10);
uart_putstr(str);
startTimer(1);
sha256_nextBlock(&ctx, data);
t = stopTimer();
uart_putstr_P(PSTR("\r\n\tone-block time: "));
ultoa((unsigned long)t, str, 10);
uart_putstr(str);
startTimer(1);
sha256_lastBlock(&ctx, data, 0);
t = stopTimer();
uart_putstr_P(PSTR("\r\n\tlast block time: "));
ultoa((unsigned long)t, str, 10);
uart_putstr(str);
uart_putstr_P(PSTR("\r\n"));
}
int main(int argc, char **argv)
{
uint32_t scan_size = 16*1024; // scan 16 kByte
// Initialize stuff
uart_init();
uart_putstr("\r\n\r\n** SOC-LM32 DDR PAHSER **\n\n");
uart_putstr("'O' => Memtest OK ; '-' => Memtest failed\n\n");
uart_putstr("Press [u] for upward scan, [d] for downward\n");
for(;;) {
uint8_t c = uart_getchar();
switch (c) {
case 'u': // scan upward
scan_phase(1, scan_size);
break;
case 'd': // scan downward
scan_phase(-1, scan_size);
break;
}
}
}
//hexdump utility
void uart_hexdump(unsigned char *buf, int len)
{
unsigned char x=0;
char sbuf[3];
while(len--){
itoa(*buf++, sbuf, 16);
if (sbuf[1] == 0) uart_putc(' ');
uart_putstr(sbuf);
uart_putc(' ');
if(++x == 16) {
uart_putstr_P(PSTR("\r\n"));
x = 0;
}
}
}
void send_dimmer_status(void)
{
UART_PUTS("Sending Dimmer Status:\r\n");
// set device ID
bufx[0] = device_id;
// update packet counter
packetcounter++;
if (packetcounter % PACKET_COUNTER_WRITE_CYCLE == 0)
{
eeprom_write_dword((uint32_t*)0, packetcounter);
}
setBuf32(1, packetcounter);
// set command ID "Dimmer Status"
bufx[5] = 30; // TODO: Move command IDs to global definition file as defines
// set current brightness
bufx[6] = (uint8_t)(current_brightness * 255 / 100);
// set end brightness
bufx[7] = end_brightness;
// set total animation time
setBuf16(8, (uint16_t)(animation_length * ANIMATION_CYCLE_MS / 1000));
// set time until animation finishes
setBuf16(10, (uint16_t)((animation_length - animation_position) * ANIMATION_CYCLE_MS / 1000));
// set CRC32
uint32_t crc = crc32(bufx, 12);
setBuf32(12, crc);
// show info
UART_PUTF("CRC32: %lx\r\n", crc);
uart_putstr("Unencrypted: ");
printbytearray(bufx, 16);
rfm12_sendbuf();
UART_PUTS("Send encrypted: ");
printbytearray(bufx, 16);
UART_PUTS("\r\n");
}
/* Initialise board */
void bugone_init(application_t* applications) {
char buf[16];
uint8_t i;
uint8_t nb_devices=0;
application_t *app=applications;
led_init();
uart_init();
rfm12_init();
config_init();
/* Count how many devices are declared */
while (!((app->init == NULL) &&
(app->get == NULL) &&
(app->set == NULL) &&
(app->cfg == NULL))) {
nb_devices++;
app++;
}
set_apps(applications,nb_devices);
uart_putstr_P(PSTR("Firmware version "));
uart_putstr_P(PSTR(FWVERSION_STR));
uart_putstr_P(PSTR("\r\n"));
uart_putstr_P(PSTR("Node address : "));
itoa(config.address,buf,10);
uart_putstr(buf);
uart_putstr_P(PSTR("\r\n"));
for (i=0 ; i < nb_devices; i++) {
uart_putc('*');
if (applications[i].init == NULL) { continue; }
applications[i].init(applications[i].cfg);
}
timer1_init();
sei();
uart_putstr_P(PSTR("AVR init complete\r\n"));
//clr_output(LED1);
//clr_output(LED2);
}
void hexprint(unsigned int hexval)
{
unsigned char digit[8];
int pos;
uart_putstr("0x");
for(pos = 0; pos < 8; pos++)
{
digit[pos] = (hexval & 0x0F); /* last hexit */
hexval = hexval >> 4;
}
for(pos = 7; pos > -1; pos--)
{
if( digit[pos] < 0x0A)
uart_putchar(digit[pos] + '0' );
else
uart_putchar(digit[pos] + 'A' - 10);
}
uart_putchar('.');
}
/** @brief Main function for UART example / test program.
*
* @return None (never returns).
*
* Sits in a loop waiting for characters on the given UART, then sends
* a string telling what it got.
*/
int main()
{
/* Choose the UART to use for test */
UART_Type *uart = UART;
uint8_t c;
/* Set up uart for 8n2 */
init_uart(uart, BAUD);
uart_putstr(uart, "Now echoing characters: ");
/* Loop forever, reporting what is received */
while(1) {
if (uart_available(uart)) {
c = uart_getchar(uart);
uart_putchar(uart, c);
}
}
}
/*****************************************************************
*SPI Functions
*/
void spi_test()
{
uart_putstr("Begin SPI Test \n");
//int i;
for(;;)
{
spi0->ssr=0;
spi0->txr = 0x50 ; // Probado en el osciloscopio
spi0->txr = 0x53 ;
spi0->txr = 0x00 ;
spi0->txr = 0x01 ;
}
//uart_putstr("Begin SPI Test \n");
//int32_t aux_read;
//int i;
//spi0->txr = 0x4B; //01001011 --> First 01: Read mode ! ---> 1011: Memoria ADXL
//Se debe enviar la direccion del registro que quiero leer..
//NO LA DIRECCION DEL ESCLAVO. ESO ES I2C !
//for(i = 0;i<100;i++){}
//aux_read = spi0->rxr;
//writeint(aux_read);
//uart_putstr("\n End SPI Test \n");
/*if(spi0->sr&20)// If TRDY (5 bit of Status register)
{
uart_putstr("al IF \n");
aux_read = spi0->rxr;
writeint(aux_read);
}
else
{
uart_putstr("Else \n");
aux_read = spi0->rxr;
writeint(aux_read);
}
uart_putstr("End SPI Test \n");
*/
}
