int main(int argc, char *argv[]) {
clock_init();
led_init();
uart_init();
//interrupt_init();
led_display(64);
fprintf(stream_board, "Welcome to camera test.\n\n");
camera_reset();
fprintf(stream_board, "Camera has reset.\n\n");
//camera_set_baudrate(9600);
//uart_set_baudrate(stream_cam, 9600);
camera_snap();
fprintf(stream_board, "Camera has snapped.\n\n");
uint16_t filesize = camera_get_filesize();
fprintf(stream_cam, "finished, filesize is %d\n", filesize);
/* Get a block */
camera_get_block(0, 16);
camera_stop_image();
while (1) {
fprintf(stream_board, "HELLO\n");
_delay_ms(3000);
}
return 0;
}
static ssize_t led_write(struct file *filp, const char __user *buf, size_t count, loff_t *f_pos)
{
char *k_buf;
k_buf = kmalloc(count, GFP_KERNEL);
if(copy_from_user(k_buf, buf, count))
{
printk("led_write() fail!\n");
return -EFAULT;
}
led_display(k_buf[0]);
kfree(k_buf);
return 0;
}
static int led_init(void)
{
int result;
result = register_chrdev(LED_MAJOR, DEVICE_NAME, &led_fops);
if(result < 0)
{
printk("%d character device driver can't be registered.\n", LED_MAJOR);
return result;
}
GPFCON = 0x55aa;
GPFUP = 0xff;
led_display(0x0);
printk("LED driver registered!\n");
return 0;
}
int main(int argc, char *argv[]) {
clock_init();
uart_init();
led_init();
motor_controller_init();
commander_init();
interrupt_init();
cmd_t cmd = 0;
while (1) {
cmd = get_cmd();
if (cmd != CMD_NONE) {
VERBOSE("motor_test", "Command recieved: [%i]", cmd);
}
switch (cmd) {
case CMD_STOP:
motor_set_movement(VERT_STOPPED, HORIZ_STOPPED);
led_display(0);
break;
case CMD_FORWARD:
motor_set_movement(VERT_FORWARD, HORIZ_STOPPED);
led_display(1);
break;
case CMD_BACK:
motor_set_movement(VERT_BACKWARD, HORIZ_STOPPED);
led_display(2);
break;
case CMD_LEFT:
motor_set_movement(VERT_STOPPED, HORIZ_LEFT);
led_display(3);
break;
case CMD_RIGHT:
motor_set_movement(VERT_STOPPED, HORIZ_RIGHT);
led_display(4);
break;
case CMD_NONE:
// Ignore it
break;
default:
led_display(cmd);
break;
}
}
return 0;
}
/** \brief Main function. */
int main(void)
{
uint8_t i;
/* Initialize the board hardware and system clocks. */
board_init();
sysclk_init();
/* Detection of all RESET excepted WDT RESET. */
if (reset_cause_get_causes() & ~CHIP_RESET_CAUSE_WDT) {
/* Wait for 2 s. */
delay_ms(2000);
state_flag = START_OF_PROG;
reset_cause_clear_causes(
CHIP_RESET_CAUSE_POR |
CHIP_RESET_CAUSE_EXTRST |
CHIP_RESET_CAUSE_BOD_CPU |
CHIP_RESET_CAUSE_OCD |
CHIP_RESET_CAUSE_SOFT |
CHIP_RESET_CAUSE_SPIKE);
} else {
reset_cause_clear_causes(CHIP_RESET_CAUSE_WDT);
}
while (true) {
led_display(state_flag);
switch (state_flag) {
case START_OF_PROG:
/* Writing test. */
wdt_set_timeout_period(WDT_TIMEOUT_PERIOD_8CLK);
if (wdt_get_timeout_period() != WDT_TIMEOUT_PERIOD_8CLK) {
state_flag = ERROR_STATE;
break;
}
wdt_set_timeout_period(WDT_TIMEOUT_PERIOD_250CLK);
if (wdt_get_timeout_period() != WDT_TIMEOUT_PERIOD_250CLK) {
state_flag = ERROR_STATE;
break;
}
/* Wait for 2 s. */
delay_ms(2000);
state_flag = WDT_MCU_RESET;
break;
case WDT_MCU_RESET:
/* Wait for 2 s. */
delay_ms(2000);
state_flag = REFRESH_NO_WIN;
wdt_reset_mcu();
break;
case REFRESH_NO_WIN:
/* Enable WDT 500 ms. */
wdt_set_timeout_period(WDT_TIMEOUT_PERIOD_500CLK);
wdt_enable();
for (i = 0; i < 8; i++) {
/* Wait for 8x 250 ms = 2 s. */
delay_ms(250);
wdt_reset();
}
wdt_disable();
state_flag = REFRESH_WINDOW;
break;
case REFRESH_WINDOW:
/* Enable Window 250 ms & WDT 500 ms. */
wdt_set_timeout_period(WDT_TIMEOUT_PERIOD_500CLK);
wdt_enable();
if (!(wdt_set_window_period(WDT_WINDOW_PERIOD_250CLK)))
{
state_flag = ERROR_STATE;
break;
}
if (!(wdt_enable_window_mode())) {
state_flag = ERROR_STATE;
break;
}
for (i = 0; i < 4; i++) {
/* Wait for 500 ms. */
delay_ms(500);
wdt_reset();
}
wdt_disable();
state_flag = WDT_RST_NO_WIN;
break;
case WDT_RST_NO_WIN:
state_flag = WDT_RST_WINDOW;
/* Enable WDT 2 s. */
wdt_set_timeout_period(WDT_TIMEOUT_PERIOD_2KCLK);
wdt_enable();
while (true) {
/* Wait for Watchdog reset. */
}
break;
case WDT_RST_WINDOW:
state_flag = WDT_RST_RFSH_W;
/* Enable Window 1 s & WDT 1 s. */
wdt_set_timeout_period(WDT_TIMEOUT_PERIOD_1KCLK);
wdt_enable();
if (!(wdt_set_window_period(WDT_WINDOW_PERIOD_1KCLK))) {
state_flag = ERROR_STATE;
break;
}
if (!(wdt_enable_window_mode())) {
state_flag = ERROR_STATE;
break;
}
while (true) {
/* Wait for Watchdog reset. */
}
break;
case WDT_RST_RFSH_W:
state_flag = END_OF_PROG;
/* Enable Window 4 s & WDT 250 ms. */
wdt_set_timeout_period(WDT_TIMEOUT_PERIOD_250CLK);
wdt_enable();
if (!(wdt_set_window_period(WDT_WINDOW_PERIOD_4KCLK))) {
state_flag = ERROR_STATE;
break;
}
if (!(wdt_enable_window_mode())) {
state_flag = ERROR_STATE;
break;
}
/* Wait for 2 s. */
delay_ms(2000);
wdt_reset();
while (true) {
/* Wait for Watchdog reset. */
}
break;
case ERROR_STATE:
while (true) {
led_display(ERROR_STATE);
/* Wait for 500 ms. */
delay_ms(500);
/* Blinking. */
led_display(~ERROR_STATE);
/* Wait for 500 ms. */
delay_ms(500);
}
break;
case END_OF_PROG:
default:
/* Wait for 2 s. */
delay_ms(2000);
reset_do_soft_reset();
break;
}
}
}
UWORD32 mac_isr(UWORD32 vector, UWORD32 data)
{
led_display(0x0F);
if(get_machw_hprx_comp_int() == BTRUE)
{
rx_complete_isr(HIGH_PRI_RXQ);
reset_machw_hprx_comp_int();
g_test_stats.hprxci++;
}
else if(get_machw_rx_comp_int() == BTRUE)
{
rx_complete_isr(NORMAL_PRI_RXQ);
reset_machw_rx_comp_int();
g_test_stats.rxci++;
}
else if(get_machw_tx_comp_int() == BTRUE)
{
tx_complete_isr();
reset_machw_tx_comp_int();
g_test_stats.txci++;
}
else if(get_machw_tbtt_int() == BTRUE)
{
tbtt_isr();
reset_machw_tbtt_int();
g_test_stats.tbtti++;
}
else if(get_machw_error_int() == BTRUE)
{
error_isr();
reset_machw_error_int();
g_test_stats.erri++;
}
else if(get_machw_deauth_int() == BTRUE)
{
deauth_isr();
reset_machw_deauth_int();
g_test_stats.deauthi++;
}
else if(get_machw_txsus_int() == BTRUE)
{
reset_machw_txsus_int();
g_test_stats.txsusi++;
}
else if(get_machw_radar_det_int() == BTRUE)
{
radar_detect_isr();
reset_machw_radar_det_int();
g_test_stats.radardeti++;
}
else if(get_machw_cap_end_int() == BTRUE)
{
reset_machw_cap_end_int();
g_test_stats.capei++;
}
else
{
g_test_stats.uki++;
}
acknowledge_interrupt(vector);
/* Kill time after interrupt is Acked */
add_delay(10);
#ifndef PHY_TEST_CODE
led_display(0xF0);
#endif /* PHY_TEST_CODE */
return OS_ISR_HANDLED;
}
