/[zanavi_public1]/navit/navit/vehicle/demo/vehicle_demo.c
ZANavi

Diff of /navit/navit/vehicle/demo/vehicle_demo.c

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

Revision 2 Revision 27
1/**
2 * ZANavi, Zoff Android Navigation system.
3 * Copyright (C) 2011-2012 Zoff <zoff@zoff.cc>
4 *
5 * This program is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU General Public License
7 * version 2 as published by the Free Software Foundation.
8 *
9 * This program is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
13 *
14 * You should have received a copy of the GNU General Public License
15 * along with this program; if not, write to the
16 * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
17 * Boston, MA 02110-1301, USA.
18 */
19
1/** 20/**
2 * Navit, a modular navigation system. 21 * Navit, a modular navigation system.
3 * Copyright (C) 2005-2008 Navit Team 22 * Copyright (C) 2005-2008 Navit Team
4 * 23 *
5 * This program is free software; you can redistribute it and/or 24 * This program is free software; you can redistribute it and/or
31#include "plugin.h" 50#include "plugin.h"
32#include "vehicle.h" 51#include "vehicle.h"
33#include "event.h" 52#include "event.h"
34#include "util.h" 53#include "util.h"
35 54
36struct vehicle_priv { 55struct vehicle_priv
56{
37 int interval; 57 int interval;
38 int position_set; 58 int position_set;
39 struct callback_list *cbl; 59 struct callback_list *cbl;
40 struct navit *navit; 60 struct navit *navit;
41 struct coord_geo geo; 61 struct coord_geo geo;
47 struct event_timeout *timer; 67 struct event_timeout *timer;
48 char *timep; 68 char *timep;
49 69
50}; 70};
51 71
52static void
53vehicle_demo_destroy(struct vehicle_priv *priv) 72static void vehicle_demo_destroy(struct vehicle_priv *priv)
54{ 73{
55 g_free(priv->timep); 74 g_free(priv->timep);
56 g_free(priv); 75 g_free(priv);
57} 76}
58 77
59static int 78static int vehicle_demo_position_attr_get(struct vehicle_priv *priv, enum attr_type type, struct attr *attr)
60vehicle_demo_position_attr_get(struct vehicle_priv *priv,
61 enum attr_type type, struct attr *attr)
62{ 79{
63 switch (type) { 80 switch (type)
81 {
64 case attr_position_speed: 82 case attr_position_speed:
65 attr->u.numd = &priv->speed; 83 attr->u.numd = &priv->speed;
66 break; 84 break;
67 case attr_position_direction: 85 case attr_position_direction:
68 attr->u.numd = &priv->direction; 86 attr->u.numd = &priv->direction;
69 break; 87 break;
70 case attr_position_coord_geo: 88 case attr_position_coord_geo:
71 attr->u.coord_geo = &priv->geo; 89 attr->u.coord_geo = &priv->geo;
72 break; 90 break;
73 case attr_position_time_iso8601: 91 case attr_position_time_iso8601:
74 g_free(priv->timep); 92 g_free(priv->timep);
75 priv->timep=current_to_iso8601(); 93 priv->timep = current_to_iso8601();
76 attr->u.str=priv->timep; 94 attr->u.str = priv->timep;
77 break; 95 break;
78 default: 96 default:
79 return 0; 97 return 0;
80 } 98 }
81 attr->type = type; 99 attr->type = type;
82 return 1; 100 return 1;
83} 101}
84 102
85static int
86vehicle_demo_set_attr(struct vehicle_priv *priv, struct attr *attr) 103static int vehicle_demo_set_attr(struct vehicle_priv *priv, struct attr *attr)
87{ 104{
88 if (attr->type == attr_navit) 105 if (attr->type == attr_navit)
89 priv->navit = attr->u.navit; 106 priv->navit = attr->u.navit;
90 return 1; 107 return 1;
91} 108}
92 109
93struct vehicle_methods vehicle_demo_methods = { 110struct vehicle_methods vehicle_demo_methods =
94 vehicle_demo_destroy, 111{ vehicle_demo_destroy, vehicle_demo_position_attr_get, vehicle_demo_set_attr, };
95 vehicle_demo_position_attr_get,
96 vehicle_demo_set_attr,
97};
98 112
99static void
100vehicle_demo_timer(struct vehicle_priv *priv) 113static void vehicle_demo_timer(struct vehicle_priv *priv)
101{ 114{
102 struct coord c, c2, pos, ci; 115 struct coord c, c2, pos, ci;
103 int slen, len, dx, dy; 116 int slen, len, dx, dy;
104 struct route *route=NULL; 117 struct route *route = NULL;
105 struct map *route_map=NULL; 118 struct map *route_map = NULL;
106 struct map_rect *mr=NULL; 119 struct map_rect *mr = NULL;
107 struct item *item=NULL; 120 struct item *item = NULL;
108 121
109 len = (priv->config_speed * priv->interval / 1000)/ 3.6; 122 len = (priv->config_speed * priv->interval / 1000) / 3.6;
110 dbg(1, "###### Entering simulation loop\n"); 123 //DBG dbg(0, "###### Entering simulation loop\n");
111 if (priv->navit) 124 if (priv->navit)
125 {
112 route=navit_get_route(priv->navit); 126 route = navit_get_route(priv->navit);
127 }
128 //DBG dbg(0,"rr 1\n");
113 if (route) 129 if (route)
130 {
114 route_map=route_get_map(route); 131 route_map = route_get_map(route);
132 }
133 //DBG dbg(0,"rr 2\n");
115 if (route_map) 134 if (route_map)
135 {
116 mr=map_rect_new(route_map, NULL); 136 mr = map_rect_new(route_map, NULL);
137 }
138 //DBG dbg(0,"rr 3\n");
117 if (mr) 139 if (mr)
140 {
118 item=map_rect_get_item(mr); 141 item = map_rect_get_item(mr);
142 }
143 //DBG dbg(0,"rr 4\n");
119 if (item && item->type == type_route_start) 144 if (item && item->type == type_route_start)
145 {
120 item=map_rect_get_item(mr); 146 item = map_rect_get_item(mr);
147 }
148 //DBG dbg(0,"rr 5\n");
121 if (item && item_coord_get(item, &pos, 1)) { 149 if (item && item_coord_get(item, &pos, 1))
150 {
122 priv->position_set=0; 151 priv->position_set = 0;
123 dbg(1, "current pos=0x%x,0x%x\n", pos.x, pos.y); 152 ////DBG dbg(0, "current pos=0x%x,0x%x\n", pos.x, pos.y);
124 dbg(1, "last pos=0x%x,0x%x\n", priv->last.x, priv->last.y); 153 ////DBG dbg(0, "last pos=0x%x,0x%x\n", priv->last.x, priv->last.y);
125 if (priv->last.x == pos.x && priv->last.y == pos.y) { 154 if (priv->last.x == pos.x && priv->last.y == pos.y)
155 {
126 dbg(1, "endless loop\n"); 156 //dbg(1, "endless loop\n");
127 } 157 }
128 priv->last = pos; 158 priv->last = pos;
129 while (item && priv->config_speed) { 159 while (item && priv->config_speed)
160 {
130 if (!item_coord_get(item, &c, 1)) { 161 if (!item_coord_get(item, &c, 1))
162 {
131 item=map_rect_get_item(mr); 163 item = map_rect_get_item(mr);
132 continue; 164 continue;
133 } 165 }
134 dbg(1, "next pos=0x%x,0x%x\n", c.x, c.y); 166 ////DBG dbg(0, "next pos=0x%x,0x%x\n", c.x, c.y);
135 slen = transform_distance(projection_mg, &pos, &c); 167 slen = transform_distance(projection_mg, &pos, &c);
136 dbg(1, "len=%d slen=%d\n", len, slen); 168 ////DBG dbg(0, "len=%d slen=%d\n", len, slen);
137 if (slen < len) { 169 if (slen < len)
170 {
138 len -= slen; 171 len -= slen;
139 pos = c; 172 pos = c;
173 }
140 } else { 174 else
175 {
141 if (item_coord_get(item, &c2, 1) || map_rect_get_item(mr)) { 176 if (item_coord_get(item, &c2, 1) || map_rect_get_item(mr))
177 {
142 dx = c.x - pos.x; 178 dx = c.x - pos.x;
143 dy = c.y - pos.y; 179 dy = c.y - pos.y;
144 ci.x = pos.x + dx * len / slen; 180 ci.x = pos.x + dx * len / slen;
145 ci.y = pos.y + dy * len / slen; 181 ci.y = pos.y + dy * len / slen;
146 priv->direction =
147 transform_get_angle_delta(&pos, &c, 0); 182 priv->direction = transform_get_angle_delta(&pos, &c, 0);
148 priv->speed=priv->config_speed; 183 priv->speed = priv->config_speed;
184 }
149 } else { 185 else
186 {
150 ci.x = pos.x; 187 ci.x = pos.x;
151 ci.y = pos.y; 188 ci.y = pos.y;
152 priv->speed=0; 189 priv->speed = 0;
153 dbg(0,"destination reached\n"); 190 ////DBG dbg(0, "destination reached\n");
154 } 191 }
155 dbg(1, "ci=0x%x,0x%x\n", ci.x, ci.y); 192 //dbg(1, "ci=0x%x,0x%x\n", ci.x, ci.y);
156 transform_to_geo(projection_mg, &ci, 193 transform_to_geo(projection_mg, &ci, &priv->geo);
157 &priv->geo);
158 callback_list_call_attr_0(priv->cbl, attr_position_coord_geo); 194 callback_list_call_attr_0(priv->cbl, attr_position_coord_geo);
159 break; 195 break;
160 } 196 }
161 } 197 }
162 } else { 198 }
199 else
200 {
163 if (priv->position_set) 201 if (priv->position_set)
164 callback_list_call_attr_0(priv->cbl, attr_position_coord_geo); 202 callback_list_call_attr_0(priv->cbl, attr_position_coord_geo);
165 } 203 }
204 //DBG dbg(0,"rr 6\n");
166 if (mr) 205 if (mr)
206 {
167 map_rect_destroy(mr); 207 map_rect_destroy(mr);
208 }
209 //DBG dbg(0,"rr F\n");
168} 210}
169
170
171 211
172static struct vehicle_priv * 212static struct vehicle_priv *
173vehicle_demo_new(struct vehicle_methods 213vehicle_demo_new(struct vehicle_methods *meth, struct callback_list *cbl, struct attr **attrs)
174 *meth, struct callback_list
175 *cbl, struct attr **attrs)
176{ 214{
177 struct vehicle_priv *ret; 215 struct vehicle_priv *ret;
178 struct attr *interval,*speed,*position_coord_geo; 216 struct attr *interval, *speed, *position_coord_geo;
179 217
180 dbg(1, "enter\n"); 218 //DBG dbg(0, "enter\n");
181 ret = g_new0(struct vehicle_priv, 1); 219 ret = g_new0(struct vehicle_priv, 1);
182 ret->cbl = cbl; 220 ret->cbl = cbl;
183 ret->interval=1000; 221 ret->interval = 1200;
184 ret->config_speed=40; 222 ret->config_speed = 41;
223
224 //dbg(0, "vd 3.1 %d %d\n", ret->interval, ret->config_speed);
225
226 //DBG dbg(0, "vd 1\n");
185 if ((speed=attr_search(attrs, NULL, attr_speed))) { 227 if ((speed = attr_search(attrs, NULL, attr_speed)))
228 {
186 ret->config_speed=speed->u.num; 229 ret->config_speed = speed->u.num;
187 } 230 }
231
232 //DBG dbg(0, "vd 2\n");
188 if ((interval=attr_search(attrs, NULL, attr_interval))) 233 if ((interval = attr_search(attrs, NULL, attr_interval)))
234 {
189 ret->interval=interval->u.num; 235 ret->interval = interval->u.num;
236 }
237
238 // ret->geo.lat = 0;
239 // ret->geo.lng = 0;
240 // //DBG dbg(0, "position_default %f %f\n", ret->geo.lat, ret->geo.lng);
241
242 //dbg(0, "vd 3.2 %d %d\n", ret->interval, ret->config_speed);
190 if ((position_coord_geo=attr_search(attrs, NULL, attr_position_coord_geo))) { 243 if ((position_coord_geo = attr_search(attrs, NULL, attr_position_coord_geo)))
244 {
191 ret->geo=*(position_coord_geo->u.coord_geo); 245 ret->geo = *(position_coord_geo->u.coord_geo);
192 ret->position_set=1; 246 ret->position_set = 1;
193 dbg(0,"position_set %f %f\n", ret->geo.lat, ret->geo.lng); 247 //DBG dbg(0, "position_set %f %f\n", ret->geo.lat, ret->geo.lng);
194 } 248 }
249
250 //DBG dbg(0, "vd 4\n");
195 *meth = vehicle_demo_methods; 251 *meth = vehicle_demo_methods;
196 ret->timer_callback=callback_new_1(callback_cast(vehicle_demo_timer), ret); 252 ret->timer_callback = callback_new_1(callback_cast(vehicle_demo_timer), ret);
253 //DBG dbg(0, "vd 5\n");
254 dbg(0, "event_add_timeout %d,%d,%p", ret->interval, 1, ret->timer_callback);
197 ret->timer=event_add_timeout(ret->interval, 1, ret->timer_callback); 255 ret->timer = event_add_timeout(ret->interval, 1, ret->timer_callback);
256 //DBG dbg(0, "leave\n");
198 return ret; 257 return ret;
199} 258}
200 259
201void
202plugin_init(void) 260void plugin_init(void)
203{ 261{
204 dbg(1, "enter\n"); 262 //DBG dbg(0, "enter\n");
205 plugin_register_vehicle_type("demo", vehicle_demo_new); 263 plugin_register_vehicle_type("demo", vehicle_demo_new);
206} 264}

Legend:
Removed from v.2  
changed lines
  Added in v.27

   
Visit the ZANavi Wiki