//控制电机转向 extern void motor_ctrl(const uchar d) { switch(d) { case 'D': direction = 0xAA; set_orientation(1); break; case 'U': direction = 0x55; set_orientation(0); break; case 'L': direction = 0x66; speed = speed_limit; break; case 'R': direction = 0x99; speed = speed_limit; break; case 's': direction = 0x00; speed = 0; break; } }
void main() { /* Disable JTAG in software, so that it does not interfere with Port C */ MCUCR |= _BV(JTD); MCUCR |= _BV(JTD); init_stdio_uart1(); init_lcd(); set_orientation(East); scanswitch_init(); button_map bmap; bmap.left = 0; bmap.right = 0; bmap.up = 0; bmap.down = 0; bmap.center = 0; bmap.wheel_d= 0; bmap.has_pressed_button=0; init_miniUI(); display_menu_at("test;tes2;tes3",1, 10,10,2); }
int main() { _delay_ms(100); //little delay for the rfm12 to initialize properly rfm12_init(); //init the RFM12 _delay_ms(100); init_lcd(); init_timer(); sei(); set_orientation(East); put_string((char*)"Initialising...\n"); char random[120] = "hello aaron rowland, this is a string which should "; char test[26] = "0123456789012345678901234"; int i = 23456; char Rpacket[150]; SendPacket(THISDEVICE, random); // while(1) { // if(RecievePacket(Rpacket)) { // put_string("PACKET RECEIVED!!!!!\n"); // put_string(Rpacket); // } // } return 0; }
Tooltip::Tooltip(int x, int y, int width, int height) : label(nullptr), color(96, 96, 96, 255), text_color(255, 255, 255, 255) { set_position(x, y); set_size(width, height); set_position(0, 0); set_orientation(0); label = new Label(); }
Tooltip::Tooltip() : label(nullptr), color(96, 96, 96, 255), text_color(255, 255, 255, 255) { set_position(0, 0); set_size(100, 50); set_position(0, 0); set_orientation(0); label = new Label(); }
void CameraObject::rotate (DTfloat angle_x, DTfloat angle_y) { Matrix3 roty, rotx; roty = Matrix3::set_rotation_y(angle_y); rotx = Matrix3::set_rotation_x(angle_x); Matrix3 o = orientation() * roty * rotx; set_orientation(o); }
int main(void) { init_lcd(); set_orientation(North); rectangle r = {get_width() * 0.2, get_width() * 0.8, get_height() * 0.2, get_height() * 0.8}; do { fill_rectangle(r, YELLOW); _delay_ms(1); } while(1); }
Edit::Edit() : color(160, 160, 160, 255), character_limit(10), cursor(true), cursor_x(0), cursor_y(0), zoom_factor(0), multilined(false) { set_position(0, 0); set_size(200, 20); // 150, 20 set_orientation(0); label = new Label(); }
Tooltip::Tooltip(const std::string& text) : label(nullptr), color(96, 96, 96, 255), text_color(255, 255, 255, 255) { label = new Label(); set_text(text); set_position(0, 0); set_size(100, 100); set_position(0, 0); set_orientation(0); }
void ingame_camera::set_to_ideal(level_graph const& level, agent const& player) { vec_t player_pos = level.get_agent_position(player); vec_t player_dir = level.get_agent_direction(player); orient_t player_orient = lookat_orientation(player_dir, player.up); set_position(calc_ideal_position(player_pos, player_orient)); set_orientation(calc_ideal_orientation(player_pos, player_orient)); }
void CameraObject::look_at (const Vector3 &to, const Vector3 &up) { Matrix3 m; Vector3 delta; delta = translation() - to; m = Matrix3::set_orientation(delta, up); set_orientation(m); }
// data: [azimuth/pitch/roll] void Orientation::set_orientation( string data ) { string token[3]; float values[3]; for (int i = 0; i < 3; i++){ data = data.substr(myStrGetTok(data, token[i], 0, '/') + 1); values[i] = (float)::atof(token[i].c_str()); } set_orientation( values[0], values[1], values[2] ); }
Mesh::Mesh(const char *filename){ // Check whether the provided file exists. ifstream ifile(filename); if(!ifile){ std::cerr << "File " << filename << " does not exist." << std::endl; exit(EXIT_FAILURE); } vtkXMLUnstructuredGridReader *reader = vtkXMLUnstructuredGridReader::New(); reader->SetFileName(filename); reader->Update(); vtkUnstructuredGrid *ug = reader->GetOutput(); NNodes = ug->GetNumberOfPoints(); NElements = ug->GetNumberOfCells(); // Get the coordinates of each mesh vertex. There is no z coordinate in 2D, // but VTK treats 2D and 3D meshes uniformly, so we have to provide memory // for z as well (r[2] will always be zero and we ignore it). for(size_t i=0;i<NNodes;i++){ double r[3]; ug->GetPoints()->GetPoint(i, r); coords.push_back(r[0]); coords.push_back(r[1]); } assert(coords.size() == 2*NNodes); // Get the metric at each vertex. for(size_t i=0;i<NNodes;i++){ double *tensor = ug->GetPointData()->GetArray("Metric")->GetTuple4(i); metric.push_back(tensor[0]); metric.push_back(tensor[1]); assert(tensor[1] == tensor[2]); metric.push_back(tensor[3]); } assert(metric.size() == 3*NNodes); // Get the 3 vertices comprising each element. for(size_t i=0;i<NElements;i++){ vtkCell *cell = ug->GetCell(i); for(int j=0;j<3;j++){ ENList.push_back(cell->GetPointId(j)); } } assert(ENList.size() == 3*NElements); reader->Delete(); create_adjacency(); find_surface(); set_orientation(); precompute_surfaceNodes(); precompute_cornerNodes(); }
Terminal::Terminal() { dock_hint = GdkRectangle{0, 0, 0, 0}; vte = vte_terminal_new(); char *argv[] = { vte_get_user_shell(), NULL }; vte_terminal_spawn_sync(VTE_TERMINAL(vte), VTE_PTY_DEFAULT, NULL, argv, NULL, (GSpawnFlags)0, NULL, NULL, &child_pid, NULL, NULL); set_orientation(Gtk::ORIENTATION_VERTICAL); scrollbox.set_orientation(Gtk::ORIENTATION_HORIZONTAL); scrollbar.set_orientation(Gtk::ORIENTATION_VERTICAL); eventbox.add(label); eventbox.signal_button_press_event().connect(mem_fun(this, &Terminal::header_button_press)); VteRegex *regex = vte_regex_new_for_match("(https?://|www\\.)[^\\s]*", -1, PCRE2_MULTILINE, NULL); vte_terminal_match_add_regex(VTE_TERMINAL(vte), regex, 0); vte_terminal_set_scrollback_lines(VTE_TERMINAL(vte), 10000); g_signal_connect(vte, "bell", G_CALLBACK(Terminal::vte_beep), this); g_signal_connect(vte, "child-exited", G_CALLBACK(Terminal::vte_child_exited), this); g_signal_connect(vte, "button-press-event", G_CALLBACK(Terminal::vte_click), this); g_signal_connect(vte, "focus-in-event", G_CALLBACK(Terminal::vte_got_focus), this); g_signal_connect(vte, "focus-out-event", G_CALLBACK(Terminal::vte_lost_focus), this); g_signal_connect(vte, "selection-changed", G_CALLBACK(Terminal::vte_selection_changed), this); g_signal_connect(vte, "window-title-changed", G_CALLBACK(Terminal::vte_title_changed), this); searchbar.add(searchentry); searchbar.connect_entry(searchentry); searchentry.signal_focus_out_event().connect(mem_fun(this, &Terminal::searchentry_lost_focus)); searchentry.signal_key_release_event().connect(mem_fun(this, &Terminal::searchentry_keypress)); pack_start(eventbox, false, false, 0); pack_start(scrollbox, true, true, 0); pack_start(searchbar, false, false, 0); gtk_box_pack_start(GTK_BOX(scrollbox.gobj()), vte, true, true, 0); scrollbox.pack_start(scrollbar, false, false, 0); gtk_range_set_adjustment(GTK_RANGE(scrollbar.gobj()), gtk_scrollable_get_vadjustment(GTK_SCROLLABLE(vte))); show_all_children(); find_label.terminal = this; find_label.set_alignment(0.0, 0.5); find_window->list_box.prepend(find_label); std::vector<Gtk::TargetEntry> listTargets; listTargets.push_back(Gtk::TargetEntry("SvanTerminal", Gtk::TARGET_SAME_APP, 0)); eventbox.drag_source_set(listTargets); drag_dest_set(listTargets); eventbox.signal_drag_begin().connect(sigc::mem_fun(this, &Terminal::on_my_drag_begin)); eventbox.signal_drag_failed().connect(sigc::mem_fun(this, &Terminal::on_my_drag_failed)); eventbox.signal_drag_end().connect(sigc::mem_fun(this, &Terminal::on_my_drag_end)); signal_drag_motion().connect(sigc::mem_fun(this, &Terminal::on_my_drag_motion)); signal_drag_drop().connect(sigc::mem_fun(this, &Terminal::on_my_drag_drop)); signal_drag_leave().connect(sigc::mem_fun(this, &Terminal::on_my_drag_leave)); }
int main(void) { init_lcd(); set_orientation(South); rectangle r = { 20, 20 + RECT_WIDTH - 1, 20, 20 + RECT_HEIGHT - 1 }; Box b = {r, 1, 1}; rectangle clear = {0, 0, 0, 0}; do { if(b.vx > 0 && (b.r.right * SCALE) >= (get_width() - SCALE)) { b.vx = - b.vx; } else if(b.vx < 0 && (b.r.left * SCALE) <= 0) { b.vx = - b.vx; } if(b.vy > 0 && (b.r.bottom * SCALE) >= get_height()) { b.vy = - b.vy; } else if(b.vy < 0 && (b.r.top * SCALE) <= 0) { b.vy = - b.vy; } if(b.vx > 0) { clear.left = b.r.left * SCALE; clear.right = (b.r.left + 1) * SCALE; clear.top = b.r.top * SCALE; clear.bottom = b.r.bottom * SCALE; fill_rectangle(clear, BLACK); } else if(b.vx < 0) { clear.right = b.r.right * SCALE; clear.left = (b.r.right - 1) * SCALE; clear.top = b.r.top * SCALE; clear.bottom = b.r.bottom * SCALE; fill_rectangle(clear, BLACK); } if(b.vy > 0) { clear.left = b.r.left * SCALE; clear.right = b.r.right * SCALE; clear.top = b.r.top * SCALE; clear.bottom = (b.r.top + 1) * SCALE; fill_rectangle(clear, BLACK); } else if(b.vy < 0) { clear.left = b.r.left * SCALE; clear.right = b.r.right * SCALE; clear.bottom = b.r.bottom * SCALE; clear.top = (b.r.bottom - 1) * SCALE; fill_rectangle(clear, BLACK); } b.r.left += b.vx; b.r.right += b.vx; b.r.top += b.vy; b.r.bottom += b.vy; fill_rectangle_indexed_scale(b.r, pic, SCALE); _delay_ms(50); } while(1); }
void RigidBody::Rotate(MATRIX3x3& R){ /** \brief Arbitrary rotation in body frame, parameterized by a matrix Warning: Matrix R should be a valid (unitary, with norm = 1) rotation matrix \param[in] R Rotation matrix */ rb_A_I_to_e = R*rb_A_I_to_e; set_orientation(rb_A_I_to_e); }
//_____________________________________________________________________________ // Convienience constructor. ContactGeometry::ContactGeometry(const Vec3& location, const Vec3& orientation, PhysicalFrame& body) : ModelComponent() { setNull(); constructProperties(); _body = &body; set_body_name(body.getName()); set_location(location); set_orientation(orientation); }
void RigidBody::Rotate_I_z(double phi){ /** Rotation around center of mass along the z axis in external coordinate system (lab frame) \param[in] phi The rotation angle, in radians */ MATRIX3x3 R; R.Rx(phi); rb_A_I_to_e = R * rb_A_I_to_e; set_orientation(rb_A_I_to_e); }
void RigidBody::Rotate(QUATERNION& quat){ /** \brief Arbitrary rotation in body frame, parameterized by a quaternion \param[in] quaternion Rotation quaternion */ MATRIX3x3 R; QUATERNION_TO_MATRIX(quat,R); rb_A_I_to_e = R*rb_A_I_to_e; set_orientation(rb_A_I_to_e); }
void CameraObject::orbit (DTfloat angle_x, DTfloat angle_y, const Vector3 &around_pt) { Matrix3 roty, rotx; roty = Matrix3::set_rotation_y(angle_y); rotx = Matrix3::set_rotation_x(angle_x); Matrix3 o = orientation(); Vector3 offset = o.inversed() * (translation() - around_pt); o = o * roty * rotx; set_translation(o * offset + around_pt); set_orientation(o); }
Menubar::Menubar() : color(106, 106, 106, 255), submenu_color(106, 106, 106, 255), // outline outline(false), outline_width(1.0), outline_color(0, 0, 0, 255), outline_antialiased(false), // highlight highlight(true), highlight_color(0, 51, 102, 255) { set_position(0, 0); set_size(300, 20); // menubar_width / menu_width = how_many_menu_can_fit set_orientation(0); }
void RigidBody::Rotate_e_z(double phi){ /** Rotation around center of mass along the y axis in body-fixed coordinate system (body frame) \param[in] phi The rotation angle, in radians */ VECTOR ux,uy,uz; rb_A_I_to_e.get_vectors(ux,uy,uz); MATRIX3x3 R; R.Rotation(phi*ux); rb_A_I_to_e = R * rb_A_I_to_e; set_orientation(rb_A_I_to_e); }
void RoomSurface::init(Ogre::Vector3 normal, Ogre::Real x_size, Ogre::Real z_size, CreateVisualActor create_visual_actor) { create_visual_actor_ = create_visual_actor == CREATE_VISUAL_ACTOR; init(); normal.normalise(); normal_ = normal; // ***Important*** // The surface is constructed from a "flat" rectangle sitting in the xz-plane, hence // we define its size by the x- and z- sizes. Once the surface has been rotated to have the // passed-in normal the x_size and z_size will not actually correspond to the surfaces' // x and z dimensions in world space. StaticBox::set_size(Ogre::Vector3(x_size, kSurfaceThickness, z_size)); // Rotate the box to correspond to the passed-in normal set_orientation(surfaceOrientationForNormal(normal)); }
void third_person_cam::update(level_graph const& level, agent const& player, float_t dtime) { vec_t player_pos = level.get_agent_position(player); vec_t player_dir = level.get_agent_direction(player); orient_t player_orient = lookat_orientation(player_dir, player.up); vec_t ideal_pos = calc_ideal_position(player_pos, player_orient); orient_t ideal_orientation = calc_ideal_orientation(player_pos, player_orient); vec_t cur_pos = get_position(); // Let's try, moving proportionally to distance, such that in 1 second we would move the whole way (if happened in single step) float const cam_move = dtime * move_speed_factor; set_position(cur_pos + (ideal_pos - cur_pos) * std::min(cam_move, 1.0f)); orient_t cur_orientation = get_orientation(); float const cam_slerp = dtime * slerp_speed_factor; orient_t interpolated = cur_orientation.slerp(std::min(cam_slerp, 1.0f), ideal_orientation); set_orientation(interpolated); }
VR_Window::VR_Window() { set_orientation( Gtk::ORIENTATION_HORIZONTAL ); pc_file_open = false; vrender = new VRender; volume_origin = make_float3( 0.5, 0, 0 ); cloud = new Cloud; cloud->world.resolution = make_float3( RENDER_RESOLUTION, RENDER_RESOLUTION, RENDER_RESOLUTION ); printf("\n World Resolution: %f x %f x %f", cloud->world.resolution.x, cloud->world.resolution.y, cloud->world.resolution.z ); cloud->world.size = make_uint3( MAX_VOLUME_SIDE, MAX_VOLUME_SIDE, MAX_VOLUME_SIDE ); printf("\n World Size: %d x %d x %d", cloud->world.size.x, cloud->world.size.y, cloud->world.size.z ); cloud->world.count = cloud->world.size.x * cloud->world.size.y * cloud->world.size.z; printf("\n World Count: %d",cloud->world.count); cloud->world.dimension = make_float3( cloud->world.resolution.x * (float)cloud->world.size.x, cloud->world.resolution.y * (float)cloud->world.size.y, cloud->world.resolution.z * (float)cloud->world.size.z ); printf("\n World Dimension: %f x %f x %f", cloud->world.dimension.x, cloud->world.dimension.y, cloud->world.dimension.z ); cloud->world.min.x = 1000.f * volume_origin.x - 0.5 * cloud->world.dimension.x; cloud->world.min.y = 1000.f * volume_origin.y - 0.5 * cloud->world.dimension.y; cloud->world.min.z = 1000.f * volume_origin.z - 0.5 * cloud->world.dimension.z; printf("\n World Minimum: %f %f %f", cloud->world.min.x, cloud->world.min.y, cloud->world.min.z ); cloud->world.max.x = cloud->world.min.x + cloud->world.dimension.x; cloud->world.max.y = cloud->world.min.y + cloud->world.dimension.y; cloud->world.max.z = cloud->world.min.z + cloud->world.dimension.z; printf("\n World Maximum: %f %f %f\n", cloud->world.max.x, cloud->world.max.y, cloud->world.max.z ); adaptive_world_sizing = false; socket_timer_idx = 0; memset( socket_timer, 0, TIMER_SIZE * sizeof(double) ); numKinects = 1; }
void init_lcd() { /* Enable extended memory interface with 10 bit addressing */ XMCRB = _BV(XMM2) | _BV(XMM1); XMCRA = _BV(SRE); DDRC |= _BV(RESET); DDRB |= _BV(BLC); _delay_ms(1); PORTC &= ~_BV(RESET); _delay_ms(20); PORTC |= _BV(RESET); _delay_ms(120); write_cmd(DISPLAY_OFF); write_cmd(SLEEP_OUT); _delay_ms(60); write_cmd_data(INTERNAL_IC_SETTING, 0x01); write_cmd(POWER_CONTROL_1); write_data16(0x2608); write_cmd_data(POWER_CONTROL_2, 0x10); write_cmd(VCOM_CONTROL_1); write_data16(0x353E); write_cmd_data(VCOM_CONTROL_2, 0xB5); write_cmd_data(INTERFACE_CONTROL, 0x01); write_data16(0x0000); write_cmd_data(PIXEL_FORMAT_SET, 0x55); /* 16bit/pixel */ set_orientation(West); clear_screen(); display.x = 0; display.y = 0; display.background = BLACK; display.foreground = WHITE; write_cmd(DISPLAY_ON); _delay_ms(50); write_cmd_data(TEARING_EFFECT_LINE_ON, 0x00); EICRB |= _BV(ISC61); PORTB |= _BV(BLC); }
/** * Called once on initialization - Initialize the io functions and the controller state. */ void init(State* state) { init_lcd(); init_adc(); DDRA = (1 << 3) | (1 << 4) | (1 << 5); //Setup up digital input ports as input PORTA = (1 << 3) | (1 << 4) | (1 << 5); //Enable pull up resistors on input ports set_orientation(North); rectangle r2 = {5, 45, 5, 45}; //The three squares denoting digital inputs rectangle r3 = {5, 45, 50, 90}; rectangle r4 = {5, 45, 95, 135}; state->r2 = r2; //Initialize the state. state->r3 = r3; state->r4 = r4; rectangle r5 = {get_width() - 50, get_width() - 5, 5, 45}; //The three squares denoting digital outputs rectangle r6 = {get_width() - 50, get_width() - 5, 50, 90}; rectangle r7 = {get_width() - 50, get_width() - 5, 95, 135}; state->r5 = r5; state->r6 = r6; state->r7 = r7; state->x10 = (get_width() / 4); //Computes the x positions of the analogue bars state->x11 = state->x10 + (get_width() / 6); state->x21 = state->x11 + (get_width() / 6); state->x31 = state->x21 + (get_width() / 6); }
SceneObject &SceneObject::rotate(float dir, float up, float tilt) { set_orientation(get_orientation() * Quaternionf(up, dir, tilt, angle_degrees, order_YXZ)); return *this; }
Menubar::Menubar(int x, int y, int width, int height) { set_position(x, y); set_size(width, height); set_orientation(0); }
Menubar::Menubar(int x, int y) { set_position(x, y); set_size(300, 20); set_orientation(0); }