/**
* Only used in UDP mode. First call will send the start marker. When all
* ttcp data has been sent, a number of end markers will be sent. After
* end marker transmission, this function will complete the ttcp process.
*/
static void
udp_send_data(struct ttcp* ttcp)
{
/* send start marker first time */
if (!ttcp->udp_started) {
if (udp_send_bytes(ttcp, 4) == 0) {
ttcp->udp_started = 1;
ttcp->start_time = timer_get_ms();
}
}
/* normal case */
else if (ttcp->left) {
/* send data */
if (udp_send_bytes(ttcp, ttcp->buflen) == 0)
ttcp->left -= ttcp->buflen;
}
/* end marker? */
else if (ttcp->left == 0 && ttcp->udp_end_marker_left) {
if (udp_send_bytes(ttcp, 4) == 0)
ttcp->udp_end_marker_left--;
}
/* all end markers sent */
else if (ttcp->left == 0) {
ttcp_done(ttcp, 0);
return;
}
ttcp->tid = timer_sched_timeout_cb(0, TIMEOUT_ONESHOT,
udp_timeout_cb, ttcp);
}
/* Ping using the raw ip */
static u8_t ping_recv(void *arg, struct raw_pcb *pcb, struct pbuf *p,
struct ip_addr *addr)
{
struct icmp_echo_hdr *iecho;
struct ip_hdr *ip = p->payload;
struct ping_info_t* ping_info = (struct ping_info_t*) arg;
uint32_t us;
if (pbuf_header( p, -PBUF_IP_HLEN)==0) {
iecho = p->payload;
if ((iecho->id == PING_ID) &&
(iecho->seqno == htons(ping_info->seq_num))) {
ping_info->last_rx_tm = timer_get_ms();
ping_info->num_rx++;
us = 1000 *
(ping_info->last_rx_tm - ping_info->last_tx_tm);
if (!ping_info->quiet)
printk("%d bytes from %s: icmp_seq=%d ttl=%d " \
"time=%d.%03d ms\n",
p->tot_len, ip2str(ip->src),
iecho->seqno,
IPH_TTL(ip),
us / 1000, us % 1000);
/* do some ping result processing */
ping_info->flags |= PING_REPLY;
}
}
pbuf_free(p);
return 1; /* eat the event */
}
/**
* Only used in UDP mode. Will finalize the ttcp process when an end marker
* is seen.
*/
static void
udp_recv_cb(void *arg, struct udp_pcb *upcb, struct pbuf *p,
struct ip_addr *addr, u16_t port)
{
struct ttcp* ttcp = arg;
/* got start marker? we might lose this so if we get it just reset
* the timer
*/
if (!ttcp->udp_started && p->tot_len <= 4) {
ttcp->start_time = timer_get_ms();
ttcp->udp_started = 1;
goto out;
}
/* after receiving at least 1 byte, check end marker
* don't check udp_started since we might have lost the start marker
*/
if (ttcp->recved && p->tot_len <= 4) {
ttcp_done(ttcp, 0);
goto out;
}
/* for print_stats() */
ttcp->recved += p->tot_len;
if (ttcp->verbose) {
printk(".");
if (ttcp->print_cnt % 80 == 0)
printk("\n");
ttcp->print_cnt++;
}
out:
pbuf_free(p);
}
static int init_ping_info(int argc, char* argv[], struct ping_info_t* ping_info)
{
int c;
ping_complete_cb_t cb;
void *ctx;
cb = ping_info->complete_cb;
ctx = ping_info->ctx;
memset(ping_info, 0, sizeof(struct ping_info_t));
ping_info->complete_cb = cb;
ping_info->ctx = ctx;
ping_info->deadline = 0;
ping_info->interval = 1000;
ping_info->timeout = 3000;
ping_info->data_size = 32;
ping_info->count = 3;
ping_info->destination =
netif_default ? netif_default->gw : ip_addr_any;
optind = 1;
while ((c = getopt(argc, argv, "c:i:s:w:q")) != -1) {
switch (c) {
case 'c':
ping_info->count = atoi(optarg);
break;
case 'i':
ping_info->interval = atoi(optarg);
break;
case 's':
ping_info->data_size = atoi(optarg);
break;
case 'q':
ping_info->quiet = 1;
break;
case 'w':
ping_info->deadline = atoi(optarg);
break;
}
}
ping_info->size = sizeof(struct icmp_echo_hdr) + ping_info->data_size;
if (optind >= argc)
return -1;
ping_info->destination = str2ip(argv[optind]);
if (!ping_info->destination.addr)
return -1;
ping_info->last_rx_tm = timer_get_ms();
return 0;
}
/**
* Send data without buffer
*/
void can_send_message2(tExtendedCAN *message) {
uint32_t send_ms = timer_get_ms();
while (mcp2515_send_extmessage(message) == 0) {
if ((timer_get_ticks() - send_ms) > 10)
return;
}
}
/**
* Send CAN Messages
*
* This handler send messages which are stored in the buffer.
*
* \see \ref can_buffer
*/
void can_send_handler(void) {
static uint32_t last_send = 0; // ms
if (can_buffer_head == can_buffer_tail)
return;
if (timer_get_ms() - last_send < SEND_DELAY)
return;
if (mcp2515_send_extmessage(&can_buffer[can_buffer_tail]) != 0) {
if (++can_buffer_tail == CAN_MSG_BUFFER_LENGTH)
can_buffer_tail = 0;
last_send = timer_get_ms();
}
}
/**
* Parser fuction for the default state.
*
* This is the parser for the normal operation.
*
* \param m The received message
*/
void parse_default(tExtendedCAN *m) {
switch (m->data[0]) {
case CMD_PING:
last_heartbeat = timer_get_ms();
can_put_cmd(CMD_PONG, NULL, 0);
break;
case CMD_GET_VERSION:
{
char *version = "RK" XSTRING(MAJOR) "." XSTRING(MINOR);
uint8_t len = strlen(version);
if (len > 7) len = 7;
can_put_cmd(CMD_VERSION, (uint8_t*) version, len);
}
break;
case CMD_DRIBBLE:
{
ballhandler_set((int8_t)m->data[1],(int8_t)m->data[2]);
}
break;
case CMD_STOP:
{
stop_set((uint8_t)m->data[1]);
}
break;
case CMD_SERVO:
{
servo_set((uint8_t)m->data[1]);
}
break;
case CMD_LIGHT:
{
if( (uint8_t)m->data[1] > 0 )
{
RESET(OF_LED);
light = true;
}
else
{
SET(OF_LED);
light = false;
}
//debug("receive light");
}
break;
case 'm':
debug("manual");
manual_mode = true;
parse_data = parse_manual;
break;
default:
error("Command not implemented");
break;
}
}
static void print_stats(struct ping_info_t* ping_info)
{
printk("\n--- %s ping statistics ---\n",
ip2str(ping_info->destination));
printk("%d packets transmitted, %d received, %d%% packet loss, "\
"time %dms\n\n",
ping_info->num_tx, ping_info->num_rx,
100 * (ping_info->num_tx - ping_info->num_rx) /
ping_info->num_tx,
timer_get_ms() - ping_info->first_tx_tm);
}
/**
* Only used in TCP mode.
*/
static err_t tcp_connect_cb(void *arg, struct tcp_pcb *tpcb, err_t err) {
struct ttcp* ttcp = arg;
INFO_TCP("TTCP [%p-%p]: connect %d %d\n", ttcp, tpcb, err, ttcp->tpcb->state);
_connected = ( ttcp->tpcb->state == ESTABLISHED) ? 1 : 0;
tcp_poll_retries = 0;
ttcp->start_time = timer_get_ms();
return ERR_OK;
}
void
poll(struct ctx_server* hs)
{
/* this will trigger any scheduled timer callbacks */
timer_poll();
/* handle console input */
console_poll();
/* wl api 'tick' */
wl_tick(timer_get_ms());
/* lwip driver poll */
wlif_poll(hs->net_cfg.netif);
if (initSpiComplete) spi_poll(hs->net_cfg.netif);
#ifdef WITH_GUI
gui_exec(timer_get_ms());
#endif
}
int Lua_GetPeriodMs(lua_State *L)
{
uint8_t pulsePerRevolution;
size_t channel;
int result = 0;
if (luaToTimerValues(L, &pulsePerRevolution, &channel)) {
int period = timer_get_ms(channel) * pulsePerRevolution;
lua_pushinteger(L, period);
result = 1;
}
return result;
}
static void ping_send(struct raw_pcb *raw, struct ping_info_t* ping_info)
{
struct pbuf *p;
struct icmp_echo_hdr *iecho;
if (!(p = pbuf_alloc(PBUF_IP, ping_info->size, PBUF_RAM))) {
return;
}
if ((p->len == p->tot_len) && (p->next == NULL)) {
iecho = p->payload;
ping_prepare_echo(iecho, ping_info);
raw_sendto(raw, p, &ping_info->destination);
if (!ping_info->first_tx_tm)
ping_info->first_tx_tm = timer_get_ms();
ping_info->last_tx_tm = timer_get_ms();
ping_info->num_tx++;
}
pbuf_free(p);
}
/*!
* Delays for ms milliseconds
* Wenn RTC_AVAILABLE dann ueber rtc, sonst ueber delay_100ms
* ==> aufloesung ohne rtc: 100ms-schritte mir rtc: 5ms-Schritte
* @param ms Anzahl der Millisekunden
*/
void delay(uint16 ms){
#ifdef TIME_AVAILABLE
uint16 ms_start = timer_get_ms();
uint16 s_start = timer_get_s();
uint16 ms_stop = ms_start + ms;
uint16 s_stop = s_start + ms_stop/1000;
ms_stop %= 1000;
while ((s_stop != timer_get_s()) && (ms_stop != timer_get_ms())){asm volatile("nop");}
#else
uint16 ms_counter=0;
while (ms_counter <ms){
delay_100ms();
ms_counter+=100;
}
#endif
}
/**
* Calculate bitrate based on number of bytes transmitted and elapsed time
*/
static void ard_tcp_print_stats(struct ttcp *ttcp) {
uint32_t ms = timer_get_ms() - ttcp->start_time;
uint32_t bytes = ttcp->mode == TTCP_MODE_TRANSMIT ? ttcp->nbuf
* ttcp->buflen : ttcp->recved;
if (ttcp->verbose)
printk("\n");
printk("TTCP [%p]: %d bytes processed, %d.%d KB/s (%s/%s)\n", ttcp, bytes,
bytes / ms, bytes % ms, ttcp->udp ? "udp" : "tcp", ttcp->mode
== TTCP_MODE_TRANSMIT ? "tx" : "rx");
}
/**
* Only used in TCP mode.
*/
static err_t
tcp_accept_cb(void *arg, struct tcp_pcb *newpcb, err_t err)
{
struct ttcp* ttcp = arg;
ttcp->tpcb = newpcb;
tcp_recv(ttcp->tpcb, tcp_recv_cb);
tcp_err(ttcp->tpcb, tcp_conn_err_cb);
printk("TTCP [%p]: accept\n", ttcp);
ttcp->start_time = timer_get_ms();
return ERR_OK;
}
/* Ping using the raw ip */
static u8_t ping_recv(void *arg, struct raw_pcb *pcb, struct pbuf *p,
struct ip_addr *addr)
{
struct icmp_echo_hdr *iecho;
struct ip_hdr *ip = p->payload;
struct ping_info_t* ping_info = (struct ping_info_t*) arg;
uint32_t us;
#if ( (LWIP_VERSION) != ((1U << 24) | (3U << 16) | (2U << 8) | (LWIP_VERSION_RC)) )
struct ip_addr ip_adr;
/* to get unpacked version without losing alignment */
memcpy(&ip_adr, &(ip->src), sizeof(ip_adr));
#endif
if (pbuf_header( p, -PBUF_IP_HLEN)==0) {
iecho = p->payload;
if ((iecho->id == PING_ID) &&
(iecho->seqno == htons(ping_info->seq_num))) {
ping_info->last_rx_tm = timer_get_ms();
ping_info->num_rx++;
us = 1000 *
(ping_info->last_rx_tm - ping_info->last_tx_tm);
if (!ping_info->quiet)
#if ( (LWIP_VERSION) == ((1U << 24) | (3U << 16) | (2U << 8) | (LWIP_VERSION_RC)) )
printk("%d bytes from %s: icmp_seq=%d ttl=%d " \
"time=%d.%03d ms\n",
p->tot_len, ip2str(ip->src),
ntohs(iecho->seqno),
IPH_TTL(ip),
us / 1000, us % 1000);
#else
printk("%d bytes from %s: icmp_seq=%d ttl=%d " \
"time=%d.%03d ms\n",
p->tot_len, ip2str(ip_adr),
ntohs(iecho->seqno),
IPH_TTL(ip),
us / 1000, us % 1000);
#endif
/* do some ping result processing */
ping_info->flags |= PING_REPLY;
}
}
pbuf_free(p);
return 1; /* eat the event */
}
/**
* Only used in TCP mode.
*/
static err_t
tcp_connect_cb(void *arg, struct tcp_pcb *tpcb, err_t err)
{
struct ttcp* ttcp = arg;
printk("TTCP [%p]: connect\n", ttcp);
ttcp->start_time = timer_get_ms();
#if 0
tcp_sent(tpcb, tcp_sent_cb);
#endif
tcp_send_data(ttcp);
return ERR_OK;
}
/**
* Only used in TCP mode.
* Will transmit a maximum of pbuf->tot_len bytes.
* Called upon connect and when there's space available in the TCP send window
*
*/
static void tcp_send_data(struct ttcp *ttcp) {
err_t err = ERR_OK;
uint32_t len, orig_len;
len = ttcp->left;
ttcp->buff_sent = 0;
INFO_TCP_VER("left=%d len:%d tcp_sndbuf:%d\n", ttcp->left, len, tcp_sndbuf(ttcp->tpcb));
/* don't send more than we have in the payload */
if (len > ttcp->buflen)
len = ttcp->buflen;
/* We cannot send more data than space available in the send
buffer. */
if (len > tcp_sndbuf(ttcp->tpcb))
len = tcp_sndbuf(ttcp->tpcb);
orig_len = len;
uint8_t count = 0;
do {
startTime = timer_get_ms();
err = tcp_write(ttcp->tpcb, ttcp->payload, len, TCP_WRITE_FLAG_COPY);
INFO_TCP_VER("%d) tcp_write %p state:%d len:%d err:%d\n", count++, ttcp->tpcb, ttcp->tpcb->state, len, err);
if (err == ERR_MEM)
{
len /= 2;
ttcp->buff_sent = 0;
}else if (err == ERR_OK){
ttcp->buff_sent = 1;
isDataSentCount = 0;
}
} while (err == ERR_MEM && len > 1);
if (err == ERR_OK){
//tcp_output(ttcp->tpcb);
INFO_TCP_VER("tcp_output: left=%d new left:%d\n",
ttcp->left, ttcp->left-len);
ttcp->left -= len;
}
else
WARN("TTCP [%p-%p]: tcp_write failed err:%d origLen:%d len:%d\n",
ttcp, ttcp->tpcb, err, orig_len, len);
//
// ttcp->tid = timer_sched_timeout_cb(0, TIMEOUT_ONESHOT,
// tcp_timeout_cb, ttcp);
}
/**
* Zeigt ein paar Infos an, die man nicht naeher zuordnen kann
*/
void misc_display(void) {
/* Anzeige der Bot-Adresse (aenderbar) */
display_cursor(1, 1);
display_puts("bot_addr=");
#ifdef KEYPAD_AVAILABLE
if (RC5_Code == RC5_CODE_MUTE) {
gui_keypad_request(change_bot_addr_callback, 1, 1, 10);
#ifdef PC
display_cursor(1, 10);
#endif
display_puts(" "); // clean
new_address = 1;
RC5_Code = 0;
}
if (new_address == 0)
#endif // KEYPAD_AVAILABLE
{
#ifdef PC
display_cursor(1, 10);
#endif
display_printf("0x%x", get_bot_address());
}
#ifdef BEHAVIOUR_AVAILABLE
display_cursor(2, 1);
display_printf("TS=%+4d %+4d", target_speed_l, target_speed_r);
#endif
#ifdef SRF10_AVAILABLE
display_cursor(2, 15);
display_printf("US%4u", sensSRF10);
#endif
display_cursor(3, 1);
display_printf("RC=%+4d %+4d", sensEncL, sensEncR);
display_cursor(4, 1);
display_printf("Speed=%+4d", v_center);
display_cursor(4, 12);
display_printf("%4u:%03u", timer_get_s(), timer_get_ms());
}
float timer_get_sample(const int cid)
{
if (cid >= TIMER_CHANNELS)
return -1;
TimerConfig *c = getWorkingLoggerConfig()->TimerConfigs + cid;
unsigned char ppr = c->pulsePerRevolution;
switch (c->mode) {
case MODE_LOGGING_TIMER_RPM:
return timer_get_rpm(cid) / ppr;
case MODE_LOGGING_TIMER_FREQUENCY:
return timer_get_hz(cid) / ppr;
case MODE_LOGGING_TIMER_PERIOD_MS:
return timer_get_ms(cid) * ppr;
case MODE_LOGGING_TIMER_PERIOD_USEC:
return timer_get_usec(cid) * ppr;
default:
return -1;
}
}
static err_t tcp_data_sent(void *arg, struct tcp_pcb *pcb, u16_t len) {
struct ttcp *_ttcp;
LWIP_UNUSED_ARG(len);
_ttcp = arg;
tcp_poll_retries = 0;
if (_ttcp) _ttcp->buff_sent = 1;
INFO_TCP("Packet sent pcb:%p len:%d dur:%d left:%d count:%d\n", pcb, len, timer_get_ms() - startTime,
(_ttcp)?(_ttcp->left):0, isDataSentCount);
isDataSentCount = 0;
if ((_ttcp)&&(_ttcp->left > 0)) {
tcp_send_data(_ttcp);
}
return ERR_OK;
}
/**
* Only used in TCP mode.
*/
static err_t atcp_accept_cb(void *arg, struct tcp_pcb *newpcb, err_t err) {
struct ttcp* ttcp = arg;
INFO_TCP("ARD TCP [%p]: accept new [%p]\n", ttcp, newpcb);
INFO_TCP("local:%d remote:%d state:%d\n", newpcb->local_port, newpcb->remote_port, newpcb->state);
if (pending_accept)
{
WARN("Accepting another connection: %p-%p\n", ttcp->tpcb, newpcb);
return ERR_OK;
}
pending_accept = true;
tcp_setprio(newpcb, TCP_PRIO_MIN);
tcp_poll_retries = 0;
ttcp->tpcb = newpcb;
tcp_recv(ttcp->tpcb, atcp_recv_cb);
tcp_err(ttcp->tpcb, atcp_conn_err_cb);
tcp_poll(ttcp->tpcb, atcp_poll, 4);
ttcp->start_time = timer_get_ms();
return ERR_OK;
}
/*!
* Direkter Zugriff auf den Motor
* @param left Geschwindigkeit fuer den linken Motor
* @param right Geschwindigkeit fuer den linken Motor
* Geschwindigkeit liegt zwischen -255 und +255.
* 0 bedeutet Stillstand, 255 volle Kraft voraus, -255 volle Kraft zurueck.
* Sinnvoll ist die Verwendung der Konstanten: BOT_SPEED_XXX,
* also z.B. motor_set(BOT_SPEED_LOW,-BOT_SPEED_LOW);
* fuer eine langsame Drehung
*/
void motor_set(int16 left, int16 right){
#ifdef SPEED_CONTROL_AVAILABLE
volatile static int16 old_mot_time_s=0;
volatile static int16 old_mot_time_ms=0;
#endif
if (left == BOT_SPEED_IGNORE)
left=BOT_SPEED_STOP;
if (right == BOT_SPEED_IGNORE)
right=BOT_SPEED_STOP;
// Haben wir ueberhaupt etwas zu tun?
if ((speed_l == left) && (speed_r == right)){
// Hier sitzt die eigentliche Regelung
#ifdef SPEED_CONTROL_AVAILABLE
if (timer_get_ms_since(old_mot_time_s,old_mot_time_ms) > SPEED_CONTROL_INTERVAL) {
speed_control();
old_mot_time_s= timer_get_s();
old_mot_time_ms= timer_get_ms();
}
#endif
return; // Keine Aenderung? Dann zuerueck
}
if (abs(left) > BOT_SPEED_MAX) // Nicht schneller fahren als moeglich
speed_l = BOT_SPEED_MAX;
else if (left == 0) // Stop wird nicht veraendert
speed_l = BOT_SPEED_STOP;
else if (abs(left) < BOT_SPEED_SLOW) // Nicht langsamer als die
speed_l = BOT_SPEED_SLOW; // Motoren koennen
else // Sonst den Wunsch uebernehmen
speed_l = abs(left);
if (abs(right) > BOT_SPEED_MAX)// Nicht schneller fahren als moeglich
speed_r = BOT_SPEED_MAX;
else if (abs(right) == 0) // Stop wird nicht veraendert
speed_r = BOT_SPEED_STOP;
else if (abs(right) < BOT_SPEED_SLOW) // Nicht langsamer als die
speed_r = BOT_SPEED_SLOW; // Motoren koennen
else // Sonst den Wunsch uebernehmen
speed_r = abs(right);
if (left < 0 )
speed_l=-speed_l;
if (right < 0 )
speed_r=-speed_r;
#ifdef SPEED_CONTROL_AVAILABLE
// TODO Hier koennten wir die Motorkennlinie heranziehen um gute Einstiegswerte fuer die Regelung zu haben
// Evtl. sogar eine im EEPROM kalibrierbare Tabelle??
encoderTargetRateL = left / SPEED_TO_ENCODER_RATE; // Geschwindigkeit [mm/s] umrechnen in [EncoderTicks/Aufruf]
encoderTargetRateR = right / SPEED_TO_ENCODER_RATE; // Geschwindigkeit [mm/s] umrechnen in [EncoderTicks/Aufruf]
#endif
// Zuerst einmal eine lineare Kennlinie annehmen
bot_motor(speed_l/2,speed_r/2);
}
int main(int argc, char **argv){
int fps = -1;
double frame_millis = -1;
double init_millis = 0;
double tick_millis = 0;
double frame_overflow = 0;
double spf = 0.0;
int tick_next = 0;
unsigned int ctt2_state = CTT2_EVT_POLL_EVENTS;
unsigned int render_test = 0;
finished = 0;
initialized_modules = 0;
print_banner();
if(argc==5 || argc==6) {
SCREEN_WIDTH = atoi( argv[1] );
SCREEN_HEIGHT = atoi( argv[2] );
fullscreen = atoi( argv[3] );
fps = atoi( argv[4] );
spf = 1.0/(double)fps;
frame_millis = (double)1000/(double)fps;
if(argc==6) {
beagle_application_path = argv[5];
printf("Application path: `%s`\n", beagle_application_path );
}
} else {
print_usage();
return;
}
loadRuntimeModule( &initLog, &dropLog, CTT2_RT_MODULE_LOG );
loadRuntimeModule( &initCore, &dropCore, CTT2_RT_MODULE_CORE );
loadRuntimeModule( &initDisplay, &dropDisplay, CTT2_RT_MODULE_DISPLAY );
loadRuntimeModule( &initOpenGL, &dropOpenGL, CTT2_RT_MODULE_OPENGL );
loadRuntimeModule( &initAudio, &dropAudio, CTT2_RT_MODULE_AUDIO );
loadRuntimeModule( &initWinMsgs, &dropWinMsgs, CTT2_RT_MODULE_WINDOW_MSGS );
loadRuntimeModule( &initTextInput, &dropTextInput, CTT2_RT_MODULE_TEXT_INPUT );
loadRuntimeModule( &initTimer, &dropTimer, CTT2_RT_MODULE_TIMER );
loadRuntimeModule( &initGamepad, &dropGamepad, CTT2_RT_MODULE_GAMEPAD);
loadRuntimeModule( &initPython, &dropPython, CTT2_RT_MODULE_PYTHON);
int run = 1;
/** MAIN DISPATCH LOOP **/
if(run) {
SDL_Event event;
double base_millis = timer_get_ms();
tick_millis = timer_get_ms();
while(finished != CTT2_RT_TERMINATED ) {
switch(ctt2_state) {
case CTT2_EVT_TICK:
if(api_tick() == API_FAILURE) {
finished = 1;
} else {
tick_millis += frame_millis;
if( (timer_get_ms() - tick_millis) > frame_millis ) {
ctt2_state = CTT2_EVT_TICK;
} else {
ctt2_state = CTT2_EVT_RENDER;
}
}
break;
case CTT2_EVT_RENDER:
if(render_test == 0) {
api_render();
}
if(render_test==1) {
hwgfx_render_test();
}
if(render_test==2) {
api_render_test();
}
ctt2_state = CTT2_EVT_SYNC_GFX;
break;
case CTT2_EVT_SYNC_GFX:
updateViewingSurface();
ctt2_state = CTT2_EVT_POLL_EVENTS;
break;
case CTT2_EVT_POLL_EVENTS:
if( (timer_get_ms() - tick_millis) > frame_millis ) {
ctt2_state = CTT2_EVT_TICK;
}
break;
}
while(SDL_PollEvent(&event)) {
switch (event.type) {
case SDL_CONTROLLERDEVICEADDED:
dropGamepad();
initGamepad();
break;
case SDL_CONTROLLERDEVICEREMOVED:
dropGamepad();
initGamepad();
break;
case SDL_JOYAXISMOTION:
GamepadHandleEvent( &event );
break;
case SDL_TEXTINPUT:
api_dispatch_text( event.text.text );
break;
case SDL_QUIT:
finished = CTT2_RT_TERMINATED;
break;
case SDL_SYSWMEVENT:
#ifdef _WIN32
#ifdef WACOM_ENABLED
handle_wm_event(event); //used for the wacom tablet module, but currently missing...
#endif
#endif
break;
case SDL_KEYDOWN:
if( api_dispatch_key(event.key.keysym.sym,1) == API_FAILURE ) finished = CTT2_RT_TERMINATED;
if( event.key.keysym.sym == SDLK_F5 && (event.key.keysym.mod & KMOD_CTRL) ) {
dropPython();
initPython();
}
if( event.key.keysym.sym == SDLK_F6 && (event.key.keysym.mod & KMOD_CTRL) ) {
render_test = (render_test+1)%3;
}
if( event.key.keysym.sym == SDLK_F4 && (event.key.keysym.mod & KMOD_ALT) ) {
finished = CTT2_RT_TERMINATED;
}
break;
case SDL_KEYUP:
if( api_dispatch_key(event.key.keysym.sym,0)
== API_FAILURE ) finished = CTT2_RT_TERMINATED;
break;
case SDL_MOUSEBUTTONDOWN:
if(api_dispatch_mousedown(
event.button.button,
event.button.x,
event.button.y) == API_FAILURE )
finished = CTT2_RT_TERMINATED ;
break;
case SDL_MOUSEBUTTONUP:
if(api_dispatch_mouseup(
event.button.button,
event.button.x,
event.button.y) == API_FAILURE )
finished = CTT2_RT_TERMINATED;
break;
case SDL_MOUSEMOTION:
if(api_dispatch_mousemotion(
event.motion.x,
event.motion.y) == API_FAILURE )
finished = CTT2_RT_TERMINATED;
break;
}
}
}
}
sequencer_halt();
dropRuntimeModules(0);
return 0;
}
/*!
* Zeigt ein paar Informationen an
*/
void display(void){
#ifdef DISPLAY_BEHAVIOUR_AVAILABLE
/*!
* Definitionen fuer die Verhaltensanzeige
*/
#undef TEST_AVAILABLE_COUNTER
Behaviour_t *ptr = behaviour;
int8 colcounter = 0;
int8 linecounter = 0;
int8 firstcol = 0;
#endif
#ifdef TEST_AVAILABLE_COUNTER
static int counter=0;
#endif
if (display_update >0)
#ifdef DISPLAY_SCREENS_AVAILABLE
switch (display_screen) {
case 0:
#endif
display_cursor(1,1);
display_printf("P=%03X %03X D=%03d %03d ",sensLDRL,sensLDRR,sensDistL,sensDistR);
display_cursor(2,1);
display_printf("B=%03X %03X L=%03X %03X ",sensBorderL,sensBorderR,sensLineL,sensLineR);
display_cursor(3,1);
display_printf("R=%2d %2d F=%d K=%d T=%d ",sensEncL % 10,sensEncR %10,sensError,sensDoor,sensTrans);
display_cursor(4,1);
display_printf("I=%04X M=%05d %05d",RC5_Code,sensMouseX,sensMouseY);
#ifdef DISPLAY_SCREENS_AVAILABLE
break;
case 1:
#ifdef TIME_AVAILABLE
display_cursor(1,1);
display_printf("Zeit: %04d:%03d", timer_get_s(), timer_get_ms());
#endif
display_cursor(2,1);
display_printf("TS=%+4d %+4d",target_speed_l,target_speed_r);
#ifdef SRF10_AVAILABLE
display_cursor(2,15);
display_printf("US%+4d",sensSRF10);
#endif
display_cursor(3,1);
display_printf("RC=%+4d %+4d",sensEncL,sensEncR);
display_cursor(4,1);
display_printf("Speed= %04d %04d",v_left,v_right);
break;
case 2:
display_cursor(1,1);
#ifdef DISPLAY_BEHAVIOUR_AVAILABLE
/*!
* zeilenweise Anzeige der Verhalten
*/
display_printf("Verhalten (Pri/Akt)%d",behaviour_page);
colcounter = 0; linecounter = 2;
/* je nach Seitenwahl die ersten Saetze ueberlesen bis richtige Seite */
firstcol = (behaviour_page -1)*6;
/*!
* max. 3 Zeilen mit 6 Verhalten anzeigbar wegen Ueberschrift
* Seitensteuerung bei mehr Verhalten
*/
while((ptr != NULL)&& (linecounter<5)) {
if ((ptr->priority > 2) &&(ptr->priority <= 200)) {
if (colcounter >= firstcol) {
display_cursor(linecounter,((colcounter % 2)* 12)+1);
display_printf(" %3d,%2d",ptr->priority,ptr->active_new);
colcounter++;
/* bei colcounter 0 neue Zeile */
if (colcounter % 2 == 0)
linecounter++;
}
else
colcounter ++;
}
ptr = ptr->next;
}
#endif
#ifdef TEST_AVAILABLE_COUNTER
display_printf("Screen 3");
display_cursor(2,1);
display_printf("count %d",counter++);
display_cursor(3,1);
display_printf("Reset-Counter %d",resets);
#endif
break;
case 3:
display_cursor(1,1);
#ifdef DISPLAY_SCREEN_RESETINFO
/* Zeige den Grund fuer Resets an */
display_printf("MCUCSR - Register");
display_cursor(2,1);
display_printf("PORF :%d WDRF :%d",binary(reset_flag,0),binary(reset_flag,3));
display_cursor(3,1);
display_printf("EXTRF:%d JTRF :%d",binary(reset_flag,1),binary(reset_flag,4));
display_cursor(4,1);
display_printf("BORF :%d",binary(reset_flag,2));
#else
display_printf("Screen 4");
#endif
break;
case 4:
/* Wird zur Ausgabe von Loggings verwendet. */
break;
}
#endif
}
void cmd_memtest(char *arg)
{
unsigned long *sdptr;
unsigned long i;
unsigned long loop;
int errcnt;
int sec,us,us2;
const int TEST_SIZE = 0x01000000;
printf("SDRAMメモリテストを開始します\n");
us = timer_get_ms();
memset((void *)0x08000000,0x55,0x01000000);
us2 = timer_get_ms();
printf("16MBytesをmemsetする時間は %d秒でした\n",(us2-us)/1000);
us = timer_get_ms();
memcpy((void *)0x08000000,(void *)0x09000000,0x01000000);
us2 = timer_get_ms();
printf("16MBytesをmemcpyする時間は %d.%06d秒でした\n",(us2-us)/1000);
sdptr = (unsigned long *)0x08000000;
// timer_start();
for(i=0;i<16777216/4;i++)
{
volatile int t = *sdptr++;
}
// timer_check(&sec,&us);
// timer_stop();
// printf("16MBytesをfor文で読み出す時間は %d.%06d秒でした\n",sec,us);
sdptr = (unsigned long *)0x08000000;
// timer_start();
for(i=0;i<16777216/4;i++)
{
*sdptr++ = i;
}
// timer_check(&sec,&us);
// timer_stop();
// printf("16MBytesにfor文で書き込む時間は %d.%06d秒でした\n",sec,us);
{
void (*func)(void);
unsigned char *src,*dst;
// timer_start();
empty_loop();
// timer_check(&sec,&us);
// timer_stop();
// printf("10^6回ループを内蔵RAM上で実行する時間は %d.%06d秒でした\n",sec,us);
src = (unsigned char *)empty_loop;
dst = (unsigned char *)0x08000000;
memcpy(dst,src,(unsigned long)empty_loop_next - (unsigned long)empty_loop);
func = (void (*)(void))0x08000000;
// timer_start();
func();
// timer_check(&sec,&us2);
// timer_stop();
printf("10^6回ループをSDRAM上で実行する時間は %d.%06d秒でした\n",(int)sec,(int)us2);
us2 *= 100;
printf("約%d.%d倍の時間がかかっています\n",(int)(us2/us/100),(int)((us2/us)%100));
}
printf("読み書きチェックを行います\n");
loop = 1;
while(!sci_rxcount())
{
srand(loop);
sdptr = (unsigned long *)0x08000000;
for(i=0;i<TEST_SIZE / sizeof(long);i++)
{
*sdptr++ = myrand();
}
srand(loop);
errcnt = 0;
sdptr = (unsigned long *)0x08000000;
for(i=0;i<TEST_SIZE / sizeof(long);i++)
{
if(*sdptr != myrand())
{
printf("Error:addr=%08x data=%02x\n",(unsigned int)sdptr,(unsigned char)*sdptr);
errcnt++;
if(sci_rxcount()) break;
if(errcnt > 50) break;
}
sdptr++;
}
gpio_write_port(PIN_BUZZ,1);
if(errcnt == 0)
{
printf("Memory test success loop=%d\n",(int)loop);
for(i=0;i<500;i++)
{
int j;
for(j=0;j<20000;j++) {}
gpio_write_port(PIN_LED2,j & 1);
}
}
else
{
printf("Memory test failed loop=%d\n",(int)loop);
for(i=0;i<100;i++)
{
int j;
for(j=0;j<100000;j++) {}
gpio_write_port(PIN_LED2,j & 1);
}
break;
}
gpio_write_port(PIN_BUZZ,0);
loop++;
}
}
cmd_state_t cmd_ping(int argc, char* argv[], void* ctx)
{
static enum {
INIT,
PING,
WAIT_REPLY
} state = INIT;
struct ping_info_t *ping_info = &INFO;
static struct raw_pcb *pcb;
switch (state) {
case INIT:
if (init_ping_info(argc, argv, ping_info) != 0) {
printk("Usage: ping [-c count] [-i interval] " \
"[-s packetsize]\n " \
"[-w deadline] [-q] destination\n");
return CMD_DONE;
}
if (!(pcb = raw_new(IP_PROTO_ICMP))) {
printk("could not allocate pcb\n");
state = INIT;
return CMD_DONE;
}
raw_recv(pcb, ping_recv, ping_info);
raw_bind(pcb, IP_ADDR_ANY);
printk("PING %s %d(%d) bytes of data\n",
ip2str(ping_info->destination),
ping_info->data_size,
ping_info->size);
state = PING;
/* fall through */
case PING:
if (!netif_is_up(netif_default)) {
printk("netif is down\n");
raw_remove(pcb);
state = INIT;
return CMD_DONE;
}
if (ping_info->count && ping_info->num_tx == ping_info->count) {
ping_finalize(ping_info);
raw_remove(pcb);
state = INIT;
return CMD_DONE;
}
if (timer_get_ms() < ping_info->last_rx_tm + ping_info->interval) {
return CMD_INPROGRESS;
}
ping_send(pcb, ping_info);
state = WAIT_REPLY;
return CMD_INPROGRESS;
case WAIT_REPLY:
if (ping_info->flags & PING_REPLY) {
ping_info->flags &= (~PING_REPLY);
state = PING;
return CMD_INPROGRESS;
}
if (timer_get_ms() >
ping_info->last_tx_tm + ping_info->timeout) {
if (!ping_info->quiet)
printk("timeout from %s\n",
ip2str(ping_info->destination));
state = PING;
return CMD_INPROGRESS;
}
if (ping_info->deadline &&
timer_get_ms() >
ping_info->first_tx_tm + ping_info->deadline * 1000) {
ping_finalize(ping_info);
raw_remove(pcb);
state = INIT;
return CMD_DONE;
}
return CMD_INPROGRESS;
}
/* unreachable */
assert(0);
return CMD_DONE;
}
