Datasets:

pe-nlp

/

ov-kit-files-filtered-dedup

like 0

cadop/HumanGenerator/exts/siborg.create.human/config/extension.toml

[package] # Semantic Versionning is used: https://semver.org/ version = "0.0.2" preview_image = "data/preview.png" # Icon is shown in Extensions window, it is recommended to be square, of size 256x256. icon = "data/icon.png" # The title and description fields are primarily for displaying extension info in UI title = "HumanGenerator" description="Human Generator for Omniverse. Create and customize humans in your Omniverse scenes." # Path (relative to the root) or content of readme markdown file for UI. readme = "docs/README.md" # URL of the extension source repository. repository = "" # One of categories for UI. category = "Services" feature = true # Keywords for the extension keywords = ["kit", "makehuman","human","character","generator","person"] # Use omni.ui to build simple UI [dependencies] "omni.kit.uiapp" = {} "omni.usd" = {} "omni.anim.skelJoint" = {} "omni.kit.browser.core" = {} "omni.kit.browser.folder.core" = {} # Main python module this extension provides, it will be publicly available as "import omni.hello.world". [[python.module]] name = "siborg.create.human" [settings] exts."siborg.create.human.browser.asset".instanceable = [] exts."siborg.create.human.browser.asset".timeout = 10 [python.pipapi] use_online_index = true # Use this to specify a list of additional repositories if your pip package is hosted somewhere other # than the default repo(s) configured in pip. Will pass these to pip with "--extra-index-url" argument repositories = ["https://test.pypi.org/simple/"] requirements = ["makehuman==1.2.2"]

TOML

cadop/HumanGenerator/exts/siborg.create.human/docs/README.md

# Overview HumanGenerator generates parametric, rigged, outfitted humans in NVIDIA Omniverse. This project relies on the Makehuman project from https://github.com/makehumancommunity/makehuman. # Getting Started The easiest way to get started is using Omniverse Create. Navigate to the Extensions window and click on "Community". Search for `HumanGenerator` and you should see our extension show up. The extension may take a few minutes to install as it will download makehuman and install it in the Omniverse's local Python instance. For use, check out the walkthrough video on Github. ## License *Our license restrictions are due to the AGPL of MakeHuman. In line with the statements from MakeHuman, the targets and resulting characters are CC0, meaning you can use whatever you create for free, without restrictions. It is only the codebase that is AGPL.

Markdown

cadop/crowds/README.md

 This repository is for the omniverse extension for crowd simulation. If you are looking for a project that can be run without omniverse, checkout [Python-only crowd simulation](https://github.com/cadop/warpcrowd) A crowd simulator API with a default demo scene. The main python API can be used in a few ways. There is an examples folder showing a few use-cases. Users can also switch between social forces and PAM as the crowds algorithm. The extension will load an populate some demo configuration. It will create an Xform called CrowdGoals. To add a goal for the crowd. Create an xform under the "CrowdGoals". We automatically check for those prims as the method of determing crowd goals. For every additional xform under CrowdGoals, we evenly split the crowd to assign those goals. There are two options for the crowd objects. The default uses geompoints, which is faster and runs its own integration of the forces for position and velocity. It does not interact with any physics in the scene. Alternatively the "Rigid Body" can be used, which creates physical spheres that interact with the scene. Press Play to see the crowd. The default number of demo agents is a 3x3 grid (9 agents). The current simulator in python may struggle above 25 agents, depending on CPU configuration. We plan to support more methods in the future, as well as more crowd simulators. Contributions are welcome.

Markdown

cadop/crowds/exts/siborg.simulate.crowd/siborg/simulate/crowd/simulator.py

import numpy as np from numpy import random from omni.physx import get_physx_interface import omni import carb from pxr import UsdGeom, Gf, Sdf, UsdShade import warp as wp import copy import usdrt from siborg.simulate.crowd.crowds import CrowdConfig from siborg.simulate.crowd.models import socialforces from siborg.simulate.crowd.models import pam wp.init() from siborg.simulate.crowd.models import socialforces_warp as crowd_force class Simulator(CrowdConfig): def __init__(self, world=None): super().__init__() self.world = world # a default dt that is surely overwritten later self._dt = 1/60.0 # set radius self.radius = 0.7 self.radius_min = 0.5 self.radius_max = 1.0 # A subscription to the physics simulation, used when this class # is asked to manage the updates self._simulation_event = None # Will use a physics scene self.rigidbody = False self.use_pam = False self.on_gpu = False self.use_instancer = False self.add_jane = False self.use_heading = False # Tracks if user wants to update agent position on each sim step self.update_agents_sim = False self.update_viz = False self.instancer_paths = ["/World/PointInstancer_Bob", "/World/PointInstancer_Jane"] self.point_instancer_sets = [] self.agent_instance_path_bob = '/World/Scope/CrowdBob' self.agent_instance_path_jane = '/World/Scope/CrowdJane' self.instance_forward_vec = (1.0,0.0,0.0) # TODO get from instance object self.instance_up_vec = (0.0,1.0,0.0) # TODO Fix to be flexible later self.vel_epsilon = 0.05 self._get_world_up() def _get_world_up(self): stage = omni.usd.get_context().get_stage() up = UsdGeom.GetStageUpAxis(stage) if up =='X': self.world_up = 0 if up =='Y': self.world_up = 1 if up =='Z': self.world_up = 2 return def register_simulation(self): self._callbacks() # we need to update the agents, otherwise won't see these results self.update_agents_sim = True self.update_viz = True def _callbacks(self): self._simulation_event = get_physx_interface( ).subscribe_physics_step_events( self._on_simulation_update) def _unregister(self): try: self._simulation_event.unsubscribe() except: self._simulation_event = None def _on_simulation_update(self, dt): if self.agent_bodies is None: return self._dt = dt self.run() def set_xform_goal(self, p): '''set the goal based on a subscribed xform Example of usage watcher = omni.usd.get_watcher() self._goal_subscriber = watcher.subscribe_to_change_info_path( Sdf.Path('/World/Goal.xformOp:translate'), self.Sim.set_xform_goal) Parameters ---------- p : str(prim path) a subscribed path ''' stage = omni.usd.get_context().get_stage() prim = stage.GetPrimAtPath(str(p).split('.')[0]) goal_point = omni.usd.utils.get_world_transform_matrix(prim).ExtractTranslation() # Set agent destination self.goals = np.asarray([goal_point for x in range(self.nagents)]) def integrate(self, x, v, f, dt): ''' take position, velocity, force, and dt to compute updated position and velocity ''' v1 = v + ( (f * 1.0) * dt ) # new velocity x1 = x + (v1 * dt) # new position return x1, v1 def update_goals(self, new_goal): '''update the goals of agents Parameters ---------- new_goal : ndarray([x,y,z]) can either be one goal that is applied to all agents, or a list of the same size as number of agents ''' if len(new_goal) == 1: self.goals = np.asarray([new_goal for x in range(self.nagents)]) else: self.goals = new_goal def compute_step(self, agent): # Set the model to PAM if asked if self.use_pam: model = pam else: model = socialforces # Get the neighbors of this agent to use in computing forces pn = model.get_neighbors(self.agents_pos[agent], self.agents_pos, self.agents_percept[agent])[1] _force = model.compute_force(self.agents_pos[agent], self.agents_radi[agent], self.agents_vel[agent], self.agents_mass[agent], self.goals[agent], self.agents_pos[pn], self.agents_vel[pn], self.agents_radi[pn], self._dt) return _force def run(self): '''Runs the simulation for one step Updates agent positions and velocities if instance flag is true Returns ------- ndarray[x,y,z] forces ''' self.force_list = [] for agent in range(self.nagents): _force = self.compute_step(agent) # remove world (up) forces _force[self.world_up] = 0 # Store all forces to be applied to agents self.force_list.append(_force) self.step_processing() def step_processing(self): '''Process the computed step for simulation Returns ------- _type_ _description_ ''' # only update agent positions if user requests, otherwise they might want to # update using forces themselves if self.update_agents_sim: # If using rigid body, apply forces to agents if self.rigidbody: self.apply_force(self.force_list) else: self.internal_integration() if self.use_instancer: self.set_instance_agents() else: self.set_geompoints() def internal_integration(self): # Integrate for new position for i in range(self.nagents): self.agents_pos[i], self.agents_vel[i] = self.integrate(self.agents_pos[i], self.agents_vel[i], self.force_list[i], self._dt) def apply_force(self, force_list): '''Used for when rigidbody agents are used Parameters ---------- force_list : List[x,y,z] list of forces in order of the agents ''' # Apply forces to simulation # with Sdf.ChangeBlock(): # for idx, force in enumerate(force_list): # self._add_force(force, self.agent_bodies[idx], self.agent_bodies[idx].position) self._add_force3(force_list, self.agent_bodies) # Update positions and velocities for i in range(self.nagents): self.agents_pos[i] = self.agent_bodies[i].position self.agents_vel[i] = self.agent_bodies[i].velocity def _add_force(self, force, rigid_body, position): force = carb.Float3(force) position = carb.Float3(position) get_physx_interface().apply_force_at_pos(rigid_body.skinMeshPath, force, position) def _add_force2(self, force, rigid_body, position): # force = Gf.Vec3d(force) _ = force[0] force = Gf.Vec3d(float(force[0]), float(force[1]),float(force[2])) rigid_body.forceAttr.Set(force) #position def _add_force3(self, force_list, rigid_body): # force = Gf.Vec3d(force) # stage = usdrt.Usd.Stage.Attach(omni.usd.get_context().get_stage_id()) # # prim = stage.GetPrimAtPath("/World/boxActor") # attr = prim.CreateAttribute("_worldForce", usdrt.Sdf.ValueTypeNames.Float3, True) # if attr: # attr.Set(usdrt.Gf.Vec3f(50000.0, 0.0, 0.0)) # prefixes = set(prefix for path in paths for prefix in path.GetPrefixes()) # with Sdf.ChangeBlock(): # for path in prefixes: # prim_spec = Sdf.CreatePrimInLayer(layer, path) # prim_spec.specifier = Sdf.SpecifierDef # prim_spec.typeName = UsdGeom.Xform.__name__ for idx, body in enumerate(rigid_body): force = force_list[idx] force = usdrt.Gf.Vec3d(float(force[0]), float(force[1]),float(force[2])) # body.forceAttr.Set(force) #position if body.world_force_attr: body.world_force_attr.Set(force) def create_geompoints(self, stage_path=None, color=None): '''create and manage geompoints representing agents Parameters ---------- stage_path : str, optional if not set, will use /World/Points, by default None color : (r,g,b), optional if not set, will make color red, by default None ''' if stage_path: stage_loc = stage_path else: stage_loc = "/World/Points" self.stage = omni.usd.get_context().get_stage() self.agent_point_prim = UsdGeom.Points.Define(self.stage, stage_loc) self.agent_point_prim.CreatePointsAttr() width_attr = self.agent_point_prim.CreateWidthsAttr() width_attr.Set(self.agents_radi) # width_attr.Set([1 for x in range(self.nagents)]) self.agent_point_prim.CreateDisplayColorAttr() # For RTX renderers, this only works for UsdGeom.Tokens.constant color_primvar = self.agent_point_prim.CreateDisplayColorPrimvar(UsdGeom.Tokens.constant) if color: point_color = color else: point_color = (1,0,0) color_primvar.Set([point_color]) def set_geompoints(self): # Set the position with an offset based on the radius # Since it is a sphere, we render_pos = np.copy(self.agents_pos) render_pos[:,1] += (self.agents_radi/2) self.agent_point_prim.GetPointsAttr().Set(render_pos) def create_instance_agents(self): if self.add_jane: bob_size = int(self.nagents/2) bob_pos = self.agents_pos[:bob_size] point_instancer = self._single_agent_instance(bob_pos, bob_size, self.agent_instance_path_bob, self.instancer_paths[0]) self.point_instancer_sets.append(point_instancer) # TODO find way to split colors of instances jane_size = int(self.nagents/2) jane_pos = self.agents_pos[bob_size:] point_instancer = self._single_agent_instance(jane_pos, jane_size , self.agent_instance_path_jane, self.instancer_paths[1]) self.point_instancer_sets.append(point_instancer) else: point_instancer = self._single_agent_instance(self.agents_pos, self.nagents, self.agent_instance_path_bob, self.instancer_paths[0]) self.point_instancer_sets.append(point_instancer) def _single_agent_instance(self, agent_pos, nagents, agent_instance_path, instance_path): stage = omni.usd.get_context().get_stage() point_instancer = UsdGeom.PointInstancer.Get(stage, instance_path) if not point_instancer: point_instancer = UsdGeom.PointInstancer(stage.DefinePrim(instance_path, "PointInstancer")) point_instancer.CreatePrototypesRel().SetTargets([agent_instance_path]) self.proto_indices_attr = point_instancer.CreateProtoIndicesAttr() self.proto_indices_attr.Set([0] * nagents) ## max radius is scale of 1 agent_scales = self.agents_radi/self.radius_max self.agent_instancer_scales = [(x,x,x) for x in agent_scales] # change to numpy # Set scale point_instancer.GetScalesAttr().Set(self.agent_instancer_scales) point_instancer.GetPositionsAttr().Set(agent_pos) # Set orientation rot = Gf.Rotation() rot.SetRotateInto(self.instance_forward_vec, self.instance_forward_vec) self.agent_headings = [Gf.Quath(rot.GetQuat()) for x in range(nagents)] point_instancer.GetOrientationsAttr().Set(self.agent_headings) return point_instancer def set_instance_agents(self): # update the points # self.point_instancer.CreatePrototypesRel().SetTargets([self.agent_instance_path]) # self.proto_indices_attr = self.point_instancer.CreateProtoIndicesAttr() # self.proto_indices_attr.Set([0] * self.nagents) for idx, point_instancer in enumerate(self.point_instancer_sets): if len(self.point_instancer_sets) == 1: agents_pos = self.agents_pos else: _slice = int(self.nagents/2) if idx == 0: # Positions for this instance agents_pos = self.agents_pos[:_slice] else: # Positions for this instance agents_pos = self.agents_pos[_slice:] # Set position point_instancer.GetPositionsAttr().Set(agents_pos) if not self.use_heading: continue self.set_heading() def set_heading(self): for idx, point_instancer in enumerate(self.point_instancer_sets): if len(self.point_instancer_sets) == 1: agents_vel = self.agents_vel nagents = self.nagents else: _slice = int(self.nagents/2) nagents = _slice if idx == 0: # Velocities for this instance agents_vel = self.agents_vel[:_slice] else: # Velocities for this instance agents_vel = self.agents_vel[_slice:] # Create array of agent headings based on velocity normalize_vel = agents_vel rot = Gf.Rotation() self.agent_headings = [] cur_orient = point_instancer.GetOrientationsAttr().Get() for i in range(0, nagents): if np.sqrt(normalize_vel[i].dot(normalize_vel[i])) < self.vel_epsilon: tovec = cur_orient[i] self.agent_headings.append(cur_orient[i]) else: tovec = Gf.Vec3d(tuple(normalize_vel[i])) rot.SetRotateInto(self.instance_forward_vec, tovec) self.agent_headings.append(Gf.Quath(rot.GetQuat())) # Set orientation point_instancer.GetOrientationsAttr().Set(self.agent_headings) return #### Change colors stage = omni.usd.get_context().get_stage() # get path of material mat_path = '/CrowdBob/Looks/Linen_Blue' linen_mat = Sdf.Path(f'/World/Scope{mat_path}') mat_prim = stage.GetPrimAtPath(linen_mat) # print(mat_prim) # shader_path = '/Shader.inputs:diffuse_tint' # tint_shader = f'/World{mat_path}{shader_path}' shader = omni.usd.get_shader_from_material(mat_prim) # print(shader) #inp = shader.GetInput('diffuse_tint').Get() inp = shader.GetInput('diffuse_tint').Set((0.5,0.5,1.0)) class WarpCrowd(Simulator): '''A class to manage the warp-based version of crowd simulation ''' def __init__(self, world=None): super().__init__(world) self.device = 'cuda:0' # generate n number of agents self.nagents = 9 # set radius self.radius = 0.7 self.radius_min = 0.5 self.radius_max = 1.0 self.hash_radius = 0.7 # Radius to use for hashgrid # set mass self.mass = 20 # set pereption radius self.perception_radius = 6 # self.dt = 1.0/30.0 self.goal = [0.0,0.0,0.0] self.generation_origin = [10,10.0,0.0] self.inv_up = wp.vec3(1.0,1.0,1.0) # z-up self.inv_up[self.world_up] = 0.0 self.on_gpu = True def demo_agents(self, s=1.6, m=50, n=50): o = self.generation_origin # Initialize agents in a grid for testing self.agents_pos = np.asarray([ np.array([(s/2) + (x * s) +(o[0]/2) , (s/2) + (y * s) +(o[1]/2), 0 ], dtype=np.double) for x in range(m) for y in range(n) ]) self.nagents = len(self.agents_pos) self.configure_params() def configure_params(self): '''Convert all parameters to warp ''' self.agents_pos = np.asarray(self.agents_pos) # self.agents_pos = np.asarray([np.array([0,0,0], dtype=float) for x in range(self.nagents)]) self.agents_vel = np.asarray([np.array([0,0,0], dtype=float) for x in range(self.nagents)]) # # Set a quath for heading # rot = Gf.Rotation() # rot.SetRotateInto(self.instance_forward_vec, self.instance_forward_vec) # from, to # _hquat = Gf.Quath(rot.GetQuat()) # # Get rotation between agent forward direction self.agents_hdir = np.asarray([np.array([0,0,0,1], dtype=float) for x in range(self.nagents)]) self.force_list = np.asarray([np.array([0,0,0], dtype=float) for x in range(self.nagents)]) self.agents_radi = np.random.uniform(self.radius_min, self.radius_max, self.nagents) self.agents_mass = [self.mass for x in range(self.nagents)] self.agents_percept = np.asarray([self.perception_radius for x in range(self.nagents)]) self.agents_goal = np.asarray([np.array(self.goal, dtype=float) for x in range(self.nagents)]) self.agent_force_wp = wp.zeros(shape=self.nagents,device=self.device, dtype=wp.vec3) self.agents_pos_wp = wp.array(self.agents_pos, device=self.device, dtype=wp.vec3) self.agents_vel_wp = wp.array(self.agents_vel, device=self.device, dtype=wp.vec3) self.agents_hdir_wp = wp.array(self.agents_hdir, device=self.device, dtype=wp.vec4) self.agents_goal_wp = wp.array(self.agents_goal, device=self.device, dtype=wp.vec3) self.agents_radi_wp = wp.array(self.agents_radi, device=self.device, dtype=float) self.agents_mass_wp = wp.array(self.agents_mass, device=self.device, dtype=float) self.agents_percept_wp = wp.array(self.agents_percept, device=self.device, dtype=float) self.xnew_wp = wp.zeros_like(wp.array(self.agents_pos, device=self.device, dtype=wp.vec3)) self.vnew_wp = wp.zeros_like(wp.array(self.agents_pos, device=self.device, dtype=wp.vec3)) self.hdir_wp = wp.zeros_like(wp.array(self.agents_hdir, device=self.device, dtype=wp.vec4)) def config_hasgrid(self, nagents=None): '''Create a hash grid based on the number of agents Currently assumes z up Parameters ---------- nagents : int, optional _description_, by default None ''' if nagents is None: nagents = self.nagents self.grid = wp.HashGrid(dim_x=200, dim_y=200, dim_z=1, device=self.device) # self.grid = wp.HashGrid(dim_x=nagents, dim_y=nagents, dim_z=1, device=self.device) def config_mesh(self, points, faces): '''Create a warp mesh object from points and faces Parameters ---------- points : List[[x,y,z]] A list of floating point xyz vertices of a mesh faces : List[int] A list of integers corresponding to vertices. Must be triangle-based ''' # fake some points and faces if empty list was passed if len(points) == 0: points = [(0,0,0), (0,0,0), (0,0,0)] faces = [[1, 2, 3]] # print(points) # print(faces) # Init mesh for environment collision self.mesh = wp.Mesh( points=wp.array(points, dtype=wp.vec3, device=self.device), indices=wp.array(faces, dtype=int ,device=self.device) ) def update_goals(self, new_goal): if len(new_goal) == 1: self.goals = np.asarray([new_goal for x in range(self.nagents)]) else: self.goals = new_goal self.agents_goal_wp = wp.array(self.goals, device=self.device, dtype=wp.vec3) def run(self): # Rebuild hashgrid given new positions self.grid.build(points=self.agents_pos_wp, radius=self.hash_radius) # launch kernel wp.launch(kernel=crowd_force.get_forces, dim=self.nagents, inputs=[self.agents_pos_wp, self.agents_vel_wp, self.agents_goal_wp, self.agents_radi_wp, self.agents_mass_wp, self._dt, self.agents_percept_wp, self.grid.id, self.mesh.id, self.inv_up], outputs=[self.agent_force_wp], device=self.device ) self.force_list = self.agent_force_wp.numpy() self.step_processing() self.agents_pos_wp = wp.array(self.agents_pos, device=self.device, dtype=wp.vec3) self.agents_vel_wp = wp.array(self.agents_vel, device=self.device, dtype=wp.vec3) return self.agent_force_wp def internal_integration(self): # Given the forces, integrate for pos and vel wp.launch(kernel=crowd_force.integrate, dim=self.nagents, inputs=[self.agents_pos_wp, self.agents_vel_wp, self.agent_force_wp, self._dt], outputs=[self.xnew_wp, self.vnew_wp], device=self.device ) self.agents_pos_wp = self.xnew_wp self.agents_vel_wp = self.vnew_wp self.agents_pos = self.agents_pos_wp.numpy() self.agents_vel = self.agents_vel_wp.numpy() def set_heading(self): up = wp.vec3(0.0,1.0,0.0) forward = wp.vec3(1.0,0.0,0.0) wp.launch(kernel=crowd_force.heading, dim=self.nagents, inputs=[self.agents_vel_wp, up, forward], outputs=[self.hdir_wp], device=self.device ) self.agents_hdir_wp = self.hdir_wp self.agents_hdir = self.agents_hdir_wp.numpy() for idx, point_instancer in enumerate(self.point_instancer_sets): if len(self.point_instancer_sets) == 1: agent_headings = self.agents_hdir else: _slice = int(self.nagents/2) if idx == 0: agent_headings = self.agents_hdir[:_slice] else: agent_headings = self.agents_hdir[_slice:] # Set orientation point_instancer.GetOrientationsAttr().Set(agent_headings)

Python

cadop/crowds/exts/siborg.simulate.crowd/siborg/simulate/crowd/usd_utils.py

import numpy as np from pxr import UsdGeom, Gf, Usd import omni def get_mesh(usd_stage, objs): points, faces = [],[] for obj in objs: f_offset = len(points) # f, p = convert_to_mesh(obj)#usd_stage.GetPrimAtPath(obj)) f, p = meshconvert(obj)#usd_stage.GetPrimAtPath(obj)) points.extend(p) faces.extend(f+f_offset) return points, faces def get_all_stage_mesh(stage, start_prim): found_meshes = [] # Traverse the scene graph and print the paths of prims, including instance proxies for x in Usd.PrimRange(start_prim, Usd.TraverseInstanceProxies()): if x.IsA(UsdGeom.Mesh): found_meshes.append(x) points, faces = get_mesh(stage, found_meshes) return points, faces def convert_to_mesh(prim): ''' convert a prim to BVH ''' # Get mesh name (prim name) m = UsdGeom.Mesh(prim) # Get verts and triangles tris = m.GetFaceVertexIndicesAttr().Get() tris_cnt = m.GetFaceVertexCountsAttr().Get() verts = m.GetPointsAttr().Get() tri_list = np.array(tris) vert_list = np.array(verts) xform = UsdGeom.Xformable(prim) time = Usd.TimeCode.Default() # The time at which we compute the bounding box world_transform: Gf.Matrix4d = xform.ComputeLocalToWorldTransform(time) translation: Gf.Vec3d = world_transform.ExtractTranslation() rotation: Gf.Rotation = world_transform.ExtractRotationMatrix() # rotation: Gf.Rotation = world_transform.ExtractRotation() scale: Gf.Vec3d = Gf.Vec3d(*(v.GetLength() for v in world_transform.ExtractRotationMatrix())) rotation = rotation.GetOrthonormalized() # New vertices vert_list = np.dot((vert_list * scale ), rotation) + translation # vert_scaled = vert_list # vert_list[:,0] *= scale[0] # vert_list[:,1] *= scale[1] # vert_list[:,2] *= scale[2] # vert_rotated = np.dot(vert_scaled, rotation) # Rotate points # vert_translated = vert_rotated + translation # vert_list = vert_translated # Check if the face counts are 4, if so, reshape and turn to triangles if tris_cnt[0] == 4: quad_list = tri_list.reshape(-1,4) tri_list = quad_to_tri(quad_list) tri_list = tri_list.flatten() return tri_list, vert_list def quad_to_tri(a): idx = np.flatnonzero(a[:,-1] == 0) out0 = np.empty((a.shape[0],2,3),dtype=a.dtype) out0[:,0,1:] = a[:,1:-1] out0[:,1,1:] = a[:,2:] out0[...,0] = a[:,0,None] out0.shape = (-1,3) mask = np.ones(out0.shape[0],dtype=bool) mask[idx*2+1] = 0 return out0[mask] def selected_as_mesh(): # Get the current active selection of the stage stage = omni.usd.get_context().get_stage() # Get the selections from the stage _usd_context = omni.usd.get_context() _selection = _usd_context.get_selection() selected_paths = _selection.get_selected_prim_paths() # Expects a list, so take first selection prims = [stage.GetPrimAtPath(x) for x in selected_paths] points, faces = get_mesh(stage, selected_paths) return points, faces def children_as_mesh(stage, parent_prim): children = parent_prim.GetAllChildren() children = [child.GetPrimPath() for child in children] points, faces = get_mesh(stage, children) return points, faces def meshconvert(prim): # Create an XformCache object to efficiently compute world transforms xform_cache = UsdGeom.XformCache() # Get the mesh schema mesh = UsdGeom.Mesh(prim) # Get verts and triangles tris = mesh.GetFaceVertexIndicesAttr().Get() if not tris: return [], [] tris_cnt = mesh.GetFaceVertexCountsAttr().Get() # Get the vertices in local space points_attr = mesh.GetPointsAttr() local_points = points_attr.Get() # Convert the VtVec3fArray to a NumPy array points_np = np.array(local_points, dtype=np.float64) # Add a fourth component (with value 1.0) to make the points homogeneous num_points = len(local_points) ones = np.ones((num_points, 1), dtype=np.float64) points_np = np.hstack((points_np, ones)) # Compute the world transform for this prim world_transform = xform_cache.GetLocalToWorldTransform(prim) # Convert the GfMatrix to a NumPy array matrix_np = np.array(world_transform, dtype=np.float64).reshape((4, 4)) # Transform all vertices to world space using matrix multiplication world_points = np.dot(points_np, matrix_np) tri_list = convert_to_triangle_mesh(tris, tris_cnt) tri_list = tri_list.flatten() world_points = world_points[:,:3] return tri_list, world_points def convert_to_triangle_mesh(FaceVertexIndices, FaceVertexCounts): """ Convert a list of vertices and a list of faces into a triangle mesh. A list of triangle faces, where each face is a list of indices of the vertices that form the face. """ # Parse the face vertex indices into individual face lists based on the face vertex counts. faces = [] start = 0 for count in FaceVertexCounts: end = start + count face = FaceVertexIndices[start:end] faces.append(face) start = end # Convert all faces to triangles triangle_faces = [] for face in faces: if len(face) < 3: newface = [] # Invalid face elif len(face) == 3: newface = [face] # Already a triangle else: # Fan triangulation: pick the first vertex and connect it to all other vertices v0 = face[0] newface = [[v0, face[i], face[i + 1]] for i in range(1, len(face) - 1)] triangle_faces.extend(newface) return np.array(triangle_faces) # from pxr import UsdGeom, Sdf, Usd # import os # def add_ext_reference(prim: Usd.Prim, ref_asset_path: str, ref_target_path: Sdf.Path) -> None: # references: Usd.References = prim.GetReferences() # references.AddReference( # assetPath=ref_asset_path, # primPath=ref_target_path # OPTIONAL: Reference a specific target prim. Otherwise, uses the referenced layer's defaultPrim. # ) # class makescope: # def __init__(self): # self.stage = omni.usd.get_context().get_stage() # scope = UsdGeom.Scope.Define(self.stage, Sdf.Path('/World/Scope')) # ref_prim = UsdGeom.Xform.Define(self.stage, Sdf.Path('/World/Scope/CrowdJane')).GetPrim() # dir_path = os.path.join('G:/ProjectRepos/crowds/exts/siborg.simulate.crowd/siborg/simulate/crowd/data/', 'CrowdBob.usda') # add_ext_reference(ref_prim, dir_path, Sdf.Path("<Default Prim>")) # ms = makescope()

Python

cadop/crowds/exts/siborg.simulate.crowd/siborg/simulate/crowd/extension.py

import numpy as np import omni.ext import omni.ui as ui import omni.usd from omni.physx import get_physx_interface try: from omni.usd import get_world_transform_matrix except: from omni.usd.utils import get_world_transform_matrix from . import window from . import simulator from .env import Environment from . import usd_utils class SFsim(omni.ext.IExt): # ext_id is current extension id. It can be used with extension manager to query # additional information, like where this extension is located on filesystem. def on_startup(self, ext_id): print("[siborg.simulate.crowd] Social Forces Sim startup") self.goal_prim_path = '/World/CrowdGoals' self.obstacle_prim_path = '/World/Obstacles' self.grid_size = 3 self.rigid_flag = False self.pam_flag = False self.gpu_flag = False self.instancer_flag = False self.jane_flag = False self.heading_flag = False self.init_scene() self.show() self.goal_prim_dict = {} # {Prim path, subscriber} self._on_update_sub = None def show(self): self._window = ui.Window("Social Forces Demo Settings", width=500, height=250) gui_window = window.make_window_elements(self, self._window, self.Sim) def init_goal_prim(self, prim_path): omni.kit.commands.execute('CreatePrimWithDefaultXform', prim_type='Xform', prim_path=prim_path, attributes={}, select_new_prim=True) def modify_goals(self, _new_goals): if len(_new_goals) == 0: return if self.Sim.nagents == 0: return # Assign goals based on number of goals available if len(_new_goals)>self.Sim.nagents: _new_goals = _new_goals[self.Sim.nagents:] # Get strides self.Sim.goals = np.asarray(self.Sim.goals, dtype=object) goal_cast = np.array_split(self.Sim.goals, len(_new_goals)) # Reassign the split arrays their new goals for idx in range(len(goal_cast)): goal_cast[idx][:] = _new_goals[idx] # Reshape into xyz vector goal_cast = np.vstack(goal_cast) goal_cast = np.asarray(goal_cast, dtype=np.float) # Update the simulations goals self.Sim.update_goals(goal_cast) def init_scene(self): self.World = Environment() if self.gpu_flag: self.Sim = simulator.WarpCrowd() else: self.Sim = simulator.Simulator() # Create the goal hierarchy self.init_goal_prim(self.goal_prim_path) self.init_goal_prim(self.obstacle_prim_path) def _on_update_event(self, dt): # Check the Goals xform path and see if there are any changes needed to the goal watchers self.stage = omni.usd.get_context().get_stage() parent_prim = self.stage.GetPrimAtPath(self.goal_prim_path) children = parent_prim.GetAllChildren() # Check if any children are gone from our dict, if so, unsubscribe their watcher dead_kids = [kid for kid in self.goal_prim_dict.keys() if kid not in children] for kid in dead_kids: try: self.goal_prim_dict[kid].unsubscribe() except: self.goal_prim_dict[kid] = None self.goal_prim_dict.pop(kid) # Check if there are any new children not in our dict, if so, add them as a goal and update watcher babies = [child for child in children if child not in self.goal_prim_dict.keys()] for baby in babies: self.goal_prim_dict[baby] = None # Update the goals new_goals = [] for x in self.goal_prim_dict.keys(): _prim = x try: t = omni.usd.get_world_transform_matrix(_prim).ExtractTranslation() except: t = omni.usd.utils.get_world_transform_matrix(_prim).ExtractTranslation() new_goals.append(t) if len(new_goals) == 0: return self.modify_goals(new_goals) def assign_meshes(self): self.stage = omni.usd.get_context().get_stage() # Use the meshes that are parent_prim = self.stage.GetPrimAtPath(self.obstacle_prim_path) # points, faces = usd_utils.children_as_mesh(self.stage, parent_prim) points, faces = usd_utils.get_all_stage_mesh(self.stage,parent_prim) self.Sim.config_mesh(points, faces) def api_example(self): self.Sim._unregister() if self.gpu_flag: self.Sim = simulator.WarpCrowd(self.World) self.Sim.config_hasgrid() self.assign_meshes() else: self.Sim = simulator.Simulator(self.World) self.demo_api_call(self.Sim) def demo_api_call(self, Sim): # Use the builtin function for demo agents Sim.rigidbody = self.rigid_flag # Set origin for spawning agents self.stage = omni.usd.get_context().get_stage() parent_prim = self.stage.GetPrimAtPath('/World/GenerationOrigin') Sim.generation_origin = [0,0,0] if parent_prim: Sim.generation_origin = get_world_transform_matrix(parent_prim).ExtractTranslation() Sim.generation_origin[2] = Sim.generation_origin[1] Sim.init_demo_agents(m=self.grid_size,n=self.grid_size,s=1.6) if self.pam_flag: Sim.use_pam = True if self.gpu_flag: Sim.configure_params() if not Sim.rigidbody: if self.jane_flag: # TODO make this work for all sim types Sim.add_jane = True else: Sim.add_jane = False if self.instancer_flag: Sim.point_instancer_sets = [] Sim.use_instancer = True if self.heading_flag: Sim.use_heading = True Sim.create_instance_agents() # Create a usdgeom point instance for easy visualization Sim.set_instance_agents() # update the usdgeom points for visualization else: Sim.use_instancer = False Sim.create_geompoints() # Create a usdgeom point instance for easy visualization Sim.set_geompoints() # update the usdgeom points for visualization # tell simulator to update positions after each run Sim.update_agents_sim = True # tell simulator to handle the update visualization Sim.update_viz = True # Register the simulation to updates, and the Sim will handle it from here Sim.register_simulation() if not self._on_update_sub: self._on_update_sub = get_physx_interface().subscribe_physics_step_events(self._on_update_event) def on_shutdown(self): print("[siborg.simulate.crowd] Crowd Sim shutdown") try: self.Sim._unregister() except: pass try: self._goal_subscriber.unsubscribe() except: self._goal_subscriber = None try: self._on_update_sub.unsubscribe() except: self._on_update_sub = None self.Sim._simulation_event = None self._window = None self.Sim = None

Python

cadop/crowds/exts/siborg.simulate.crowd/siborg/simulate/crowd/crowds.py

import numpy as np from siborg.simulate.crowd.agent import Agent class CrowdConfig: def __init__(self): self._goal = [0,0,0] self.goals = None self.agent_bodies = None self.nagents = 1 # set pereption radius self.perception_radius = 1.5 # set radius self.radius = .5 # set mass self.mass = 2 # Will use a physics scene self.rigidbody = False # Assume z-up world self.world_up = 2 def create_agents(self, num=None, goals=None, pos=None): '''Creates a set of agents and goals Uses the class instance defaults for radius, mass, perception, etc. Parameters ---------- num : int, optional number of agents to create (if not defined in init), by default None goals : ndarray([x,y,z]), optional either 1 or size equal to number of agents, by default None pos : ndarray([x,y,z]), optional must be same size as number of agents (otherwise will set all to origin, which is bad), because they will explode, by default None ''' # generate n number of agents if num: self.nagents = num # Check we can assign goals to agents if not goals: goals = [self._goal] if len(goals) != 1: if len(goals) != self.nagents: raise ValueError('If goals is not 1, must be same size as number of agents') elif len(goals) == 1: self.goals = np.asarray([goals[0] for x in range(self.nagents)], dtype=np.double) else: self.goals = goals # Set the agent positions if pos is not None: self.agents_pos = np.asarray(pos, dtype=np.double) else: self.agents_pos = np.asarray([np.array(0,0,0, dtype=np.double) for x in range(self.nagents)]) # only create an agent instance if user wants physics-based spheres if self.rigidbody: self.agent_bodies = [Agent() for x in range(self.nagents)] # move agents to their positions for i in range(len(self.agent_bodies)): x,y,z = self.agents_pos[i] self.agent_bodies[i].translate(x,y,z) else: self.agent_bodies = [None for x in range(self.nagents)] # set initial velocities to 0 self.agents_vel = np.asarray([np.array([0,0,0], dtype=np.double) for x in range(self.nagents)]) self.set_radius() self.set_mass() self.set_perception_radius() def set_radius(self,v=None): '''sets agents radius Parameters ---------- v : List[float], float, optional set the radius of the agents, if None, all agents get same radius, by default None ''' if v: if type(v) is float: self.agents_radi = np.asarray([v for x in range(self.nagents)]) elif len(v) != self.nagents: raise ValueError('Radius array must be same size as number of agents') else: self.agents_radi = v else: self.agents_radi = np.asarray([self.radius for x in range(self.nagents)]) def set_mass(self,v=None): '''sets agents mass Parameters ---------- v : List[float], optional set the mass of the agents, if None, all agents get same mass, by default None Raises ------ ValueError if size of mass array does not match number of agents ''' if v: if type(v) is float: self.agents_mass = np.asarray([v for x in range(self.nagents)]) elif len(v) != self.nagents: raise ValueError('mass array must be same size as number of agents') else: self.agents_mass = v else: self.agents_mass = np.asarray([self.mass for x in range(self.nagents)]) def set_perception_radius(self, v=None): '''sets agents perception radius Parameters ---------- v : List[float], optional set the percept radius of the agents, if None, all agents get same raidus, by default None Raises ------ ValueError if size of perception array does not match number of agents ''' if v: if type(v) is float: self.agents_percept = np.asarray([v for x in range(self.nagents)]) elif len(v) != self.nagents: raise ValueError('perception radius array must be same size as number of agents') else: self.agents_percept = v else: self.agents_percept = np.asarray([self.perception_radius for x in range(self.nagents)]) def init_demo_agents(self, m=5, n=5, s=1, o=[0,0,0]): '''Create a set of demo agents Parameters ---------- m : int, optional number of agents in row, by default 5 n : int, optional number of agents in col, by default 5 s : int, optional spacing between agents, by default 1 ''' o = self.generation_origin # Initialize agents in a grid for testing self.agents_pos = np.asarray([ np.array([(s/2) + (x * s) +(o[0]/2) , (s/2) + (y * s) +(o[1]/2), 0], dtype=np.double) for x in range(m) for y in range(n) ]) # # Initialize agents in a grid for testing # self.agents_pos = np.asarray([ # np.array([(s/2) + (x * s), (s/2) + (y * s), 0], dtype=np.double) # for x in range(m) # for y in range(n) # ]) self.agents_pos[:, [2, self.world_up]] = self.agents_pos[:, [self.world_up, 2]] self.nagents = len(self.agents_pos) #### if self.rigidbody: self.agent_bodies = [Agent() for x in range(self.nagents)] for i in range(len(self.agent_bodies)): x,y,z = self.agents_pos[i] self.agent_bodies[i].translate(x,y,z) else: self.agent_bodies = [None for x in range(self.nagents)] self.goals = np.asarray([self._goal for x in range(self.nagents)], dtype=np.double) self.agents_vel = np.asarray([np.array([0,0,0],dtype=np.double) for x in range(self.nagents)]) self.set_radius() self.set_mass() self.set_perception_radius()

Python

cadop/crowds/exts/siborg.simulate.crowd/siborg/simulate/crowd/env.py

import omni import omni.kit.commands from pxr import Usd, Gf from pxr import UsdGeom from pxr import UsdPhysics, PhysxSchema class Environment: def __init__(self): print('Initializing Environment') self._stage = omni.usd.get_context().get_stage() self.set_scene(self._stage) def set_scene(self, stage): print(f'Setting up {stage}') self._stage = stage self.defaultPrimPath = str(self._stage.GetDefaultPrim().GetPath()) # Physics scene # UsdGeom.SetStageUpAxis(stage, UsdGeom.Tokens.z) UsdGeom.SetStageMetersPerUnit(stage, 1.0) self.scene = UsdPhysics.Scene.Define(stage, self.defaultPrimPath + "/physicsScene") stage_axis = UsdGeom.GetStageUpAxis(stage) gravity_dir = Gf.Vec3f(0.0, 0.0, 0) if stage_axis is 'X': gravity_dir[0] = -1.0 if stage_axis is 'Y': gravity_dir[1] = -1.0 if stage_axis is 'Z': gravity_dir[2] = -1.0 self.scene.CreateGravityDirectionAttr().Set(gravity_dir) self.scene.CreateGravityMagnitudeAttr().Set(9.81) physxSceneAPI = PhysxSchema.PhysxSceneAPI.Apply(self.scene.GetPrim()) physxSceneAPI.CreateEnableCCDAttr().Set(True) # Check if there is a physics groundplane in the scene plane_path = self.defaultPrimPath+"/GroundPlane" if self._stage.GetPrimAtPath(plane_path).IsValid(): pass else: # If not, make one omni.kit.commands.execute('AddGroundPlaneCommand', stage=self._stage, planePath='/GroundPlane', axis=UsdGeom.GetStageUpAxis(stage), size=1.0, position=Gf.Vec3f(0.0, 0.0, 0.0), color=Gf.Vec3f(0.5, 0.5, 0.5))

Python

cadop/crowds/exts/siborg.simulate.crowd/siborg/simulate/crowd/agent.py

import omni from omni.physx.scripts import physicsUtils from pxr import Gf, UsdPhysics, PhysxSchema, UsdGeom, UsdShade import usdrt class Agent: def __init__(self): stage = omni.usd.get_context().get_stage() # Create a sphere representing the agent self.skin_mesh , self.skinMeshPath = self.sphere(stage) # Set a rigid body material and collider self.set_material(stage, self.skinMeshPath) # Add a translation operator and set it to zero position # Since we changed to create this object with an xform, don't need to add, just get it. # self.translateOp = self.skin_mesh.AddTranslateOp() self.translateOp = UsdGeom.XformOp(self.skin_mesh.GetPrim().GetAttribute("xformOp:translate")) self.translateOp.Set(Gf.Vec3f(0.0, 0.0, 0.0)) def sphere(self, stage): # Create sphere representing agent _, skinMeshPath = omni.kit.commands.execute("CreateMeshPrimWithDefaultXform", prim_type="Sphere", prim_path='/World/Agents/Sphere', prepend_default_prim=True) skin_mesh = UsdGeom.Mesh.Get(stage, skinMeshPath) prim = skin_mesh.GetPrim() # setup physics - rigid body self.rigidBodyAPI = UsdPhysics.RigidBodyAPI.Apply(prim) linVelocity = Gf.Vec3f(0.0, 0.0, 0.0) angularVelocity = Gf.Vec3f(0.0, 0.0, 0.0) # apply initial velocities self.rigidBodyAPI.CreateVelocityAttr().Set(linVelocity) self.rigidBodyAPI.CreateAngularVelocityAttr().Set(angularVelocity) self.massAPI = UsdPhysics.MassAPI.Apply(prim) self.massAPI.CreateMassAttr(2) self.massAPI.CreateCenterOfMassAttr().Set(Gf.Vec3f(0.0, 0.0, 0.0)) # Add a force attribute # shuttleForcePath = skinMeshPath + "/shuttleForce" # xform = UsdGeom.Xform.Define(stage, shuttleForcePath) # self.forceApi = PhysxSchema.PhysxForceAPI.Apply(xform.GetPrim()) # # self.forceApi = PhysxSchema.PhysxForceAPI.Apply(prim) # self.forceAttr = self.forceApi.GetForceAttr() self.usdrt_stage = usdrt.Usd.Stage.Attach(omni.usd.get_context().get_stage_id()) prim = self.usdrt_stage.GetPrimAtPath(skinMeshPath) self.world_force_attr = prim.CreateAttribute("_worldForce", usdrt.Sdf.ValueTypeNames.Float3, True) return skin_mesh, skinMeshPath def translate(self, x=0, y=0, z=0): self.translateOp.Set(self.translateOp.Get() + Gf.Vec3d( x, y, z)) @property def position(self): return self.translateOp.Get() @property def velocity(self): return self.rigidBodyAPI.GetVelocityAttr().Get() def set_material(self, stage, skinMeshPath): defaultPrimPath = str(stage.GetDefaultPrim().GetPath()) # Floor Material path = defaultPrimPath + "/rigidMaterial" prim_path = stage.GetPrimAtPath(skinMeshPath) # Set it as a rigid body rigidBodyAPI = UsdPhysics.RigidBodyAPI.Apply(prim_path) # Add a collider (defaults to mesh triangulation) UsdPhysics.CollisionAPI.Apply(prim_path) # Apply a specific mass parameter UsdPhysics.MassAPI.Apply(prim_path) #Get the rigidbody parameter to set values on physxRbAPI = PhysxSchema.PhysxRigidBodyAPI.Apply(prim_path) #Enable CCD for this object physxRbAPI.CreateEnableCCDAttr().Set(True) # Create a (separate) physics material that gets added to the object path = defaultPrimPath + "/highdensitymaterial" UsdShade.Material.Define(stage, path) material = UsdPhysics.MaterialAPI.Apply(stage.GetPrimAtPath(path)) material.CreateStaticFrictionAttr().Set(0) material.CreateDynamicFrictionAttr().Set(0) material.CreateRestitutionAttr().Set(.2) material.CreateDensityAttr().Set(0.01) # Add material physicsUtils.add_physics_material_to_prim(stage, prim_path, path)

Python

cadop/crowds/exts/siborg.simulate.crowd/siborg/simulate/crowd/window.py

from .models.socialforces import Parameters import omni.ui as ui combo_sub = None def make_window_elements(self, _window, Sim): with _window.frame: with ui.VStack(): with ui.HStack(): ui.Label('Max Speed') max_speed = ui.FloatField(height=20) max_speed.model.add_value_changed_fn(lambda m : setattr(Parameters, 'max_speed', m.get_value_as_float())) max_speed.model.set_value(Parameters.max_speed) with ui.HStack(): ui.Label('Desired Speed') v_desired = ui.FloatField(height=20) v_desired.model.add_value_changed_fn(lambda m : setattr(Parameters, 'v_desired', m.get_value_as_float())) v_desired.model.set_value(Parameters.v_desired) with ui.HStack(): ui.Label('A') A = ui.FloatField(height=20) A.model.add_value_changed_fn(lambda m : setattr(Parameters, 'A', m.get_value_as_float())) A.model.set_value(Parameters.A) with ui.HStack(): ui.Label('B') B = ui.FloatField(height=20) B.model.add_value_changed_fn(lambda m : setattr(Parameters, 'B', m.get_value_as_float())) B.model.set_value(Parameters.B) with ui.HStack(): ui.Label('kn') kn = ui.FloatField(height=20) kn.model.add_value_changed_fn(lambda m : setattr(Parameters, 'kn', m.get_value_as_float())) kn.model.set_value(Parameters.kn) with ui.HStack(): ui.Label('kt') kt = ui.FloatField(height=20) kt.model.add_value_changed_fn(lambda m : setattr(Parameters, 'kt', m.get_value_as_float())) kt.model.set_value(Parameters.kt) with ui.HStack(): ui.Label('Agent grid (nxn)') agent_grid = ui.IntField(height=20) agent_grid.model.add_value_changed_fn(lambda m : setattr(self, 'grid_size', m.get_value_as_int())) agent_grid.model.set_value(3) # with ui.HStack(): # ui.Label('Agent Mass') # kt = ui.FloatField(height=20) # kt.model.add_value_changed_fn(lambda m : setattr(Sim, 'mass', m.get_value_as_float())) # kt.model.set_value(Sim.mass) # with ui.HStack(): # ui.Label('Agent Radius') # kt = ui.FloatField(height=20) # kt.model.add_value_changed_fn(lambda m : Sim.set_radius(m.get_value_as_float())) # kt.model.set_value(Sim.radius) # with ui.HStack(): # ui.Label('Agent Perception Radius') # kt = ui.FloatField(height=20) # kt.model.add_value_changed_fn(lambda m : setattr(Sim, 'perception_radius', m.get_value_as_float())) # kt.model.set_value(Sim.perception_radius) # with ui.HStack(height=20): # ui.Button("Gen Agents", clicked_fn=Sim.create_agents) # nagents = ui.IntField(height=5) # nagents.model.set_value(Sim.nagents) # nagents.model.add_value_changed_fn(lambda m : setattr(Sim, 'nagents', m.get_value_as_int())) with ui.HStack(height=20): ui.Label('GPU', width=20) WarpModel = ui.CheckBox(width=30) WarpModel.model.add_value_changed_fn(lambda m : setattr(self, 'gpu_flag', m.get_value_as_bool())) WarpModel.model.set_value(True) ui.Label('Use Instances', width=20) SFModel = ui.CheckBox(width=30) SFModel.model.add_value_changed_fn(lambda m : setattr(self, 'instancer_flag', m.get_value_as_bool())) SFModel.model.set_value(True) ui.Label('Add Jane', width=5) RigidBody = ui.CheckBox(width=30) RigidBody.model.add_value_changed_fn(lambda m : setattr(self, 'jane_flag', m.get_value_as_bool())) RigidBody.model.set_value(False) ui.Label('Use Direction', width=5) RigidBody = ui.CheckBox(width=30) RigidBody.model.add_value_changed_fn(lambda m : setattr(self, 'heading_flag', m.get_value_as_bool())) RigidBody.model.set_value(True) ui.Label('Rigid Body', width=5) RigidBody = ui.CheckBox(width=30) RigidBody.model.add_value_changed_fn(lambda m : setattr(self, 'rigid_flag', m.get_value_as_bool())) RigidBody.model.set_value(False) ui.Label('PAM', width=20) SFModel = ui.CheckBox(width=30) SFModel.model.add_value_changed_fn(lambda m : setattr(self, 'pam_flag', m.get_value_as_bool())) SFModel.model.set_value(False) # options = ["GeomPoints", "RigidBody"] # combo_model: ui.AbstractItemModel = ui.ComboBox(0, *options).model # def combo_changed(item_model: ui.AbstractItemModel, item: ui.AbstractItem): # value_model = item_model.get_item_value_model(item) # current_index = value_model.as_int # option = options[current_index] # print(f"Selected '{option}' at index {current_index}.") # combo_sub = combo_model.subscribe_item_changed_fn(combo_changed) # def clicked(): # value_model = combo_model.get_item_value_model() # current_index = value_model.as_int # option = options[current_index] # print(f"Button Clicked! Selected '{option}' at index {current_index}.") # self.api_example(current_index) # ui.Button("Set Selected Meshes", width=5, clicked_fn=self.assign_meshes) ui.Button("Start Demo", width=5, clicked_fn=self.api_example) with ui.HStack(height=10): pass

Python

cadop/crowds/exts/siborg.simulate.crowd/siborg/simulate/crowd/examples/ex4.py

'''_summary_ ''' from siborg.simulate.crowd.simulator import Simulator def example_4(): # Example of using API Sim = Simulator() Sim.rigidbody = True # use rigid bodies Sim.init_demo_agents(m=3, n=5, s=1.1) # Register the simulation to updates, and the Sim will handle it from here Sim.register_simulation() # tell simulator to update positions after each run, if not need to call Sim.integrate() Sim.update_agents_sim = True # tell simulator to handle the update visualization Sim.update_viz = True example_4()

Python

cadop/crowds/exts/siborg.simulate.crowd/siborg/simulate/crowd/examples/ex3.py

'''_summary_ ''' import time from omni.physx import get_physx_interface from siborg.simulate.crowd.simulator import Simulator Sim = Simulator() start_time = time.time() _simulation_event = None def example_3(): # Example of using API # Use a builtin helper function to generate a grid of agents Sim.init_demo_agents(m=3, n=5, s=1.1) Sim.create_geompoints() # Create a usdgeom point instance for easy visualization Sim.set_geompoints() # update the usdgeom points for visualization # tell simulator to update positions after each run, if not need to call Sim.integrate() Sim.update_agents_sim = True # don't have the simulator update the geompoints, we do it ourselves Sim.update_viz = False # Register to our own physx update sim_subscriber() def sim_subscriber(): # This would need to get cleaned up _simulation_event = get_physx_interface().subscribe_physics_step_events(_on_update) def _on_update(dt): # Run one step of simulation # don't need to use forces since we told simulator to update forces = Sim.run() Sim.set_geompoints() # update the usdgeom points for visualization # For this demo we will unsubscribe after a few seconds if time.time() - start_time > 100 : print('ending') _simulation_event.unsubscribe() example_3()

Python

cadop/crowds/exts/siborg.simulate.crowd/siborg/simulate/crowd/examples/ex2.py

'''Example for Simulator handling update and using GeomPoints. Uses a helper function for initializing agents ''' from siborg.simulate.crowd.simulator import Simulator def example_2(): Sim = Simulator() # Use a builtin helper function to generate a grid of agents Sim.init_demo_agents(m=3,n=5,s=1.1) Sim.create_geompoints() # Create a usdgeom point instance for easy visualization # tell simulator to update positions after each run, if not need to call Sim.integrate() Sim.update_agents_sim = True # don't have the simulator update the geompoints, we do it ourselves Sim.update_viz = True Sim.register_simulation() example_2()

Python

cadop/crowds/exts/siborg.simulate.crowd/siborg/simulate/crowd/examples/ex1.py

'''Example for Simulator handling update and using GeomPoints ''' from siborg.simulate.crowd.simulator import Simulator import numpy as np from math import sqrt def example_1(): # Example of using API Sim = Simulator() nagents = 10 # Some trickery to make a grid of agents and get the cloest number of agents to an even grid pos = np.asarray([ np.array([(1/2) + (x), (1/2) + (y), 0], dtype=np.double) for x in range(int(sqrt(nagents))) for y in range(int(sqrt(nagents))) ]) pos[:, [2, Sim.world_up]] = pos[:, [Sim.world_up, 2]] nagents = len(pos) Sim.create_agents(num=nagents, goals=[[10,10,0]], pos=pos) # initialize a set of agents Sim.create_geompoints() # Create a usdgeom point instance for easy visualization # tell simulator to update positions after each run, if not need to call Sim.integrate() Sim.update_agents_sim = True # don't have the simulator update the geompoints, we do it ourselves Sim.update_viz = True Sim.register_simulation() example_1()

Python

cadop/crowds/exts/siborg.simulate.crowd/siborg/simulate/crowd/models/pam.py

''' Python implementation of the Predictive Avoidance Model (PAM) from A Predictive Collision Avoidance Model for Pedestrian Simulation, I. Karamouzas, P. Heil, P. van Beek, M. H. Overmars Motion in Games (MIG 2009), Lecture Notes in Computer Science (LNCS), Vol. 5884, 2009 ''' from dataclasses import dataclass import numpy as np from scipy.spatial import distance @dataclass class Parameters: # The agents field of view field_of_view = 200.0 # The agents radius ? Used here in this implementation or in sim? agent_radius = 0.5 # Minimum agent distance min_agent_dist = 0.1 # the mid distance parameters in peicewise personal space function predictive force dist dmid = 4.0 # KSI ksi = 0.5 # Nearest Neighbour distance ? Used here in this implementation or in sim? neighbor_dist = 10.0 # Maximum neighbours to consider ? Used here in this implementation or in sim? max_neighbors = 3 # Maximum acceleration ? Used here in this implementation or in sim/physics? max_accel = 20.0 # Maximum speed max_speed = 7 # Preferred Speed preferred_vel = 2.5 # Goal acquired radius goal_radius = 1.0 # Time Horizon time_horizon = 4.0 # Agent Distance agent_dist = 0.1 # Wall Distance wall_dist = 0.1 # Wall Steepnes wall_steepness = 2.0 # Agent Strength agent_strength = 1.0 # wFactor, factor to progressively scale down forces in when in a non-collision state w_factor = 0.8 # Noise flag (should noise be added to the movement action) noise = False force_clamp = 40.0 # *private* Ideal wall distance _ideal_wall_dist = agent_radius + wall_dist # *private* Squared ideal wall distance _SAFE = _ideal_wall_dist * _ideal_wall_dist # *private* Agent Personal space _agent_personal_space = agent_radius + min_agent_dist # *private* the min distance parameters in peicewise personal space function _dmin = agent_radius + _agent_personal_space # *private* the max distance parameters in peicewise personal space function _dmax = time_horizon * max_speed # *private* FOV cosine _cosFOV = np.cos((0.5 * np.pi * field_of_view) / 180.0) def ray_intersects_disc(pi, pj, v, r): # calc ray disc est. time to collision t = 0.0 w = pj - pi a = np.dot(v, v) b = np.dot(w, v) c = np.dot(w, w) - (r * r) discr = (b * b) - (a * c) if discr > 0.0: t = (b - np.sqrt(discr)) / a if t < 0.0: t = 999999.0 else: t = 999999.0 return t def mag(v): # calc magnitude of vector v_mag = np.sqrt(v.dot(v)) return v_mag def norm(v): # normalize a vector v_norm = np.array([0, 0, 0], dtype='float64') magnitude = mag(v) if magnitude > 0.0: v_norm = v / magnitude return v_norm def get_neighbors(cur, agents, pn_r): dist = distance.cdist([cur], agents) pn = dist < pn_r # Index to remove is when its zero pn_self = dist == 0 pn_self = np.nonzero(pn_self) pn[pn_self] = False pn = np.nonzero(pn) return pn def wall_force(obstacles, rr_i, closest_point, SAFE, add_force): for i in range(len(obstacles)): # Step 1: get closest point on obstacle to agent # [[ Need python code for this in simulation ]] n_w = rr_i - closest_point d_w = mag(n_w) * mag(n_w) if (d_w < SAFE): d_w = np.sqrt(d_w) if (d_w > 0): n_w /= d_w if ((d_w - Parameters.agent_radius) < 0.001): dist_min_radius = 0.001 else: d_w - Parameters.agent_radius obstacle_force = (Parameters._ideal_wall_dist - d_w) / np.pow(dist_min_radius, Parameters.wall_steepness) * n_w add_force(obstacle_force) def calc_goal_force(goal, rr_i, vv_i): # Preferred velocity is preferred speed in direction of goal preferred_vel = Parameters.preferred_vel * norm(goal - rr_i) # Goal force, is always added goal_force = (preferred_vel - vv_i) / Parameters.ksi return goal_force def collision_param(rr_i, vv_i, desired_vel, pn_rr, pn_vv, pn_r): # Keep track of if we ever enter a collision state agent_collision = False t_pairs = [] # Handle agents tc values for predictive forces among neighbours for j, rr_j in enumerate(pn_rr): # Get position and velocity of neighbor agent vv_j = pn_vv[j] # Get radii of neighbor agent rj = pn_r[j] combined_radius = Parameters._agent_personal_space + rj w = rr_j - rr_i if (mag(w) < combined_radius): agent_collision = True t_pairs.append((0.0, j)) else: rel_dir = norm(w) if np.dot(rel_dir, norm(vv_i)) < Parameters._cosFOV: continue tc = ray_intersects_disc(rr_i, rr_j, desired_vel - vv_j, combined_radius) if tc < Parameters.time_horizon: if len(t_pairs) < Parameters.max_neighbors: t_pairs.append((tc, j)) elif tc < t_pairs[0][0]: t_pairs.pop() t_pairs.append((tc, j)) return t_pairs, agent_collision def predictive_force(rr_i, desired_vel, desired_speed, pn_rr, pn_vv, pn_r, vv_i): # Handle predictive forces// Predictive forces # Setup collision parameters t_pairs, agent_collision = collision_param(rr_i, vv_i, desired_vel, pn_rr, pn_vv, pn_r) # This will be all the other forces, added in a particular way steering_force = np.array([0, 0, 0], dtype='float64') # will store a list of tuples, each tuple is (tc, agent) force_count = 0 for t_pair in t_pairs: # Nice variables from the t_pair tuples t = t_pair[0] agent_idx = t_pair[1] force_dir = rr_i + (desired_vel * t) - pn_rr[agent_idx] - (pn_vv[agent_idx] * t) force_dist = mag(force_dir) if force_dist > 0: force_dir /= force_dist collision_dist = np.maximum(force_dist - Parameters.agent_radius - pn_r[agent_idx], 0.0) #D = input to evasive force magnitude piecewise function D = np.maximum( (desired_speed * t) + collision_dist, 0.001) force_mag = 0.0 if D < Parameters._dmin: force_mag = Parameters.agent_strength * Parameters._dmin / D elif D < Parameters.dmid: force_mag = Parameters.agent_strength elif D < Parameters._dmax: force_mag = Parameters.agent_strength * (Parameters._dmax - D) / (Parameters._dmax - Parameters.dmid) else: continue force_mag *= np.power( (1.0 if agent_collision else Parameters.w_factor), force_count) force_count += 1 steering_force = force_mag * force_dir return steering_force def add_noise(steering_force): angle = np.random.uniform(0.0, 1.0) * 2.0 * np.pi dist = np.random.uniform(0.0, 1.0) * 0.001 steering_force += dist * np.array([np.cos(angle),np.sin(angle),0], dtype='float64') return steering_force def compute_force(rr_i, ri, vv_i, mass, goal, pn_rr, pn_vv, pn_r, dt): # Get the goal force goal_force = calc_goal_force(goal, rr_i, vv_i) # Desired values if all was going well in an empty world desired_vel = vv_i + goal_force * dt desired_speed = mag(desired_vel) # Get obstacle (wall) forces obstacle_force = np.array([0, 0, 0], dtype='float64') #@TODO # obstacle_force = wall_force() # Get predictive steering forces steering_force = predictive_force(rr_i, desired_vel, desired_speed, pn_rr, pn_vv, pn_r, vv_i) # Add noise for reducing deadlocks adding naturalness if Parameters.noise: steering_force = add_noise(steering_force) # Clamp driving force if mag(steering_force) > Parameters.force_clamp: steering_force = norm(steering_force) * Parameters.force_clamp return goal_force + obstacle_force + steering_force

Python

cadop/crowds/exts/siborg.simulate.crowd/siborg/simulate/crowd/models/socialforces.py

from dataclasses import dataclass import numpy as np from scipy.spatial import distance # zero_vec = np.array([0,0,0], dtype='float64') @dataclass class Parameters: # names from https://www.sciencedirect.com/science/article/pii/S0378437120306853 Tau = 0.5 #(s) A = 2000.0 B = 0.08 kn = 1.2 * 100_000 # Kgs^-2 kt = 2.4 * 100_000 # Kg m^-1 s^-1 max_speed = 10 v_desired = 3.5 def calc_wall_force(): # TODO add wall and geometry recognition force = np.array([0,0,0], dtype='float64') return force def calc_agent_force(rr_i, ri, vv_i, pn_rr, pn_vv, pn_r): # Sum the forces of neighboring agents force = np.array([0,0,0], dtype='float64') # Set the total force of the other agents to zero ff_ij = np.array([0,0,0], dtype='float64') rr_j =np.array([0,0,0], dtype='float64') # Iterate through the neighbors and sum (f_ij) for j, rr_j in enumerate(pn_rr): # Get position and velocity of neighbor agent vv_j = pn_vv[j] # Get radii of neighbor agent rj = pn_r[j] # Pass agent position to AgentForce calculation ff_ij = neighbor_force(rr_i, ri, vv_i, rr_j, rj, vv_j) # Sum Forces force += ff_ij return force def neighbor_force(rr_i, ri, vv_i, rr_j, rj, vv_j): # Calculate the force exerted by another agent # Take in this agent (i) and a neighbors (j) position and radius # Sum of radii rij = ri + rj # distance between center of mass d_ij = mag(rr_i - rr_j) # "n_ij is the normalized vector points from pedestrian j to i" n_ij = norm(rr_i - rr_j) # Normalized vector pointing from j to i # t_ij "Vector of tangential relative velocity pointing from i to j." # A sliding force is applied on agent i in this direction to reduce the relative velocity. t_ij = np.cross(vv_j - vv_i, [0,0,1] ) dv_ji = np.dot(vv_j - vv_i, t_ij) # Calculate f_ij force = repulsion(rij, d_ij, n_ij) + proximity(rij, d_ij, n_ij) + sliding(rij, d_ij, dv_ji, t_ij) return force def calc_goal_force(goal, pos, vel, mass, v_desired, dt): ee_i = norm(goal - pos) force = mass * ( ( (v_desired * ee_i) - vel ) / Parameters.Tau ) return force def G(r_ij, d_ij): # g(x) is a function that returns zero if pedestrians touch # otherwise is equal to the argument x if (d_ij > r_ij): return 0.0 return r_ij - d_ij; def repulsion(r_ij, d_ij, n_ij): force = Parameters.A * np.exp( (r_ij - d_ij) / Parameters.B) * n_ij return force def proximity(r_ij, d_ij, n_ij): force = Parameters.kn * G(r_ij, d_ij) * n_ij return force def sliding(r_ij, d_ij, dv_ji, t_ij): force = Parameters.kt * G(r_ij, d_ij) * (dv_ji * t_ij) return force def mag(v): # calc magnitude of vector v_mag = np.sqrt(v.dot(v)) return v_mag def norm(v): # normalize a vector v_norm = v / mag(v) return v_norm def get_neighbors(cur, agents, pn_r): dist = distance.cdist([cur], agents) pn = dist < pn_r # Index to remove is when its zero pn_self = dist == 0 pn_self = np.nonzero(pn_self) pn[pn_self] = False pn = np.nonzero(pn) return pn def compute_force(rr_i, ri, vv_i, mass, goal, pn_rr, pn_vv, pn_r, dt): # Get the force for this agent to the goal goal = calc_goal_force(goal, rr_i, vv_i, mass, Parameters.v_desired, dt) agent = calc_agent_force(rr_i, ri, vv_i, pn_rr, pn_vv, pn_r) wall = calc_wall_force() force = goal + agent + wall force = norm(force) * min(mag(force), Parameters.max_speed) return force

Python

cadop/crowds/exts/siborg.simulate.crowd/siborg/simulate/crowd/models/socialforces_warp.py

import warp as wp Tau = wp.constant(0.5) # s (acceleration) A = wp.constant(2000.0) # N B = wp.constant(0.08) # m kn = wp.constant(1.2 * 100000) # kg/s^-2 kt = wp.constant(2.4 * 100000) # kg/m^-1 s^-2 max_speed = wp.constant(10.0) # m/s v_desired = wp.constant(2.5) # m/s @wp.kernel def get_forces(positions: wp.array(dtype=wp.vec3), velocities: wp.array(dtype=wp.vec3), goals: wp.array(dtype=wp.vec3), radius: wp.array(dtype=float), mass: wp.array(dtype=float), dt: float, percept : wp.array(dtype=float), grid : wp.uint64, mesh: wp.uint64, inv_up: wp.vec3, forces: wp.array(dtype=wp.vec3), ): # thread index tid = wp.tid() cur_pos = positions[tid] cur_rad = radius[tid] cur_vel = velocities[tid] cur_mass = mass[tid] goal = goals[tid] pn = percept[tid] _force = compute_force(cur_pos, cur_rad, cur_vel, cur_mass, goal, positions, velocities, radius, dt, pn, grid, mesh) # Clear any vertical forces with Element-wise mul _force = wp.cw_mul(_force, inv_up) # compute distance of each point from origin forces[tid] = _force @wp.kernel def integrate(x : wp.array(dtype=wp.vec3), v : wp.array(dtype=wp.vec3), f : wp.array(dtype=wp.vec3), dt: float, xnew: wp.array(dtype=wp.vec3), vnew: wp.array(dtype=wp.vec3), ): tid = wp.tid() x0 = x[tid] v0 = v[tid] f0 = f[tid] v1 = v0 + (f0*1.0) * dt x1 = x0 + v1 * dt xnew[tid] = x1 vnew[tid] = v1 @wp.kernel def heading(v : wp.array(dtype=wp.vec3), up : wp.vec3, forward : wp.vec3, hdir: wp.array(dtype=wp.vec4), ): tid = wp.tid() v0 = v[tid] vnorm = wp.normalize(v0) hdir[tid] = velocity_to_quaternion(up, forward, vnorm) @wp.func def velocity_to_quaternion(up : wp.vec3, forward : wp.vec3, velocity: wp.vec3): # Construct a quaternion that rotates the agent's forward direction to align with the velocity vector if wp.length(forward) > 0: forward = wp.normalize(forward) if wp.length(velocity) > 0: velocity = wp.normalize(velocity) else: velocity = forward dot = wp.dot(forward, velocity) # Clip the dot product to avoid numerical instability if dot == 1.0: # If the forward and velocity vectors are already aligned, return the identity quaternion return wp.vec4(0.0, 0.0, 0.0, 1.0) else: axis = wp.cross(forward, velocity) axis = up * wp.sign(wp.dot(axis, up)) # Project the axis onto the up plane if wp.length(axis) > 0.0: axis = wp.normalize(axis) # Normalize the axis of rotation else:axis = up # Use a default axis of rotation if the iwput is a zero vector angle = wp.acos(dot) # Calculate the angle of rotation with clipping qw = wp.cos(angle/2.0) # Calculate the scalar component of the quaternion qx = wp.sin(angle/2.0) * axis[0] # Calculate the vector component of the quaternion qy = wp.sin(angle/2.0) * axis[1] # Calculate the vector component of the quaternion qz = wp.sin(angle/2.0) * axis[2] # Calculate the vector component of the quaternion return wp.vec4(qx, qy, qz, qw) @wp.func def calc_goal_force(goal: wp.vec3, pos: wp.vec3, vel: wp.vec3, mass: float, v_desired: float, dt: float): ee_i = wp.normalize(goal - pos) force = mass * ( ( (v_desired * ee_i) - vel ) / (Tau) ) return force @wp.func def calc_wall_force(rr_i: wp.vec3, ri: float, vv_i: wp.vec3, mesh: wp.uint64): ''' rr_i : position ri : radius vv_i : velocity Computes: (A * exp[(ri-diw)/B] + kn*g(ri-diw))*niw - kt * g(ri-diw)(vi * tiw)tiw ''' face_index = int(0) face_u = float(0.0) face_v = float(0.0) sign = float(0.0) force = wp.vec3(0.0,0.0,0.0) # Define the up direction up_dir = wp.vec3(0.0, 0.0, 1.0) max_dist = float(ri * 5.0) has_point = wp.mesh_query_point(mesh, rr_i, max_dist, sign, face_index, face_u, face_v) if (not has_point): return wp.vec3(0.0, 0.0, 0.0) p = wp.mesh_eval_position(mesh, face_index, face_u, face_v) # d_iw = distance to wall W d_iw = wp.length(p - rr_i) # vector of the wall to the agent nn_iw = wp.normalize(rr_i - p) # perpendicular vector of the agent-wall (tangent force) tt_iw = wp.cross(up_dir, nn_iw) if wp.dot(vv_i, tt_iw) < 0.0: tt_iw = -1.0 * tt_iw # Compute force # f_iW = { A * exp[(ri-diw)/B] + kn*g(ri-diw) } * niw # - kt * g(ri-diw)(vi * tiw)tiw f_rep = ( A * wp.exp((ri-d_iw)/B) + kn * G(ri, d_iw) ) * nn_iw f_tan = kt * G(ri,d_iw) * wp.dot(vv_i, tt_iw) * tt_iw force = f_rep - f_tan return force @wp.func def calc_agent_force(rr_i: wp.vec3, ri: float, vv_i: wp.vec3, pn_rr: wp.array(dtype=wp.vec3), pn_vv: wp.array(dtype=wp.vec3), pn_r: wp.array(dtype=float), pn: float, grid : wp.uint64, ): '''Sum the forces of neighboring agents''' # Set the total force of the other agents to zero force = wp.vec3(0.0, 0.0, 0.0) ff_ij = wp.vec3(0.0, 0.0, 0.0) rr_j = wp.vec3(0.0, 0.0, 0.0) # create grid query around point query = wp.hash_grid_query(grid, rr_i, pn) index = int(0) # Iterate through the neighbors and sum (f_ij) while(wp.hash_grid_query_next(query, index)): j = index neighbor = pn_rr[j] # compute distance to neighbor point dist = wp.length(rr_i-neighbor) if (dist <= pn): # Get position and velocity of neighbor agent rr_j = pn_rr[j] vv_j = pn_vv[j] # Get radii of neighbor agent rj = pn_r[j] # Pass agent position to AgentForce calculation ff_ij = neighbor_force(rr_i, ri, vv_i, rr_j, rj, vv_j) # Sum Forces force += ff_ij return force @wp.func def neighbor_force(rr_i: wp.vec3, ri: float, vv_i: wp.vec3, rr_j: wp.vec3, rj: float, vv_j: wp.vec3): '''Calculate the force exerted by another agent. Take in this agent (i) and a neighbors (j) position and radius''' # Sum of radii rij = ri + rj # distance between center of mass d_ij = wp.length(rr_i - rr_j) # "n_ij is the normalized vector points from pedestrian j to i" n_ij = wp.normalize(rr_i - rr_j) # Normalized vector pointing from j to i # t_ij "Vector of tangential relative velocity pointing from i to j." # A sliding force is applied on agent i in this direction to reduce the relative velocity. t_ij = vv_j - vv_i dv_ji = wp.dot(vv_j - vv_i, t_ij) # Calculate f_ij force = repulsion(rij, d_ij, n_ij) + proximity(rij, d_ij, n_ij) + sliding(rij, d_ij, dv_ji, t_ij) return force @wp.func def G(r_ij: float, d_ij: float ): # g(x) is a function that returns zero if pedestrians touch # otherwise is equal to the argument x if (d_ij > r_ij): return 0.0 return r_ij - d_ij @wp.func def repulsion(r_ij: float, d_ij: float, n_ij: wp.vec3): force = A * wp.exp( (r_ij - d_ij) / B) * n_ij return force @wp.func def proximity(r_ij: float, d_ij: float, n_ij: wp.vec3): force = (kn * G(r_ij, d_ij)) * n_ij # body force return force @wp.func def sliding(r_ij: float, d_ij: float, dv_ji: float, t_ij: wp.vec3): force = kt * G(r_ij, d_ij) * (dv_ji * t_ij) return force @wp.func def compute_force(rr_i: wp.vec3, ri: float, vv_i: wp.vec3, mass:float, goal:wp.vec3, pn_rr: wp.array(dtype=wp.vec3), pn_vv: wp.array(dtype=wp.vec3), pn_r: wp.array(dtype=float), dt: float, pn: float, grid : wp.uint64, mesh: wp.uint64 ): ''' rr_i : position ri : radius vv_i : velocity pn_rr : List[perceived neighbor positions] pn_vv : List[perceived neighbor velocities] pn_r : List[perceived neighbor radius] ''' # Get the force for this agent to the goal goal = calc_goal_force(goal, rr_i, vv_i, mass, v_desired, dt) agent = calc_agent_force(rr_i, ri, vv_i, pn_rr, pn_vv, pn_r, pn, grid) wall = calc_wall_force(rr_i, ri, vv_i, mesh) # Sum of forces force = goal + agent + wall force = wp.normalize(force) * wp.min(wp.length(force), max_speed) return force

Python

cadop/crowds/exts/siborg.simulate.crowd/siborg/simulate/crowd/tests/__init__.py

from .test_hello_world import *

Python

cadop/crowds/exts/siborg.simulate.crowd/config/extension.toml

[package] # Semantic Versioning is used: https://semver.org/ version = "0.0.3-alpha" # The title and description fields are primarily for displaying extension info in UI title = "Crowd Simulation" description="An implementation of the Social Forces crowd simulation (it may or may not be correct). There is currently no environment detection. The current implementation is in PhysX. We plan to support more methods in the future, as well as more crowd simulators. Contributions are welcome." # Path (relative to the root) or content of readme markdown file for UI. readme = "docs/README.md" # URL of the extension source repository. repository = "" # One of categories for UI. category = "Create" # Keywords for the extension keywords = ["kit", "example", "crowds", "simulation"] # Icon to show in the extension manager icon = "data/icon.png" # Preview to show in the extension manager preview_image = "data/preview.png" # Use omni.ui to build simple UI [dependencies] "omni.kit.uiapp" = {} # Main python module this extension provides, it will be publicly available as "import siborg.simulate.crowd". [[python.module]] name = "siborg.simulate.crowd" [[test]] # Extra dependencies only to be used during test run dependencies = [ "omni.kit.ui_test" # UI testing extension ] [python.pipapi] use_online_index = true requirements = ["scipy"]

TOML

cadop/crowds/exts/siborg.simulate.crowd/docs/CHANGELOG.md

# Changelog The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/). ## [1.0.0] - 2021-04-26 - Initial version of extension UI template with a window

Markdown

cadop/arduverse/puppet_handle_1.py

from omni.kit.scripting import BehaviorScript import socket import numpy as np import math from pxr import Gf import numpy as np import math class Puppet2(BehaviorScript): def on_init(self): print(f"{__class__.__name__}.on_init()->{self.prim_path}") # Set up the server address and port UDP_IP = "0.0.0.0" UDP_PORT = 8881 # Create a UDP socket self.sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) self.sock.bind((UDP_IP, UDP_PORT)) self.sock.setblocking(0) print("Waiting for data...") def on_destroy(self): print(f"{__class__.__name__}.on_destroy()->{self.prim_path}") self.sock = None rot = [0, 0, 0] self.prim.GetAttribute('xformOp:rotateXYZ').Set(Gf.Vec3d(rot)) def on_play(self): print(f"{__class__.__name__}.on_play()->{self.prim_path}") # Set up the server address and port UDP_IP = "0.0.0.0" UDP_PORT = 8881 # Create a UDP socket self.sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) self.sock.bind((UDP_IP, UDP_PORT)) self.sock.setblocking(0) # Time interval between sensor readings in seconds self.dt = 0.02 def on_pause(self): print(f"{__class__.__name__}.on_pause()->{self.prim_path}") def on_stop(self): print(f"{__class__.__name__}.on_stop()->{self.prim_path}") self.on_destroy() def on_update(self, current_time: float, delta_time: float): self.get_data() def get_data(self): # # Receive data from the Arduino data = self.clear_socket_buffer() if data is None: return # Decode the data and split it into Pitch and Roll data = data.decode() device, pitch, roll, yaw = data.split(",") x,y,z = float(roll), float(yaw), 180-float(pitch) rot = [x, y, z] self.prim.GetAttribute('xformOp:rotateXYZ').Set(Gf.Vec3d(rot)) def clear_socket_buffer(self): # Function to clear the socket's buffer latest_data = None while True: try: # Try to read data from the socket in a non-blocking way latest_data, addr = self.sock.recvfrom(1024) except BlockingIOError: # No more data to read (buffer is empty) return latest_data

Python

cadop/arduverse/README.md

# arduverse Project files and source code for making a real-time streaming from arduino to omniverse Clone/download the repo. You should be able to just open the usda file in *PuppetScene* folder. To use: - Upload the *UDP_FilteredAngle.ino* file to an arduino (RP2040 is what I used). - Make sure to change the wifi network credentials to your own - Try to run the *udp.py* file to make sure the arduino is connecting and sending data - If the udp to python connection is working, you should be able to get the scene running. - To use the base file, in omniverse create a python behavior script on any xform, and attach the script (e.g. *puppet_handle_1.py*) Open an issue if you have problems. Also if you want to contribute go for it. 

Markdown

cadop/arduverse/udp.py

import socket # Set up the server address and port UDP_IP = "0.0.0.0" UDP_PORT1 = 8881 UDP_PORT2 = 8882 # Create a UDP socket sock1 = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) sock2 = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) sock1.bind((UDP_IP, UDP_PORT1)) sock2.bind((UDP_IP, UDP_PORT2)) sock1.setblocking(0) sock2.setblocking(0) print("Waiting for data...") while True: # Receive data from the Arduino try: data, addr = sock1.recvfrom(1024) print("Received message 1:", data.decode()) except: pass try: data, addr = sock2.recvfrom(1024) print("Received message 2:", data.decode()) except: pass

Python

jshrake-nvidia/kit-cv-video-example/README.md

# kit-cv-video-example Example Omniverse Kit extension that demonstrates how to stream video (webcam, RTSP, mp4, mov, ) to a dynamic texture using [OpenCV VideoCapture](https://docs.opencv.org/3.4/dd/d43/tutorial_py_video_display.html) and [omni.ui.DynamicTextureProvider](https://docs.omniverse.nvidia.com/kit/docs/omni.ui/latest/omni.ui/omni.ui.ByteImageProvider.html#byteimageprovider).  For a basic example of how to use `omni.ui.DynamicTextureProvider`, please see <https://github.com/jshrake-nvidia/kit-dynamic-texture-example>. **WARNING**: This is a prototype and is not necessarily ready for production use. The performance of this example may not meet your performance requirements and is not optimized. This example is a temporary solution until a more mature and optimized streaming solution becomes available in the platform. This example currently only scales to a very limited number of low resolution streams. ## Getting Started - Requires Kit 104.1 >= - Tested in Create 2022.3.1, 2022.3.3 ``` ./link_app.bat --app create ./app/omni.create.bat --/rtx/ecoMode/enabled=false --ext-folder exts --enable omni.cv-video.example ``` Make sure that eco mode is disabled under Render Settings > Raytracing. From the extension UI window, update the URI and click the Create button. A plane prim will be created at (0, 0, 0) with an OmniPBR material containing a dynamic video stream for the albedo texture. The extension should support whatever the OpenCV VideoCapture API supports. Here are a few URIs you can use to test: - Your own web camera: `0` - HLS: `https://test-streams.mux.dev/x36xhzz/x36xhzz.m3u8` - RTSP: `rtsp://wowzaec2demo.streamlock.net/vod/mp4:BigBuckBunny_115k.mp4`

Markdown

jshrake-nvidia/kit-cv-video-example/exts/omni.cv-video.example/config/extension.toml

[package] # Semantic Versionning is used: https://semver.org/ version = "1.0.0" # The title and description fields are primarily for displaying extension info in UI title = "Omni RTSP Dyanmic Texture Example" description = "An example that demonstrates how to stream RTSP feeds using OpenCV and omni.ui.DynamicTextureProvider" # Path (relative to the root) or content of readme markdown file for UI. readme = "docs/README.md" # Path (relative to the root) of changelog changelog = "docs/CHANGELOG.md" # URL of the extension source repository. repository = "https://github.com/NVIDIA-Omniverse/kit-extension-template" # One of categories for UI. category = "Example" # Keywords for the extension keywords = ["kit", "example"] # Icon to show in the extension manager icon = "data/icon.png" # Preview to show in the extension manager preview_image = "data/preview.png" # Use omni.ui to build simple UI [dependencies] "omni.kit.uiapp" = {} "omni.kit.pipapi" = {} "omni.warp" = {} [python.pipapi] requirements = [ "opencv-python" ] use_online_index = true [[python.module]] name = "omni.cv-video.example" [[test]] # Extra dependencies only to be used during test run dependencies = [ "omni.kit.ui_test" # UI testing extension ]

TOML

jshrake-nvidia/kit-cv-video-example/exts/omni.cv-video.example/omni/cv-video/example/extension.py

""" Omniverse Kit example extension that demonstrates how to stream video (such as RTSP) to a dynamic texture using [OpenCV VideoCapture](https://docs.opencv.org/3.4/dd/d43/tutorial_py_video_display.html) and [omni.ui.DynamicTextureProvider](https://docs.omniverse.nvidia.com/kit/docs/omni.ui/latest/omni.ui/omni.ui.ByteImageProvider.html#byteimageprovider). TODO: - [x] Investigate how to perform the color space conversion and texture updates in a separate thread - [ ] Investigate how to avoid the color space conversion and instead use the native format of the frame provided by OpenCV """ import asyncio import threading import time from typing import List import carb import carb.profiler import cv2 as cv import numpy as np import omni.ext import omni.kit.app import omni.ui from pxr import Kind, Sdf, Usd, UsdGeom, UsdShade DEFAULT_STREAM_URI = "rtsp://wowzaec2demo.streamlock.net/vod/mp4:BigBuckBunny_115k.mp4" #DEFAULT_STREAM_URI = "C:/Users/jshrake/Downloads/1080p.mp4" def create_textured_plane_prim( stage: Usd.Stage, prim_path: str, texture_name: str, width: float, height: float ) -> Usd.Prim: """ Creates a plane prim and an OmniPBR material with a dynamic texture for the albedo map """ hw = width / 2 hh = height / 2 # This code is mostly copy pasted from https://graphics.pixar.com/usd/release/tut_simple_shading.html billboard: UsdGeom.Mesh = UsdGeom.Mesh.Define(stage, f"{prim_path}/Mesh") billboard.CreatePointsAttr([(-hw, -hh, 0), (hw, -hh, 0), (hw, hh, 0), (-hw, hh, 0)]) billboard.CreateFaceVertexCountsAttr([4]) billboard.CreateFaceVertexIndicesAttr([0, 1, 2, 3]) billboard.CreateExtentAttr([(-430, -145, 0), (430, 145, 0)]) texCoords = UsdGeom.PrimvarsAPI(billboard).CreatePrimvar( "st", Sdf.ValueTypeNames.TexCoord2fArray, UsdGeom.Tokens.varying ) texCoords.Set([(0, 0), (1, 0), (1, 1), (0, 1)]) material_path = f"{prim_path}/Material" material: UsdShade.Material = UsdShade.Material.Define(stage, material_path) shader: UsdShade.Shader = UsdShade.Shader.Define(stage, f"{material_path}/Shader") shader.SetSourceAsset("OmniPBR.mdl", "mdl") shader.SetSourceAssetSubIdentifier("OmniPBR", "mdl") shader.CreateIdAttr("OmniPBR") shader.CreateInput("diffuse_texture", Sdf.ValueTypeNames.Asset).Set(f"dynamic://{texture_name}") material.CreateSurfaceOutput().ConnectToSource(shader.ConnectableAPI(), "surface") billboard.GetPrim().ApplyAPI(UsdShade.MaterialBindingAPI) UsdShade.MaterialBindingAPI(billboard).Bind(material) return billboard class OpenCvVideoStream: """ A small abstraction around OpenCV VideoCapture and omni.ui.DynamicTextureProvider, making a one-to-one mapping between the two Resources: - https://docs.opencv.org/3.4/d8/dfe/classcv_1_1VideoCapture.html - https://docs.opencv.org/3.4/dd/d43/tutorial_py_video_display.html - https://docs.omniverse.nvidia.com/kit/docs/omni.ui/latest/omni.ui/omni.ui.ByteImageProvider.html#omni.ui.ByteImageProvider.set_bytes_data_from_gpu """ def __init__(self, name: str, stream_uri: str): self.name = name self.uri = stream_uri self.texture_array = None try: # Attempt to treat the uri as an int # https://docs.opencv.org/3.4/d8/dfe/classcv_1_1VideoCapture.html#a5d5f5dacb77bbebdcbfb341e3d4355c1 stream_uri_as_int = int(stream_uri) self._video_capture = cv.VideoCapture(stream_uri_as_int) except: # Otherwise treat the uri as a str self._video_capture = cv.VideoCapture(stream_uri) self.fps: float = self._video_capture.get(cv.CAP_PROP_FPS) self.width: int = self._video_capture.get(cv.CAP_PROP_FRAME_WIDTH) self.height: int = self._video_capture.get(cv.CAP_PROP_FRAME_HEIGHT) self._dynamic_texture = omni.ui.DynamicTextureProvider(name) self._last_read = time.time() self.is_ok = self._video_capture.isOpened() # If this FPS is 0, set it to something sensible if self.fps == 0: self.fps = 24 @carb.profiler.profile def update_texture(self): # Rate limit frame reads to the underlying FPS of the capture stream now = time.time() time_delta = now - self._last_read if time_delta < 1.0 / self.fps: return self._last_read = now # Read the frame carb.profiler.begin(0, "read") ret, frame = self._video_capture.read() carb.profiler.end(0) # The video may be at the end, loop by setting the frame position back to 0 if not ret: self._video_capture.set(cv.CAP_PROP_POS_FRAMES, 0) self._last_read = time.time() return # By default, OpenCV converts the frame to BGR # We need to convert the frame to a texture format suitable for RTX # In this case, we convert to BGRA, but the full list of texture formats can be found at # # kit\source\extensions\omni.gpu_foundation\bindings\python\omni.gpu_foundation_factory\GpuFoundationFactoryBindingsPython.cpp frame: np.ndarray carb.profiler.begin(0, "color space conversion") frame = cv.cvtColor(frame, cv.COLOR_BGR2RGBA) carb.profiler.end(0) height, width, channels = frame.shape carb.profiler.begin(0, "set_bytes_data") self._dynamic_texture.set_data_array(frame, [width, height, channels]) carb.profiler.end(0) class OmniRtspExample(omni.ext.IExt): def on_startup(self, ext_id): # stream = omni.kit.app.get_app().get_update_event_stream() # self._sub = stream.create_subscription_to_pop(self._update_streams, name="update") self._streams: List[OpenCvVideoStream] = [] self._stream_threads: List[threading.Thread] = [] self._stream_uri_model = omni.ui.SimpleStringModel(DEFAULT_STREAM_URI) self._window = omni.ui.Window("OpenCV Video Streaming Example", width=800, height=200) with self._window.frame: with omni.ui.VStack(): omni.ui.StringField(model=self._stream_uri_model) omni.ui.Button("Create", clicked_fn=self._on_click_create) @carb.profiler.profile def _update_stream(self, i): async def loop(): while self._running: await asyncio.sleep(0.001) self._streams[i].update_texture() asyncio.run(loop()) def _on_click_create(self): name = f"Video{len(self._streams)}" image_name = name usd_context = omni.usd.get_context() stage: Usd.Stage = usd_context.get_stage() prim_path = f"/World/{name}" # If the prim already exists, remove it so we can create it again try: stage.RemovePrim(prim_path) self._streams = [stream for stream in self._streams if stream.name != image_name] except: pass # Create the stream stream_uri = self._stream_uri_model.get_value_as_string() video_stream = OpenCvVideoStream(image_name, stream_uri) if not video_stream.is_ok: carb.log_error(f"Error opening stream: {stream_uri}") return self._streams.append(video_stream) carb.log_info(f"Creating video steam {stream_uri} {video_stream.width}x{video_stream.height}") # Create the mesh + material + shader model_root = UsdGeom.Xform.Define(stage, prim_path) Usd.ModelAPI(model_root).SetKind(Kind.Tokens.component) create_textured_plane_prim(stage, prim_path, image_name, video_stream.width, video_stream.height) # Clear the string model # self._stream_uri_model.set_value("") # Create the thread to pump the video stream self._running = True i = len(self._streams) - 1 thread = threading.Thread(target=self._update_stream, args=(i, )) thread.daemon = True thread.start() self._stream_threads.append(thread) def on_shutdown(self): # self._sub.unsubscribe() self._running = False for thread in self._stream_threads: thread.join() self._stream_threads = [] self._streams = []

Python

jshrake-nvidia/kit-cv-video-example/exts/omni.cv-video.example/omni/cv-video/example/__init__.py

# TODO: Work around OM-108110 # by explicitly adding the python3.dll directory to the DLL search path list. # cv2.dll fails to load because it can't load the python3.dll dependency try: import os import pathlib import sys # The python3.dll lives in the python directory adjacent to the kit executable # Get the path to the current kit process exe_path = sys.executable exe_dir = pathlib.Path(exe_path).parent python_dir = exe_dir / "python" print(f"Adding {python_dir} to DLL search path list") os.add_dll_directory(python_dir) except Exception as e: print(f"Error adding python directory to DLL search path list {e}") from .extension import *

Python

jshrake-nvidia/kit-cv-video-example/exts/omni.cv-video.example/docs/README.md

# Simple UI Extension Template The simplest python extension example. Use it as a starting point for your extensions.

Markdown

jshrake-nvidia/kit-dynamic-texture-example/README.md

# Dynamic Texture Provider Example Demonstrates how to programmatically generate a textured quad using the [omni.ui.DynamicTextureProvider](https://docs.omniverse.nvidia.com/kit/docs/omni.ui/latest/omni.ui/omni.ui.ByteImageProvider.html) API. Tested against Create 2022.3.1. ```console .\link_app.bat --path C:\Users\jshrake\AppData\Local\ov\pkg\prod-create-2022.3.1 .\app\omni.create.bat --ext-folder exts --enable omni.dynamic_texture_example ```  ## *Omniverse Kit* Extensions Project Template This project is a template for developing extensions for *Omniverse Kit*. # Getting Started ## Install Omniverse and some Apps 1. Install *Omniverse Launcher*: [download](https://www.nvidia.com/en-us/omniverse/download) 2. Install and launch one of *Omniverse* apps in the Launcher. For instance: *Code*. ## Add a new extension to your *Omniverse App* 1. Fork and clone this repo, for example in `C:\projects\kit-extension-template` 2. In the *Omniverse App* open extension manager: *Window* &rarr; *Extensions*. 3. In the *Extension Manager Window* open a settings page, with a small gear button in the top left bar. 4. In the settings page there is a list of *Extension Search Paths*. Add cloned repo `exts` subfolder there as another search path: `C:\projects\kit-extension-template\exts`  5. Now you can find `omni.hello.world` extension in the top left search bar. Select and enable it. 6. "My Window" window will pop up. *Extension Manager* watches for any file changes. You can try changing some code in this extension and see them applied immediately with a hotreload. ### Few tips * Now that `exts` folder was added to the search you can add new extensions to this folder and they will be automatically found by the *App*. * Look at the *Console* window for warnings and errors. It also has a small button to open current log file. * All the same commands work on linux. Replace `.bat` with `.sh` and `\` with `/`. * Extension name is a folder name in `exts` folder, in this example: `omni.hello.world`. * Most important thing extension has is a config file: `extension.toml`, take a peek. ## Next Steps: Alternative way to add a new extension To get a better understanding and learn a few other things, we recommend following next steps: 1. Remove search path added in the previous section. 1. Open this cloned repo using Visual Studio Code: `code C:\projects\kit-extension-template`. It will suggest installing a few extensions to improve python experience. 2. In the terminal (CTRL + \`) run `link_app.bat` (more in [Linking with an *Omniverse* app](#linking-with-an-omniverse-app) section). 3. Run this app with `exts` folder added as an extensions search path and new extension enabled: ```bash > app\omni.code.bat --ext-folder exts --enable omni.hello.world ``` - `--ext-folder [path]` - adds new folder to the search path - `--enable [extension]` - enables an extension on startup. Use `-h` for help: ```bash > app\omni.code.bat -h ``` 4. After the *App* started you should see: * new "My Window" window popup. * extension search paths in *Extensions* window as in the previous section. * extension enabled in the list of extensions. 5. If you look inside `omni.code.bat` or any other *Omniverse App*, they all run *Omniverse Kit* (`kit.exe`). *Omniverse Kit* is the Omniverse Application runtime that powers *Apps* build out of extensions. Think of it as `python.exe`. It is a small runtime, that enables all the basics, like settings, python, logging and searches for extensions. **Everything else is an extension.** You can run only this new extension without running any big *App* like *Code*: ```bash > app\kit\kit.exe --ext-folder exts --enable omni.hello.world ``` It starts much faster and will only have extensions enabled that are required for this new extension (look at `[dependencies]` section of `extension.toml`). You can enable more extensions: try adding `--enable omni.kit.window.extensions` to have extensions window enabled (yes, extension window is an extension too!): ```bash > app\kit\kit.exe --ext-folder exts --enable omni.hello.world --enable omni.kit.window.extensions ``` You should see a menu in the top left. From here you can enable more extensions from the UI. ### Few tips * In the *Extensions* window, press *Bread* button near the search bar and select *Show Extension Graph*. It will show how the current *App* comes to be: all extensions and dependencies. * Extensions system documentation: http://omniverse-docs.s3-website-us-east-1.amazonaws.com/kit-sdk/104.0/docs/guide/extensions.html # Running Tests To run tests we run a new process where only the tested extension (and it's dependencies) is enabled. Like in example above + testing system (`omni.kit.test` extension). There are 2 ways to run extension tests: 1. Run: `app\kit\test_ext.bat omni.hello.world --ext-folder exts` That will run a test process with all tests and exit. For development mode pass `--dev`: that will open test selection window. As everywhere, hotreload also works in this mode, give it a try by changing some code! 2. Alternatively, in *Extension Manager* (*Window &rarr; Extensions*) find your extension, click on *TESTS* tab, click *Run Test* For more information about testing refer to: [testing doc](http://omniverse-docs.s3-website-us-east-1.amazonaws.com/kit-sdk/104.0/docs/guide/ext_testing.html). # Linking with an *Omniverse* app For a better developer experience, it is recommended to create a folder link named `app` to the *Omniverse Kit* app installed from *Omniverse Launcher*. A convenience script to use is included. Run: ```bash > link_app.bat ``` If successful you should see `app` folder link in the root of this repo. If multiple Omniverse apps is installed script will select recommended one. Or you can explicitly pass an app: ```bash > link_app.bat --app create ``` You can also just pass a path to create link to: ```bash > link_app.bat --path "C:/Users/bob/AppData/Local/ov/pkg/create-2021.3.4" ``` # Adding a new extension Adding a new extension is as simple as copying and renaming existing one: 1. copy `exts/omni.hello.world` to `exts/[new extension name]` 2. rename python module (namespace) in `exts/[new extension name]/omni/hello/world` to `exts/[new extension name]/[new python module]` 3. update `exts/[new extension name]/config/extension.toml`, most importantly specify new python module to load: ```toml [[python.module]] name = "[new python module]" ``` No restart is needed, you should be able to find and enable `[new extension name]` in extension manager. # Sharing extensions To make extension available to other users use [Github Releases](https://docs.github.com/en/repositories/releasing-projects-on-github/managing-releases-in-a-repository). 1. Make sure the repo has [omniverse-kit-extension](https://github.com/topics/omniverse-kit-extension) topic set for auto discovery. 2. For each new release increment extension version (in `extension.toml`) and update the changelog (in `docs/CHANGELOG.md`). [Semantic versionning](https://semver.org/) must be used to express severity of API changes. # Contributing The source code for this repository is provided as-is and we are not accepting outside contributions.

Markdown

jshrake-nvidia/kit-dynamic-texture-example/exts/omni.dynamic_texture_example/config/extension.toml

[package] # Semantic Versionning is used: https://semver.org/ version = "1.0.0" # The title and description fields are primarily for displaying extension info in UI title = "Dynamic Texture Example" description = "Demonstrates how to programmatically generate a textured quad using the omni.ui.DynamicTextureProvider API" # Path (relative to the root) or content of readme markdown file for UI. readme = "docs/README.md" # Path (relative to the root) of changelog changelog = "docs/CHANGELOG.md" # URL of the extension source repository. repository = "https://github.com/NVIDIA-Omniverse/kit-extension-template" # One of categories for UI. category = "Example" # Keywords for the extension keywords = ["kit", "example"] # Icon to show in the extension manager icon = "data/icon.png" # Preview to show in the extension manager preview_image = "data/preview.png" # Use omni.ui to build simple UI [dependencies] "omni.kit.uiapp" = {} "omni.kit.pipapi" = {} [python.pipapi] requirements = [ "pillow" ] use_online_index = true # Main python module this extension provides, it will be publicly available as "import omni.hello.world". [[python.module]] name = "omni.dynamic_texture_example" [[test]] # Extra dependencies only to be used during test run dependencies = [ "omni.kit.ui_test" # UI testing extension ]

TOML

jshrake-nvidia/kit-dynamic-texture-example/exts/omni.dynamic_texture_example/omni/dynamic_texture_example/extension.py

''' Demonstrates how to programmatically generate a textured quad using the omni.ui.DynamicTextureProvider API. This is contrived example that reads the image from the local filesystem (cat.jpg). You can imagine sourcing the image bytes from a network request instead. Resources: - https://docs.omniverse.nvidia.com/kit/docs/omni.ui/latest/omni.ui/omni.ui.ByteImageProvider.html - See the full list of omni.ui.TextureFormat variants at .\app\kit\extscore\omni.gpu_foundation\omni\gpu_foundation_factory\_gpu_foundation_factory.pyi TODO(jshrake): - [ ] Currently the dynamic texture name only works with the OmniPBR.mdl material. Need to understand why it doesn't work with other materials, such as UsdPreviewSurface. - [ ] Test instantiating and using the DynamicTextureProvider in a separate thread ''' from typing import Tuple, Union import pathlib import omni import omni.ui as ui from PIL import Image from pxr import Kind, Sdf, Usd, UsdGeom, UsdShade def create_textured_plane_prim(stage: Usd.Stage, prim_path: str, texture_name: str) -> Usd.Prim: # This code is mostly copy pasted from https://graphics.pixar.com/usd/release/tut_simple_shading.html billboard: UsdGeom.Mesh = UsdGeom.Mesh.Define(stage, f"{prim_path}/Mesh") billboard.CreatePointsAttr([(-430, -145, 0), (430, -145, 0), (430, 145, 0), (-430, 145, 0)]) billboard.CreateFaceVertexCountsAttr([4]) billboard.CreateFaceVertexIndicesAttr([0,1,2,3]) billboard.CreateExtentAttr([(-430, -145, 0), (430, 145, 0)]) texCoords = UsdGeom.PrimvarsAPI(billboard).CreatePrimvar("st", Sdf.ValueTypeNames.TexCoord2fArray, UsdGeom.Tokens.varying) texCoords.Set([(0, 0), (1, 0), (1,1), (0, 1)]) material_path = f"{prim_path}/Material" material = UsdShade.Material.Define(stage, material_path) shader: UsdShade.Shader = UsdShade.Shader.Define(stage, f"{material_path}/Shader") shader.SetSourceAsset("OmniPBR.mdl", "mdl") shader.SetSourceAssetSubIdentifier("OmniPBR", "mdl") shader.CreateIdAttr("OmniPBR") shader.CreateInput("diffuse_texture", Sdf.ValueTypeNames.Asset).Set(f"dynamic://{texture_name}") material.CreateSurfaceOutput().ConnectToSource(shader.ConnectableAPI(), "surface") billboard.GetPrim().ApplyAPI(UsdShade.MaterialBindingAPI) UsdShade.MaterialBindingAPI(billboard).Bind(material) return billboard def create_dynamic_texture(texture_name: str, bytes: bytes, resolution: Tuple[int, int], format: ui.TextureFormat) -> ui.DynamicTextureProvider: # See https://docs.omniverse.nvidia.com/kit/docs/omni.ui/latest/omni.ui/omni.ui.ByteImageProvider.html#omni.ui.ByteImageProvider.set_bytes_data_from_gpu bytes_list = list(bytes) dtp = ui.DynamicTextureProvider(texture_name) dtp.set_bytes_data(bytes_list, list(resolution), format) return dtp class DynamicTextureProviderExample(omni.ext.IExt): def on_startup(self, ext_id): self._texture: Union[None, ui.DynamicTextureProvider] = None self._window = ui.Window("Create Dynamic Texture Provider Example", width=300, height=300) with self._window.frame: ui.Button("Create", clicked_fn=self._on_click_create) def _on_click_create(self): usd_context = omni.usd.get_context() stage: Usd.Stage = usd_context.get_stage() name = f"TexturePlane" image_name = name prim_path = f"/World/{name}" # If the prim already exists, remove it so we can create it again try: stage.RemovePrim(prim_path) self._texture = None except: pass # Create the prim root model_root = UsdGeom.Xform.Define(stage, prim_path) Usd.ModelAPI(model_root).SetKind(Kind.Tokens.component) # Create the mesh + material + shader create_textured_plane_prim(stage, prim_path, image_name) # Open the adjacent cat.jpg file and create the texture dir = pathlib.Path(__file__).parent.resolve() image_path = dir.joinpath("cat.jpg") image: Image.Image = Image.open(image_path, mode='r') # Ensure the image format is RGBA image = image.convert('RGBA') image_bytes = image.tobytes() image_resolution = (image.width, image.height) image_format = ui.TextureFormat.RGBA8_UNORM self._texture = create_dynamic_texture(image_name, image_bytes, image_resolution, image_format) def on_shutdown(self): self._texture = None

Python

renanmb/Omniverse_legged_robotics/README.md

The idea of this repo is to start converting open source models of robots into Omniverse Isaac-Sim friendly format. # URDF Descriptions The URDFs found in this repository have been forked/modified/linked from the following projects: ## Quadrupeds - [kodlab_gazebo - Ghost Robotics](https://github.com/KodlabPenn/kodlab_gazebo) - [ANYbotics](https://github.com/ANYbotics) - [ANYbotics' ANYmal B](https://github.com/ANYbotics/anymal_b_simple_description) - [ANYbotics' ANYmal B - Modified for CHAMP](https://github.com/chvmp/anymal_b_simple_description) - [ANYbotics' ANYmal C](https://github.com/ANYbotics/anymal_c_simple_description) - [ANYbotics' ANYmal B - Modified for CHAMP](https://github.com/chvmp/anymal_c_simple_description) - Boston Dynamic's Little Dog - [Boston Dynamic's Little Dog - by RobotLocomotion](https://github.com/RobotLocomotion/LittleDog) - [Boston Dynamic's Little Dog - Modified for CHAMP](https://github.com/chvmp/littledog_description) - Boston Dynamic's Spot - [Boston Dynamic's Spot - by heuristicus](https://github.com/heuristicus/spot_ros) - [Boston Dynamic's Spot - Modified for CHAMP](https://github.com/chvmp/spot_ros) - [Dream Walker](https://github.com/Ohaginia/dream_walker) - [MIT Mini Cheetah - Original](https://github.com/HitSZwang/mini-cheetah-gazebo-urdf) - [MIT Mini Cheetah - Modified for CHAMP](https://github.com/chvmp/mini-cheetah-gazebo-urdf) - [OpenDog V2 - Original](https://github.com/XRobots/openDogV2) - [OpenDog V2 - Modified for CHAMP](https://github.com/chvmp/opendog_description) - Open Quadruped - [Open Quadruped](https://github.com/moribots/spot_mini_mini) - [SpotMicroAI - Gitlab](https://gitlab.com/custom_robots/spotmicroai) - [Spot Micro](https://github.com/chvmp/spotmicro_description) - [Unitree Robotics All](https://github.com/unitreerobotics/unitree_ros) - [Unitree Robotics All - Modified for CHAMP](https://github.com/chvmp/unitree_ros) - [Unitree Robotics' A1](https://github.com/unitreerobotics/unitree_ros/tree/master/robots/a1_description) - [Unitree Robotics' AliengoZ1](https://github.com/unitreerobotics/unitree_ros/tree/master/robots/aliengoZ1_description) - [Unitree Robotics'Aliengo](https://github.com/unitreerobotics/unitree_ros/tree/master/robots/aliengo_description) - [Unitree Robotics' B1](https://github.com/unitreerobotics/unitree_ros/tree/master/robots/b1_description) - [Unitree Robotics' Go1](https://github.com/unitreerobotics/unitree_ros/tree/master/robots/go1_description) - [Unitree Robotics' Laikago](https://github.com/unitreerobotics/unitree_ros/tree/master/robots/laikago_description) - [Unitree Robotics' Z1](https://github.com/unitreerobotics/unitree_ros/tree/master/robots/z1_description) - [Stochlab's Stochlite](https://stochlab.github.io/) - [Stochlab's Stochlite - Modified by aditya-shirwatkar](https://github.com/aditya-shirwatkar/stochlite_description) - Mini Pupper - [MangDang's Mini Pupper](https://github.com/mangdangroboticsclub/QuadrupedRobot) - [simplified robot description of the MangDang's Mini Pupper](https://github.com/nisshan-x/mini_pupper_description) - [Stanford pupper - Original](https://stanfordstudentrobotics.org/pupper) - [Stanford pupper - Modified by Chandykunju Alex](https://github.com/chandyalex/stanford_pupper_description.git) ## Bipedal - [Agility Robotics' Cassie - UMich-BipedLab](https://github.com/UMich-BipedLab/cassie_description) - [Agility Robotics' Digit - DigitRobot.jl](https://github.com/adubredu/DigitRobot.jl) - [NJIT - TOCABI](https://github.com/cadop/tocabi) ## Manipulation - [GoogleAI ROBEL D'Kitty](https://github.com/google-research/robel-scenes) - [GoogleAI ROBEL D'Kitty - Modified for CHAMP](https://github.com/chvmp/dkitty_description) - [The Shadow Robot Company](https://github.com/shadow-robot) - [Shadow Hand - archived](https://github.com/AndrejOrsula/shadow_hand_ign) # ## Cassie_description This repository contains the .urdf model of the CASSIE robot from Agility Robotics. It also includes a way to visualize the robot using ROS and rviz. https://github.com/UMich-BipedLab/cassie_description ## a1 robot simulation - Python version This repository contains all the files and code needed to simulate the a1 quadrupedal robot using Gazebo and ROS. The software runs on ROS noetic and Ubuntu 20.04. https://github.com/lnotspotl/a1_sim_py ## Here are the ROS simulation packages for Unitree robots https://github.com/unitreerobotics/unitree_ros ## Zoo from CHAMP This repository contains configuration packages of various quadrupedal robots generated by CHAMP's setup assistant. The URDFs found in this repository have been forked/modified/linked from the following projects: https://github.com/chvmp/robots

Markdown

renanmb/Omniverse_legged_robotics/URDF-Descriptions/unitreerobotics/z1_description/config/robot_control.yaml

z1_gazebo: # Publish all joint states ----------------------------------- joint_state_controller: type: joint_state_controller/JointStateController publish_rate: 1000 Joint01_controller: type: unitree_legged_control/UnitreeJointController joint: joint1 pid: {p: 300.0, i: 0.0, d: 5.0} Joint02_controller: type: unitree_legged_control/UnitreeJointController joint: joint2 pid: {p: 300.0, i: 0.0, d: 5.0} Joint03_controller: type: unitree_legged_control/UnitreeJointController joint: joint3 pid: {p: 300.0, i: 0.0, d: 5.0} Joint04_controller: type: unitree_legged_control/UnitreeJointController joint: joint4 pid: {p: 300.0, i: 0.0, d: 5.0} Joint05_controller: type: unitree_legged_control/UnitreeJointController joint: joint5 pid: {p: 300.0, i: 0.0, d: 5.0} Joint06_controller: type: unitree_legged_control/UnitreeJointController joint: joint6 pid: {p: 300.0, i: 0.0, d: 5.0} gripper_controller: type: unitree_legged_control/UnitreeJointController joint: jointGripper pid: {p: 300.0, i: 0.0, d: 5.0}

YAML

renanmb/Omniverse_legged_robotics/URDF-Descriptions/unitreerobotics/laikago_description/config/robot_control.yaml

laikago_gazebo: # Publish all joint states ----------------------------------- joint_state_controller: type: joint_state_controller/JointStateController publish_rate: 1000 # FL Controllers --------------------------------------- FL_hip_controller: type: unitree_legged_control/UnitreeJointController joint: FL_hip_joint pid: {p: 100.0, i: 0.0, d: 5.0} FL_thigh_controller: type: unitree_legged_control/UnitreeJointController joint: FL_thigh_joint pid: {p: 300.0, i: 0.0, d: 8.0} FL_calf_controller: type: unitree_legged_control/UnitreeJointController joint: FL_calf_joint pid: {p: 300.0, i: 0.0, d: 8.0} # FR Controllers --------------------------------------- FR_hip_controller: type: unitree_legged_control/UnitreeJointController joint: FR_hip_joint pid: {p: 100.0, i: 0.0, d: 5.0} FR_thigh_controller: type: unitree_legged_control/UnitreeJointController joint: FR_thigh_joint pid: {p: 300.0, i: 0.0, d: 8.0} FR_calf_controller: type: unitree_legged_control/UnitreeJointController joint: FR_calf_joint pid: {p: 300.0, i: 0.0, d: 8.0} # RL Controllers --------------------------------------- RL_hip_controller: type: unitree_legged_control/UnitreeJointController joint: RL_hip_joint pid: {p: 100.0, i: 0.0, d: 5.0} RL_thigh_controller: type: unitree_legged_control/UnitreeJointController joint: RL_thigh_joint pid: {p: 300.0, i: 0.0, d: 8.0} RL_calf_controller: type: unitree_legged_control/UnitreeJointController joint: RL_calf_joint pid: {p: 300.0, i: 0.0, d: 8.0} # RR Controllers --------------------------------------- RR_hip_controller: type: unitree_legged_control/UnitreeJointController joint: RR_hip_joint pid: {p: 100.0, i: 0.0, d: 5.0} RR_thigh_controller: type: unitree_legged_control/UnitreeJointController joint: RR_thigh_joint pid: {p: 300.0, i: 0.0, d: 8.0} RR_calf_controller: type: unitree_legged_control/UnitreeJointController joint: RR_calf_joint pid: {p: 300.0, i: 0.0, d: 8.0}

YAML

renanmb/Omniverse_legged_robotics/URDF-Descriptions/unitreerobotics/unitree_ros-CHAMP/README.md

# Introduction Here are the ROS simulation packages for Unitree robots, You can load robots and joint controllers in Gazebo, so you can perform low-level control (control the torque, position and angular velocity) of the robot joints. Please be aware that the Gazebo simulation cannot do high-level control, namely walking. Aside from these simulation functions, you can also control your real robots in ROS with the [unitree_ros_to_real](https://github.com/unitreerobotics/unitree_ros_to_real) packages. For real robots, you can do high-level and low-level control using our ROS packages. ## Packages: Robot description: `go1_description`, `a1_description`, `aliengo_description`, `laikago_description` Robot and joints controller: `unitree_controller` Simulation related: `unitree_gazebo`, `unitree_legged_control` # Dependencies * [ROS](https://www.ros.org/) Melodic or ROS Kinetic (has not been tested) * [Gazebo8](http://gazebosim.org/) * [unitree_legged_msgs](https://github.com/unitreerobotics/unitree_ros_to_real): `unitree_legged_msgs` is a package under [unitree_ros_to_real](https://github.com/unitreerobotics/unitree_ros_to_real). # Build <!-- If you would like to fully compile the `unitree_ros`, please run the following command to install relative packages. --> For ROS Melodic: ``` sudo apt-get install ros-melodic-controller-interface ros-melodic-gazebo-ros-control ros-melodic-joint-state-controller ros-melodic-effort-controllers ros-melodic-joint-trajectory-controller ``` For ROS Kinetic: ``` sudo apt-get install ros-kinetic-controller-manager ros-kinetic-ros-control ros-kinetic-ros-controllers ros-kinetic-joint-state-controller ros-kinetic-effort-controllers ros-kinetic-velocity-controllers ros-kinetic-position-controllers ros-kinetic-robot-controllers ros-kinetic-robot-state-publisher ros-kinetic-gazebo8-ros ros-kinetic-gazebo8-ros-control ros-kinetic-gazebo8-ros-pkgs ros-kinetic-gazebo8-ros-dev ``` And open the file `unitree_gazebo/worlds/stairs.world`. At the end of the file: ``` <include> <uri>model:///home/unitree/catkin_ws/src/unitree_ros/unitree_gazebo/worlds/building_editor_models/stairs</uri> </include> ``` Please change the path of `building_editor_models/stairs` to the real path on your PC. Then you can use catkin_make to build: ``` cd ~/catkin_ws catkin_make ``` If you face a dependency problem, you can just run `catkin_make` again. # Detail of Packages ## unitree_legged_control: It contains the joints controllers for Gazebo simulation, which allows users to control joints with position, velocity and torque. Refer to "[unitree_ros/unitree_controller/src/servo.cpp](https://github.com/unitreerobotics/unitree_ros/blob/master/unitree_controller/src/servo.cpp)" for joint control examples in different modes. ## The description of robots: Namely the description of Go1, A1, Aliengo and Laikago. Each package includes mesh, urdf and xacro files of robot. Take Laikago for example, you can check the model in Rviz by: ``` roslaunch laikago_description laikago_rviz.launch ``` ## unitree_gazebo & unitree_controller: You can launch the Gazebo simulation with the following command: ``` roslaunch unitree_gazebo normal.launch rname:=a1 wname:=stairs ``` Where the `rname` means robot name, which can be `laikago`, `aliengo`, `a1` or `go1`. The `wname` means world name, which can be `earth`, `space` or `stairs`. And the default value of `rname` is `laikago`, while the default value of `wname` is `earth`. In Gazebo, the robot should be lying on the ground with joints not activated. ### Stand controller After launching the gazebo simulation, you can start to control the robot: ``` rosrun unitree_controller unitree_servo ``` And you can add external disturbances, like a push or a kick: ``` rosrun unitree_controller unitree_external_force ``` ### Position and pose publisher Here we demonstrated how to control the position and pose of robot without a controller, which should be useful in SLAM or visual development. Then run the position and pose publisher in another terminal: ``` rosrun unitree_controller unitree_move_kinetic ``` The robot will turn around the origin, which is the movement under the world coordinate frame. And inside of the source file [move_publisher.cpp](https://github.com/unitreerobotics/unitree_ros/blob/master/unitree_controller/src/move_publisher.cpp), we also provide the method to move using the robot coordinate frame. You can change the value of `def_frame` to `coord::ROBOT` and run the catkin_make again, then the `unitree_move_publisher` will move robot under its own coordinate frame.

Markdown

renanmb/Omniverse_legged_robotics/URDF-Descriptions/unitreerobotics/unitree_ros-CHAMP/unitree_gazebo/plugin/foot_contact_plugin.cc

/************************************************************************ Copyright (c) 2018-2019, Unitree Robotics.Co.Ltd. All rights reserved. Use of this source code is governed by the MPL-2.0 license, see LICENSE. ************************************************************************/ #include <string> #include <gazebo/common/Events.hh> #include <ros/ros.h> #include <ros/advertise_options.h> #include <gazebo/gazebo.hh> #include <gazebo/sensors/sensors.hh> #include <geometry_msgs/WrenchStamped.h> namespace gazebo { class UnitreeFootContactPlugin : public SensorPlugin { public: UnitreeFootContactPlugin() : SensorPlugin(){} ~UnitreeFootContactPlugin(){} void Load(sensors::SensorPtr _sensor, sdf::ElementPtr _sdf) { this->parentSensor = std::dynamic_pointer_cast<sensors::ContactSensor>(_sensor); // Make sure the parent sensor is valid. if (!this->parentSensor){ gzerr << "UnitreeFootContactPlugin requires a ContactSensor.\n"; return; } this->contact_namespace = "contact/"; this->rosnode = new ros::NodeHandle(this->contact_namespace); // add "visual" is for the same name of draw node this->force_pub = this->rosnode->advertise<geometry_msgs::WrenchStamped>("/visual/"+_sensor->Name()+"/the_force", 100); // Connect to the sensor update event. this->update_connection = this->parentSensor->ConnectUpdated(std::bind(&UnitreeFootContactPlugin::OnUpdate, this)); this->parentSensor->SetActive(true); // Make sure the parent sensor is active. count = 0; Fx = 0; Fy = 0; Fz = 0; ROS_INFO("Load %s plugin.", _sensor->Name().c_str()); } private: void OnUpdate() { msgs::Contacts contacts; contacts = this->parentSensor->Contacts(); count = contacts.contact_size(); // std::cout << count <<"\n"; for (unsigned int i = 0; i < count; ++i){ if(contacts.contact(i).position_size() != 1){ ROS_ERROR("Contact count isn't correct!!!!"); } for (unsigned int j = 0; j < contacts.contact(i).position_size(); ++j){ // std::cout << i <<" "<< contacts.contact(i).position_size() <<" Force:" // << contacts.contact(i).wrench(j).body_1_wrench().force().x() << " " // << contacts.contact(i).wrench(j).body_1_wrench().force().y() << " " // << contacts.contact(i).wrench(j).body_1_wrench().force().z() << "\n"; Fx += contacts.contact(i).wrench(0).body_1_wrench().force().x(); // Notice: the force is in local coordinate, not in world or base coordnate. Fy += contacts.contact(i).wrench(0).body_1_wrench().force().y(); Fz += contacts.contact(i).wrench(0).body_1_wrench().force().z(); } } if(count != 0){ force.wrench.force.x = Fx/double(count); force.wrench.force.y = Fy/double(count); force.wrench.force.z = Fz/double(count); count = 0; Fx = 0; Fy = 0; Fz = 0; } else{ force.wrench.force.x = 0; force.wrench.force.y = 0; force.wrench.force.z = 0; } this->force_pub.publish(force); } private: ros::NodeHandle* rosnode; ros::Publisher force_pub; event::ConnectionPtr update_connection; std::string contact_namespace; sensors::ContactSensorPtr parentSensor; geometry_msgs::WrenchStamped force; int count = 0; double Fx=0, Fy=0, Fz=0; }; GZ_REGISTER_SENSOR_PLUGIN(UnitreeFootContactPlugin) }

C++

renanmb/Omniverse_legged_robotics/URDF-Descriptions/unitreerobotics/unitree_ros-CHAMP/unitree_gazebo/plugin/draw_force_plugin.cc

/************************************************************************ Copyright (c) 2018-2019, Unitree Robotics.Co.Ltd. All rights reserved. Use of this source code is governed by the MPL-2.0 license, see LICENSE. ************************************************************************/ #include <ignition/math/Color.hh> #include <gazebo/common/Events.hh> #include <gazebo/msgs/msgs.hh> #include <gazebo/transport/Node.hh> #include <gazebo/common/Plugin.hh> #include <ros/ros.h> #include "gazebo/rendering/DynamicLines.hh" #include "gazebo/rendering/RenderTypes.hh" #include "gazebo/rendering/Visual.hh" #include "gazebo/rendering/Scene.hh" #include <ros/ros.h> #include <boost/bind.hpp> #include <geometry_msgs/WrenchStamped.h> namespace gazebo { class UnitreeDrawForcePlugin : public VisualPlugin { public: UnitreeDrawForcePlugin():line(NULL){} ~UnitreeDrawForcePlugin(){ this->visual->DeleteDynamicLine(this->line); } void Load(rendering::VisualPtr _parent, sdf::ElementPtr _sdf ) { this->visual = _parent; this->visual_namespace = "visual/"; if (!_sdf->HasElement("topicName")){ ROS_INFO("Force draw plugin missing <topicName>, defaults to /default_force_draw"); this->topic_name = "/default_force_draw"; } else{ this->topic_name = _sdf->Get<std::string>("topicName"); } if (!ros::isInitialized()){ int argc = 0; char** argv = NULL; ros::init(argc,argv,"gazebo_visual",ros::init_options::NoSigintHandler|ros::init_options::AnonymousName); } this->line = this->visual->CreateDynamicLine(rendering::RENDERING_LINE_STRIP); this->line->AddPoint(ignition::math::Vector3d(0, 0, 0), common::Color(0, 1, 0, 1.0)); this->line->AddPoint(ignition::math::Vector3d(1, 1, 1), common::Color(0, 1, 0, 1.0)); this->line->setMaterial("Gazebo/Purple"); this->line->setVisibilityFlags(GZ_VISIBILITY_GUI); this->visual->SetVisible(true); this->rosnode = new ros::NodeHandle(this->visual_namespace); this->force_sub = this->rosnode->subscribe(this->topic_name+"/"+"the_force", 30, &UnitreeDrawForcePlugin::GetForceCallback, this); this->update_connection = event::Events::ConnectPreRender(boost::bind(&UnitreeDrawForcePlugin::OnUpdate, this)); ROS_INFO("Load %s Draw Force plugin.", this->topic_name.c_str()); } void OnUpdate() { this->line->SetPoint(1, ignition::math::Vector3d(Fx, Fy, Fz)); } void GetForceCallback(const geometry_msgs::WrenchStamped & msg) { Fx = msg.wrench.force.x/20.0; Fy = msg.wrench.force.y/20.0; Fz = msg.wrench.force.z/20.0; // Fx = msg.wrench.force.x; // Fy = msg.wrench.force.y; // Fz = msg.wrench.force.z; } private: ros::NodeHandle* rosnode; std::string topic_name; rendering::VisualPtr visual; rendering::DynamicLines *line; std::string visual_namespace; ros::Subscriber force_sub; double Fx=0, Fy=0, Fz=0; event::ConnectionPtr update_connection; }; GZ_REGISTER_VISUAL_PLUGIN(UnitreeDrawForcePlugin) }

C++

renanmb/Omniverse_legged_robotics/URDF-Descriptions/unitreerobotics/unitree_ros-CHAMP/unitree_controller/src/move_publisher.cpp

#include <ros/ros.h> #include <gazebo_msgs/ModelState.h> #include <gazebo_msgs/SetModelState.h> #include <string> #include <stdio.h> #include <tf/transform_datatypes.h> // #include <std_msgs/Float64.h> #include <math.h> #include <iostream> int main(int argc, char **argv) { enum coord { WORLD, ROBOT }; coord def_frame = coord::WORLD; ros::init(argc, argv, "move_publisher"); ros::NodeHandle nh; ros::Publisher move_publisher = nh.advertise<gazebo_msgs::ModelState>("/gazebo/set_model_state", 1000); gazebo_msgs::ModelState model_state_pub; std::string robot_name; ros::param::get("/robot_name", robot_name); std::cout << "robot_name: " << robot_name << std::endl; model_state_pub.model_name = robot_name + "_gazebo"; ros::Rate loop_rate(1000); if(def_frame == coord::WORLD) { model_state_pub.pose.position.x = 0.0; model_state_pub.pose.position.y = 0.0; model_state_pub.pose.position.z = 0.5; model_state_pub.pose.orientation.x = 0.0; model_state_pub.pose.orientation.y = 0.0; model_state_pub.pose.orientation.z = 0.0; model_state_pub.pose.orientation.w = 1.0; model_state_pub.reference_frame = "world"; long long time_ms = 0; //time, ms const double period = 5000; //ms const double radius = 1.5; //m tf::Quaternion q; while(ros::ok()) { model_state_pub.pose.position.x = radius * sin(2*M_PI*(double)time_ms/period); model_state_pub.pose.position.y = radius * cos(2*M_PI*(double)time_ms/period); model_state_pub.pose.orientation = tf::createQuaternionMsgFromRollPitchYaw(0, 0, - 2*M_PI*(double)time_ms/period); move_publisher.publish(model_state_pub); loop_rate.sleep(); time_ms += 1; } } else if(def_frame == coord::ROBOT) { model_state_pub.twist.linear.x= 0.02; //0.02: 2cm/sec model_state_pub.twist.linear.y= 0.0; model_state_pub.twist.linear.z= 0.08; model_state_pub.twist.angular.x= 0.0; model_state_pub.twist.angular.y= 0.0; model_state_pub.twist.angular.z= 0.0; model_state_pub.reference_frame = "base"; while(ros::ok()) { move_publisher.publish(model_state_pub); loop_rate.sleep(); } } }

C++

renanmb/Omniverse_legged_robotics/URDF-Descriptions/unitreerobotics/unitree_ros-CHAMP/unitree_controller/src/external_force.cpp

/************************************************************************ Copyright (c) 2018-2019, Unitree Robotics.Co.Ltd. All rights reserved. Use of this source code is governed by the MPL-2.0 license, see LICENSE. ************************************************************************/ #include <ros/ros.h> #include <geometry_msgs/Wrench.h> #include <signal.h> #include <termios.h> #include <stdio.h> #define KEYCODE_UP 0x41 #define KEYCODE_DOWN 0x42 #define KEYCODE_LEFT 0x44 #define KEYCODE_RIGHT 0x43 #define KEYCODE_SPACE 0x20 int mode = 1; // pulsed mode or continuous mode class teleForceCmd { public: teleForceCmd(); void keyLoop(); void pubForce(double x, double y, double z); private: double Fx, Fy, Fz; ros::NodeHandle n; ros::Publisher force_pub; geometry_msgs::Wrench Force; }; teleForceCmd::teleForceCmd() { Fx = 0; Fy = 0; Fz = 0; force_pub = n.advertise<geometry_msgs::Wrench>("/apply_force/trunk", 20); sleep(1); pubForce(Fx, Fy, Fz); } int kfd = 0; struct termios cooked, raw; void quit(int sig) { tcsetattr(kfd, TCSANOW, &cooked); ros::shutdown(); exit(0); } int main(int argc, char** argv) { ros::init(argc, argv, "external_force"); teleForceCmd remote; signal(SIGINT,quit); remote.keyLoop(); return(0); } void teleForceCmd::pubForce(double x, double y, double z) { Force.force.x = Fx; Force.force.y = Fy; Force.force.z = Fz; force_pub.publish(Force); ros::spinOnce(); } void teleForceCmd::keyLoop() { char c; bool dirty=false; // get the console in raw mode tcgetattr(kfd, &cooked); memcpy(&raw, &cooked, sizeof(struct termios)); raw.c_lflag &=~ (ICANON | ECHO); // Setting a new line, then end of file raw.c_cc[VEOL] = 1; raw.c_cc[VEOF] = 2; tcsetattr(kfd, TCSANOW, &raw); puts("Reading from keyboard"); puts("---------------------------"); puts("Use 'Space' to change mode, default is Pulsed mode:"); puts("Use 'Up/Down/Left/Right' to change direction"); for(;;){ // get the next event from the keyboard if(read(kfd, &c, 1) < 0){ perror("read():"); exit(-1); } ROS_DEBUG("value: 0x%02X\n", c); switch(c){ case KEYCODE_UP: if(mode > 0) { Fx = 60; } else { Fx += 16; if(Fx > 220) Fx = 220; if(Fx < -220) Fx = -220; } ROS_INFO("Fx:%3d Fy:%3d Fz:%3d", (int)Fx, (int)Fy, (int)Fz); dirty = true; break; case KEYCODE_DOWN: if(mode > 0) { Fx = -60; } else { Fx -= 16; if(Fx > 220) Fx = 220; if(Fx < -220) Fx = -220; } ROS_INFO("Fx:%3d Fy:%3d Fz:%3d", (int)Fx, (int)Fy, (int)Fz); dirty = true; break; case KEYCODE_LEFT: if(mode > 0) { Fy = 30; } else { Fy += 8; if(Fy > 220) Fy = 220; if(Fy < -220) Fy = -220; } ROS_INFO("Fx:%3d Fy:%3d Fz:%3d", (int)Fx, (int)Fy, (int)Fz); dirty = true; break; case KEYCODE_RIGHT: if(mode > 0) { Fy = -30; } else { Fy -= 8; if(Fy > 220) Fy = 220; if(Fy < -220) Fy = -220; } ROS_INFO("Fx:%3d Fy:%3d Fz:%3d", (int)Fx, (int)Fy, (int)Fz); dirty = true; break; case KEYCODE_SPACE: mode = mode*(-1); if(mode > 0){ ROS_INFO("Change to Pulsed mode."); } else { ROS_INFO("Change to Continuous mode."); } Fx = 0; Fy = 0; Fz = 0; ROS_INFO("Fx:%3d Fy:%3d Fz:%3d", (int)Fx, (int)Fy, (int)Fz); dirty = true; break; } if(dirty == true){ pubForce(Fx, Fy, Fz); if(mode > 0){ usleep(100000); // 100 ms Fx = 0; Fy = 0; Fz = 0; pubForce(Fx, Fy, Fz); } dirty=false; } } return; }

C++

renanmb/Omniverse_legged_robotics/URDF-Descriptions/unitreerobotics/unitree_ros-CHAMP/unitree_controller/src/body.cpp

/************************************************************************ Copyright (c) 2018-2019, Unitree Robotics.Co.Ltd. All rights reserved. Use of this source code is governed by the MPL-2.0 license, see LICENSE. ************************************************************************/ #include "body.h" namespace unitree_model { ros::Publisher servo_pub[12]; unitree_legged_msgs::LowCmd lowCmd; unitree_legged_msgs::LowState lowState; // These parameters are only for reference. // Actual patameters need to be debugged if you want to run on real robot. void paramInit() { for(int i=0; i<4; i++){ lowCmd.motorCmd[i*3+0].mode = 0x0A; lowCmd.motorCmd[i*3+0].Kp = 70; lowCmd.motorCmd[i*3+0].dq = 0; lowCmd.motorCmd[i*3+0].Kd = 3; lowCmd.motorCmd[i*3+0].tau = 0; lowCmd.motorCmd[i*3+1].mode = 0x0A; lowCmd.motorCmd[i*3+1].Kp = 180; lowCmd.motorCmd[i*3+1].dq = 0; lowCmd.motorCmd[i*3+1].Kd = 8; lowCmd.motorCmd[i*3+1].tau = 0; lowCmd.motorCmd[i*3+2].mode = 0x0A; lowCmd.motorCmd[i*3+2].Kp = 300; lowCmd.motorCmd[i*3+2].dq = 0; lowCmd.motorCmd[i*3+2].Kd = 15; lowCmd.motorCmd[i*3+2].tau = 0; } for(int i=0; i<12; i++){ lowCmd.motorCmd[i].q = lowState.motorState[i].q; } } void stand() { double pos[12] = {0.0, 0.67, -1.3, -0.0, 0.67, -1.3, 0.0, 0.67, -1.3, -0.0, 0.67, -1.3}; moveAllPosition(pos, 2*1000); } void motion_init() { paramInit(); stand(); } void sendServoCmd() { for(int m=0; m<12; m++){ servo_pub[m].publish(lowCmd.motorCmd[m]); } ros::spinOnce(); usleep(1000); } void moveAllPosition(double* targetPos, double duration) { double pos[12] ,lastPos[12], percent; for(int j=0; j<12; j++) lastPos[j] = lowState.motorState[j].q; for(int i=1; i<=duration; i++){ if(!ros::ok()) break; percent = (double)i/duration; for(int j=0; j<12; j++){ lowCmd.motorCmd[j].q = lastPos[j]*(1-percent) + targetPos[j]*percent; } sendServoCmd(); } } }

C++

renanmb/Omniverse_legged_robotics/URDF-Descriptions/unitreerobotics/unitree_ros-CHAMP/unitree_controller/src/servo.cpp

/************************************************************************ Copyright (c) 2018-2019, Unitree Robotics.Co.Ltd. All rights reserved. Use of this source code is governed by the MPL-2.0 license, see LICENSE. ************************************************************************/ #include "ros/ros.h" #include <stdio.h> #include <stdlib.h> #include "unitree_legged_msgs/LowCmd.h" #include "unitree_legged_msgs/LowState.h" #include "unitree_legged_msgs/MotorCmd.h" #include "unitree_legged_msgs/MotorState.h" #include <geometry_msgs/WrenchStamped.h> #include <sensor_msgs/Imu.h> #include <std_msgs/Bool.h> #include <vector> #include <string> #include <math.h> #include <nav_msgs/Odometry.h> #include "body.h" using namespace std; using namespace unitree_model; bool start_up = true; class multiThread { public: multiThread(string rname){ robot_name = rname; imu_sub = nm.subscribe("/trunk_imu", 1, &multiThread::imuCallback, this); footForce_sub[0] = nm.subscribe("/visual/FR_foot_contact/the_force", 1, &multiThread::FRfootCallback, this); footForce_sub[1] = nm.subscribe("/visual/FL_foot_contact/the_force", 1, &multiThread::FLfootCallback, this); footForce_sub[2] = nm.subscribe("/visual/RR_foot_contact/the_force", 1, &multiThread::RRfootCallback, this); footForce_sub[3] = nm.subscribe("/visual/RL_foot_contact/the_force", 1, &multiThread::RLfootCallback, this); servo_sub[0] = nm.subscribe("/" + robot_name + "_gazebo/FR_hip_controller/state", 1, &multiThread::FRhipCallback, this); servo_sub[1] = nm.subscribe("/" + robot_name + "_gazebo/FR_thigh_controller/state", 1, &multiThread::FRthighCallback, this); servo_sub[2] = nm.subscribe("/" + robot_name + "_gazebo/FR_calf_controller/state", 1, &multiThread::FRcalfCallback, this); servo_sub[3] = nm.subscribe("/" + robot_name + "_gazebo/FL_hip_controller/state", 1, &multiThread::FLhipCallback, this); servo_sub[4] = nm.subscribe("/" + robot_name + "_gazebo/FL_thigh_controller/state", 1, &multiThread::FLthighCallback, this); servo_sub[5] = nm.subscribe("/" + robot_name + "_gazebo/FL_calf_controller/state", 1, &multiThread::FLcalfCallback, this); servo_sub[6] = nm.subscribe("/" + robot_name + "_gazebo/RR_hip_controller/state", 1, &multiThread::RRhipCallback, this); servo_sub[7] = nm.subscribe("/" + robot_name + "_gazebo/RR_thigh_controller/state", 1, &multiThread::RRthighCallback, this); servo_sub[8] = nm.subscribe("/" + robot_name + "_gazebo/RR_calf_controller/state", 1, &multiThread::RRcalfCallback, this); servo_sub[9] = nm.subscribe("/" + robot_name + "_gazebo/RL_hip_controller/state", 1, &multiThread::RLhipCallback, this); servo_sub[10] = nm.subscribe("/" + robot_name + "_gazebo/RL_thigh_controller/state", 1, &multiThread::RLthighCallback, this); servo_sub[11] = nm.subscribe("/" + robot_name + "_gazebo/RL_calf_controller/state", 1, &multiThread::RLcalfCallback, this); } void imuCallback(const sensor_msgs::Imu & msg) { lowState.imu.quaternion[0] = msg.orientation.w; lowState.imu.quaternion[1] = msg.orientation.x; lowState.imu.quaternion[2] = msg.orientation.y; lowState.imu.quaternion[3] = msg.orientation.z; lowState.imu.gyroscope[0] = msg.angular_velocity.x; lowState.imu.gyroscope[1] = msg.angular_velocity.y; lowState.imu.gyroscope[2] = msg.angular_velocity.z; lowState.imu.accelerometer[0] = msg.linear_acceleration.x; lowState.imu.accelerometer[1] = msg.linear_acceleration.y; lowState.imu.accelerometer[2] = msg.linear_acceleration.z; } void FRhipCallback(const unitree_legged_msgs::MotorState& msg) { start_up = false; lowState.motorState[0].mode = msg.mode; lowState.motorState[0].q = msg.q; lowState.motorState[0].dq = msg.dq; lowState.motorState[0].tauEst = msg.tauEst; } void FRthighCallback(const unitree_legged_msgs::MotorState& msg) { lowState.motorState[1].mode = msg.mode; lowState.motorState[1].q = msg.q; lowState.motorState[1].dq = msg.dq; lowState.motorState[1].tauEst = msg.tauEst; } void FRcalfCallback(const unitree_legged_msgs::MotorState& msg) { lowState.motorState[2].mode = msg.mode; lowState.motorState[2].q = msg.q; lowState.motorState[2].dq = msg.dq; lowState.motorState[2].tauEst = msg.tauEst; } void FLhipCallback(const unitree_legged_msgs::MotorState& msg) { start_up = false; lowState.motorState[3].mode = msg.mode; lowState.motorState[3].q = msg.q; lowState.motorState[3].dq = msg.dq; lowState.motorState[3].tauEst = msg.tauEst; } void FLthighCallback(const unitree_legged_msgs::MotorState& msg) { lowState.motorState[4].mode = msg.mode; lowState.motorState[4].q = msg.q; lowState.motorState[4].dq = msg.dq; lowState.motorState[4].tauEst = msg.tauEst; } void FLcalfCallback(const unitree_legged_msgs::MotorState& msg) { lowState.motorState[5].mode = msg.mode; lowState.motorState[5].q = msg.q; lowState.motorState[5].dq = msg.dq; lowState.motorState[5].tauEst = msg.tauEst; } void RRhipCallback(const unitree_legged_msgs::MotorState& msg) { start_up = false; lowState.motorState[6].mode = msg.mode; lowState.motorState[6].q = msg.q; lowState.motorState[6].dq = msg.dq; lowState.motorState[6].tauEst = msg.tauEst; } void RRthighCallback(const unitree_legged_msgs::MotorState& msg) { lowState.motorState[7].mode = msg.mode; lowState.motorState[7].q = msg.q; lowState.motorState[7].dq = msg.dq; lowState.motorState[7].tauEst = msg.tauEst; } void RRcalfCallback(const unitree_legged_msgs::MotorState& msg) { lowState.motorState[8].mode = msg.mode; lowState.motorState[8].q = msg.q; lowState.motorState[8].dq = msg.dq; lowState.motorState[8].tauEst = msg.tauEst; } void RLhipCallback(const unitree_legged_msgs::MotorState& msg) { start_up = false; lowState.motorState[9].mode = msg.mode; lowState.motorState[9].q = msg.q; lowState.motorState[9].dq = msg.dq; lowState.motorState[9].tauEst = msg.tauEst; } void RLthighCallback(const unitree_legged_msgs::MotorState& msg) { lowState.motorState[10].mode = msg.mode; lowState.motorState[10].q = msg.q; lowState.motorState[10].dq = msg.dq; lowState.motorState[10].tauEst = msg.tauEst; } void RLcalfCallback(const unitree_legged_msgs::MotorState& msg) { lowState.motorState[11].mode = msg.mode; lowState.motorState[11].q = msg.q; lowState.motorState[11].dq = msg.dq; lowState.motorState[11].tauEst = msg.tauEst; } void FRfootCallback(const geometry_msgs::WrenchStamped& msg) { lowState.eeForce[0].x = msg.wrench.force.x; lowState.eeForce[0].y = msg.wrench.force.y; lowState.eeForce[0].z = msg.wrench.force.z; lowState.footForce[0] = msg.wrench.force.z; } void FLfootCallback(const geometry_msgs::WrenchStamped& msg) { lowState.eeForce[1].x = msg.wrench.force.x; lowState.eeForce[1].y = msg.wrench.force.y; lowState.eeForce[1].z = msg.wrench.force.z; lowState.footForce[1] = msg.wrench.force.z; } void RRfootCallback(const geometry_msgs::WrenchStamped& msg) { lowState.eeForce[2].x = msg.wrench.force.x; lowState.eeForce[2].y = msg.wrench.force.y; lowState.eeForce[2].z = msg.wrench.force.z; lowState.footForce[2] = msg.wrench.force.z; } void RLfootCallback(const geometry_msgs::WrenchStamped& msg) { lowState.eeForce[3].x = msg.wrench.force.x; lowState.eeForce[3].y = msg.wrench.force.y; lowState.eeForce[3].z = msg.wrench.force.z; lowState.footForce[3] = msg.wrench.force.z; } private: ros::NodeHandle nm; ros::Subscriber servo_sub[12], footForce_sub[4], imu_sub; string robot_name; }; int main(int argc, char **argv) { ros::init(argc, argv, "unitree_gazebo_servo"); string robot_name; ros::param::get("/robot_name", robot_name); cout << "robot_name: " << robot_name << endl; multiThread listen_publish_obj(robot_name); ros::AsyncSpinner spinner(1); // one threads spinner.start(); usleep(300000); // must wait 300ms, to get first state ros::NodeHandle n; ros::Publisher lowState_pub; //for rviz visualization // ros::Rate loop_rate(1000); // the following nodes have been initialized by "gazebo.launch" lowState_pub = n.advertise<unitree_legged_msgs::LowState>("/" + robot_name + "_gazebo/lowState/state", 1); servo_pub[0] = n.advertise<unitree_legged_msgs::MotorCmd>("/" + robot_name + "_gazebo/FR_hip_controller/command", 1); servo_pub[1] = n.advertise<unitree_legged_msgs::MotorCmd>("/" + robot_name + "_gazebo/FR_thigh_controller/command", 1); servo_pub[2] = n.advertise<unitree_legged_msgs::MotorCmd>("/" + robot_name + "_gazebo/FR_calf_controller/command", 1); servo_pub[3] = n.advertise<unitree_legged_msgs::MotorCmd>("/" + robot_name + "_gazebo/FL_hip_controller/command", 1); servo_pub[4] = n.advertise<unitree_legged_msgs::MotorCmd>("/" + robot_name + "_gazebo/FL_thigh_controller/command", 1); servo_pub[5] = n.advertise<unitree_legged_msgs::MotorCmd>("/" + robot_name + "_gazebo/FL_calf_controller/command", 1); servo_pub[6] = n.advertise<unitree_legged_msgs::MotorCmd>("/" + robot_name + "_gazebo/RR_hip_controller/command", 1); servo_pub[7] = n.advertise<unitree_legged_msgs::MotorCmd>("/" + robot_name + "_gazebo/RR_thigh_controller/command", 1); servo_pub[8] = n.advertise<unitree_legged_msgs::MotorCmd>("/" + robot_name + "_gazebo/RR_calf_controller/command", 1); servo_pub[9] = n.advertise<unitree_legged_msgs::MotorCmd>("/" + robot_name + "_gazebo/RL_hip_controller/command", 1); servo_pub[10] = n.advertise<unitree_legged_msgs::MotorCmd>("/" + robot_name + "_gazebo/RL_thigh_controller/command", 1); servo_pub[11] = n.advertise<unitree_legged_msgs::MotorCmd>("/" + robot_name + "_gazebo/RL_calf_controller/command", 1); motion_init(); while (ros::ok()){ /* control logic */ lowState_pub.publish(lowState); sendServoCmd(); } return 0; }

C++

renanmb/Omniverse_legged_robotics/URDF-Descriptions/unitreerobotics/unitree_ros-CHAMP/unitree_controller/include/body.h

/************************************************************************ Copyright (c) 2018-2019, Unitree Robotics.Co.Ltd. All rights reserved. Use of this source code is governed by the MPL-2.0 license, see LICENSE. ************************************************************************/ #ifndef __BODY_H__ #define __BODY_H__ #include "ros/ros.h" #include "unitree_legged_msgs/LowCmd.h" #include "unitree_legged_msgs/LowState.h" #include "unitree_legged_msgs/HighState.h" #define PosStopF (2.146E+9f) #define VelStopF (16000.f) namespace unitree_model { extern ros::Publisher servo_pub[12]; extern ros::Publisher highState_pub; extern unitree_legged_msgs::LowCmd lowCmd; extern unitree_legged_msgs::LowState lowState; void stand(); void motion_init(); void sendServoCmd(); void moveAllPosition(double* jointPositions, double duration); } #endif

C

renanmb/Omniverse_legged_robotics/URDF-Descriptions/unitreerobotics/unitree_ros-CHAMP/unitree_legged_control/unitree_controller_plugins.xml

<library path="lib/libunitree_legged_control"> <class name="unitree_legged_control/UnitreeJointController" type="unitree_legged_control::UnitreeJointController" base_class_type="controller_interface::ControllerBase"/> <description> The unitree joint controller. </description> </library>

XML

renanmb/Omniverse_legged_robotics/URDF-Descriptions/unitreerobotics/unitree_ros-CHAMP/unitree_legged_control/src/joint_controller.cpp

/************************************************************************ Copyright (c) 2018-2019, Unitree Robotics.Co.Ltd. All rights reserved. Use of this source code is governed by the MPL-2.0 license, see LICENSE. ************************************************************************/ // #include "unitree_legged_control/joint_controller.h" #include "joint_controller.h" #include <pluginlib/class_list_macros.h> // #define rqtTune // use rqt or not namespace unitree_legged_control { UnitreeJointController::UnitreeJointController(){ memset(&lastCmd, 0, sizeof(unitree_legged_msgs::MotorCmd)); memset(&lastState, 0, sizeof(unitree_legged_msgs::MotorState)); memset(&servoCmd, 0, sizeof(ServoCmd)); } UnitreeJointController::~UnitreeJointController(){ sub_ft.shutdown(); sub_cmd.shutdown(); } void UnitreeJointController::setTorqueCB(const geometry_msgs::WrenchStampedConstPtr& msg) { if(isHip) sensor_torque = msg->wrench.torque.x; else sensor_torque = msg->wrench.torque.y; // printf("sensor torque%f\n", sensor_torque); } void UnitreeJointController::setCommandCB(const unitree_legged_msgs::MotorCmdConstPtr& msg) { lastCmd.mode = msg->mode; lastCmd.q = msg->q; lastCmd.Kp = msg->Kp; lastCmd.dq = msg->dq; lastCmd.Kd = msg->Kd; lastCmd.tau = msg->tau; // the writeFromNonRT can be used in RT, if you have the guarantee that // * no non-rt thread is calling the same function (we're not subscribing to ros callbacks) // * there is only one single rt thread command.writeFromNonRT(lastCmd); } // Controller initialization in non-realtime bool UnitreeJointController::init(hardware_interface::EffortJointInterface *robot, ros::NodeHandle &n) { isHip = false; isThigh = false; isCalf = false; // rqtTune = false; sensor_torque = 0; name_space = n.getNamespace(); if (!n.getParam("joint", joint_name)){ ROS_ERROR("No joint given in namespace: '%s')", n.getNamespace().c_str()); return false; } // load pid param from ymal only if rqt need // if(rqtTune) { #ifdef rqtTune // Load PID Controller using gains set on parameter server if (!pid_controller_.init(ros::NodeHandle(n, "pid"))) return false; #endif // } urdf::Model urdf; // Get URDF info about joint if (!urdf.initParamWithNodeHandle("robot_description", n)){ ROS_ERROR("Failed to parse urdf file"); return false; } joint_urdf = urdf.getJoint(joint_name); if (!joint_urdf){ ROS_ERROR("Could not find joint '%s' in urdf", joint_name.c_str()); return false; } if(joint_name == "FR_hip_joint" || joint_name == "FL_hip_joint" || joint_name == "RR_hip_joint" || joint_name == "RL_hip_joint"){ isHip = true; } if(joint_name == "FR_calf_joint" || joint_name == "FL_calf_joint" || joint_name == "RR_calf_joint" || joint_name == "RL_calf_joint"){ isCalf = true; } joint = robot->getHandle(joint_name); // Start command subscriber sub_ft = n.subscribe(name_space + "/" +"joint_wrench", 1, &UnitreeJointController::setTorqueCB, this); sub_cmd = n.subscribe("command", 20, &UnitreeJointController::setCommandCB, this); // pub_state = n.advertise<unitree_legged_msgs::MotorState>(name_space + "/state", 20); // Start realtime state publisher controller_state_publisher_.reset( new realtime_tools::RealtimePublisher<unitree_legged_msgs::MotorState>(n, name_space + "/state", 1)); return true; } void UnitreeJointController::setGains(const double &p, const double &i, const double &d, const double &i_max, const double &i_min, const bool &antiwindup) { pid_controller_.setGains(p,i,d,i_max,i_min,antiwindup); } void UnitreeJointController::getGains(double &p, double &i, double &d, double &i_max, double &i_min, bool &antiwindup) { pid_controller_.getGains(p,i,d,i_max,i_min,antiwindup); } void UnitreeJointController::getGains(double &p, double &i, double &d, double &i_max, double &i_min) { bool dummy; pid_controller_.getGains(p,i,d,i_max,i_min,dummy); } // Controller startup in realtime void UnitreeJointController::starting(const ros::Time& time) { // lastCmd.Kp = 0; // lastCmd.Kd = 0; double init_pos = joint.getPosition(); lastCmd.q = init_pos; lastState.q = init_pos; lastCmd.dq = 0; lastState.dq = 0; lastCmd.tau = 0; lastState.tauEst = 0; command.initRT(lastCmd); pid_controller_.reset(); } // Controller update loop in realtime void UnitreeJointController::update(const ros::Time& time, const ros::Duration& period) { double currentPos, currentVel, calcTorque; lastCmd = *(command.readFromRT()); // set command data if(lastCmd.mode == PMSM) { servoCmd.pos = lastCmd.q; positionLimits(servoCmd.pos); servoCmd.posStiffness = lastCmd.Kp; if(fabs(lastCmd.q - PosStopF) < 0.00001){ servoCmd.posStiffness = 0; } servoCmd.vel = lastCmd.dq; velocityLimits(servoCmd.vel); servoCmd.velStiffness = lastCmd.Kd; if(fabs(lastCmd.dq - VelStopF) < 0.00001){ servoCmd.velStiffness = 0; } servoCmd.torque = lastCmd.tau; effortLimits(servoCmd.torque); } if(lastCmd.mode == BRAKE) { servoCmd.posStiffness = 0; servoCmd.vel = 0; servoCmd.velStiffness = 20; servoCmd.torque = 0; effortLimits(servoCmd.torque); } // } else { // servoCmd.posStiffness = 0; // servoCmd.velStiffness = 5; // servoCmd.torque = 0; // } // rqt set P D gains // if(rqtTune) { #ifdef rqtTune double i, i_max, i_min; getGains(servoCmd.posStiffness,i,servoCmd.velStiffness,i_max,i_min); #endif // } currentPos = joint.getPosition(); currentVel = computeVel(currentPos, (double)lastState.q, (double)lastState.dq, period.toSec()); calcTorque = computeTorque(currentPos, currentVel, servoCmd); effortLimits(calcTorque); joint.setCommand(calcTorque); lastState.q = currentPos; lastState.dq = currentVel; // lastState.tauEst = calcTorque; // lastState.tauEst = sensor_torque; lastState.tauEst = joint.getEffort(); // pub_state.publish(lastState); // publish state if (controller_state_publisher_ && controller_state_publisher_->trylock()) { controller_state_publisher_->msg_.q = lastState.q; controller_state_publisher_->msg_.dq = lastState.dq; controller_state_publisher_->msg_.tauEst = lastState.tauEst; controller_state_publisher_->unlockAndPublish(); } // printf("sensor torque%f\n", sensor_torque); // if(joint_name == "wrist1_joint") printf("wrist1 setp:%f getp:%f t:%f\n", servoCmd.pos, currentPos, calcTorque); } // Controller stopping in realtime void UnitreeJointController::stopping(){} void UnitreeJointController::positionLimits(double &position) { if (joint_urdf->type == urdf::Joint::REVOLUTE || joint_urdf->type == urdf::Joint::PRISMATIC) clamp(position, joint_urdf->limits->lower, joint_urdf->limits->upper); } void UnitreeJointController::velocityLimits(double &velocity) { if (joint_urdf->type == urdf::Joint::REVOLUTE || joint_urdf->type == urdf::Joint::PRISMATIC) clamp(velocity, -joint_urdf->limits->velocity, joint_urdf->limits->velocity); } void UnitreeJointController::effortLimits(double &effort) { if (joint_urdf->type == urdf::Joint::REVOLUTE || joint_urdf->type == urdf::Joint::PRISMATIC) clamp(effort, -joint_urdf->limits->effort, joint_urdf->limits->effort); } } // namespace // Register controller to pluginlib PLUGINLIB_EXPORT_CLASS(unitree_legged_control::UnitreeJointController, controller_interface::ControllerBase);

C++

renanmb/Omniverse_legged_robotics/URDF-Descriptions/unitreerobotics/unitree_ros-CHAMP/unitree_legged_control/include/unitree_joint_control_tool.h

/************************************************************************ Copyright (c) 2018-2019, Unitree Robotics.Co.Ltd. All rights reserved. Use of this source code is governed by the MPL-2.0 license, see LICENSE. ************************************************************************/ // #ifndef _UNITREE_JOINT_CONTROL_TOOL_H_ // #define _UNITREE_JOINT_CONTROL_TOOL_H_ #ifndef _LAIKAGO_CONTROL_TOOL_H_ #define _LAIKAGO_CONTROL_TOOL_H_ #include <stdio.h> #include <stdint.h> #include <algorithm> #include <math.h> #define posStopF (2.146E+9f) // stop position control mode #define velStopF (16000.0f) // stop velocity control mode typedef struct { uint8_t mode; double pos; double posStiffness; double vel; double velStiffness; double torque; } ServoCmd; double clamp(double&, double, double); // eg. clamp(1.5, -1, 1) = 1 double computeVel(double current_position, double last_position, double last_velocity, double duration); // get current velocity double computeTorque(double current_position, double current_velocity, ServoCmd&); // get torque #endif

C

renanmb/Omniverse_legged_robotics/URDF-Descriptions/unitreerobotics/unitree_ros-CHAMP/unitree_legged_control/include/joint_controller.h

/************************************************************************ Copyright (c) 2018-2019, Unitree Robotics.Co.Ltd. All rights reserved. Use of this source code is governed by the MPL-2.0 license, see LICENSE. ************************************************************************/ #ifndef _UNITREE_ROS_JOINT_CONTROLLER_H_ #define _UNITREE_ROS_JOINT_CONTROLLER_H_ #include <ros/node_handle.h> #include <urdf/model.h> #include <control_toolbox/pid.h> #include <boost/scoped_ptr.hpp> #include <boost/thread/condition.hpp> #include <realtime_tools/realtime_publisher.h> #include <hardware_interface/joint_command_interface.h> #include <controller_interface/controller.h> #include <std_msgs/Float64.h> #include <realtime_tools/realtime_buffer.h> #include <controller_interface/controller.h> #include <hardware_interface/joint_command_interface.h> #include "unitree_legged_msgs/MotorCmd.h" #include "unitree_legged_msgs/MotorState.h" #include <geometry_msgs/WrenchStamped.h> #include "unitree_joint_control_tool.h" #define PMSM (0x0A) #define BRAKE (0x00) #define PosStopF (2.146E+9f) #define VelStopF (16000.0f) namespace unitree_legged_control { class UnitreeJointController: public controller_interface::Controller<hardware_interface::EffortJointInterface> { private: hardware_interface::JointHandle joint; ros::Subscriber sub_cmd, sub_ft; // ros::Publisher pub_state; control_toolbox::Pid pid_controller_; boost::scoped_ptr<realtime_tools::RealtimePublisher<unitree_legged_msgs::MotorState> > controller_state_publisher_ ; public: // bool start_up; std::string name_space; std::string joint_name; float sensor_torque; bool isHip, isThigh, isCalf, rqtTune; urdf::JointConstSharedPtr joint_urdf; realtime_tools::RealtimeBuffer<unitree_legged_msgs::MotorCmd> command; unitree_legged_msgs::MotorCmd lastCmd; unitree_legged_msgs::MotorState lastState; ServoCmd servoCmd; UnitreeJointController(); ~UnitreeJointController(); virtual bool init(hardware_interface::EffortJointInterface *robot, ros::NodeHandle &n); virtual void starting(const ros::Time& time); virtual void update(const ros::Time& time, const ros::Duration& period); virtual void stopping(); void setTorqueCB(const geometry_msgs::WrenchStampedConstPtr& msg); void setCommandCB(const unitree_legged_msgs::MotorCmdConstPtr& msg); void positionLimits(double &position); void velocityLimits(double &velocity); void effortLimits(double &effort); void setGains(const double &p, const double &i, const double &d, const double &i_max, const double &i_min, const bool &antiwindup = false); void getGains(double &p, double &i, double &d, double &i_max, double &i_min, bool &antiwindup); void getGains(double &p, double &i, double &d, double &i_max, double &i_min); }; } #endif

C

renanmb/Omniverse_legged_robotics/URDF-Descriptions/openDogV2/opendog_description-CHAMP/README.md

URDF and Gazebo model of [Jame's Bruton's](https://www.youtube.com/user/jamesbruton) [OpenDog V2](https://github.com/XRobots/openDogV2) project.

Markdown

renanmb/Omniverse_legged_robotics/URDF-Descriptions/openDogV2/openDogV2-original/README.md

# openDogV2: CAD and Code that relates to this YouTube series: https://www.youtube.com/playlist?list=PLpwJoq86vov9CcmrLGyM2XyyYDAYG0-Iu Release 1: created at the end of part 6 of the YouTube series. Please note the issues stated at the end of this video. Release 2: created at the end of part 7 of the YouTube series. Please note the issues stated during this video. Note that the remote is unchanged since release 1. Relase 3: created for part 8 of the YouTube series. Includes the modified knee motor pulley, Python and Arduino code for the deep learning model. # Related Community Projects: OpenDog URDF/config for CHAMP: https://github.com/chvmp/opendog_description 'openDog 2.1' with higher belt reductions and cooling fans: https://github.com/J-DIndustries/openDog-V2.1

Markdown

renanmb/Omniverse_legged_robotics/URDF-Descriptions/openDogV2/openDogV2-original/Release02/Code/openDogV2_R2/MPU6050_6Axis_MotionApps20.h

// I2Cdev library collection - MPU6050 I2C device class, 6-axis MotionApps 2.0 implementation // Based on InvenSense MPU-6050 register map document rev. 2.0, 5/19/2011 (RM-MPU-6000A-00) // 5/20/2013 by Jeff Rowberg <jeff@rowberg.net> // Updates should (hopefully) always be available at https://github.com/jrowberg/i2cdevlib // // Changelog: // ... - ongoing debug release /* ============================================ I2Cdev device library code is placed under the MIT license Copyright (c) 2012 Jeff Rowberg Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. =============================================== */ #ifndef _MPU6050_6AXIS_MOTIONAPPS20_H_ #define _MPU6050_6AXIS_MOTIONAPPS20_H_ #include "I2Cdev.h" #include "helper_3dmath.h" // MotionApps 2.0 DMP implementation, built using the MPU-6050EVB evaluation board #define MPU6050_INCLUDE_DMP_MOTIONAPPS20 #include "MPU6050.h" // Tom Carpenter's conditional PROGMEM code // http://forum.arduino.cc/index.php?topic=129407.0 #ifndef __arm__ #include <avr/pgmspace.h> #else // Teensy 3.0 library conditional PROGMEM code from Paul Stoffregen #ifndef __PGMSPACE_H_ #define __PGMSPACE_H_ 1 #include <inttypes.h> #define PROGMEM #define PGM_P const char * #define PSTR(str) (str) #define F(x) x typedef void prog_void; typedef char prog_char; typedef unsigned char prog_uchar; typedef int8_t prog_int8_t; typedef uint8_t prog_uint8_t; typedef int16_t prog_int16_t; typedef uint16_t prog_uint16_t; typedef int32_t prog_int32_t; typedef uint32_t prog_uint32_t; #define strcpy_P(dest, src) strcpy((dest), (src)) #define strcat_P(dest, src) strcat((dest), (src)) #define strcmp_P(a, b) strcmp((a), (b)) #define pgm_read_byte(addr) (*(const unsigned char *)(addr)) #define pgm_read_word(addr) (*(const unsigned short *)(addr)) #define pgm_read_dword(addr) (*(const unsigned long *)(addr)) #define pgm_read_float(addr) (*(const float *)(addr)) #define pgm_read_byte_near(addr) pgm_read_byte(addr) #define pgm_read_word_near(addr) pgm_read_word(addr) #define pgm_read_dword_near(addr) pgm_read_dword(addr) #define pgm_read_float_near(addr) pgm_read_float(addr) #define pgm_read_byte_far(addr) pgm_read_byte(addr) #define pgm_read_word_far(addr) pgm_read_word(addr) #define pgm_read_dword_far(addr) pgm_read_dword(addr) #define pgm_read_float_far(addr) pgm_read_float(addr) #endif #endif /* Source is from the InvenSense MotionApps v2 demo code. Original source is * unavailable, unless you happen to be amazing as decompiling binary by * hand (in which case, please contact me, and I'm totally serious). * * Also, I'd like to offer many, many thanks to Noah Zerkin for all of the * DMP reverse-engineering he did to help make this bit of wizardry * possible. */ // NOTE! Enabling DEBUG adds about 3.3kB to the flash program size. // Debug output is now working even on ATMega328P MCUs (e.g. Arduino Uno) // after moving string constants to flash memory storage using the F() // compiler macro (Arduino IDE 1.0+ required). //#define DEBUG #ifdef DEBUG #define DEBUG_PRINT(x) Serial.print(x) #define DEBUG_PRINTF(x, y) Serial.print(x, y) #define DEBUG_PRINTLN(x) Serial.println(x) #define DEBUG_PRINTLNF(x, y) Serial.println(x, y) #else #define DEBUG_PRINT(x) #define DEBUG_PRINTF(x, y) #define DEBUG_PRINTLN(x) #define DEBUG_PRINTLNF(x, y) #endif #define MPU6050_DMP_CODE_SIZE 1929 // dmpMemory[] #define MPU6050_DMP_CONFIG_SIZE 192 // dmpConfig[] #define MPU6050_DMP_UPDATES_SIZE 47 // dmpUpdates[] /* ================================================================================================ * | Default MotionApps v2.0 42-byte FIFO packet structure: | | | | [QUAT W][ ][QUAT X][ ][QUAT Y][ ][QUAT Z][ ][GYRO X][ ][GYRO Y][ ] | | 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 | | | | [GYRO Z][ ][ACC X ][ ][ACC Y ][ ][ACC Z ][ ][ ] | | 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 | * ================================================================================================ */ // this block of memory gets written to the MPU on start-up, and it seems // to be volatile memory, so it has to be done each time (it only takes ~1 // second though) const unsigned char dmpMemory[MPU6050_DMP_CODE_SIZE] PROGMEM = { // bank 0, 256 bytes 0xFB, 0x00, 0x00, 0x3E, 0x00, 0x0B, 0x00, 0x36, 0x00, 0x01, 0x00, 0x02, 0x00, 0x03, 0x00, 0x00, 0x00, 0x65, 0x00, 0x54, 0xFF, 0xEF, 0x00, 0x00, 0xFA, 0x80, 0x00, 0x0B, 0x12, 0x82, 0x00, 0x01, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x28, 0x00, 0x00, 0xFF, 0xFF, 0x45, 0x81, 0xFF, 0xFF, 0xFA, 0x72, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0xE8, 0x00, 0x00, 0x00, 0x01, 0x00, 0x01, 0x7F, 0xFF, 0xFF, 0xFE, 0x80, 0x01, 0x00, 0x1B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3E, 0x03, 0x30, 0x40, 0x00, 0x00, 0x00, 0x02, 0xCA, 0xE3, 0x09, 0x3E, 0x80, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x41, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x0B, 0x2A, 0x00, 0x00, 0x16, 0x55, 0x00, 0x00, 0x21, 0x82, 0xFD, 0x87, 0x26, 0x50, 0xFD, 0x80, 0x00, 0x00, 0x00, 0x1F, 0x00, 0x00, 0x00, 0x05, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x6F, 0x00, 0x02, 0x65, 0x32, 0x00, 0x00, 0x5E, 0xC0, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFB, 0x8C, 0x6F, 0x5D, 0xFD, 0x5D, 0x08, 0xD9, 0x00, 0x7C, 0x73, 0x3B, 0x00, 0x6C, 0x12, 0xCC, 0x32, 0x00, 0x13, 0x9D, 0x32, 0x00, 0xD0, 0xD6, 0x32, 0x00, 0x08, 0x00, 0x40, 0x00, 0x01, 0xF4, 0xFF, 0xE6, 0x80, 0x79, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0xD0, 0xD6, 0x00, 0x00, 0x27, 0x10, // bank 1, 256 bytes 0xFB, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFA, 0x36, 0xFF, 0xBC, 0x30, 0x8E, 0x00, 0x05, 0xFB, 0xF0, 0xFF, 0xD9, 0x5B, 0xC8, 0xFF, 0xD0, 0x9A, 0xBE, 0x00, 0x00, 0x10, 0xA9, 0xFF, 0xF4, 0x1E, 0xB2, 0x00, 0xCE, 0xBB, 0xF7, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x04, 0x00, 0x02, 0x00, 0x02, 0x02, 0x00, 0x00, 0x0C, 0xFF, 0xC2, 0x80, 0x00, 0x00, 0x01, 0x80, 0x00, 0x00, 0xCF, 0x80, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x3F, 0x68, 0xB6, 0x79, 0x35, 0x28, 0xBC, 0xC6, 0x7E, 0xD1, 0x6C, 0x80, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0xB2, 0x6A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3F, 0xF0, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x25, 0x4D, 0x00, 0x2F, 0x70, 0x6D, 0x00, 0x00, 0x05, 0xAE, 0x00, 0x0C, 0x02, 0xD0, // bank 2, 256 bytes 0x00, 0x00, 0x00, 0x00, 0x00, 0x65, 0x00, 0x54, 0xFF, 0xEF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x44, 0x00, 0x00, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x65, 0x00, 0x00, 0x00, 0x54, 0x00, 0x00, 0xFF, 0xEF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x1B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // bank 3, 256 bytes 0xD8, 0xDC, 0xBA, 0xA2, 0xF1, 0xDE, 0xB2, 0xB8, 0xB4, 0xA8, 0x81, 0x91, 0xF7, 0x4A, 0x90, 0x7F, 0x91, 0x6A, 0xF3, 0xF9, 0xDB, 0xA8, 0xF9, 0xB0, 0xBA, 0xA0, 0x80, 0xF2, 0xCE, 0x81, 0xF3, 0xC2, 0xF1, 0xC1, 0xF2, 0xC3, 0xF3, 0xCC, 0xA2, 0xB2, 0x80, 0xF1, 0xC6, 0xD8, 0x80, 0xBA, 0xA7, 0xDF, 0xDF, 0xDF, 0xF2, 0xA7, 0xC3, 0xCB, 0xC5, 0xB6, 0xF0, 0x87, 0xA2, 0x94, 0x24, 0x48, 0x70, 0x3C, 0x95, 0x40, 0x68, 0x34, 0x58, 0x9B, 0x78, 0xA2, 0xF1, 0x83, 0x92, 0x2D, 0x55, 0x7D, 0xD8, 0xB1, 0xB4, 0xB8, 0xA1, 0xD0, 0x91, 0x80, 0xF2, 0x70, 0xF3, 0x70, 0xF2, 0x7C, 0x80, 0xA8, 0xF1, 0x01, 0xB0, 0x98, 0x87, 0xD9, 0x43, 0xD8, 0x86, 0xC9, 0x88, 0xBA, 0xA1, 0xF2, 0x0E, 0xB8, 0x97, 0x80, 0xF1, 0xA9, 0xDF, 0xDF, 0xDF, 0xAA, 0xDF, 0xDF, 0xDF, 0xF2, 0xAA, 0xC5, 0xCD, 0xC7, 0xA9, 0x0C, 0xC9, 0x2C, 0x97, 0x97, 0x97, 0x97, 0xF1, 0xA9, 0x89, 0x26, 0x46, 0x66, 0xB0, 0xB4, 0xBA, 0x80, 0xAC, 0xDE, 0xF2, 0xCA, 0xF1, 0xB2, 0x8C, 0x02, 0xA9, 0xB6, 0x98, 0x00, 0x89, 0x0E, 0x16, 0x1E, 0xB8, 0xA9, 0xB4, 0x99, 0x2C, 0x54, 0x7C, 0xB0, 0x8A, 0xA8, 0x96, 0x36, 0x56, 0x76, 0xF1, 0xB9, 0xAF, 0xB4, 0xB0, 0x83, 0xC0, 0xB8, 0xA8, 0x97, 0x11, 0xB1, 0x8F, 0x98, 0xB9, 0xAF, 0xF0, 0x24, 0x08, 0x44, 0x10, 0x64, 0x18, 0xF1, 0xA3, 0x29, 0x55, 0x7D, 0xAF, 0x83, 0xB5, 0x93, 0xAF, 0xF0, 0x00, 0x28, 0x50, 0xF1, 0xA3, 0x86, 0x9F, 0x61, 0xA6, 0xDA, 0xDE, 0xDF, 0xD9, 0xFA, 0xA3, 0x86, 0x96, 0xDB, 0x31, 0xA6, 0xD9, 0xF8, 0xDF, 0xBA, 0xA6, 0x8F, 0xC2, 0xC5, 0xC7, 0xB2, 0x8C, 0xC1, 0xB8, 0xA2, 0xDF, 0xDF, 0xDF, 0xA3, 0xDF, 0xDF, 0xDF, 0xD8, 0xD8, 0xF1, 0xB8, 0xA8, 0xB2, 0x86, // bank 4, 256 bytes 0xB4, 0x98, 0x0D, 0x35, 0x5D, 0xB8, 0xAA, 0x98, 0xB0, 0x87, 0x2D, 0x35, 0x3D, 0xB2, 0xB6, 0xBA, 0xAF, 0x8C, 0x96, 0x19, 0x8F, 0x9F, 0xA7, 0x0E, 0x16, 0x1E, 0xB4, 0x9A, 0xB8, 0xAA, 0x87, 0x2C, 0x54, 0x7C, 0xB9, 0xA3, 0xDE, 0xDF, 0xDF, 0xA3, 0xB1, 0x80, 0xF2, 0xC4, 0xCD, 0xC9, 0xF1, 0xB8, 0xA9, 0xB4, 0x99, 0x83, 0x0D, 0x35, 0x5D, 0x89, 0xB9, 0xA3, 0x2D, 0x55, 0x7D, 0xB5, 0x93, 0xA3, 0x0E, 0x16, 0x1E, 0xA9, 0x2C, 0x54, 0x7C, 0xB8, 0xB4, 0xB0, 0xF1, 0x97, 0x83, 0xA8, 0x11, 0x84, 0xA5, 0x09, 0x98, 0xA3, 0x83, 0xF0, 0xDA, 0x24, 0x08, 0x44, 0x10, 0x64, 0x18, 0xD8, 0xF1, 0xA5, 0x29, 0x55, 0x7D, 0xA5, 0x85, 0x95, 0x02, 0x1A, 0x2E, 0x3A, 0x56, 0x5A, 0x40, 0x48, 0xF9, 0xF3, 0xA3, 0xD9, 0xF8, 0xF0, 0x98, 0x83, 0x24, 0x08, 0x44, 0x10, 0x64, 0x18, 0x97, 0x82, 0xA8, 0xF1, 0x11, 0xF0, 0x98, 0xA2, 0x24, 0x08, 0x44, 0x10, 0x64, 0x18, 0xDA, 0xF3, 0xDE, 0xD8, 0x83, 0xA5, 0x94, 0x01, 0xD9, 0xA3, 0x02, 0xF1, 0xA2, 0xC3, 0xC5, 0xC7, 0xD8, 0xF1, 0x84, 0x92, 0xA2, 0x4D, 0xDA, 0x2A, 0xD8, 0x48, 0x69, 0xD9, 0x2A, 0xD8, 0x68, 0x55, 0xDA, 0x32, 0xD8, 0x50, 0x71, 0xD9, 0x32, 0xD8, 0x70, 0x5D, 0xDA, 0x3A, 0xD8, 0x58, 0x79, 0xD9, 0x3A, 0xD8, 0x78, 0x93, 0xA3, 0x4D, 0xDA, 0x2A, 0xD8, 0x48, 0x69, 0xD9, 0x2A, 0xD8, 0x68, 0x55, 0xDA, 0x32, 0xD8, 0x50, 0x71, 0xD9, 0x32, 0xD8, 0x70, 0x5D, 0xDA, 0x3A, 0xD8, 0x58, 0x79, 0xD9, 0x3A, 0xD8, 0x78, 0xA8, 0x8A, 0x9A, 0xF0, 0x28, 0x50, 0x78, 0x9E, 0xF3, 0x88, 0x18, 0xF1, 0x9F, 0x1D, 0x98, 0xA8, 0xD9, 0x08, 0xD8, 0xC8, 0x9F, 0x12, 0x9E, 0xF3, 0x15, 0xA8, 0xDA, 0x12, 0x10, 0xD8, 0xF1, 0xAF, 0xC8, 0x97, 0x87, // bank 5, 256 bytes 0x34, 0xB5, 0xB9, 0x94, 0xA4, 0x21, 0xF3, 0xD9, 0x22, 0xD8, 0xF2, 0x2D, 0xF3, 0xD9, 0x2A, 0xD8, 0xF2, 0x35, 0xF3, 0xD9, 0x32, 0xD8, 0x81, 0xA4, 0x60, 0x60, 0x61, 0xD9, 0x61, 0xD8, 0x6C, 0x68, 0x69, 0xD9, 0x69, 0xD8, 0x74, 0x70, 0x71, 0xD9, 0x71, 0xD8, 0xB1, 0xA3, 0x84, 0x19, 0x3D, 0x5D, 0xA3, 0x83, 0x1A, 0x3E, 0x5E, 0x93, 0x10, 0x30, 0x81, 0x10, 0x11, 0xB8, 0xB0, 0xAF, 0x8F, 0x94, 0xF2, 0xDA, 0x3E, 0xD8, 0xB4, 0x9A, 0xA8, 0x87, 0x29, 0xDA, 0xF8, 0xD8, 0x87, 0x9A, 0x35, 0xDA, 0xF8, 0xD8, 0x87, 0x9A, 0x3D, 0xDA, 0xF8, 0xD8, 0xB1, 0xB9, 0xA4, 0x98, 0x85, 0x02, 0x2E, 0x56, 0xA5, 0x81, 0x00, 0x0C, 0x14, 0xA3, 0x97, 0xB0, 0x8A, 0xF1, 0x2D, 0xD9, 0x28, 0xD8, 0x4D, 0xD9, 0x48, 0xD8, 0x6D, 0xD9, 0x68, 0xD8, 0xB1, 0x84, 0x0D, 0xDA, 0x0E, 0xD8, 0xA3, 0x29, 0x83, 0xDA, 0x2C, 0x0E, 0xD8, 0xA3, 0x84, 0x49, 0x83, 0xDA, 0x2C, 0x4C, 0x0E, 0xD8, 0xB8, 0xB0, 0xA8, 0x8A, 0x9A, 0xF5, 0x20, 0xAA, 0xDA, 0xDF, 0xD8, 0xA8, 0x40, 0xAA, 0xD0, 0xDA, 0xDE, 0xD8, 0xA8, 0x60, 0xAA, 0xDA, 0xD0, 0xDF, 0xD8, 0xF1, 0x97, 0x86, 0xA8, 0x31, 0x9B, 0x06, 0x99, 0x07, 0xAB, 0x97, 0x28, 0x88, 0x9B, 0xF0, 0x0C, 0x20, 0x14, 0x40, 0xB8, 0xB0, 0xB4, 0xA8, 0x8C, 0x9C, 0xF0, 0x04, 0x28, 0x51, 0x79, 0x1D, 0x30, 0x14, 0x38, 0xB2, 0x82, 0xAB, 0xD0, 0x98, 0x2C, 0x50, 0x50, 0x78, 0x78, 0x9B, 0xF1, 0x1A, 0xB0, 0xF0, 0x8A, 0x9C, 0xA8, 0x29, 0x51, 0x79, 0x8B, 0x29, 0x51, 0x79, 0x8A, 0x24, 0x70, 0x59, 0x8B, 0x20, 0x58, 0x71, 0x8A, 0x44, 0x69, 0x38, 0x8B, 0x39, 0x40, 0x68, 0x8A, 0x64, 0x48, 0x31, 0x8B, 0x30, 0x49, 0x60, 0xA5, 0x88, 0x20, 0x09, 0x71, 0x58, 0x44, 0x68, // bank 6, 256 bytes 0x11, 0x39, 0x64, 0x49, 0x30, 0x19, 0xF1, 0xAC, 0x00, 0x2C, 0x54, 0x7C, 0xF0, 0x8C, 0xA8, 0x04, 0x28, 0x50, 0x78, 0xF1, 0x88, 0x97, 0x26, 0xA8, 0x59, 0x98, 0xAC, 0x8C, 0x02, 0x26, 0x46, 0x66, 0xF0, 0x89, 0x9C, 0xA8, 0x29, 0x51, 0x79, 0x24, 0x70, 0x59, 0x44, 0x69, 0x38, 0x64, 0x48, 0x31, 0xA9, 0x88, 0x09, 0x20, 0x59, 0x70, 0xAB, 0x11, 0x38, 0x40, 0x69, 0xA8, 0x19, 0x31, 0x48, 0x60, 0x8C, 0xA8, 0x3C, 0x41, 0x5C, 0x20, 0x7C, 0x00, 0xF1, 0x87, 0x98, 0x19, 0x86, 0xA8, 0x6E, 0x76, 0x7E, 0xA9, 0x99, 0x88, 0x2D, 0x55, 0x7D, 0x9E, 0xB9, 0xA3, 0x8A, 0x22, 0x8A, 0x6E, 0x8A, 0x56, 0x8A, 0x5E, 0x9F, 0xB1, 0x83, 0x06, 0x26, 0x46, 0x66, 0x0E, 0x2E, 0x4E, 0x6E, 0x9D, 0xB8, 0xAD, 0x00, 0x2C, 0x54, 0x7C, 0xF2, 0xB1, 0x8C, 0xB4, 0x99, 0xB9, 0xA3, 0x2D, 0x55, 0x7D, 0x81, 0x91, 0xAC, 0x38, 0xAD, 0x3A, 0xB5, 0x83, 0x91, 0xAC, 0x2D, 0xD9, 0x28, 0xD8, 0x4D, 0xD9, 0x48, 0xD8, 0x6D, 0xD9, 0x68, 0xD8, 0x8C, 0x9D, 0xAE, 0x29, 0xD9, 0x04, 0xAE, 0xD8, 0x51, 0xD9, 0x04, 0xAE, 0xD8, 0x79, 0xD9, 0x04, 0xD8, 0x81, 0xF3, 0x9D, 0xAD, 0x00, 0x8D, 0xAE, 0x19, 0x81, 0xAD, 0xD9, 0x01, 0xD8, 0xF2, 0xAE, 0xDA, 0x26, 0xD8, 0x8E, 0x91, 0x29, 0x83, 0xA7, 0xD9, 0xAD, 0xAD, 0xAD, 0xAD, 0xF3, 0x2A, 0xD8, 0xD8, 0xF1, 0xB0, 0xAC, 0x89, 0x91, 0x3E, 0x5E, 0x76, 0xF3, 0xAC, 0x2E, 0x2E, 0xF1, 0xB1, 0x8C, 0x5A, 0x9C, 0xAC, 0x2C, 0x28, 0x28, 0x28, 0x9C, 0xAC, 0x30, 0x18, 0xA8, 0x98, 0x81, 0x28, 0x34, 0x3C, 0x97, 0x24, 0xA7, 0x28, 0x34, 0x3C, 0x9C, 0x24, 0xF2, 0xB0, 0x89, 0xAC, 0x91, 0x2C, 0x4C, 0x6C, 0x8A, 0x9B, 0x2D, 0xD9, 0xD8, 0xD8, 0x51, 0xD9, 0xD8, 0xD8, 0x79, // bank 7, 138 bytes (remainder) 0xD9, 0xD8, 0xD8, 0xF1, 0x9E, 0x88, 0xA3, 0x31, 0xDA, 0xD8, 0xD8, 0x91, 0x2D, 0xD9, 0x28, 0xD8, 0x4D, 0xD9, 0x48, 0xD8, 0x6D, 0xD9, 0x68, 0xD8, 0xB1, 0x83, 0x93, 0x35, 0x3D, 0x80, 0x25, 0xDA, 0xD8, 0xD8, 0x85, 0x69, 0xDA, 0xD8, 0xD8, 0xB4, 0x93, 0x81, 0xA3, 0x28, 0x34, 0x3C, 0xF3, 0xAB, 0x8B, 0xF8, 0xA3, 0x91, 0xB6, 0x09, 0xB4, 0xD9, 0xAB, 0xDE, 0xFA, 0xB0, 0x87, 0x9C, 0xB9, 0xA3, 0xDD, 0xF1, 0xA3, 0xA3, 0xA3, 0xA3, 0x95, 0xF1, 0xA3, 0xA3, 0xA3, 0x9D, 0xF1, 0xA3, 0xA3, 0xA3, 0xA3, 0xF2, 0xA3, 0xB4, 0x90, 0x80, 0xF2, 0xA3, 0xA3, 0xA3, 0xA3, 0xA3, 0xA3, 0xA3, 0xA3, 0xA3, 0xA3, 0xB2, 0xA3, 0xA3, 0xA3, 0xA3, 0xA3, 0xA3, 0xB0, 0x87, 0xB5, 0x99, 0xF1, 0xA3, 0xA3, 0xA3, 0x98, 0xF1, 0xA3, 0xA3, 0xA3, 0xA3, 0x97, 0xA3, 0xA3, 0xA3, 0xA3, 0xF3, 0x9B, 0xA3, 0xA3, 0xDC, 0xB9, 0xA7, 0xF1, 0x26, 0x26, 0x26, 0xD8, 0xD8, 0xFF }; // thanks to Noah Zerkin for piecing this stuff together! const unsigned char dmpConfig[MPU6050_DMP_CONFIG_SIZE] PROGMEM = { // BANK OFFSET LENGTH [DATA] 0x03, 0x7B, 0x03, 0x4C, 0xCD, 0x6C, // FCFG_1 inv_set_gyro_calibration 0x03, 0xAB, 0x03, 0x36, 0x56, 0x76, // FCFG_3 inv_set_gyro_calibration 0x00, 0x68, 0x04, 0x02, 0xCB, 0x47, 0xA2, // D_0_104 inv_set_gyro_calibration 0x02, 0x18, 0x04, 0x00, 0x05, 0x8B, 0xC1, // D_0_24 inv_set_gyro_calibration 0x01, 0x0C, 0x04, 0x00, 0x00, 0x00, 0x00, // D_1_152 inv_set_accel_calibration 0x03, 0x7F, 0x06, 0x0C, 0xC9, 0x2C, 0x97, 0x97, 0x97, // FCFG_2 inv_set_accel_calibration 0x03, 0x89, 0x03, 0x26, 0x46, 0x66, // FCFG_7 inv_set_accel_calibration 0x00, 0x6C, 0x02, 0x20, 0x00, // D_0_108 inv_set_accel_calibration 0x02, 0x40, 0x04, 0x00, 0x00, 0x00, 0x00, // CPASS_MTX_00 inv_set_compass_calibration 0x02, 0x44, 0x04, 0x00, 0x00, 0x00, 0x00, // CPASS_MTX_01 0x02, 0x48, 0x04, 0x00, 0x00, 0x00, 0x00, // CPASS_MTX_02 0x02, 0x4C, 0x04, 0x00, 0x00, 0x00, 0x00, // CPASS_MTX_10 0x02, 0x50, 0x04, 0x00, 0x00, 0x00, 0x00, // CPASS_MTX_11 0x02, 0x54, 0x04, 0x00, 0x00, 0x00, 0x00, // CPASS_MTX_12 0x02, 0x58, 0x04, 0x00, 0x00, 0x00, 0x00, // CPASS_MTX_20 0x02, 0x5C, 0x04, 0x00, 0x00, 0x00, 0x00, // CPASS_MTX_21 0x02, 0xBC, 0x04, 0x00, 0x00, 0x00, 0x00, // CPASS_MTX_22 0x01, 0xEC, 0x04, 0x00, 0x00, 0x40, 0x00, // D_1_236 inv_apply_endian_accel 0x03, 0x7F, 0x06, 0x0C, 0xC9, 0x2C, 0x97, 0x97, 0x97, // FCFG_2 inv_set_mpu_sensors 0x04, 0x02, 0x03, 0x0D, 0x35, 0x5D, // CFG_MOTION_BIAS inv_turn_on_bias_from_no_motion 0x04, 0x09, 0x04, 0x87, 0x2D, 0x35, 0x3D, // FCFG_5 inv_set_bias_update 0x00, 0xA3, 0x01, 0x00, // D_0_163 inv_set_dead_zone // SPECIAL 0x01 = enable interrupts 0x00, 0x00, 0x00, 0x01, // SET INT_ENABLE at i=22, SPECIAL INSTRUCTION 0x07, 0x86, 0x01, 0xFE, // CFG_6 inv_set_fifo_interupt 0x07, 0x41, 0x05, 0xF1, 0x20, 0x28, 0x30, 0x38, // CFG_8 inv_send_quaternion 0x07, 0x7E, 0x01, 0x30, // CFG_16 inv_set_footer 0x07, 0x46, 0x01, 0x9A, // CFG_GYRO_SOURCE inv_send_gyro 0x07, 0x47, 0x04, 0xF1, 0x28, 0x30, 0x38, // CFG_9 inv_send_gyro -> inv_construct3_fifo 0x07, 0x6C, 0x04, 0xF1, 0x28, 0x30, 0x38, // CFG_12 inv_send_accel -> inv_construct3_fifo 0x02, 0x16, 0x02, 0x00, 0x09 // D_0_22 inv_set_fifo_rate // This very last 0x01 WAS a 0x09, which drops the FIFO rate down to 20 Hz. 0x07 is 25 Hz, // 0x01 is 100Hz. Going faster than 100Hz (0x00=200Hz) tends to result in very noisy data. // DMP output frequency is calculated easily using this equation: (200Hz / (1 + value)) // It is important to make sure the host processor can keep up with reading and processing // the FIFO output at the desired rate. Handling FIFO overflow cleanly is also a good idea. }; const unsigned char dmpUpdates[MPU6050_DMP_UPDATES_SIZE] PROGMEM = { 0x01, 0xB2, 0x02, 0xFF, 0xFF, 0x01, 0x90, 0x04, 0x09, 0x23, 0xA1, 0x35, 0x01, 0x6A, 0x02, 0x06, 0x00, 0x01, 0x60, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x60, 0x04, 0x40, 0x00, 0x00, 0x00, 0x01, 0x62, 0x02, 0x00, 0x00, 0x00, 0x60, 0x04, 0x00, 0x40, 0x00, 0x00 }; uint8_t MPU6050::dmpInitialize() { // reset device DEBUG_PRINTLN(F("\n\nResetting MPU6050...")); reset(); delay(30); // wait after reset // enable sleep mode and wake cycle /*Serial.println(F("Enabling sleep mode...")); setSleepEnabled(true); Serial.println(F("Enabling wake cycle...")); setWakeCycleEnabled(true);*/ // disable sleep mode DEBUG_PRINTLN(F("Disabling sleep mode...")); setSleepEnabled(false); // get MPU hardware revision DEBUG_PRINTLN(F("Selecting user bank 16...")); setMemoryBank(0x10, true, true); DEBUG_PRINTLN(F("Selecting memory byte 6...")); setMemoryStartAddress(0x06); DEBUG_PRINTLN(F("Checking hardware revision...")); uint8_t hwRevision = readMemoryByte(); DEBUG_PRINT(F("Revision @ user[16][6] = ")); DEBUG_PRINTLNF(hwRevision, HEX); DEBUG_PRINTLN(F("Resetting memory bank selection to 0...")); setMemoryBank(0, false, false); // check OTP bank valid DEBUG_PRINTLN(F("Reading OTP bank valid flag...")); uint8_t otpValid = getOTPBankValid(); DEBUG_PRINT(F("OTP bank is ")); DEBUG_PRINTLN(otpValid ? F("valid!") : F("invalid!")); // get X/Y/Z gyro offsets DEBUG_PRINTLN(F("Reading gyro offset TC values...")); int8_t xgOffsetTC = getXGyroOffsetTC(); int8_t ygOffsetTC = getYGyroOffsetTC(); int8_t zgOffsetTC = getZGyroOffsetTC(); DEBUG_PRINT(F("X gyro offset = ")); DEBUG_PRINTLN(xgOffset); DEBUG_PRINT(F("Y gyro offset = ")); DEBUG_PRINTLN(ygOffset); DEBUG_PRINT(F("Z gyro offset = ")); DEBUG_PRINTLN(zgOffset); // setup weird slave stuff (?) DEBUG_PRINTLN(F("Setting slave 0 address to 0x7F...")); setSlaveAddress(0, 0x7F); DEBUG_PRINTLN(F("Disabling I2C Master mode...")); setI2CMasterModeEnabled(false); DEBUG_PRINTLN(F("Setting slave 0 address to 0x68 (self)...")); setSlaveAddress(0, 0x68); DEBUG_PRINTLN(F("Resetting I2C Master control...")); resetI2CMaster(); delay(20); // load DMP code into memory banks DEBUG_PRINT(F("Writing DMP code to MPU memory banks (")); DEBUG_PRINT(MPU6050_DMP_CODE_SIZE); DEBUG_PRINTLN(F(" bytes)")); if (writeProgMemoryBlock(dmpMemory, MPU6050_DMP_CODE_SIZE)) { DEBUG_PRINTLN(F("Success! DMP code written and verified.")); // write DMP configuration DEBUG_PRINT(F("Writing DMP configuration to MPU memory banks (")); DEBUG_PRINT(MPU6050_DMP_CONFIG_SIZE); DEBUG_PRINTLN(F(" bytes in config def)")); if (writeProgDMPConfigurationSet(dmpConfig, MPU6050_DMP_CONFIG_SIZE)) { DEBUG_PRINTLN(F("Success! DMP configuration written and verified.")); DEBUG_PRINTLN(F("Setting clock source to Z Gyro...")); setClockSource(MPU6050_CLOCK_PLL_ZGYRO); DEBUG_PRINTLN(F("Setting DMP and FIFO_OFLOW interrupts enabled...")); setIntEnabled(0x12); DEBUG_PRINTLN(F("Setting sample rate to 200Hz...")); setRate(4); // 1khz / (1 + 4) = 200 Hz DEBUG_PRINTLN(F("Setting external frame sync to TEMP_OUT_L[0]...")); setExternalFrameSync(MPU6050_EXT_SYNC_TEMP_OUT_L); DEBUG_PRINTLN(F("Setting DLPF bandwidth to 42Hz...")); setDLPFMode(MPU6050_DLPF_BW_42); DEBUG_PRINTLN(F("Setting gyro sensitivity to +/- 2000 deg/sec...")); setFullScaleGyroRange(MPU6050_GYRO_FS_2000); DEBUG_PRINTLN(F("Setting DMP configuration bytes (function unknown)...")); setDMPConfig1(0x03); setDMPConfig2(0x00); DEBUG_PRINTLN(F("Clearing OTP Bank flag...")); setOTPBankValid(false); DEBUG_PRINTLN(F("Setting X/Y/Z gyro offset TCs to previous values...")); setXGyroOffsetTC(xgOffsetTC); setYGyroOffsetTC(ygOffsetTC); setZGyroOffsetTC(zgOffsetTC); //DEBUG_PRINTLN(F("Setting X/Y/Z gyro user offsets to zero...")); //setXGyroOffset(0); //setYGyroOffset(0); //setZGyroOffset(0); DEBUG_PRINTLN(F("Writing final memory update 1/7 (function unknown)...")); uint8_t dmpUpdate[16], j; uint16_t pos = 0; for (j = 0; j < 4 || j < dmpUpdate[2] + 3; j++, pos++) dmpUpdate[j] = pgm_read_byte(&dmpUpdates[pos]); writeMemoryBlock(dmpUpdate + 3, dmpUpdate[2], dmpUpdate[0], dmpUpdate[1]); DEBUG_PRINTLN(F("Writing final memory update 2/7 (function unknown)...")); for (j = 0; j < 4 || j < dmpUpdate[2] + 3; j++, pos++) dmpUpdate[j] = pgm_read_byte(&dmpUpdates[pos]); writeMemoryBlock(dmpUpdate + 3, dmpUpdate[2], dmpUpdate[0], dmpUpdate[1]); DEBUG_PRINTLN(F("Resetting FIFO...")); resetFIFO(); DEBUG_PRINTLN(F("Reading FIFO count...")); uint16_t fifoCount = getFIFOCount(); uint8_t fifoBuffer[128]; DEBUG_PRINT(F("Current FIFO count=")); DEBUG_PRINTLN(fifoCount); getFIFOBytes(fifoBuffer, fifoCount); DEBUG_PRINTLN(F("Setting motion detection threshold to 2...")); setMotionDetectionThreshold(2); DEBUG_PRINTLN(F("Setting zero-motion detection threshold to 156...")); setZeroMotionDetectionThreshold(156); DEBUG_PRINTLN(F("Setting motion detection duration to 80...")); setMotionDetectionDuration(80); DEBUG_PRINTLN(F("Setting zero-motion detection duration to 0...")); setZeroMotionDetectionDuration(0); DEBUG_PRINTLN(F("Resetting FIFO...")); resetFIFO(); DEBUG_PRINTLN(F("Enabling FIFO...")); setFIFOEnabled(true); DEBUG_PRINTLN(F("Enabling DMP...")); setDMPEnabled(true); DEBUG_PRINTLN(F("Resetting DMP...")); resetDMP(); DEBUG_PRINTLN(F("Writing final memory update 3/7 (function unknown)...")); for (j = 0; j < 4 || j < dmpUpdate[2] + 3; j++, pos++) dmpUpdate[j] = pgm_read_byte(&dmpUpdates[pos]); writeMemoryBlock(dmpUpdate + 3, dmpUpdate[2], dmpUpdate[0], dmpUpdate[1]); DEBUG_PRINTLN(F("Writing final memory update 4/7 (function unknown)...")); for (j = 0; j < 4 || j < dmpUpdate[2] + 3; j++, pos++) dmpUpdate[j] = pgm_read_byte(&dmpUpdates[pos]); writeMemoryBlock(dmpUpdate + 3, dmpUpdate[2], dmpUpdate[0], dmpUpdate[1]); DEBUG_PRINTLN(F("Writing final memory update 5/7 (function unknown)...")); for (j = 0; j < 4 || j < dmpUpdate[2] + 3; j++, pos++) dmpUpdate[j] = pgm_read_byte(&dmpUpdates[pos]); writeMemoryBlock(dmpUpdate + 3, dmpUpdate[2], dmpUpdate[0], dmpUpdate[1]); DEBUG_PRINTLN(F("Waiting for FIFO count > 2...")); while ((fifoCount = getFIFOCount()) < 3); DEBUG_PRINT(F("Current FIFO count=")); DEBUG_PRINTLN(fifoCount); DEBUG_PRINTLN(F("Reading FIFO data...")); getFIFOBytes(fifoBuffer, fifoCount); DEBUG_PRINTLN(F("Reading interrupt status...")); uint8_t mpuIntStatus = getIntStatus(); DEBUG_PRINT(F("Current interrupt status=")); DEBUG_PRINTLNF(mpuIntStatus, HEX); DEBUG_PRINTLN(F("Reading final memory update 6/7 (function unknown)...")); for (j = 0; j < 4 || j < dmpUpdate[2] + 3; j++, pos++) dmpUpdate[j] = pgm_read_byte(&dmpUpdates[pos]); readMemoryBlock(dmpUpdate + 3, dmpUpdate[2], dmpUpdate[0], dmpUpdate[1]); DEBUG_PRINTLN(F("Waiting for FIFO count > 2...")); while ((fifoCount = getFIFOCount()) < 3); DEBUG_PRINT(F("Current FIFO count=")); DEBUG_PRINTLN(fifoCount); DEBUG_PRINTLN(F("Reading FIFO data...")); getFIFOBytes(fifoBuffer, fifoCount); DEBUG_PRINTLN(F("Reading interrupt status...")); mpuIntStatus = getIntStatus(); DEBUG_PRINT(F("Current interrupt status=")); DEBUG_PRINTLNF(mpuIntStatus, HEX); DEBUG_PRINTLN(F("Writing final memory update 7/7 (function unknown)...")); for (j = 0; j < 4 || j < dmpUpdate[2] + 3; j++, pos++) dmpUpdate[j] = pgm_read_byte(&dmpUpdates[pos]); writeMemoryBlock(dmpUpdate + 3, dmpUpdate[2], dmpUpdate[0], dmpUpdate[1]); DEBUG_PRINTLN(F("DMP is good to go! Finally.")); DEBUG_PRINTLN(F("Disabling DMP (you turn it on later)...")); setDMPEnabled(false); DEBUG_PRINTLN(F("Setting up internal 42-byte (default) DMP packet buffer...")); dmpPacketSize = 42; /*if ((dmpPacketBuffer = (uint8_t *)malloc(42)) == 0) { return 3; // TODO: proper error code for no memory }*/ DEBUG_PRINTLN(F("Resetting FIFO and clearing INT status one last time...")); resetFIFO(); getIntStatus(); } else { DEBUG_PRINTLN(F("ERROR! DMP configuration verification failed.")); return 2; // configuration block loading failed } } else { DEBUG_PRINTLN(F("ERROR! DMP code verification failed.")); return 1; // main binary block loading failed } return 0; // success } bool MPU6050::dmpPacketAvailable() { return getFIFOCount() >= dmpGetFIFOPacketSize(); } // uint8_t MPU6050::dmpSetFIFORate(uint8_t fifoRate); // uint8_t MPU6050::dmpGetFIFORate(); // uint8_t MPU6050::dmpGetSampleStepSizeMS(); // uint8_t MPU6050::dmpGetSampleFrequency(); // int32_t MPU6050::dmpDecodeTemperature(int8_t tempReg); //uint8_t MPU6050::dmpRegisterFIFORateProcess(inv_obj_func func, int16_t priority); //uint8_t MPU6050::dmpUnregisterFIFORateProcess(inv_obj_func func); //uint8_t MPU6050::dmpRunFIFORateProcesses(); // uint8_t MPU6050::dmpSendQuaternion(uint_fast16_t accuracy); // uint8_t MPU6050::dmpSendGyro(uint_fast16_t elements, uint_fast16_t accuracy); // uint8_t MPU6050::dmpSendAccel(uint_fast16_t elements, uint_fast16_t accuracy); // uint8_t MPU6050::dmpSendLinearAccel(uint_fast16_t elements, uint_fast16_t accuracy); // uint8_t MPU6050::dmpSendLinearAccelInWorld(uint_fast16_t elements, uint_fast16_t accuracy); // uint8_t MPU6050::dmpSendControlData(uint_fast16_t elements, uint_fast16_t accuracy); // uint8_t MPU6050::dmpSendSensorData(uint_fast16_t elements, uint_fast16_t accuracy); // uint8_t MPU6050::dmpSendExternalSensorData(uint_fast16_t elements, uint_fast16_t accuracy); // uint8_t MPU6050::dmpSendGravity(uint_fast16_t elements, uint_fast16_t accuracy); // uint8_t MPU6050::dmpSendPacketNumber(uint_fast16_t accuracy); // uint8_t MPU6050::dmpSendQuantizedAccel(uint_fast16_t elements, uint_fast16_t accuracy); // uint8_t MPU6050::dmpSendEIS(uint_fast16_t elements, uint_fast16_t accuracy); uint8_t MPU6050::dmpGetAccel(int32_t *data, const uint8_t* packet) { // TODO: accommodate different arrangements of sent data (ONLY default supported now) if (packet == 0) packet = dmpPacketBuffer; data[0] = ((packet[28] << 24) + (packet[29] << 16) + (packet[30] << 8) + packet[31]); data[1] = ((packet[32] << 24) + (packet[33] << 16) + (packet[34] << 8) + packet[35]); data[2] = ((packet[36] << 24) + (packet[37] << 16) + (packet[38] << 8) + packet[39]); return 0; } uint8_t MPU6050::dmpGetAccel(int16_t *data, const uint8_t* packet) { // TODO: accommodate different arrangements of sent data (ONLY default supported now) if (packet == 0) packet = dmpPacketBuffer; data[0] = (packet[28] << 8) + packet[29]; data[1] = (packet[32] << 8) + packet[33]; data[2] = (packet[36] << 8) + packet[37]; return 0; } uint8_t MPU6050::dmpGetAccel(VectorInt16 *v, const uint8_t* packet) { // TODO: accommodate different arrangements of sent data (ONLY default supported now) if (packet == 0) packet = dmpPacketBuffer; v -> x = (packet[28] << 8) + packet[29]; v -> y = (packet[32] << 8) + packet[33]; v -> z = (packet[36] << 8) + packet[37]; return 0; } uint8_t MPU6050::dmpGetQuaternion(int32_t *data, const uint8_t* packet) { // TODO: accommodate different arrangements of sent data (ONLY default supported now) if (packet == 0) packet = dmpPacketBuffer; data[0] = ((packet[0] << 24) + (packet[1] << 16) + (packet[2] << 8) + packet[3]); data[1] = ((packet[4] << 24) + (packet[5] << 16) + (packet[6] << 8) + packet[7]); data[2] = ((packet[8] << 24) + (packet[9] << 16) + (packet[10] << 8) + packet[11]); data[3] = ((packet[12] << 24) + (packet[13] << 16) + (packet[14] << 8) + packet[15]); return 0; } uint8_t MPU6050::dmpGetQuaternion(int16_t *data, const uint8_t* packet) { // TODO: accommodate different arrangements of sent data (ONLY default supported now) if (packet == 0) packet = dmpPacketBuffer; data[0] = ((packet[0] << 8) + packet[1]); data[1] = ((packet[4] << 8) + packet[5]); data[2] = ((packet[8] << 8) + packet[9]); data[3] = ((packet[12] << 8) + packet[13]); return 0; } uint8_t MPU6050::dmpGetQuaternion(Quaternion *q, const uint8_t* packet) { // TODO: accommodate different arrangements of sent data (ONLY default supported now) int16_t qI[4]; uint8_t status = dmpGetQuaternion(qI, packet); if (status == 0) { q -> w = (float)qI[0] / 16384.0f; q -> x = (float)qI[1] / 16384.0f; q -> y = (float)qI[2] / 16384.0f; q -> z = (float)qI[3] / 16384.0f; return 0; } return status; // int16 return value, indicates error if this line is reached } // uint8_t MPU6050::dmpGet6AxisQuaternion(long *data, const uint8_t* packet); // uint8_t MPU6050::dmpGetRelativeQuaternion(long *data, const uint8_t* packet); uint8_t MPU6050::dmpGetGyro(int32_t *data, const uint8_t* packet) { // TODO: accommodate different arrangements of sent data (ONLY default supported now) if (packet == 0) packet = dmpPacketBuffer; data[0] = ((packet[16] << 24) + (packet[17] << 16) + (packet[18] << 8) + packet[19]); data[1] = ((packet[20] << 24) + (packet[21] << 16) + (packet[22] << 8) + packet[23]); data[2] = ((packet[24] << 24) + (packet[25] << 16) + (packet[26] << 8) + packet[27]); return 0; } uint8_t MPU6050::dmpGetGyro(int16_t *data, const uint8_t* packet) { // TODO: accommodate different arrangements of sent data (ONLY default supported now) if (packet == 0) packet = dmpPacketBuffer; data[0] = (packet[16] << 8) + packet[17]; data[1] = (packet[20] << 8) + packet[21]; data[2] = (packet[24] << 8) + packet[25]; return 0; } uint8_t MPU6050::dmpGetGyro(VectorInt16 *v, const uint8_t* packet) { // TODO: accommodate different arrangements of sent data (ONLY default supported now) if (packet == 0) packet = dmpPacketBuffer; v -> x = (packet[16] << 8) + packet[17]; v -> y = (packet[20] << 8) + packet[21]; v -> z = (packet[24] << 8) + packet[25]; return 0; } // uint8_t MPU6050::dmpSetLinearAccelFilterCoefficient(float coef); // uint8_t MPU6050::dmpGetLinearAccel(long *data, const uint8_t* packet); uint8_t MPU6050::dmpGetLinearAccel(VectorInt16 *v, VectorInt16 *vRaw, VectorFloat *gravity) { // get rid of the gravity component (+1g = +8192 in standard DMP FIFO packet, sensitivity is 2g) v -> x = vRaw -> x - gravity -> x*8192; v -> y = vRaw -> y - gravity -> y*8192; v -> z = vRaw -> z - gravity -> z*8192; return 0; } // uint8_t MPU6050::dmpGetLinearAccelInWorld(long *data, const uint8_t* packet); uint8_t MPU6050::dmpGetLinearAccelInWorld(VectorInt16 *v, VectorInt16 *vReal, Quaternion *q) { // rotate measured 3D acceleration vector into original state // frame of reference based on orientation quaternion memcpy(v, vReal, sizeof(VectorInt16)); v -> rotate(q); return 0; } // uint8_t MPU6050::dmpGetGyroAndAccelSensor(long *data, const uint8_t* packet); // uint8_t MPU6050::dmpGetGyroSensor(long *data, const uint8_t* packet); // uint8_t MPU6050::dmpGetControlData(long *data, const uint8_t* packet); // uint8_t MPU6050::dmpGetTemperature(long *data, const uint8_t* packet); // uint8_t MPU6050::dmpGetGravity(long *data, const uint8_t* packet); uint8_t MPU6050::dmpGetGravity(VectorFloat *v, Quaternion *q) { v -> x = 2 * (q -> x*q -> z - q -> w*q -> y); v -> y = 2 * (q -> w*q -> x + q -> y*q -> z); v -> z = q -> w*q -> w - q -> x*q -> x - q -> y*q -> y + q -> z*q -> z; return 0; } // uint8_t MPU6050::dmpGetUnquantizedAccel(long *data, const uint8_t* packet); // uint8_t MPU6050::dmpGetQuantizedAccel(long *data, const uint8_t* packet); // uint8_t MPU6050::dmpGetExternalSensorData(long *data, int size, const uint8_t* packet); // uint8_t MPU6050::dmpGetEIS(long *data, const uint8_t* packet); uint8_t MPU6050::dmpGetEuler(float *data, Quaternion *q) { data[0] = atan2(2*q -> x*q -> y - 2*q -> w*q -> z, 2*q -> w*q -> w + 2*q -> x*q -> x - 1); // psi data[1] = -asin(2*q -> x*q -> z + 2*q -> w*q -> y); // theta data[2] = atan2(2*q -> y*q -> z - 2*q -> w*q -> x, 2*q -> w*q -> w + 2*q -> z*q -> z - 1); // phi return 0; } uint8_t MPU6050::dmpGetYawPitchRoll(float *data, Quaternion *q, VectorFloat *gravity) { // yaw: (about Z axis) data[0] = atan2(2*q -> x*q -> y - 2*q -> w*q -> z, 2*q -> w*q -> w + 2*q -> x*q -> x - 1); // pitch: (nose up/down, about Y axis) data[1] = atan(gravity -> x / sqrt(gravity -> y*gravity -> y + gravity -> z*gravity -> z)); // roll: (tilt left/right, about X axis) data[2] = atan(gravity -> y / sqrt(gravity -> x*gravity -> x + gravity -> z*gravity -> z)); return 0; } // uint8_t MPU6050::dmpGetAccelFloat(float *data, const uint8_t* packet); // uint8_t MPU6050::dmpGetQuaternionFloat(float *data, const uint8_t* packet); uint8_t MPU6050::dmpProcessFIFOPacket(const unsigned char *dmpData) { /*for (uint8_t k = 0; k < dmpPacketSize; k++) { if (dmpData[k] < 0x10) Serial.print("0"); Serial.print(dmpData[k], HEX); Serial.print(" "); } Serial.print("\n");*/ //Serial.println((uint16_t)dmpPacketBuffer); return 0; } uint8_t MPU6050::dmpReadAndProcessFIFOPacket(uint8_t numPackets, uint8_t *processed) { uint8_t status; uint8_t buf[dmpPacketSize]; for (uint8_t i = 0; i < numPackets; i++) { // read packet from FIFO getFIFOBytes(buf, dmpPacketSize); // process packet if ((status = dmpProcessFIFOPacket(buf)) > 0) return status; // increment external process count variable, if supplied if (processed != 0) *processed++; } return 0; } // uint8_t MPU6050::dmpSetFIFOProcessedCallback(void (*func) (void)); // uint8_t MPU6050::dmpInitFIFOParam(); // uint8_t MPU6050::dmpCloseFIFO(); // uint8_t MPU6050::dmpSetGyroDataSource(uint_fast8_t source); // uint8_t MPU6050::dmpDecodeQuantizedAccel(); // uint32_t MPU6050::dmpGetGyroSumOfSquare(); // uint32_t MPU6050::dmpGetAccelSumOfSquare(); // void MPU6050::dmpOverrideQuaternion(long *q); uint16_t MPU6050::dmpGetFIFOPacketSize() { return dmpPacketSize; } #endif /* _MPU6050_6AXIS_MOTIONAPPS20_H_ */

C

renanmb/Omniverse_legged_robotics/URDF-Descriptions/openDogV2/openDogV2-original/Release03/code/Python/camera100.py

import RPi.GPIO as GPIO import jetson.inference import jetson.utils import time import argparse import sys # parse the command line parser = argparse.ArgumentParser(description="Locate objects in a live camera stream using an object detection DNN.", formatter_class=argparse.RawTextHelpFormatter, epilog=jetson.inference.detectNet.Usage() + jetson.utils.videoSource.Usage() + jetson.utils.videoOutput.Usage() + jetson.utils.logUsage()) parser.add_argument("input_URI", type=str, default="", nargs='?', help="URI of the input stream") parser.add_argument("output_URI", type=str, default="", nargs='?', help="URI of the output stream") parser.add_argument("--network", type=str, default="ssd-mobilenet-v2", help="pre-trained model to load (see below for options)") parser.add_argument("--overlay", type=str, default="box,labels,conf", help="detection overlay flags (e.g. --overlay=box,labels,conf)\nvalid combinations are: 'box', 'labels', 'conf', 'none'") parser.add_argument("--threshold", type=float, default=0.5, help="minimum detection threshold to use") is_headless = ["--headless"] if sys.argv[0].find('console.py') != -1 else [""] try: opt = parser.parse_known_args()[0] except: print("") parser.print_help() sys.exit(0) # load the object detection network net = jetson.inference.detectNet(opt.network, sys.argv, opt.threshold) # create video sources & outputs input = jetson.utils.videoSource(opt.input_URI, argv=sys.argv) output = jetson.utils.videoOutput(opt.output_URI, argv=sys.argv+is_headless) #setup GPIO pins GPIO.setmode(GPIO.BCM) #RaspPi pin numbering GPIO.setup(18, GPIO.OUT, initial=GPIO.HIGH) GPIO.output(18, GPIO.HIGH) GPIO.setup(17, GPIO.OUT, initial=GPIO.HIGH) GPIO.output(17, GPIO.HIGH) GPIO.setup(16, GPIO.OUT, initial=GPIO.HIGH) GPIO.output(16, GPIO.HIGH) GPIO.setup(20, GPIO.OUT, initial=GPIO.HIGH) GPIO.output(20, GPIO.HIGH) GPIO.setup(21, GPIO.OUT, initial=GPIO.HIGH) GPIO.output(21, GPIO.HIGH) def back(): GPIO.output(18, GPIO.LOW) GPIO.output(17, GPIO.HIGH) GPIO.output(16, GPIO.HIGH) GPIO.output(20, GPIO.HIGH) GPIO.output(21, GPIO.HIGH) print("back") def forward(): GPIO.output(18, GPIO.HIGH) GPIO.output(17, GPIO.LOW) GPIO.output(16, GPIO.HIGH) GPIO.output(20, GPIO.HIGH) GPIO.output(21, GPIO.HIGH) print("forward") def left(): GPIO.output(18, GPIO.HIGH) GPIO.output(17, GPIO.HIGH) GPIO.output(16, GPIO.LOW) GPIO.output(20, GPIO.HIGH) GPIO.output(21, GPIO.HIGH) print("left") def right(): GPIO.output(18, GPIO.HIGH) GPIO.output(17, GPIO.HIGH) GPIO.output(16, GPIO.HIGH) GPIO.output(20, GPIO.LOW) GPIO.output(21, GPIO.HIGH) print("right") def up(): GPIO.output(18, GPIO.HIGH) GPIO.output(17, GPIO.HIGH) GPIO.output(16, GPIO.HIGH) GPIO.output(20, GPIO.HIGH) GPIO.output(21, GPIO.LOW) print("up") def nothing(): GPIO.output(18, GPIO.HIGH) GPIO.output(17, GPIO.HIGH) GPIO.output(16, GPIO.HIGH) GPIO.output(20, GPIO.HIGH) GPIO.output(21, GPIO.HIGH) print("nothing") # declare variables as global and that global index global width global location global confidence index = 0 width = 0 location = 0 condifence = 0; # process frames until the user exits while True: # capture the next image img = input.Capture() # detect objects in the image (with overlay) detections = net.Detect(img, overlay=opt.overlay) # print the detections #print("detected {:d} objects in image".format(len(detections))) # check for detections, otherwise nothing if(len(detections) > 0): print("object detected") for detection in detections: index = detections[0].ClassID confidence = (detections[0].Confidence) width = (detections[0].Width) location = (detections[0].Center[0]) # print index of item, width and horizonal location print(index) print(width) print(location) print(confidence) # look for detections if (index == 1 and confidence > 0.9): back() elif (index == 2 and confidence > 0.7): forward() elif (index == 3 and confidence > 0.7): left() elif (index == 4 and confidence > 0.7): right() elif (index == 5 and confidence > 0.7): up() else: nothing() # nothing is detected # render the image output.Render(img) # update the title bar output.SetStatus("{:s} | Network {:.0f} FPS".format(opt.network, net.GetNetworkFPS())) # print out performance info #net.PrintProfilerTimes() # exit on input/output EOS if not input.IsStreaming() or not output.IsStreaming(): break

Python

renanmb/Omniverse_legged_robotics/URDF-Descriptions/cassie_description-UMich-BipedLab/README.md

# cassie_description This repository contains the .urdf model of the CASSIE robot from Agility Robotics. It also includes a a way to visualize the robot using ROS and rviz. Installation to view .urdf using rviz ===================================== - Download and install ROS by following the instructions at http://wiki.ros.org/indigo/Installation/Ubuntu. - Create a folder for the catkin workspace ``` mkdir ~/catkin_ws cd ~/catkin_ws mkdir src cd src catkin_init_workspace ``` - Clone the repository to get the cassie_description package ``` git clone https://github.com/UMich-BipedLab/cassie_description.git ``` - Build the package ``` cd ../ catkin_make source devel/setup.bash ``` - Launch rviz to visualize the .urdf file ``` roslaunch cassie_description display.launch ```

Markdown

renanmb/Omniverse_legged_robotics/URDF-Descriptions/cassie_description-UMich-BipedLab/config/dependent_joints.yaml

dependent_joints: knee_to_shin_left: {parent: knee_joint_left, factor: -1 } ankle_joint_left: {parent: knee_joint_left, factor: 0 } knee_to_shin_right: {parent: knee_joint_right, factor: 0 } ankle_joint_right: {parent: knee_joint_right, factor: -1 } zeros: knee_to_shin_left: 0 ankle_joint_left: 0.226893 knee_to_shin_right: 0 ankle_joint_right: 0.226893

YAML

renanmb/Omniverse_legged_robotics/URDF-Descriptions/Mini_pupper/StanfordQuadruped-pupper/calibrate_servos.py

from pupper.HardwareInterface import HardwareInterface from pupper.Config import PWMParams, ServoParams import numpy as np import re def get_motor_name(i, j): motor_type = {0: "abduction", 1: "inner", 2: "outer"} # Top # Bottom leg_pos = {0: "front-right", 1: "front-left", 2: "back-right", 3: "back-left"} final_name = motor_type[i] + " " + leg_pos[j] return final_name def get_motor_setpoint(i, j): data = np.array([[0, 0, 0, 0], [45, 45, 45, 45], [45, 45, 45, 45]]) return data[i, j] def degrees_to_radians(input_array): """Converts degrees to radians. Parameters ---------- input_array : Numpy array or float Degrees Returns ------- Numpy array or float Radians """ return input_array * np.pi / 180.0 def radians_to_degrees(input_array): """Converts degrees to radians. Parameters ---------- input_array : Numpy array or float Radians Returns ------- Numpy array or float Degrees """ return input_array * 180.0 / np.pi def step_until(hardware_interface, axis, leg, set_point): """Returns the angle offset needed to correct a given link by asking the user for input. Returns ------- Float Angle offset needed to correct the link. """ found_position = False set_names = ["horizontal", "horizontal", "vertical"] offset = 0 while not found_position: move_input = str( input("Enter 'a' or 'b' to move the link until it is **" + set_names[axis] + "**. Enter 'd' when done. Input: " ) ) if move_input == "a": offset += 1.0 hardware_interface.set_actuator_position( degrees_to_radians(set_point + offset), axis, leg, ) elif move_input == "b": offset -= 1.0 hardware_interface.set_actuator_position( degrees_to_radians(set_point + offset), axis, leg, ) elif move_input == "d": found_position = True print("Offset: ", offset) return offset def calibrate_angle_offset(hardware_interface): """Calibrate the angle offset for the twelve motors on the robot. Note that servo_params is modified in-place. Parameters ---------- servo_params : ServoParams Servo parameters. This variable is updated in-place. pi_board : Pi RaspberryPi object. pwm_params : PWMParams PWMParams object. """ # Found K value of (11.4) print("The scaling constant for your servo represents how much you have to increase\nthe pwm pulse width (in microseconds) to rotate the servo output 1 degree.") print("This value is currently set to: {:.3f}".format(degrees_to_radians(hardware_interface.servo_params.micros_per_rad))) print("For newer CLS6336 and CLS6327 servos the value should be 11.333.") ks = input("Press <Enter> to keep the current value, or enter a new value: ") if ks != '': k = float(ks) hardware_interface.servo_params.micros_per_rad = k * 180 / np.pi hardware_interface.servo_params.neutral_angle_degrees = np.zeros((3, 4)) for leg_index in range(4): for axis in range(3): # Loop until we're satisfied with the calibration completed = False while not completed: motor_name = get_motor_name(axis, leg_index) print("\n\nCalibrating the **" + motor_name + " motor **") set_point = get_motor_setpoint(axis, leg_index) # Zero out the neutral angle hardware_interface.servo_params.neutral_angle_degrees[axis, leg_index] = 0 # Move servo to set_point angle hardware_interface.set_actuator_position( degrees_to_radians(set_point), axis, leg_index, ) # Adjust the angle using keyboard input until it matches the reference angle offset = step_until( hardware_interface, axis, leg_index, set_point ) print("Final offset: ", offset) # The upper leg link has a different equation because we're calibrating to make it horizontal, not vertical if axis == 1: hardware_interface.servo_params.neutral_angle_degrees[axis, leg_index] = set_point - offset else: hardware_interface.servo_params.neutral_angle_degrees[axis, leg_index] = -(set_point + offset) print("Calibrated neutral angle: ", hardware_interface.servo_params.neutral_angle_degrees[axis, leg_index]) # Send the servo command using the new beta value and check that it's ok hardware_interface.set_actuator_position( degrees_to_radians([0, 45, -45][axis]), axis, leg_index, ) okay = "" prompt = "The leg should be at exactly **" + ["horizontal", "45 degrees", "45 degrees"][axis] + "**. Are you satisfied? Enter 'yes' or 'no': " while okay not in ["y", "n", "yes", "no"]: okay = str( input(prompt) ) completed = okay == "y" or okay == "yes" def overwrite_ServoCalibration_file(servo_params): preamble = """# WARNING: This file is machine generated. Edit at your own risk. import numpy as np """ # Format array object string for np.array p1 = re.compile("([0-9]\.) ( *)") # pattern to replace the space that follows each number with a comma partially_formatted_matrix = p1.sub(r"\1,\2", str(servo_params.neutral_angle_degrees)) p2 = re.compile("(\]\n)") # pattern to add a comma at the end of the first two lines formatted_matrix_with_required_commas = p2.sub("],\n", partially_formatted_matrix) # Overwrite pupper/ServoCalibration.py file with modified values with open("pupper/ServoCalibration.py", "w") as f: print(preamble, file = f) print("MICROS_PER_RAD = {:.3f} * 180.0 / np.pi".format(degrees_to_radians(servo_params.micros_per_rad)), file = f) print("NEUTRAL_ANGLE_DEGREES = np.array(", file = f) print(formatted_matrix_with_required_commas, file = f) print(")", file = f) def main(): """Main program """ hardware_interface = HardwareInterface() calibrate_angle_offset(hardware_interface) overwrite_ServoCalibration_file(hardware_interface.servo_params) print("\n\n CALIBRATION COMPLETE!\n") print("Calibrated neutral angles:") print(hardware_interface.servo_params.neutral_angle_degrees) main()

Python

renanmb/Omniverse_legged_robotics/URDF-Descriptions/Mini_pupper/StanfordQuadruped-pupper/run_robot.py

import numpy as np import time from src.IMU import IMU from src.Controller import Controller from src.JoystickInterface import JoystickInterface from src.State import State from pupper.HardwareInterface import HardwareInterface from pupper.Config import Configuration from pupper.Kinematics import four_legs_inverse_kinematics def main(use_imu=False): """Main program """ # Create config config = Configuration() hardware_interface = HardwareInterface() # Create imu handle if use_imu: imu = IMU(port="/dev/ttyACM0") imu.flush_buffer() # Create controller and user input handles controller = Controller( config, four_legs_inverse_kinematics, ) state = State() print("Creating joystick listener...") joystick_interface = JoystickInterface(config) print("Done.") last_loop = time.time() print("Summary of gait parameters:") print("overlap time: ", config.overlap_time) print("swing time: ", config.swing_time) print("z clearance: ", config.z_clearance) print("x shift: ", config.x_shift) # Wait until the activate button has been pressed while True: print("Waiting for L1 to activate robot.") while True: command = joystick_interface.get_command(state) joystick_interface.set_color(config.ps4_deactivated_color) if command.activate_event == 1: break time.sleep(0.1) print("Robot activated.") joystick_interface.set_color(config.ps4_color) while True: now = time.time() if now - last_loop < config.dt: continue last_loop = time.time() # Parse the udp joystick commands and then update the robot controller's parameters command = joystick_interface.get_command(state) if command.activate_event == 1: print("Deactivating Robot") break # Read imu data. Orientation will be None if no data was available quat_orientation = ( imu.read_orientation() if use_imu else np.array([1, 0, 0, 0]) ) state.quat_orientation = quat_orientation # Step the controller forward by dt controller.run(state, command) # Update the pwm widths going to the servos hardware_interface.set_actuator_postions(state.joint_angles) main()

Python

renanmb/Omniverse_legged_robotics/URDF-Descriptions/Mini_pupper/StanfordQuadruped-pupper/src/Gaits.py

class GaitController: def __init__(self, config): self.config = config def phase_index(self, ticks): """Calculates which part of the gait cycle the robot should be in given the time in ticks. Parameters ---------- ticks : int Number of timesteps since the program started gaitparams : GaitParams GaitParams object Returns ------- Int The index of the gait phase that the robot should be in. """ phase_time = ticks % self.config.phase_length phase_sum = 0 for i in range(self.config.num_phases): phase_sum += self.config.phase_ticks[i] if phase_time < phase_sum: return i assert False def subphase_ticks(self, ticks): """Calculates the number of ticks (timesteps) since the start of the current phase. Parameters ---------- ticks : Int Number of timesteps since the program started gaitparams : GaitParams GaitParams object Returns ------- Int Number of ticks since the start of the current phase. """ phase_time = ticks % self.config.phase_length phase_sum = 0 subphase_ticks = 0 for i in range(self.config.num_phases): phase_sum += self.config.phase_ticks[i] if phase_time < phase_sum: subphase_ticks = phase_time - phase_sum + self.config.phase_ticks[i] return subphase_ticks assert False def contacts(self, ticks): """Calculates which feet should be in contact at the given number of ticks Parameters ---------- ticks : Int Number of timesteps since the program started. gaitparams : GaitParams GaitParams object Returns ------- numpy array (4,) Numpy vector with 0 indicating flight and 1 indicating stance. """ return self.config.contact_phases[:, self.phase_index(ticks)]

Python

renanmb/Omniverse_legged_robotics/URDF-Descriptions/Mini_pupper/StanfordQuadruped-pupper/src/Command.py

import numpy as np class Command: """Stores movement command """ def __init__(self): self.horizontal_velocity = np.array([0, 0]) self.yaw_rate = 0.0 self.height = -0.16 self.pitch = 0.0 self.roll = 0.0 self.activation = 0 self.hop_event = False self.trot_event = False self.activate_event = False

Python

renanmb/Omniverse_legged_robotics/URDF-Descriptions/Mini_pupper/StanfordQuadruped-pupper/src/SwingLegController.py

import numpy as np from transforms3d.euler import euler2mat class SwingController: def __init__(self, config): self.config = config def raibert_touchdown_location( self, leg_index, command ): delta_p_2d = ( self.config.alpha * self.config.stance_ticks * self.config.dt * command.horizontal_velocity ) delta_p = np.array([delta_p_2d[0], delta_p_2d[1], 0]) theta = ( self.config.beta * self.config.stance_ticks * self.config.dt * command.yaw_rate ) R = euler2mat(0, 0, theta) return R @ self.config.default_stance[:, leg_index] + delta_p def swing_height(self, swing_phase, triangular=True): if triangular: if swing_phase < 0.5: swing_height_ = swing_phase / 0.5 * self.config.z_clearance else: swing_height_ = self.config.z_clearance * (1 - (swing_phase - 0.5) / 0.5) return swing_height_ def next_foot_location( self, swing_prop, leg_index, state, command, ): assert swing_prop >= 0 and swing_prop <= 1 foot_location = state.foot_locations[:, leg_index] swing_height_ = self.swing_height(swing_prop) touchdown_location = self.raibert_touchdown_location(leg_index, command) time_left = self.config.dt * self.config.swing_ticks * (1.0 - swing_prop) v = (touchdown_location - foot_location) / time_left * np.array([1, 1, 0]) delta_foot_location = v * self.config.dt z_vector = np.array([0, 0, swing_height_ + command.height]) return foot_location * np.array([1, 1, 0]) + z_vector + delta_foot_location

Python

renanmb/Omniverse_legged_robotics/URDF-Descriptions/Mini_pupper/StanfordQuadruped-pupper/src/State.py

import numpy as np from enum import Enum class State: def __init__(self): self.horizontal_velocity = np.array([0.0, 0.0]) self.yaw_rate = 0.0 self.height = -0.16 self.pitch = 0.0 self.roll = 0.0 self.activation = 0 self.behavior_state = BehaviorState.REST self.ticks = 0 self.foot_locations = np.zeros((3, 4)) self.joint_angles = np.zeros((3, 4)) self.behavior_state = BehaviorState.REST class BehaviorState(Enum): DEACTIVATED = -1 REST = 0 TROT = 1 HOP = 2 FINISHHOP = 3

Python

renanmb/Omniverse_legged_robotics/URDF-Descriptions/Mini_pupper/StanfordQuadruped-pupper/src/StanceController.py

import numpy as np from transforms3d.euler import euler2mat class StanceController: def __init__(self, config): self.config = config def position_delta(self, leg_index, state, command): """Calculate the difference between the next desired body location and the current body location Parameters ---------- z_measured : float Z coordinate of the feet relative to the body. stance_params : StanceParams Stance parameters object. movement_reference : MovementReference Movement reference object. gait_params : GaitParams Gait parameters object. Returns ------- (Numpy array (3), Numpy array (3, 3)) (Position increment, rotation matrix increment) """ z = state.foot_locations[2, leg_index] v_xy = np.array( [ -command.horizontal_velocity[0], -command.horizontal_velocity[1], 1.0 / self.config.z_time_constant * (state.height - z), ] ) delta_p = v_xy * self.config.dt delta_R = euler2mat(0, 0, -command.yaw_rate * self.config.dt) return (delta_p, delta_R) # TODO: put current foot location into state def next_foot_location(self, leg_index, state, command): foot_location = state.foot_locations[:, leg_index] (delta_p, delta_R) = self.position_delta(leg_index, state, command) incremented_location = delta_R @ foot_location + delta_p return incremented_location

Python

renanmb/Omniverse_legged_robotics/URDF-Descriptions/Mini_pupper/StanfordQuadruped-pupper/src/IMU.py

import serial import numpy as np import time class IMU: def __init__(self, port, baudrate=500000): self.serial_handle = serial.Serial( port=port, baudrate=baudrate, parity=serial.PARITY_NONE, stopbits=serial.STOPBITS_ONE, bytesize=serial.EIGHTBITS, timeout=0, ) self.last_quat = np.array([1, 0, 0, 0]) self.start_time = time.time() def flush_buffer(self): self.serial_handle.reset_input_buffer() def read_orientation(self): """Reads quaternion measurements from the Teensy until none are left. Returns the last read quaternion. Parameters ---------- serial_handle : Serial object Handle to the pyserial Serial object Returns ------- np array (4,) If there was quaternion data to read on the serial port returns the quaternion as a numpy array, otherwise returns the last read quaternion. """ while True: x = self.serial_handle.readline().decode("utf").strip() if x is "" or x is None: return self.last_quat else: parsed = x.split(",") if len(parsed) == 4: self.last_quat = np.array(parsed, dtype=np.float64) else: print("Did not receive 4-vector from imu")

Python

renanmb/Omniverse_legged_robotics/URDF-Descriptions/Mini_pupper/StanfordQuadruped-pupper/src/Tests.py

# using LinearAlgebra # using Profile # using StaticArrays # using Plots # using BenchmarkTools # include("Kinematics.jl") # include("PupperConfig.jl") # include("Gait.jl") # include("StanceController.jl") # include("SwingLegController.jl") # include("Types.jl") # include("Controller.jl") import numpy as np import matplotlib.pyplot as plt from Kinematics import leg_explicit_inverse_kinematics from PupperConfig import * from Gaits import * from StanceController import position_delta, stance_foot_location from SwingLegController import * from Types import MovementReference, GaitParams, StanceParams, SwingParams from Controller import * # function round_(a, dec) # return map(x -> round(x, digits=dec), a) # end # function testInverseKinematicsExplicit!() # println("\n-------------- Testing Inverse Kinematics -----------") # config = PupperConfig() # println("\nTesting Inverse Kinematics") # function testHelper(r, alpha_true, i; do_assert=true) # eps = 1e-6 # @time α = leg_explicitinversekinematics_prismatic(r, i, config) # println("Leg ", i, ": r: ", r, " -> α: ", α) # if do_assert # @assert norm(α - alpha_true) < eps # end # end # c = config.LEG_L/sqrt(2) # offset = config.ABDUCTION_OFFSET # testHelper(SVector(0, offset, -0.125), SVector(0, 0, 0), 2) # testHelper(SVector(c, offset, -c), SVector(0, -pi/4, 0), 2) # testHelper(SVector(-c, offset, -c), SVector(0, pi/4, 0), 2) # testHelper(SVector(0, c, -c), missing, 2, do_assert=false) # testHelper(SVector(-c, -offset, -c), [0, pi/4, 0], 1) # testHelper(SVector(config.LEG_L * sqrt(3)/2, offset, -config.LEG_L / 2), SVector(0, -pi/3, 0), 2) # end def test_inverse_kinematics_linkage(): print("\n-------------- Testing Five-bar Linkage Inverse Kinematics -----------") config = PupperConfig() print("\nTesting Inverse Kinematics") def testHelper(r, alpha_true, i, do_assert=True): eps = 1e-6 alpha = leg_explicit_inverse_kinematics(r, i, config) print("Leg ", i, ": r: ", r, " -> α: ", alpha) if do_assert: assert np.linalg.norm(alpha - alpha_true) < eps c = config.LEG_L / (2 ** 0.5) offset = config.ABDUCTION_OFFSET testHelper(np.array([0, offset, -0.125]), None, 1, do_assert=False) testHelper(np.array([c, offset, -c]), None, 1, do_assert=False) testHelper(np.array([-c, offset, -c]), None, 1, do_assert=False) testHelper(np.array([0, c, -c]), None, 1, do_assert=False) testHelper(np.array([-c, -offset, -c]), None, 0, do_assert=False) testHelper( np.array([config.LEG_L * (3 ** 0.5) / 2, offset, -config.LEG_L / 2]), None, 1, do_assert=False, ) # function testForwardKinematics!() # println("\n-------------- Testing Forward Kinematics -----------") # config = PupperConfig() # println("\nTesting Forward Kinematics") # function testHelper(alpha, r_true, i; do_assert=true) # eps = 1e-6 # r = zeros(3) # println("Vectors") # a = [alpha.data...] # @time legForwardKinematics!(r, a, i, config) # println("SVectors") # @time r = legForwardKinematics(alpha, i, config) # println("Leg ", i, ": α: ", alpha, " -> r: ", r) # if do_assert # @assert norm(r_true - r) < eps # end # end # l = config.LEG_L # offset = config.ABDUCTION_OFFSET # testHelper(SVector{3}([0.0, 0.0, 0.0]), SVector{3}([0, offset, -l]), 2) # testHelper(SVector{3}([0.0, pi/4, 0.0]), missing, 2, do_assert=false) # # testHelper([0.0, 0.0, 0.0], [0, offset, -l], 2) # # testHelper([0.0, pi/4, 0.0], missing, 2, do_assert=false) # end # function testForwardInverseAgreeance() # println("\n-------------- Testing Forward/Inverse Consistency -----------") # config = PupperConfig() # println("\nTest forward/inverse consistency") # eps = 1e-6 # for i in 1:10 # alpha = SVector(rand()-0.5, rand()-0.5, (rand()-0.5)*0.05) # leg = rand(1:4) # @time r = legForwardKinematics(alpha, leg, config) # # @code_warntype legForwardKinematics!(r, alpha, leg, config) # @time alpha_prime = leg_explicitinversekinematics_prismatic(r, leg, config) # # @code_warntype inverseKinematicsExplicit!(alpha_prime, r, leg, config) # println("Leg ", leg, ": α: ", round_(alpha, 3), " -> r_body_foot: ", round_(r, 3), " -> α': ", round_(alpha_prime, 3)) # @assert norm(alpha_prime - alpha) < eps # end # end # function testAllInverseKinematics() # println("\n-------------- Testing Four Leg Inverse Kinematics -----------") # function helper(r_body, alpha_true; do_assert=true) # println("Timing for fourlegs_inversekinematics") # config = PupperConfig() # @time alpha = fourlegs_inversekinematics(SMatrix(r_body), config) # @code_warntype fourlegs_inversekinematics(SMatrix(r_body), config) # println("r: ", r_body, " -> α: ", alpha) # if do_assert # @assert norm(alpha - alpha_true) < 1e-10 # end # end # config = PupperConfig() # f = config.LEG_FB # l = config.LEG_LR # s = -0.125 # o = config.ABDUCTION_OFFSET # r_body = MMatrix{3,4}(zeros(3,4)) # r_body[:,1] = [f, -l-o, s] # r_body[:,2] = [f, l+o, s] # r_body[:,3] = [-f, -l-o, s] # r_body[:,4] = [-f, l+o, s] # helper(r_body, zeros(3,4)) # helper(SMatrix{3,4}(zeros(3,4)), missing, do_assert=false) # end # function testKinematics() # testInverseKinematicsExplicit!() # testForwardKinematics!() # testForwardInverseAgreeance() # testAllInverseKinematics() # end # function testGait() # println("\n-------------- Testing Gait -----------") # p = GaitParams() # # println("Gait params=",p) # t = 680 # println("Timing for phaseindex") # @time ph = phaseindex(t, p) # # @code_warntype phaseindex(t, p) # println("t=",t," phase=",ph) # @assert ph == 4 # @assert phaseindex(0, p) == 1 # println("Timing for contacts") # @time c = contacts(t, p) # # @code_warntype contacts(t, p) # @assert typeof(c) == SArray{Tuple{4},Int64,1,4} # println("t=", t, " contacts=", c) # end def test_stance_controller(): print("\n-------------- Testing Stance Controller -----------") stanceparams = StanceParams() gaitparams = GaitParams() zmeas = -0.20 mvref = MovementReference() dp, dR = position_delta(zmeas, stanceparams, mvref, gaitparams) assert np.linalg.norm(dR - np.eye(3)) < 1e-10 assert np.linalg.norm(dp - np.array([0, 0, gaitparams.dt * 0.04])) < 1e-10 zmeas = -0.18 mvref = MovementReference() mvref.v_xy_ref = np.array([1.0, 0.0]) mvref.z_ref = -0.18 dp, dR = position_delta(zmeas, stanceparams, mvref, gaitparams) zmeas = -0.20 mvref = MovementReference() mvref.wz_ref = 1.0 mvref.z_ref = -0.20 dp, dR = position_delta(zmeas, stanceparams, mvref, gaitparams) assert np.linalg.norm(dp - np.array([0, 0, 0])) < 1e-10 assert np.linalg.norm(dR[0, 1] - (gaitparams.dt)) < 1e-6 stancefootloc = np.zeros(3) sloc = stance_foot_location(stancefootloc, stanceparams, gaitparams, mvref) # function typeswinglegcontroller() # println("\n--------------- Code warn type for raibert_tdlocation[s] ----------") # swp = SwingParams() # stp = StanceParams() # gp = GaitParams() # mvref = MovementReference(SVector(1.0, 0.0), 0, -0.18) # raibert_tdlocations(swp, stp, gp, mvref) # mvref = MovementReference(SVector(1.0, 0.0), 0, -0.18) # raibert_tdlocation(1, swp, stp, gp, mvref) # end # function TestSwingLegController() # println("\n-------------- Testing Swing Leg Controller -----------") # swp = SwingParams() # stp = StanceParams() # gp = GaitParams() # p = ControllerParams() # println("Timing for swingheight:") # @time z = swingheight(0.5, swp) # println("z clearance at t=1/2swingtime =>",z) # @assert abs(z - swp.zclearance) < 1e-10 # println("Timing for swingheight:") # @time z = swingheight(0, swp) # println("Z clearance at t=0 =>",z) # @assert abs(z) < 1e-10 # mvref = MovementReference(SVector(1.0, 0.0), 0, -0.18) # println("Timing for raibert tdlocation*s*:") # @time l = raibert_tdlocations(swp, stp, gp, mvref) # target = stp.defaultstance .+ [gp.stanceticks*gp.dt*0.5*1, 0, 0] # println("Touchdown locations =>", l, " <?=> ", target) # @assert norm(l - target) <= 1e-10 # mvref = MovementReference(SVector(1.0, 0.0), 0, -0.18) # println("Timing for raibert tdlocation:") # @time l = raibert_tdlocation(1, swp, stp, gp, mvref) # fcurrent = SMatrix{3, 4, Float64}(stp.defaultstance) # mvref = MovementReference() # tswing = 0.125 # println("Timing for swingfootlocation*s* increment") # @time l = swingfootlocations(tswing, fcurrent, swp, stp, gp, mvref) # println(l) # fcurrent = SVector{3, Float64}(0.0, 0.0, 0.0) # println("Timing for swingfootlocation") # @time swingfootlocation(tswing, fcurrent, 1, swp, stp, gp, mvref) # typeswinglegcontroller() # return nothing # end def test_run(): print("Run timing") foot_loc_history, joint_angle_history = run() plt.subplot(211) x = plt.plot(foot_loc_history[0, :, :].T, label="x") y = plt.plot(foot_loc_history[1, :, :].T, label="y") z = plt.plot(foot_loc_history[2, :, :].T, label="z") plt.subplot(212) alpha = plt.plot(joint_angle_history[0, :, :].T, label="alpha") beta = plt.plot(joint_angle_history[1, :, :].T, label="beta") gamma = plt.plot(joint_angle_history[2, :, :].T, label="gamma") plt.show() # plot(x, β, y, α, z, γ, layout=(3,2), legend=false)) # function teststep() # swingparams = SwingParams() # stanceparams = StanceParams() # gaitparams = GaitParams() # mvref = MovementReference(vxyref=SVector{2}(0.2, 0.0), wzref=0.0) # conparams = ControllerParams() # robotconfig = PupperConfig() # footlocations::SMatrix{3, 4, Float64, 12} = stanceparams.defaultstance .+ SVector{3, Float64}(0, 0, mvref.zref) # ticks = 1 # println("Timing for step!") # @btime step($ticks, $footlocations, $swingparams, $stanceparams, $gaitparams, $mvref, $conparams) # @code_warntype step(ticks, footlocations, swingparams, stanceparams, gaitparams, mvref, conparams) # end # # testGait() # # testKinematics() # # TestStanceController() # # testStaticArrays() # # TestSwingLegController() # test_inversekinematics_linkage() # # teststep() # # testrun() test_inverse_kinematics_linkage() test_stance_controller() test_run()

Python

renanmb/Omniverse_legged_robotics/URDF-Descriptions/Mini_pupper/StanfordQuadruped-pupper/src/JoystickInterface.py

import UDPComms import numpy as np import time from src.State import BehaviorState, State from src.Command import Command from src.Utilities import deadband, clipped_first_order_filter class JoystickInterface: def __init__( self, config, udp_port=8830, udp_publisher_port = 8840, ): self.config = config self.previous_gait_toggle = 0 self.previous_state = BehaviorState.REST self.previous_hop_toggle = 0 self.previous_activate_toggle = 0 self.message_rate = 50 self.udp_handle = UDPComms.Subscriber(udp_port, timeout=0.3) self.udp_publisher = UDPComms.Publisher(udp_publisher_port) def get_command(self, state, do_print=False): try: msg = self.udp_handle.get() command = Command() ####### Handle discrete commands ######## # Check if requesting a state transition to trotting, or from trotting to resting gait_toggle = msg["R1"] command.trot_event = (gait_toggle == 1 and self.previous_gait_toggle == 0) # Check if requesting a state transition to hopping, from trotting or resting hop_toggle = msg["x"] command.hop_event = (hop_toggle == 1 and self.previous_hop_toggle == 0) activate_toggle = msg["L1"] command.activate_event = (activate_toggle == 1 and self.previous_activate_toggle == 0) # Update previous values for toggles and state self.previous_gait_toggle = gait_toggle self.previous_hop_toggle = hop_toggle self.previous_activate_toggle = activate_toggle ####### Handle continuous commands ######## x_vel = msg["ly"] * self.config.max_x_velocity y_vel = msg["lx"] * -self.config.max_y_velocity command.horizontal_velocity = np.array([x_vel, y_vel]) command.yaw_rate = msg["rx"] * -self.config.max_yaw_rate message_rate = msg["message_rate"] message_dt = 1.0 / message_rate pitch = msg["ry"] * self.config.max_pitch deadbanded_pitch = deadband( pitch, self.config.pitch_deadband ) pitch_rate = clipped_first_order_filter( state.pitch, deadbanded_pitch, self.config.max_pitch_rate, self.config.pitch_time_constant, ) command.pitch = state.pitch + message_dt * pitch_rate height_movement = msg["dpady"] command.height = state.height - message_dt * self.config.z_speed * height_movement roll_movement = - msg["dpadx"] command.roll = state.roll + message_dt * self.config.roll_speed * roll_movement return command except UDPComms.timeout: if do_print: print("UDP Timed out") return Command() def set_color(self, color): joystick_msg = {"ps4_color": color} self.udp_publisher.send(joystick_msg)

Python

renanmb/Omniverse_legged_robotics/URDF-Descriptions/Mini_pupper/StanfordQuadruped-pupper/src/Utilities.py

import numpy as np def deadband(value, band_radius): return max(value - band_radius, 0) + min(value + band_radius, 0) def clipped_first_order_filter(input, target, max_rate, tau): rate = (target - input) / tau return np.clip(rate, -max_rate, max_rate)

Python

renanmb/Omniverse_legged_robotics/URDF-Descriptions/Mini_pupper/StanfordQuadruped-pupper/src/Controller.py

from src.Gaits import GaitController from src.StanceController import StanceController from src.SwingLegController import SwingController from src.Utilities import clipped_first_order_filter from src.State import BehaviorState, State import numpy as np from transforms3d.euler import euler2mat, quat2euler from transforms3d.quaternions import qconjugate, quat2axangle from transforms3d.axangles import axangle2mat class Controller: """Controller and planner object """ def __init__( self, config, inverse_kinematics, ): self.config = config self.smoothed_yaw = 0.0 # for REST mode only self.inverse_kinematics = inverse_kinematics self.contact_modes = np.zeros(4) self.gait_controller = GaitController(self.config) self.swing_controller = SwingController(self.config) self.stance_controller = StanceController(self.config) self.hop_transition_mapping = {BehaviorState.REST: BehaviorState.HOP, BehaviorState.HOP: BehaviorState.FINISHHOP, BehaviorState.FINISHHOP: BehaviorState.REST, BehaviorState.TROT: BehaviorState.HOP} self.trot_transition_mapping = {BehaviorState.REST: BehaviorState.TROT, BehaviorState.TROT: BehaviorState.REST, BehaviorState.HOP: BehaviorState.TROT, BehaviorState.FINISHHOP: BehaviorState.TROT} self.activate_transition_mapping = {BehaviorState.DEACTIVATED: BehaviorState.REST, BehaviorState.REST: BehaviorState.DEACTIVATED} def step_gait(self, state, command): """Calculate the desired foot locations for the next timestep Returns ------- Numpy array (3, 4) Matrix of new foot locations. """ contact_modes = self.gait_controller.contacts(state.ticks) new_foot_locations = np.zeros((3, 4)) for leg_index in range(4): contact_mode = contact_modes[leg_index] foot_location = state.foot_locations[:, leg_index] if contact_mode == 1: new_location = self.stance_controller.next_foot_location(leg_index, state, command) else: swing_proportion = ( self.gait_controller.subphase_ticks(state.ticks) / self.config.swing_ticks ) new_location = self.swing_controller.next_foot_location( swing_proportion, leg_index, state, command ) new_foot_locations[:, leg_index] = new_location return new_foot_locations, contact_modes def run(self, state, command): """Steps the controller forward one timestep Parameters ---------- controller : Controller Robot controller object. """ ########## Update operating state based on command ###### if command.activate_event: state.behavior_state = self.activate_transition_mapping[state.behavior_state] elif command.trot_event: state.behavior_state = self.trot_transition_mapping[state.behavior_state] elif command.hop_event: state.behavior_state = self.hop_transition_mapping[state.behavior_state] if state.behavior_state == BehaviorState.TROT: state.foot_locations, contact_modes = self.step_gait( state, command, ) # Apply the desired body rotation rotated_foot_locations = ( euler2mat( command.roll, command.pitch, 0.0 ) @ state.foot_locations ) # Construct foot rotation matrix to compensate for body tilt (roll, pitch, yaw) = quat2euler(state.quat_orientation) correction_factor = 0.8 max_tilt = 0.4 roll_compensation = correction_factor * np.clip(roll, -max_tilt, max_tilt) pitch_compensation = correction_factor * np.clip(pitch, -max_tilt, max_tilt) rmat = euler2mat(roll_compensation, pitch_compensation, 0) rotated_foot_locations = rmat.T @ rotated_foot_locations state.joint_angles = self.inverse_kinematics( rotated_foot_locations, self.config ) elif state.behavior_state == BehaviorState.HOP: state.foot_locations = ( self.config.default_stance + np.array([0, 0, -0.09])[:, np.newaxis] ) state.joint_angles = self.inverse_kinematics( state.foot_locations, self.config ) elif state.behavior_state == BehaviorState.FINISHHOP: state.foot_locations = ( self.config.default_stance + np.array([0, 0, -0.22])[:, np.newaxis] ) state.joint_angles = self.inverse_kinematics( state.foot_locations, self.config ) elif state.behavior_state == BehaviorState.REST: yaw_proportion = command.yaw_rate / self.config.max_yaw_rate self.smoothed_yaw += ( self.config.dt * clipped_first_order_filter( self.smoothed_yaw, yaw_proportion * -self.config.max_stance_yaw, self.config.max_stance_yaw_rate, self.config.yaw_time_constant, ) ) # Set the foot locations to the default stance plus the standard height state.foot_locations = ( self.config.default_stance + np.array([0, 0, command.height])[:, np.newaxis] ) # Apply the desired body rotation rotated_foot_locations = ( euler2mat( command.roll, command.pitch, self.smoothed_yaw, ) @ state.foot_locations ) state.joint_angles = self.inverse_kinematics( rotated_foot_locations, self.config ) state.ticks += 1 state.pitch = command.pitch state.roll = command.roll state.height = command.height def set_pose_to_default(self): state.foot_locations = ( self.config.default_stance + np.array([0, 0, self.config.default_z_ref])[:, np.newaxis] ) state.joint_angles = controller.inverse_kinematics( state.foot_locations, self.config )

Python

renanmb/Omniverse_legged_robotics/URDF-Descriptions/Mini_pupper/StanfordQuadruped-pupper/pupper/ServoCalibration.py

# WARNING: This file is machine generated. Edit at your own risk. import numpy as np MICROS_PER_RAD = 11.333 * 180.0 / np.pi NEUTRAL_ANGLE_DEGREES = np.array( [[ 0., 0., 0., 0.], [ 45., 45., 45., 45.], [-45.,-45.,-45.,-45.]] )

Python

renanmb/Omniverse_legged_robotics/URDF-Descriptions/Mini_pupper/StanfordQuadruped-pupper/pupper/HardwareInterface.py

import pigpio from pupper.Config import ServoParams, PWMParams class HardwareInterface: def __init__(self): self.pi = pigpio.pi() self.pwm_params = PWMParams() self.servo_params = ServoParams() initialize_pwm(self.pi, self.pwm_params) def set_actuator_postions(self, joint_angles): send_servo_commands(self.pi, self.pwm_params, self.servo_params, joint_angles) def set_actuator_position(self, joint_angle, axis, leg): send_servo_command(self.pi, self.pwm_params, self.servo_params, joint_angle, axis, leg) def pwm_to_duty_cycle(pulsewidth_micros, pwm_params): """Converts a pwm signal (measured in microseconds) to a corresponding duty cycle on the gpio pwm pin Parameters ---------- pulsewidth_micros : float Width of the pwm signal in microseconds pwm_params : PWMParams PWMParams object Returns ------- float PWM duty cycle corresponding to the pulse width """ return int(pulsewidth_micros / 1e6 * pwm_params.freq * pwm_params.range) def angle_to_pwm(angle, servo_params, axis_index, leg_index): """Converts a desired servo angle into the corresponding PWM command Parameters ---------- angle : float Desired servo angle, relative to the vertical (z) axis servo_params : ServoParams ServoParams object axis_index : int Specifies which joint of leg to control. 0 is abduction servo, 1 is inner hip servo, 2 is outer hip servo. leg_index : int Specifies which leg to control. 0 is front-right, 1 is front-left, 2 is back-right, 3 is back-left. Returns ------- float PWM width in microseconds """ angle_deviation = ( angle - servo_params.neutral_angles[axis_index, leg_index] ) * servo_params.servo_multipliers[axis_index, leg_index] pulse_width_micros = ( servo_params.neutral_position_pwm + servo_params.micros_per_rad * angle_deviation ) return pulse_width_micros def angle_to_duty_cycle(angle, pwm_params, servo_params, axis_index, leg_index): return pwm_to_duty_cycle( angle_to_pwm(angle, servo_params, axis_index, leg_index), pwm_params ) def initialize_pwm(pi, pwm_params): for leg_index in range(4): for axis_index in range(3): pi.set_PWM_frequency( pwm_params.pins[axis_index, leg_index], pwm_params.freq ) pi.set_PWM_range(pwm_params.pins[axis_index, leg_index], pwm_params.range) def send_servo_commands(pi, pwm_params, servo_params, joint_angles): for leg_index in range(4): for axis_index in range(3): duty_cycle = angle_to_duty_cycle( joint_angles[axis_index, leg_index], pwm_params, servo_params, axis_index, leg_index, ) pi.set_PWM_dutycycle(pwm_params.pins[axis_index, leg_index], duty_cycle) def send_servo_command(pi, pwm_params, servo_params, joint_angle, axis, leg): duty_cycle = angle_to_duty_cycle(joint_angle, pwm_params, servo_params, axis, leg) pi.set_PWM_dutycycle(pwm_params.pins[axis, leg], duty_cycle) def deactivate_servos(pi, pwm_params): for leg_index in range(4): for axis_index in range(3): pi.set_PWM_dutycycle(pwm_params.pins[axis_index, leg_index], 0)

Python

renanmb/Omniverse_legged_robotics/URDF-Descriptions/Mini_pupper/StanfordQuadruped-pupper/pupper/Kinematics.py

import numpy as np from transforms3d.euler import euler2mat def leg_explicit_inverse_kinematics(r_body_foot, leg_index, config): """Find the joint angles corresponding to the given body-relative foot position for a given leg and configuration Parameters ---------- r_body_foot : [type] [description] leg_index : [type] [description] config : [type] [description] Returns ------- numpy array (3) Array of corresponding joint angles. """ (x, y, z) = r_body_foot # Distance from the leg origin to the foot, projected into the y-z plane R_body_foot_yz = (y ** 2 + z ** 2) ** 0.5 # Distance from the leg's forward/back point of rotation to the foot R_hip_foot_yz = (R_body_foot_yz ** 2 - config.ABDUCTION_OFFSET ** 2) ** 0.5 # Interior angle of the right triangle formed in the y-z plane by the leg that is coincident to the ab/adduction axis # For feet 2 (front left) and 4 (back left), the abduction offset is positive, for the right feet, the abduction offset is negative. arccos_argument = config.ABDUCTION_OFFSETS[leg_index] / R_body_foot_yz arccos_argument = np.clip(arccos_argument, -0.99, 0.99) phi = np.arccos(arccos_argument) # Angle of the y-z projection of the hip-to-foot vector, relative to the positive y-axis hip_foot_angle = np.arctan2(z, y) # Ab/adduction angle, relative to the positive y-axis abduction_angle = phi + hip_foot_angle # theta: Angle between the tilted negative z-axis and the hip-to-foot vector theta = np.arctan2(-x, R_hip_foot_yz) # Distance between the hip and foot R_hip_foot = (R_hip_foot_yz ** 2 + x ** 2) ** 0.5 # Angle between the line going from hip to foot and the link L1 arccos_argument = (config.LEG_L1 ** 2 + R_hip_foot ** 2 - config.LEG_L2 ** 2) / ( 2 * config.LEG_L1 * R_hip_foot ) arccos_argument = np.clip(arccos_argument, -0.99, 0.99) trident = np.arccos(arccos_argument) # Angle of the first link relative to the tilted negative z axis hip_angle = theta + trident # Angle between the leg links L1 and L2 arccos_argument = (config.LEG_L1 ** 2 + config.LEG_L2 ** 2 - R_hip_foot ** 2) / ( 2 * config.LEG_L1 * config.LEG_L2 ) arccos_argument = np.clip(arccos_argument, -0.99, 0.99) beta = np.arccos(arccos_argument) # Angle of the second link relative to the tilted negative z axis knee_angle = hip_angle - (np.pi - beta) return np.array([abduction_angle, hip_angle, knee_angle]) def four_legs_inverse_kinematics(r_body_foot, config): """Find the joint angles for all twelve DOF correspoinding to the given matrix of body-relative foot positions. Parameters ---------- r_body_foot : numpy array (3,4) Matrix of the body-frame foot positions. Each column corresponds to a separate foot. config : Config object Object of robot configuration parameters. Returns ------- numpy array (3,4) Matrix of corresponding joint angles. """ alpha = np.zeros((3, 4)) for i in range(4): body_offset = config.LEG_ORIGINS[:, i] alpha[:, i] = leg_explicit_inverse_kinematics( r_body_foot[:, i] - body_offset, i, config ) return alpha

Python

renanmb/Omniverse_legged_robotics/URDF-Descriptions/Mini_pupper/StanfordQuadruped-pupper/pupper/HardwareConfig.py

""" Per-robot configuration file that is particular to each individual robot, not just the type of robot. """ PS4_COLOR = {"red": 0, "blue": 0, "green": 255} PS4_DEACTIVATED_COLOR = {"red": 0, "blue": 0, "green": 50}

Python

renanmb/Omniverse_legged_robotics/URDF-Descriptions/Mini_pupper/StanfordQuadruped-pupper/pupper/Config.py

import numpy as np from pupper.ServoCalibration import MICROS_PER_RAD, NEUTRAL_ANGLE_DEGREES from pupper.HardwareConfig import PS4_COLOR, PS4_DEACTIVATED_COLOR from enum import Enum # TODO: put these somewhere else class PWMParams: def __init__(self): self.pins = np.array([[2, 14, 18, 23], [3, 15, 27, 24], [4, 17, 22, 25]]) self.range = 4000 self.freq = 250 class ServoParams: def __init__(self): self.neutral_position_pwm = 1500 # Middle position self.micros_per_rad = MICROS_PER_RAD # Must be calibrated # The neutral angle of the joint relative to the modeled zero-angle in degrees, for each joint self.neutral_angle_degrees = NEUTRAL_ANGLE_DEGREES self.servo_multipliers = np.array( [[1, 1, 1, 1], [-1, 1, -1, 1], [1, -1, 1, -1]] ) @property def neutral_angles(self): return self.neutral_angle_degrees * np.pi / 180.0 # Convert to radians class Configuration: def __init__(self): ################# CONTROLLER BASE COLOR ############## self.ps4_color = PS4_COLOR self.ps4_deactivated_color = PS4_DEACTIVATED_COLOR #################### COMMANDS #################### self.max_x_velocity = 0.4 self.max_y_velocity = 0.3 self.max_yaw_rate = 2.0 self.max_pitch = 30.0 * np.pi / 180.0 #################### MOVEMENT PARAMS #################### self.z_time_constant = 0.02 self.z_speed = 0.03 # maximum speed [m/s] self.pitch_deadband = 0.02 self.pitch_time_constant = 0.25 self.max_pitch_rate = 0.15 self.roll_speed = 0.16 # maximum roll rate [rad/s] self.yaw_time_constant = 0.3 self.max_stance_yaw = 1.2 self.max_stance_yaw_rate = 2.0 #################### STANCE #################### self.delta_x = 0.1 self.delta_y = 0.09 self.x_shift = 0.0 self.default_z_ref = -0.16 #################### SWING ###################### self.z_coeffs = None self.z_clearance = 0.07 self.alpha = ( 0.5 # Ratio between touchdown distance and total horizontal stance movement ) self.beta = ( 0.5 # Ratio between touchdown distance and total horizontal stance movement ) #################### GAIT ####################### self.dt = 0.01 self.num_phases = 4 self.contact_phases = np.array( [[1, 1, 1, 0], [1, 0, 1, 1], [1, 0, 1, 1], [1, 1, 1, 0]] ) self.overlap_time = ( 0.10 # duration of the phase where all four feet are on the ground ) self.swing_time = ( 0.15 # duration of the phase when only two feet are on the ground ) ######################## GEOMETRY ###################### self.LEG_FB = 0.10 # front-back distance from center line to leg axis self.LEG_LR = 0.04 # left-right distance from center line to leg plane self.LEG_L2 = 0.115 self.LEG_L1 = 0.1235 self.ABDUCTION_OFFSET = 0.03 # distance from abduction axis to leg self.FOOT_RADIUS = 0.01 self.HIP_L = 0.0394 self.HIP_W = 0.0744 self.HIP_T = 0.0214 self.HIP_OFFSET = 0.0132 self.L = 0.276 self.W = 0.100 self.T = 0.050 self.LEG_ORIGINS = np.array( [ [self.LEG_FB, self.LEG_FB, -self.LEG_FB, -self.LEG_FB], [-self.LEG_LR, self.LEG_LR, -self.LEG_LR, self.LEG_LR], [0, 0, 0, 0], ] ) self.ABDUCTION_OFFSETS = np.array( [ -self.ABDUCTION_OFFSET, self.ABDUCTION_OFFSET, -self.ABDUCTION_OFFSET, self.ABDUCTION_OFFSET, ] ) ################### INERTIAL #################### self.FRAME_MASS = 0.560 # kg self.MODULE_MASS = 0.080 # kg self.LEG_MASS = 0.030 # kg self.MASS = self.FRAME_MASS + (self.MODULE_MASS + self.LEG_MASS) * 4 # Compensation factor of 3 because the inertia measurement was just # of the carbon fiber and plastic parts of the frame and did not # include the hip servos and electronics self.FRAME_INERTIA = tuple( map(lambda x: 3.0 * x, (1.844e-4, 1.254e-3, 1.337e-3)) ) self.MODULE_INERTIA = (3.698e-5, 7.127e-6, 4.075e-5) leg_z = 1e-6 leg_mass = 0.010 leg_x = 1 / 12 * self.LEG_L1 ** 2 * leg_mass leg_y = leg_x self.LEG_INERTIA = (leg_x, leg_y, leg_z) @property def default_stance(self): return np.array( [ [ self.delta_x + self.x_shift, self.delta_x + self.x_shift, -self.delta_x + self.x_shift, -self.delta_x + self.x_shift, ], [-self.delta_y, self.delta_y, -self.delta_y, self.delta_y], [0, 0, 0, 0], ] ) ################## SWING ########################### @property def z_clearance(self): return self.__z_clearance @z_clearance.setter def z_clearance(self, z): self.__z_clearance = z # b_z = np.array([0, 0, 0, 0, self.__z_clearance]) # A_z = np.array( # [ # [0, 0, 0, 0, 1], # [1, 1, 1, 1, 1], # [0, 0, 0, 1, 0], # [4, 3, 2, 1, 0], # [0.5 ** 4, 0.5 ** 3, 0.5 ** 2, 0.5 ** 1, 0.5 ** 0], # ] # ) # self.z_coeffs = solve(A_z, b_z) ########################### GAIT #################### @property def overlap_ticks(self): return int(self.overlap_time / self.dt) @property def swing_ticks(self): return int(self.swing_time / self.dt) @property def stance_ticks(self): return 2 * self.overlap_ticks + self.swing_ticks @property def phase_ticks(self): return np.array( [self.overlap_ticks, self.swing_ticks, self.overlap_ticks, self.swing_ticks] ) @property def phase_length(self): return 2 * self.overlap_ticks + 2 * self.swing_ticks class SimulationConfig: def __init__(self): self.XML_IN = "pupper.xml" self.XML_OUT = "pupper_out.xml" self.START_HEIGHT = 0.3 self.MU = 1.5 # coeff friction self.DT = 0.001 # seconds between simulation steps self.JOINT_SOLREF = "0.001 1" # time constant and damping ratio for joints self.JOINT_SOLIMP = "0.9 0.95 0.001" # joint constraint parameters self.GEOM_SOLREF = "0.01 1" # time constant and damping ratio for geom contacts self.GEOM_SOLIMP = "0.9 0.95 0.001" # geometry contact parameters # Joint params G = 220 # Servo gear ratio m_rotor = 0.016 # Servo rotor mass r_rotor = 0.005 # Rotor radius self.ARMATURE = G ** 2 * m_rotor * r_rotor ** 2 # Inertia of rotational joints # print("Servo armature", self.ARMATURE) NATURAL_DAMPING = 1.0 # Damping resulting from friction ELECTRICAL_DAMPING = 0.049 # Damping resulting from back-EMF self.REV_DAMPING = ( NATURAL_DAMPING + ELECTRICAL_DAMPING ) # Damping torque on the revolute joints # Servo params self.SERVO_REV_KP = 300 # Position gain [Nm/rad] # Force limits self.MAX_JOINT_TORQUE = 3.0 self.REVOLUTE_RANGE = 1.57

Python

renanmb/Omniverse_legged_robotics/URDF-Descriptions/Mini_pupper/StanfordQuadruped-pupper/woofer/HardwareInterface.py

import odrive from odrive.enums import * from woofer.Config import RobotConfig from woofer.HardwareConfig import ( ODRIVE_SERIAL_NUMBERS, ACTUATOR_DIRECTIONS, ANGLE_OFFSETS, map_actuators_to_axes, ) import time import threading import numpy as np class HardwareInterface: def __init__(self): self.config = RobotConfig() assert len(ODRIVE_SERIAL_NUMBERS) == self.config.NUM_ODRIVES self.odrives = [None for _ in range(self.config.NUM_ODRIVES)] threads = [] for i in range(self.config.NUM_ODRIVES): t = threading.Thread(target=find_odrive, args=(i, self.odrives)) threads.append(t) t.start() for t in threads: t.join() input("Press enter to calibrate odrives...") calibrate_odrives(self.odrives) set_position_control(self.odrives) self.axes = assign_axes(self.odrives) def set_actuator_postions(self, joint_angles): set_all_odrive_positions(self.axes, joint_angles, self.config) def deactivate_actuators(self): set_odrives_idle(self.odrives) def find_odrive(i, odrives): o = odrive.find_any(serial_number=ODRIVE_SERIAL_NUMBERS[i]) print("Found odrive: ", i) odrives[i] = o def calibrate_odrives(odrives): for odrv in odrives: odrv.axis0.requested_state = AXIS_STATE_FULL_CALIBRATION_SEQUENCE odrv.axis1.requested_state = AXIS_STATE_FULL_CALIBRATION_SEQUENCE for odrv in odrives: while ( odrv.axis0.current_state != AXIS_STATE_IDLE or odrv.axis1.current_state != AXIS_STATE_IDLE ): time.sleep(0.1) # busy waiting - not ideal def set_position_control(odrives): for odrv in odrives: for axis in [odrv.axis0, odrv.axis1]: axis.controller.config.pos_gain = 60 axis.controller.config.vel_gain = 0.002 axis.controller.config.vel_limit_tolerance = 0 axis.controller.config.vel_integrator_gain = 0 axis.motor.config.current_lim = 15 print("Updated gains") odrv.axis0.requested_state = AXIS_STATE_CLOSED_LOOP_CONTROL odrv.axis1.requested_state = AXIS_STATE_CLOSED_LOOP_CONTROL def set_odrives_idle(odrives): for odrv in odrives: odrv.axis0.requested_state = AXIS_STATE_IDLE odrv.axis1.requested_state = AXIS_STATE_IDLE def assign_axes(odrives): return map_actuators_to_axes(odrives) def set_all_odrive_positions(axes, joint_angles, config): for i in range(joint_angles.shape[0]): for j in range(joint_angles.shape[1]): axes[i][j].controller.pos_setpoint = actuator_angle_to_odrive( joint_angles, i, j, config ) def radians_to_encoder_count(angle, config): return (angle / (2 * np.pi)) * config.ENCODER_CPR * config.MOTOR_REDUCTION def actuator_angle_to_odrive(joint_angles, i, j, config): offset_angle = joint_angles[i][j] + ANGLE_OFFSETS[i][j] odrive_radians = offset_angle * ACTUATOR_DIRECTIONS[i][j] return radians_to_encoder_count(odrive_radians, config)

Python

renanmb/Omniverse_legged_robotics/URDF-Descriptions/Mini_pupper/StanfordQuadruped-pupper/woofer/Kinematics.py

import numpy as np def leg_forward_kinematics(alpha, leg_index, config): """Find the body-centric coordinates of a given foot given the joint angles. Parameters ---------- alpha : Numpy array (3) Joint angles ordered as (abduction, hip, knee) leg_index : int Leg index. config : Config object Robot parameters object Returns ------- Numpy array (3) Body-centric coordinates of the specified foot """ pass def leg_explicit_inverse_kinematics(r_body_foot, leg_index, config): """Find the joint angles corresponding to the given body-relative foot position for a given leg and configuration Parameters ---------- r_body_foot : [type] [description] leg_index : [type] [description] config : [type] [description] Returns ------- numpy array (3) Array of corresponding joint angles. """ (x, y, z) = r_body_foot # Distance from the leg origin to the foot, projected into the y-z plane R_body_foot_yz = (y ** 2 + z ** 2) ** 0.5 # Distance from the leg's forward/back point of rotation to the foot R_hip_foot_yz = (R_body_foot_yz ** 2 - config.ABDUCTION_OFFSET ** 2) ** 0.5 # Interior angle of the right triangle formed in the y-z plane by the leg that is coincident to the ab/adduction axis # For feet 2 (front left) and 4 (back left), the abduction offset is positive, for the right feet, the abduction offset is negative. cos_param = config.ABDUCTION_OFFSETS[leg_index] / R_body_foot_yz if abs(cos_param) > 0.9: print("Clipping 1st cos param") cos_param = np.clip(cos_param, -0.9, 0.9) phi = np.arccos(cos_param) # Angle of the y-z projection of the hip-to-foot vector, relative to the positive y-axis hip_foot_angle = np.arctan2(z, y) # Ab/adduction angle, relative to the positive y-axis abduction_angle = phi + hip_foot_angle # theta: Angle between the tilted negative z-axis and the hip-to-foot vector theta = np.arctan2(-x, R_hip_foot_yz) # Distance between the hip and foot R_hip_foot = (R_hip_foot_yz ** 2 + x ** 2) ** 0.5 # Using law of cosines to determine the angle between upper leg links cos_param = (config.UPPER_LEG ** 2 + R_hip_foot ** 2 - config.LOWER_LEG ** 2) / (2.0*config.UPPER_LEG*R_hip_foot) # Ensure that the leg isn't over or under extending cos_param = np.clip(cos_param, -0.9, 0.9) if abs(cos_param) > 0.9: print("Clipping 2nd cos param") # gamma: Angle between upper leg links and the center of the leg gamma = np.arccos(cos_param) return np.array([abduction_angle, theta - gamma, theta + gamma]) def four_legs_inverse_kinematics(r_body_foot, config): """Find the joint angles for all twelve DOF correspoinding to the given matrix of body-relative foot positions. Parameters ---------- r_body_foot : numpy array (3,4) Matrix of the body-frame foot positions. Each column corresponds to a separate foot. config : Config object Object of robot configuration parameters. Returns ------- numpy array (3,4) Matrix of corresponding joint angles. """ alpha = np.zeros((3, 4)) for i in range(4): body_offset = config.LEG_ORIGINS[:, i] alpha[:, i] = leg_explicit_inverse_kinematics( r_body_foot[:, i] - body_offset, i, config ) return alpha

Python

renanmb/Omniverse_legged_robotics/URDF-Descriptions/Mini_pupper/StanfordQuadruped-pupper/woofer/HardwareConfig.py

""" Per-robot configuration file that is particular to each individual robot, not just the type of robot. """ import numpy as np ODRIVE_SERIAL_NUMBERS = [ "2065339F304B", "208F3384304B", "365833753037", "207E35753748", "208F3385304B", "208E3387304B", ] ACTUATOR_DIRECTIONS = np.array([[1, 1, -1, -1], [-1, -1, -1, -1], [1, 1, 1, 1]]) ANGLE_OFFSETS = np.array( [ [0, 0, 0, 0], [np.pi / 2, np.pi / 2, np.pi / 2, np.pi / 2], [-np.pi / 2, -np.pi / 2, -np.pi / 2, -np.pi / 2], ] ) def map_actuators_to_axes(odrives): axes = [[None for _ in range(4)] for _ in range(3)] axes[0][0] = odrives[1].axis1 axes[1][0] = odrives[0].axis0 axes[2][0] = odrives[0].axis1 axes[0][1] = odrives[1].axis0 axes[1][1] = odrives[2].axis1 axes[2][1] = odrives[2].axis0 axes[0][2] = odrives[4].axis1 axes[1][2] = odrives[5].axis0 axes[2][2] = odrives[5].axis1 axes[0][3] = odrives[4].axis0 axes[1][3] = odrives[3].axis1 axes[2][3] = odrives[3].axis0 return axes

Python

renanmb/Omniverse_legged_robotics/URDF-Descriptions/Mini_pupper/StanfordQuadruped-pupper/woofer/Config.py

import numpy as np from scipy.linalg import solve class BehaviorState(Enum): REST = 0 TROT = 1 HOP = 2 FINISHHOP = 3 class UserInputParams: def __init__(self): self.max_x_velocity = 0.5 self.max_y_velocity = 0.24 self.max_yaw_rate = 0.2 self.max_pitch = 30.0 * np.pi / 180.0 class MovementReference: """Stores movement reference """ def __init__(self): self.v_xy_ref = np.array([0, 0]) self.wz_ref = 0.0 self.z_ref = -0.265 self.pitch = 0.0 self.roll = 0.0 class SwingParams: """Swing Parameters """ def __init__(self): self.z_coeffs = None self.z_clearance = 0.05 self.alpha = ( 0.5 ) # Ratio between touchdown distance and total horizontal stance movement self.beta = ( 0.5 ) # Ratio between touchdown distance and total horizontal stance movement @property def z_clearance(self): return self.__z_clearance @z_clearance.setter def z_clearance(self, z): self.__z_clearance = z b_z = np.array([0, 0, 0, 0, self.__z_clearance]) A_z = np.array( [ [0, 0, 0, 0, 1], [1, 1, 1, 1, 1], [0, 0, 0, 1, 0], [4, 3, 2, 1, 0], [0.5 ** 4, 0.5 ** 3, 0.5 ** 2, 0.5 ** 1, 0.5 ** 0], ] ) self.z_coeffs = solve(A_z, b_z) class StanceParams: """Stance parameters """ def __init__(self): self.z_time_constant = 0.02 self.z_speed = 0.03 # maximum speed [m/s] self.pitch_deadband = 0.02 self.pitch_time_constant = 0.25 self.max_pitch_rate = 0.15 self.roll_speed = 0.16 # maximum roll rate [rad/s] self.delta_x = 0.23 self.delta_y = 0.173 self.x_shift = -0.01 @property def default_stance(self): return np.array( [ [ self.delta_x + self.x_shift, self.delta_x + self.x_shift, -self.delta_x + self.x_shift, -self.delta_x + self.x_shift, ], [-self.delta_y, self.delta_y, -self.delta_y, self.delta_y], [0, 0, 0, 0], ] ) class GaitParams: """Gait Parameters """ def __init__(self): self.dt = 0.01 self.num_phases = 4 self.contact_phases = np.array( [[1, 1, 1, 1], [1, 1, 1, 1], [1, 1, 1, 1], [1, 1, 1, 1]] ) self.overlap_time = ( 0.5 # duration of the phase where all four feet are on the ground ) self.swing_time = ( 0.5 # duration of the phase when only two feet are on the ground ) @property def overlap_ticks(self): return int(self.overlap_time / self.dt) @property def swing_ticks(self): return int(self.swing_time / self.dt) @property def stance_ticks(self): return 2 * self.overlap_ticks + self.swing_ticks @property def phase_times(self): return np.array( [self.overlap_ticks, self.swing_ticks, self.overlap_ticks, self.swing_ticks] ) @property def phase_length(self): return 2 * self.overlap_ticks + 2 * self.swing_ticks class RobotConfig: """Woofer hardware parameters """ def __init__(self): # Robot geometry self.LEG_FB = 0.23 # front-back distance from center line to leg axis self.LEG_LR = 0.109 # left-right distance from center line to leg plane self.ABDUCTION_OFFSET = 0.064 # distance from abduction axis to leg self.FOOT_RADIUS = 0.02 self.UPPER_LEG = 0.18 self.LOWER_LEG = 0.32 # Update hip geometry self.HIP_L = 0.0394 self.HIP_W = 0.0744 self.HIP_T = 0.0214 self.HIP_OFFSET = 0.0132 self.L = 0.66 self.W = 0.176 self.T = 0.092 self.LEG_ORIGINS = np.array( [ [self.LEG_FB, self.LEG_FB, -self.LEG_FB, -self.LEG_FB], [-self.LEG_LR, self.LEG_LR, -self.LEG_LR, self.LEG_LR], [0, 0, 0, 0], ] ) self.ABDUCTION_OFFSETS = np.array( [ -self.ABDUCTION_OFFSET, self.ABDUCTION_OFFSET, -self.ABDUCTION_OFFSET, self.ABDUCTION_OFFSET, ] ) self.START_HEIGHT = 0.3 # Robot inertia params self.FRAME_MASS = 3.0 # kg self.MODULE_MASS = 1.033 # kg self.LEG_MASS = 0.15 # kg self.MASS = self.FRAME_MASS + (self.MODULE_MASS + self.LEG_MASS) * 4 # Compensation factor of 3 because the inertia measurement was just # of the carbon fiber and plastic parts of the frame and did not # include the hip servos and electronics self.FRAME_INERTIA = tuple( map(lambda x: 3.0 * x, (1.844e-4, 1.254e-3, 1.337e-3)) ) self.MODULE_INERTIA = (3.698e-5, 7.127e-6, 4.075e-5) leg_z = 1e-6 leg_mass = 0.010 leg_x = 1 / 12 * self.LOWER_LEG ** 2 * leg_mass leg_y = leg_x self.LEG_INERTIA = (leg_x, leg_y, leg_z) # Joint params G = 220 # Servo gear ratio m_rotor = 0.016 # Servo rotor mass r_rotor = 0.005 # Rotor radius self.ARMATURE = G ** 2 * m_rotor * r_rotor ** 2 # Inertia of rotational joints # print("Servo armature", self.ARMATURE) NATURAL_DAMPING = 1.0 # Damping resulting from friction ELECTRICAL_DAMPING = 0.049 # Damping resulting from back-EMF self.REV_DAMPING = ( NATURAL_DAMPING + ELECTRICAL_DAMPING ) # Damping torque on the revolute joints # Force limits self.MAX_JOINT_TORQUE = 12.0 self.REVOLUTE_RANGE = 3 self.NUM_ODRIVES = 6 self.ENCODER_CPR = 2000 self.MOTOR_REDUCTION = 4 class EnvironmentConfig: """Environmental parameters """ def __init__(self): self.MU = 1.5 # coeff friction self.DT = 0.001 # seconds between simulation steps class SolverConfig: """MuJoCo solver parameters """ def __init__(self): self.JOINT_SOLREF = "0.001 1" # time constant and damping ratio for joints self.JOINT_SOLIMP = "0.9 0.95 0.001" # joint constraint parameters self.GEOM_SOLREF = "0.01 1" # time constant and damping ratio for geom contacts self.GEOM_SOLIMP = "0.9 0.95 0.001" # geometry contact parameters

Python

renanmb/Omniverse_legged_robotics/URDF-Descriptions/Mini_pupper/mini_pupper_simplified/README.md

# Mini Pupper Robot Description (URDF) ## Overview This package contains a simplified robot description (URDF) of the [Mini Pupper](https://www.kickstarter.com/projects/336477435/mini-pupper-open-sourceros-robot-dog-kit) developed by [MangDang](https://twitter.com/LeggedRobot). STL filesare forked from [mayataka/mini_pupper_trajopt](https://github.com/mayataka/mini_pupper_trajopt). ## License This software is released under a [BSD 3-Clause license](LICENSE). ## Usage See [CHAMP](https://github.com/chvmp/champ)

Markdown

renanmb/Omniverse_legged_robotics/URDF-Descriptions/Mini_pupper/QuadrupedRobot-mini_pupper/UDPComms/rover.py

#!/usr/bin/env python3 import sys import argparse import json import time import select import pexpect import UDPComms import msgpack def peek_func(port): sub = UDPComms.Subscriber(port, timeout = 10) while 1: try: data = sub.recv() print( json.dumps(data) ) except UDPComms.timeout: exit() def poke_func(port, rate): pub = UDPComms.Publisher(port) data = None while 1: if select.select([sys.stdin], [], [], 0)[0]: line = sys.stdin.readline() # detailed behaviour # reading from file: -ignores empty lines -repeats last line forever # reading from terminal: -repeats last command if line.rstrip(): data = line.rstrip() elif len(line) == 0: # exit() #uncomment to quit on end of file pass else: continue if data != None: pub.send( json.loads(data) ) time.sleep( rate/1000 ) def call_func(command, ssh = True): child = pexpect.spawn(command) if ssh: i = 1 while i == 1: try: i = child.expect(['password:', 'Are you sure you want to continue connecting', 'Welcome'], timeout=20) except pexpect.EOF: print("Can't connect to device") exit() except pexpect.TIMEOUT: print("Interaction with device failed") exit() if i == 1: child.sendline('yes') if i == 0: child.sendline('raspberry') else: try: child.expect('robot:', timeout=1) child.sendline('hello') except pexpect.TIMEOUT: pass child.interact() if __name__ == '__main__': parser = argparse.ArgumentParser() subparsers = parser.add_subparsers(dest='subparser') peek = subparsers.add_parser("peek") peek.add_argument('port', help="UDP port to subscribe to", type=int) poke = subparsers.add_parser("poke") poke.add_argument('port', help="UDP port to publish the data to", type=int) poke.add_argument('rate', help="how often to republish (ms)", type=float) peek = subparsers.add_parser("discover") commands = ['status', 'log', 'start', 'stop', 'restart', 'enable', 'disable'] for command in commands: status = subparsers.add_parser(command) status.add_argument('host', help="Which device to look for this program on") status.add_argument('unit', help="The unit whose status we want to know", nargs='?', default=None) connect = subparsers.add_parser('connect') connect.add_argument('host', help="Which device to log into") args = parser.parse_args() if args.subparser == 'peek': peek_func(args.port) elif args.subparser == 'poke': poke_func(args.port, args.rate) elif args.subparser == 'connect': call_func("ssh pi@"+args.host+".local") elif args.subparser == 'discover': call_func("nmap -sP 10.0.0.0/24", ssh=False) elif args.subparser in commands: if args.unit is None: args.unit = args.host if args.host == 'local': prefix = "" ssh = False else: prefix = "ssh pi@"+args.host+".local " ssh = True if args.subparser == 'status': call_func(prefix + "sudo systemctl status "+args.unit, ssh) elif args.subparser == 'log': call_func(prefix + "sudo journalctl -f -u "+args.unit, ssh) elif args.subparser == 'start': call_func(prefix + "sudo systemctl start "+args.unit, ssh) elif args.subparser == 'stop': call_func(prefix + "sudo systemctl stop "+args.unit, ssh) elif args.subparser == 'restart': call_func(prefix + "sudo systemctl restart "+args.unit, ssh) elif args.subparser == 'enable': call_func(prefix + "sudo systemctl enable "+args.unit, ssh) elif args.subparser == 'disable': call_func(prefix + "sudo systemctl disable "+args.unit, ssh) else: parser.print_help()

Python

renanmb/Omniverse_legged_robotics/URDF-Descriptions/Mini_pupper/QuadrupedRobot-mini_pupper/UDPComms/__init__.py

from .UDPComms import Publisher from .UDPComms import Subscriber from .UDPComms import timeout

Python

renanmb/Omniverse_legged_robotics/URDF-Descriptions/Mini_pupper/QuadrupedRobot-mini_pupper/UDPComms/setup.py

#!/usr/bin/env python from distutils.core import setup setup(name='UDPComms', version='1.1dev', py_modules=['UDPComms'], description='Simple library for sending messages over UDP', author='Michal Adamkiewicz', author_email='mikadam@stanford.edu', url='https://github.com/stanfordroboticsclub/UDP-Comms', )

Python

renanmb/Omniverse_legged_robotics/URDF-Descriptions/Mini_pupper/QuadrupedRobot-mini_pupper/UDPComms/UDPComms.py

import socket import struct from collections import namedtuple from time import monotonic import msgpack import time timeout = socket.timeout MAX_SIZE = 65507 class Publisher: def __init__(self, port_tx,port): """ Create a Publisher Object Arguments: port -- the port to publish the messages on """ self.sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) self.des_address = ("127.0.0.1",port_tx) self.sock.bind(("127.0.0.1", port)) self.sock.settimeout(0.2) def send(self, obj): """ Publish a message. The obj can be any nesting of standard python types """ msg = msgpack.dumps(obj, use_bin_type=False) assert len(msg) < MAX_SIZE, "Encoded message too big!" self.sock.sendto(msg,self.des_address) def __del__(self): self.sock.close() class Subscriber: def __init__(self, port_rx, timeout=0.2): """ Create a Subscriber Object Arguments: port -- the port to listen to messages on timeout -- how long to wait before a message is considered out of date """ self.max_size = MAX_SIZE self.timeout = timeout self.last_data = None self.last_time = float('-inf') self.sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) self.sock.settimeout(timeout) self.sock.bind(("127.0.0.1", port_rx)) def recv(self): """ Receive a single message from the socket buffer. It blocks for up to timeout seconds. If no message is received before timeout it raises a UDPComms.timeout exception""" try: self.last_data, address = self.sock.recvfrom(3) except BlockingIOError: raise socket.timeout("no messages in buffer and called with timeout = 0") print(self.last_data) self.last_time = monotonic() return msgpack.loads(self.last_data, raw=False) def get(self): """ Returns the latest message it can without blocking. If the latest massage is older then timeout seconds it raises a UDPComms.timeout exception""" try: self.sock.settimeout(0) while True: self.last_data, address = self.sock.recvfrom(self.max_size) self.last_time = monotonic() except socket.error: pass finally: self.sock.settimeout(self.timeout) current_time = monotonic() if (current_time - self.last_time) < self.timeout: return msgpack.loads(self.last_data, raw=False) else: raise socket.timeout("timeout=" + str(self.timeout) + \ ", last message time=" + str(self.last_time) + \ ", current time=" + str(current_time)) def get_list(self): """ Returns list of messages, in the order they were received""" msg_bufer = [] try: self.sock.settimeout(0) while True: self.last_data, address = self.sock.recvfrom(self.max_size) self.last_time = monotonic() msg = msgpack.loads(self.last_data, raw=False) msg_bufer.append(msg) except socket.error: pass finally: self.sock.settimeout(self.timeout) return msg_bufer def __del__(self): self.sock.close() class Subscriber: def __init__(self, port, timeout=0.2): """ Create a Subscriber Object Arguments: port -- the port to listen to messages on timeout -- how long to wait before a message is considered out of date """ self.max_size = MAX_SIZE self.port = port self.timeout = timeout self.last_data = None self.last_time = float('-inf') self.sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) # UDP self.sock.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1) self.sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) if hasattr(socket, "SO_REUSEPORT"): self.sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEPORT, 1) self.sock.settimeout(timeout) self.sock.bind(("", port)) def recv(self): """ Receive a single message from the socket buffer. It blocks for up to timeout seconds. If no message is received before timeout it raises a UDPComms.timeout exception""" try: self.last_data, address = self.sock.recvfrom(self.max_size) except BlockingIOError: raise socket.timeout("no messages in buffer and called with timeout = 0") self.last_time = monotonic() return msgpack.loads(self.last_data, raw=False) def get(self): """ Returns the latest message it can without blocking. If the latest massage is older then timeout seconds it raises a UDPComms.timeout exception""" try: self.sock.settimeout(0) while True: self.last_data, address = self.sock.recvfrom(self.max_size) self.last_time = monotonic() except socket.error: pass finally: self.sock.settimeout(self.timeout) current_time = monotonic() if (current_time - self.last_time) < self.timeout: return msgpack.loads(self.last_data, raw=False) else: raise socket.timeout("timeout=" + str(self.timeout) + \ ", last message time=" + str(self.last_time) + \ ", current time=" + str(current_time)) def get_list(self): """ Returns list of messages, in the order they were received""" msg_bufer = [] try: self.sock.settimeout(0) while True: self.last_data, address = self.sock.recvfrom(self.max_size) self.last_time = monotonic() msg = msgpack.loads(self.last_data, raw=False) msg_bufer.append(msg) except socket.error: pass finally: self.sock.settimeout(self.timeout) return msg_bufer def __del__(self): self.sock.close() if __name__ == "__main__": msg = 'very important data' a = Publisher(1000) a.send( {"text": "magic", "number":5.5, "bool":False} )

Python

renanmb/Omniverse_legged_robotics/URDF-Descriptions/Mini_pupper/QuadrupedRobot-mini_pupper/UDPComms/README.md

# UDPComms This is a simple library to enable communication between different processes (potentially on different machines) over a network using UDP. It's goals a simplicity and easy of understanding and reliability. It works for devices on the `10.0.0.X` subnet although this can easiliy be changed. Currently it works in python 2 and 3 but it should be relatively simple to extend it to other languages such as C (to run on embeded devices) or Julia (to interface with faster solvers). This new verison of the library automatically determines the type of the message and trasmits it along with it, so the subscribers can decode it correctly. While faster to prototype with then systems with explicit type declaration (such as ROS) its easy to shoot yourself in the foot if types are mismatched between publisher and subscriber. ### To Send Messages ``` >>> from UDPComms import Publisher >>> a = Publisher(5500) >>> a.send({"name":"Bob", "age": 20, "height": 180.5, "mass": 70.1}) ``` ### To Receive Messages #### recv Method Note: before using the `Subsciber.recv()` method read about the `Subsciber.get()` and understand the difference between them. The `Subsciber.recv()` method will pull a message from the socket buffer and it won't necessary be the most recent message. If you are calling it too slowly and there is a lot of messages you will be getting old messages. The `Subsciber.recv()` can also block for up to `timeout` seconds messing up timing. ``` >>> from UDPComms import Subscriber >>> a = Subscriber(5500) >>> message = a.recv() >>> message['age'] 20 >>> message['height'] 180.5 >>> message['name'] "Bob" >>> message {"name":"Bob", "age": 20, "height": 180.5, "mass": 70.1} ``` #### get Method The preferred way of accessing messages is the `Subsciber.get()` method (as opposed to the `recv()` method). It is guaranteed to be nonblocking so it can be used in places without messing with timing. It checks for any new messages and returns the newest one. If the newest message is older then `timeout` seconds it raises the `UDPComms.timeout` exception. **This is an important safety feature!** Make sure to catch the timeout using `try: ... except UDPComms.timeout: ...` and put the robot in a safe configuration (e.g. turn off motors, when the joystick stop sending messages) Note that if you call `.get` immediately after creating a subscriber it is possible its hasn't received any messages yet and it will timeout. In general it is better to have a short timeout and gracefully catch timeouts then to have long timeouts ``` >>> from UDPComms import Subscriber, timout >>> a = Subscriber(5500) >>> while 1: >>> try: >>> message = a.get() >>> print("got", message) >>> except timeout: >>> print("safing robot") ``` #### get_list Method Although UDPComms isn't ideal for commands that need to be processed in order (as the underlying UDP protocol has no guarantees of deliverry) it can be used as such in a pinch. The `Subsciber.get_list()` method will return all the messages we haven't seen yet in a list ``` >>> from UDPComms import Subscriber, timout >>> a = Subscriber(5500) >>> messages = a.get_list() >>> for message in messages: >>> print("got", message) ``` ### Publisher Arguments - `port` The port the messages will be sent on. If you are part of Stanford Student Robotics make sure there isn't any port conflicts by checking the `UDP Ports` sheet of the [CS Comms System](https://docs.google.com/spreadsheets/d/1pqduUwYa1_sWiObJDrvCCz4Al3pl588ytE4u-Dwa6Pw/edit?usp=sharing) document. If you are not I recommend keep track of your port numbers somewhere. It's possible that in the future UDPComms will have a system of naming (with a string) as opposed to numbering publishers. - `ip` By default UDPComms sends to the `10.0.0.X` subnet, but can be changed to a different ip using this argument. Set to localhost (`127.0.0.1`) for development on the same computer. ### Subscriber Arguments - `port` The port the subscriber will be listen on. - `timeout` If the `recv()` method don't get a message in `timeout` seconds it throws a `UDPComms.timeout` exception ### Rover The library also comes with the `rover` command that can be used to interact with the messages manually. | Command | Descripion | |---------|------------| | `rover peek port` | print messages sent on port `port` | | `rover poke port rate` | send messages to `port` once every `rate` milliseconds. Type message in json format and press return | There are more commands used for starting and stoping services described in [this repo](https://github.com/stanfordroboticsclub/RPI-Setup/blob/master/README.md) ### To Install ``` $git clone https://github.com/stanfordroboticsclub/UDPComms.git $sudo bash UDPComms/install.sh ``` ### To Update ``` $cd UDPComms $git pull $sudo bash install.sh ``` ### Developing without hardware Because this library expects you to be connected to the robot (`10.0.0.X`) network you won't be able to send messages between two programs on your computer without any other hardware connected. You can get around this by forcing your (unused) ethernet interface to get an ip on the rover network without anything being connected to it. On my computer you can do this using this command: `sudo ifconfig en1 10.0.0.52 netmask 255.255.255.0` Note that the exact command depends which interface on your computer is unused and what ip you want. So only use this if you know what you are doing. If you have internet access a slightly cleaner way to do it is to setup [RemoteVPN](https://github.com/stanfordroboticsclub/RemoteVPN) on your development computer and simply connect to a development network (given if you are the only computer there) ### Known issues: - Macs have issues sending large messages. They are fine receiving them. I think it is related to [this issue](https://github.com/BanTheRewind/Cinder-Asio/issues/9). I wonder does it work on Linux by chance (as the packets happen to be in order) but so far we didn't have issues. - Messages over the size of one MTU (typically 1500 bytes) will be split up into multiple frames which reduces their chance of getting to their destination on wireless networks.

Markdown

renanmb/Omniverse_legged_robotics/URDF-Descriptions/Mini_pupper/QuadrupedRobot-mini_pupper/Doc/guide/software_installation.rst

===================== Software Installation ===================== .. contents:: :depth: 4 Setting up your Raspberry Pi ------------------------------ * Raspberry Pi 4(2GB DDR for normal use, 4GB DDR for install and debug by self) * SD Card (32GB recommended) * Raspberry Pi 4 power supply (USB-C, 5V, >=3A) * Ethernet cable Preparing the Pi's SD card ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ From your desktop / laptop: 1. Put the SD card into your desktop / laptop. ############################################### 2. Download this version of Ubuntu 21.10 ################################################################# Download Ubuntu21.10 server version 64bit image(NOT including desktop). Use `this version <https://drive.google.com/file/d/1JVtjFTKE6FloG3giyMN_VuS0dKt4n2xq/view?usp=sharing>`_ so everyone is using the same version. Unzip and extract the file. You can also check the version from `ubuntu offical website. <https://ubuntu.com/download/raspberry-pi>`_ 3. Use `etcher <https://www.balena.io/etcher/>`_ to flash the card. ########################################################################################## * For quick start, you can also download the `pre-installed image <https://drive.google.com/drive/folders/12FDFbZzO61Euh8pJI9oCxN-eLVm5zjyi?usp=sharing>`_ , (username: ubuntu , password: mangdang ) flash it into the card, then skip all the following steps and start to calibarte the Pupper Mini. * If you are using the recommended etcher, this is the start-up menu. Select ubuntu-21.10-preinstalled-server-arm64+raspi.img (file inside zip )and the SD card. .. image:: ../_static/flash1.png :align: center * Image of SD card being flashed. .. image:: ../_static/flash2.png :align: center * Done! .. image:: ../_static/flash3.png :align: center Enabling Basic Functionality ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 1. Turn on your Raspberry Pi. ################################################################################################### Remove SD card from computer and put it into your Raspberry Pi. Connect the IO board to the Pi, Connect battery power from IO board power interface, Connect keyboard, and mouse to the Pi as well. Connect the Pi to a displayer by HDMI line. Switch power on/off button to set up the Pi. Follow the prompts to change the password((The default password is ``mangdang``)), and then install desktop. Before installation, please make sure that raspberry pi is plugged into the network cable to access the Internet. After installing the desktop, you only need to reboot it one time. The system will enter the desktop system by default. Run ``$sudo apt install ubuntu-desktop`` .. image:: ../_static/installDesktop.jpg :align: center 2. Initial Ubuntu server ######################################################## * The install time depends on your network speed, probably dozens of minutes. Input "Y" to continue, and then input "startx" to boot up desktop at first time. .. image:: ../_static/installDesktop2.jpg :align: center Reboot it only at first time, and then check the IP address, you can connect it later by SSH. .. image:: ../_static/bootupDesktop4.jpg :align: center 2. SSH into the pi from your computer and install the robot program. ###################################### Run ``ssh ubuntu@IP address`` (The default password is ``mangdang``) .. image:: ../_static/ssh.png :align: center Make ``Robotics`` folder and download the source code. Run ``git clone -b MiniPupper_V2 https://github.com/mangdangroboticsclub/QuadrupedRobot.git`` .. image:: ../_static/gitclonesourcecode.png :align: center Install requirements (on the Pi). Run ``sudo bash Legacy/pre_install.sh``, the pre-install time depends on your network speed, maybe dezons of minutes, or several hours. .. image:: ../_static/preInstall.png :align: center Insall the pupper robot program. * ``cd QuadrupedRobot`` * ``sudo bash install.sh`` .. image:: ../_static/preInstall.png :align: center 3. Power-cycle the robot ############################# Unplug the battery, wait about 30 seconds, and then plug it back in. 4. Verify everything is working ############################### #. If you just powered on the Pi, wait about 30 seconds until the green light stops blinking. #. SSH into the robot * Run ``ssh pi@10.0.0.xx (where xx is the IP address you chose for the robot)`` #. Check the status for the joystick service * Run ``sudo systemctl status joystick`` * If you haven't yet connected the PS4 controller, it should say something like :: pi@pupper(rw):~/StanfordQuadruped$ sudo systemctl status joystick ● joystick.service - Pupper Joystick service Loaded: loaded (/home/pi/PupperCommand/joystick.service; enabled; vendor preset: enabled) Active: active (running) since Sun 2020-03-01 06:57:20 GMT; 1s ago Main PID: 5692 (python3) Tasks: 3 (limit: 4035) Memory: 7.1M CGroup: /system.slice/joystick.service ├─5692 /usr/bin/python3 /home/pi/PupperCommand/joystick.py └─5708 hcitool scan --flush Mar 01 06:57:20 pupper systemd[1]: Started Pupper Joystick service. Mar 01 06:57:21 pupper python3[5692]: [info][controller 1] Created devices /dev/input/js0 (joystick) /dev/input/event0 (evdev) Mar 01 06:57:21 pupper python3[5692]: [info][bluetooth] Scanning for devices #. Connect the PS4 controller to the Pi by putting it pairing mode. * To put it into pairing mode, hold the share button and circular Playstation button at the same time until it starts making quick double flashes. * If it starts making slow single flashes, hold the Playstation button down until it stops blinking and try again. #. Once the controller is connected, check the status again * Run ``sudo systemctl status joystick`` * It should now look something like:: pi@pupper(rw):~/StanfordQuadruped$ sudo systemctl status joystick ● joystick.service - Pupper Joystick service Loaded: loaded (/home/pi/PupperCommand/joystick.service; enabled; vendor preset: enabled) Active: active (running) since Sun 2020-03-01 06:57:20 GMT; 55s ago Main PID: 5692 (python3) Tasks: 2 (limit: 4035) Memory: 7.3M CGroup: /system.slice/joystick.service └─5692 /usr/bin/python3 /home/pi/PupperCommand/joystick.py Mar 01 06:57:20 pupper systemd[1]: Started Pupper Joystick service. Mar 01 06:57:21 pupper python3[5692]: [info][controller 1] Created devices /dev/input/js0 (joystick) /dev/input/event0 (evdev) Mar 01 06:57:21 pupper python3[5692]: [info][bluetooth] Scanning for devices Mar 01 06:58:12 pupper python3[5692]: [info][bluetooth] Found device A0:AB:51:33:B5:A0 Mar 01 06:58:13 pupper python3[5692]: [info][controller 1] Connected to Bluetooth Controller (A0:AB:51:33:B5:A0) Mar 01 06:58:14 pupper python3[5692]: running Mar 01 06:58:14 pupper python3[5692]: [info][controller 1] Battery: 50% * If the pi can't find the joystick after a minute or two, it's possible that the pi's bluetooth controller was never turned on. Run ``sudo hciconfig hci0 up`` to turn the radio on. Then restart the pi. #. Check the status of the robot service * Run ``sudo systemctl status robot`` * The output varies depending on the order of you running various programs, but just check that it doesn't have any red text saying that it failed. * If it did fail, usually this fixes it: ``sudo systemctl restart robot`` 7. Done! ######### Continue to Calibration.

reStructuredText

renanmb/Omniverse_legged_robotics/URDF-Descriptions/Mini_pupper/QuadrupedRobot-mini_pupper/Mangdang/Example/display/demo.py

import os import sys from PIL import Image sys.path.append("/home/ubuntu/Robotics/QuadrupedRobot") sys.path.extend([os.path.join(root, name) for root, dirs, _ in os.walk("/home/ubuntu/Robotics/QuadrupedRobot") for name in dirs]) from Mangdang.LCD.ST7789 import ST7789 def main(): """ The demo for picture show """ # init st7789 device disp = ST7789() disp.begin() disp.clear() # show exaple picture image=Image.open("./dog.png") image.resize((320,240)) disp.display(image) main()

Python

renanmb/Omniverse_legged_robotics/URDF-Descriptions/Mini_pupper/QuadrupedRobot-mini_pupper/Mangdang/PWMController/pwm-pca9685.c

// SPDX-License-Identifier: GPL-2.0-only /* * Driver for PCA9685 16-channel 12-bit PWM LED controller * * Copyright (C) 2013 Steffen Trumtrar <s.trumtrar@pengutronix.de> * Copyright (C) 2015 Clemens Gruber <clemens.gruber@pqgruber.com> * * based on the pwm-twl-led.c driver */ #include <linux/acpi.h> #include <linux/gpio/driver.h> #include <linux/i2c.h> #include <linux/module.h> #include <linux/mutex.h> #include <linux/platform_device.h> #include <linux/property.h> #include <linux/pwm.h> #include <linux/regmap.h> #include <linux/slab.h> #include <linux/delay.h> #include <linux/pm_runtime.h> #include <linux/bitmap.h> /* * Because the PCA9685 has only one prescaler per chip, only the first channel * that is enabled is allowed to change the prescale register. * PWM channels requested afterwards must use a period that results in the same * prescale setting as the one set by the first requested channel. * GPIOs do not count as enabled PWMs as they are not using the prescaler. */ #define PCA9685_MODE1 0x00 #define PCA9685_MODE2 0x01 #define PCA9685_SUBADDR1 0x02 #define PCA9685_SUBADDR2 0x03 #define PCA9685_SUBADDR3 0x04 #define PCA9685_ALLCALLADDR 0x05 #define PCA9685_LEDX_ON_L 0x06 #define PCA9685_LEDX_ON_H 0x07 #define PCA9685_LEDX_OFF_L 0x08 #define PCA9685_LEDX_OFF_H 0x09 #define PCA9685_ALL_LED_ON_L 0xFA #define PCA9685_ALL_LED_ON_H 0xFB #define PCA9685_ALL_LED_OFF_L 0xFC #define PCA9685_ALL_LED_OFF_H 0xFD #define PCA9685_PRESCALE 0xFE #define PCA9685_PRESCALE_MIN 0x03 /* => max. frequency of 1526 Hz */ #define PCA9685_PRESCALE_MAX 0xFF /* => min. frequency of 24 Hz */ #define PCA9685_COUNTER_RANGE 4096 #define PCA9685_OSC_CLOCK_MHZ 25 /* Internal oscillator with 25 MHz */ #define PCA9685_NUMREGS 0xFF #define PCA9685_MAXCHAN 0x10 #define LED_FULL BIT(4) #define MODE1_ALLCALL BIT(0) #define MODE1_SUB3 BIT(1) #define MODE1_SUB2 BIT(2) #define MODE1_SUB1 BIT(3) #define MODE1_SLEEP BIT(4) #define MODE2_INVRT BIT(4) #define MODE2_OUTDRV BIT(2) #define LED_N_ON_H(N) (PCA9685_LEDX_ON_H + (4 * (N))) #define LED_N_ON_L(N) (PCA9685_LEDX_ON_L + (4 * (N))) #define LED_N_OFF_H(N) (PCA9685_LEDX_OFF_H + (4 * (N))) #define LED_N_OFF_L(N) (PCA9685_LEDX_OFF_L + (4 * (N))) #define REG_ON_H(C) ((C) >= PCA9685_MAXCHAN ? PCA9685_ALL_LED_ON_H : LED_N_ON_H((C))) #define REG_ON_L(C) ((C) >= PCA9685_MAXCHAN ? PCA9685_ALL_LED_ON_L : LED_N_ON_L((C))) #define REG_OFF_H(C) ((C) >= PCA9685_MAXCHAN ? PCA9685_ALL_LED_OFF_H : LED_N_OFF_H((C))) #define REG_OFF_L(C) ((C) >= PCA9685_MAXCHAN ? PCA9685_ALL_LED_OFF_L : LED_N_OFF_L((C))) struct pca9685 { struct pwm_chip chip; struct regmap *regmap; struct mutex lock; DECLARE_BITMAP(pwms_enabled, PCA9685_MAXCHAN + 1); #if IS_ENABLED(CONFIG_GPIOLIB) struct gpio_chip gpio; DECLARE_BITMAP(pwms_inuse, PCA9685_MAXCHAN + 1); #endif }; static inline struct pca9685 *to_pca(struct pwm_chip *chip) { return container_of(chip, struct pca9685, chip); } /* This function is supposed to be called with the lock mutex held */ static bool pca9685_prescaler_can_change(struct pca9685 *pca, int channel) { /* No PWM enabled: Change allowed */ if (bitmap_empty(pca->pwms_enabled, PCA9685_MAXCHAN + 1)) return true; /* More than one PWM enabled: Change not allowed */ if (bitmap_weight(pca->pwms_enabled, PCA9685_MAXCHAN + 1) > 1) return false; /* * Only one PWM enabled: Change allowed if the PWM about to * be changed is the one that is already enabled */ return test_bit(channel, pca->pwms_enabled); } /* Helper function to set the duty cycle ratio to duty/4096 (e.g. duty=2048 -> 50%) */ static void pca9685_pwm_set_duty(struct pca9685 *pca, int channel, unsigned int duty) { if (duty == 0) { /* Set the full OFF bit, which has the highest precedence */ regmap_write(pca->regmap, REG_OFF_H(channel), LED_FULL); } else if (duty >= PCA9685_COUNTER_RANGE) { /* Set the full ON bit and clear the full OFF bit */ regmap_write(pca->regmap, REG_ON_H(channel), LED_FULL); regmap_write(pca->regmap, REG_OFF_H(channel), 0); } else { /* Set OFF time (clears the full OFF bit) */ regmap_write(pca->regmap, REG_OFF_L(channel), duty & 0xff); regmap_write(pca->regmap, REG_OFF_H(channel), (duty >> 8) & 0xf); /* Clear the full ON bit */ regmap_write(pca->regmap, REG_ON_H(channel), 0); } } static unsigned int pca9685_pwm_get_duty(struct pca9685 *pca, int channel) { unsigned int off_h = 0, val = 0; if (WARN_ON(channel >= PCA9685_MAXCHAN)) { /* HW does not support reading state of "all LEDs" channel */ return 0; } regmap_read(pca->regmap, LED_N_OFF_H(channel), &off_h); if (off_h & LED_FULL) { /* Full OFF bit is set */ return 0; } regmap_read(pca->regmap, LED_N_ON_H(channel), &val); if (val & LED_FULL) { /* Full ON bit is set */ return PCA9685_COUNTER_RANGE; } if (regmap_read(pca->regmap, LED_N_OFF_L(channel), &val)) { /* Reset val to 0 in case reading LED_N_OFF_L failed */ val = 0; } return ((off_h & 0xf) << 8) | (val & 0xff); } #if IS_ENABLED(CONFIG_GPIOLIB) static bool pca9685_pwm_test_and_set_inuse(struct pca9685 *pca, int pwm_idx) { bool is_inuse; mutex_lock(&pca->lock); if (pwm_idx >= PCA9685_MAXCHAN) { /* * "All LEDs" channel: * pretend already in use if any of the PWMs are requested */ if (!bitmap_empty(pca->pwms_inuse, PCA9685_MAXCHAN)) { is_inuse = true; goto out; } } else { /* * Regular channel: * pretend already in use if the "all LEDs" channel is requested */ if (test_bit(PCA9685_MAXCHAN, pca->pwms_inuse)) { is_inuse = true; goto out; } } is_inuse = test_and_set_bit(pwm_idx, pca->pwms_inuse); out: mutex_unlock(&pca->lock); return is_inuse; } static void pca9685_pwm_clear_inuse(struct pca9685 *pca, int pwm_idx) { mutex_lock(&pca->lock); clear_bit(pwm_idx, pca->pwms_inuse); mutex_unlock(&pca->lock); } static int pca9685_pwm_gpio_request(struct gpio_chip *gpio, unsigned int offset) { struct pca9685 *pca = gpiochip_get_data(gpio); if (pca9685_pwm_test_and_set_inuse(pca, offset)) return -EBUSY; pm_runtime_get_sync(pca->chip.dev); return 0; } static int pca9685_pwm_gpio_get(struct gpio_chip *gpio, unsigned int offset) { struct pca9685 *pca = gpiochip_get_data(gpio); return pca9685_pwm_get_duty(pca, offset) != 0; } static void pca9685_pwm_gpio_set(struct gpio_chip *gpio, unsigned int offset, int value) { struct pca9685 *pca = gpiochip_get_data(gpio); pca9685_pwm_set_duty(pca, offset, value ? PCA9685_COUNTER_RANGE : 0); } static void pca9685_pwm_gpio_free(struct gpio_chip *gpio, unsigned int offset) { struct pca9685 *pca = gpiochip_get_data(gpio); pca9685_pwm_set_duty(pca, offset, 0); pm_runtime_put(pca->chip.dev); pca9685_pwm_clear_inuse(pca, offset); } static int pca9685_pwm_gpio_get_direction(struct gpio_chip *chip, unsigned int offset) { /* Always out */ return GPIO_LINE_DIRECTION_OUT; } static int pca9685_pwm_gpio_direction_input(struct gpio_chip *gpio, unsigned int offset) { return -EINVAL; } static int pca9685_pwm_gpio_direction_output(struct gpio_chip *gpio, unsigned int offset, int value) { pca9685_pwm_gpio_set(gpio, offset, value); return 0; } /* * The PCA9685 has a bit for turning the PWM output full off or on. Some * boards like Intel Galileo actually uses these as normal GPIOs so we * expose a GPIO chip here which can exclusively take over the underlying * PWM channel. */ static int pca9685_pwm_gpio_probe(struct pca9685 *pca) { struct device *dev = pca->chip.dev; pca->gpio.label = dev_name(dev); pca->gpio.parent = dev; pca->gpio.request = pca9685_pwm_gpio_request; pca->gpio.free = pca9685_pwm_gpio_free; pca->gpio.get_direction = pca9685_pwm_gpio_get_direction; pca->gpio.direction_input = pca9685_pwm_gpio_direction_input; pca->gpio.direction_output = pca9685_pwm_gpio_direction_output; pca->gpio.get = pca9685_pwm_gpio_get; pca->gpio.set = pca9685_pwm_gpio_set; pca->gpio.base = -1; pca->gpio.ngpio = PCA9685_MAXCHAN; pca->gpio.can_sleep = true; return devm_gpiochip_add_data(dev, &pca->gpio, pca); } #else static inline bool pca9685_pwm_test_and_set_inuse(struct pca9685 *pca, int pwm_idx) { return false; } static inline void pca9685_pwm_clear_inuse(struct pca9685 *pca, int pwm_idx) { } static inline int pca9685_pwm_gpio_probe(struct pca9685 *pca) { return 0; } #endif static void pca9685_set_sleep_mode(struct pca9685 *pca, bool enable) { regmap_update_bits(pca->regmap, PCA9685_MODE1, MODE1_SLEEP, enable ? MODE1_SLEEP : 0); if (!enable) { /* Wait 500us for the oscillator to be back up */ udelay(500); } } static int __pca9685_pwm_apply(struct pwm_chip *chip, struct pwm_device *pwm, const struct pwm_state *state) { struct pca9685 *pca = to_pca(chip); unsigned long long duty, prescale; unsigned int val = 0; if (state->polarity != PWM_POLARITY_NORMAL) return -EINVAL; prescale = DIV_ROUND_CLOSEST_ULL(PCA9685_OSC_CLOCK_MHZ * state->period, PCA9685_COUNTER_RANGE * 1000) - 1; if (prescale < PCA9685_PRESCALE_MIN || prescale > PCA9685_PRESCALE_MAX) { dev_err(chip->dev, "pwm not changed: period out of bounds!\n"); return -EINVAL; } if (!state->enabled) { pca9685_pwm_set_duty(pca, pwm->hwpwm, 0); return 0; } regmap_read(pca->regmap, PCA9685_PRESCALE, &val); if (prescale != val) { if (!pca9685_prescaler_can_change(pca, pwm->hwpwm)) { dev_err(chip->dev, "pwm not changed: periods of enabled pwms must match!\n"); return -EBUSY; } /* * Putting the chip briefly into SLEEP mode * at this point won't interfere with the * pm_runtime framework, because the pm_runtime * state is guaranteed active here. */ /* Put chip into sleep mode */ pca9685_set_sleep_mode(pca, true); /* Change the chip-wide output frequency */ regmap_write(pca->regmap, PCA9685_PRESCALE, prescale); /* Wake the chip up */ pca9685_set_sleep_mode(pca, false); } duty = PCA9685_COUNTER_RANGE * state->duty_cycle; duty = DIV_ROUND_UP_ULL(duty, state->period); pca9685_pwm_set_duty(pca, pwm->hwpwm, duty); return 0; } static int pca9685_pwm_apply(struct pwm_chip *chip, struct pwm_device *pwm, const struct pwm_state *state) { struct pca9685 *pca = to_pca(chip); int ret; mutex_lock(&pca->lock); ret = __pca9685_pwm_apply(chip, pwm, state); if (ret == 0) { if (state->enabled) set_bit(pwm->hwpwm, pca->pwms_enabled); else clear_bit(pwm->hwpwm, pca->pwms_enabled); } mutex_unlock(&pca->lock); return ret; } static void pca9685_pwm_get_state(struct pwm_chip *chip, struct pwm_device *pwm, struct pwm_state *state) { struct pca9685 *pca = to_pca(chip); unsigned long long duty; unsigned int val = 0; /* Calculate (chip-wide) period from prescale value */ regmap_read(pca->regmap, PCA9685_PRESCALE, &val); /* * PCA9685_OSC_CLOCK_MHZ is 25, i.e. an integer divider of 1000. * The following calculation is therefore only a multiplication * and we are not losing precision. */ state->period = (PCA9685_COUNTER_RANGE * 1000 / PCA9685_OSC_CLOCK_MHZ) * (val + 1); /* The (per-channel) polarity is fixed */ state->polarity = PWM_POLARITY_NORMAL; if (pwm->hwpwm >= PCA9685_MAXCHAN) { /* * The "all LEDs" channel does not support HW readout * Return 0 and disabled for backwards compatibility */ state->duty_cycle = 0; state->enabled = false; return; } state->enabled = true; duty = pca9685_pwm_get_duty(pca, pwm->hwpwm); state->duty_cycle = DIV_ROUND_DOWN_ULL(duty * state->period, PCA9685_COUNTER_RANGE); } static int pca9685_pwm_request(struct pwm_chip *chip, struct pwm_device *pwm) { struct pca9685 *pca = to_pca(chip); if (pca9685_pwm_test_and_set_inuse(pca, pwm->hwpwm)) return -EBUSY; if (pwm->hwpwm < PCA9685_MAXCHAN) { /* PWMs - except the "all LEDs" channel - default to enabled */ mutex_lock(&pca->lock); set_bit(pwm->hwpwm, pca->pwms_enabled); mutex_unlock(&pca->lock); } pm_runtime_get_sync(chip->dev); return 0; } static void pca9685_pwm_free(struct pwm_chip *chip, struct pwm_device *pwm) { struct pca9685 *pca = to_pca(chip); mutex_lock(&pca->lock); pca9685_pwm_set_duty(pca, pwm->hwpwm, 0); clear_bit(pwm->hwpwm, pca->pwms_enabled); mutex_unlock(&pca->lock); pm_runtime_put(chip->dev); pca9685_pwm_clear_inuse(pca, pwm->hwpwm); } static const struct pwm_ops pca9685_pwm_ops = { .apply = pca9685_pwm_apply, .get_state = pca9685_pwm_get_state, .request = pca9685_pwm_request, .free = pca9685_pwm_free, .owner = THIS_MODULE, }; static const struct regmap_config pca9685_regmap_i2c_config = { .reg_bits = 8, .val_bits = 8, .max_register = PCA9685_NUMREGS, .cache_type = REGCACHE_NONE, }; static int pca9685_pwm_probe(struct i2c_client *client, const struct i2c_device_id *id) { struct pca9685 *pca; unsigned int reg; int ret; pca = devm_kzalloc(&client->dev, sizeof(*pca), GFP_KERNEL); if (!pca) return -ENOMEM; pca->regmap = devm_regmap_init_i2c(client, &pca9685_regmap_i2c_config); if (IS_ERR(pca->regmap)) { ret = PTR_ERR(pca->regmap); dev_err(&client->dev, "Failed to initialize register map: %d\n", ret); return ret; } i2c_set_clientdata(client, pca); mutex_init(&pca->lock); regmap_read(pca->regmap, PCA9685_MODE2, &reg); if (device_property_read_bool(&client->dev, "invert")) reg |= MODE2_INVRT; else reg &= ~MODE2_INVRT; if (device_property_read_bool(&client->dev, "open-drain")) reg &= ~MODE2_OUTDRV; else reg |= MODE2_OUTDRV; regmap_write(pca->regmap, PCA9685_MODE2, reg); /* Disable all LED ALLCALL and SUBx addresses to avoid bus collisions */ regmap_read(pca->regmap, PCA9685_MODE1, &reg); reg &= ~(MODE1_ALLCALL | MODE1_SUB1 | MODE1_SUB2 | MODE1_SUB3); regmap_write(pca->regmap, PCA9685_MODE1, reg); /* Reset OFF registers to POR default */ regmap_write(pca->regmap, PCA9685_ALL_LED_OFF_L, LED_FULL); regmap_write(pca->regmap, PCA9685_ALL_LED_OFF_H, LED_FULL); pca->chip.ops = &pca9685_pwm_ops; /* Add an extra channel for ALL_LED */ pca->chip.npwm = PCA9685_MAXCHAN + 1; pca->chip.dev = &client->dev; ret = pwmchip_add(&pca->chip); if (ret < 0) return ret; ret = pca9685_pwm_gpio_probe(pca); if (ret < 0) { pwmchip_remove(&pca->chip); return ret; } pm_runtime_enable(&client->dev); if (pm_runtime_enabled(&client->dev)) { /* * Although the chip comes out of power-up in the sleep state, * we force it to sleep in case it was woken up before */ pca9685_set_sleep_mode(pca, true); pm_runtime_set_suspended(&client->dev); } else { /* Wake the chip up if runtime PM is disabled */ pca9685_set_sleep_mode(pca, false); } return 0; } static int pca9685_pwm_remove(struct i2c_client *client) { struct pca9685 *pca = i2c_get_clientdata(client); int ret; //ret = pwmchip_remove(&pca->chip); pwmchip_remove(&pca->chip); //if (ret) // return ret; if (!pm_runtime_enabled(&client->dev)) { /* Put chip in sleep state if runtime PM is disabled */ pca9685_set_sleep_mode(pca, true); } pm_runtime_disable(&client->dev); return 0; } static int __maybe_unused pca9685_pwm_runtime_suspend(struct device *dev) { struct i2c_client *client = to_i2c_client(dev); struct pca9685 *pca = i2c_get_clientdata(client); pca9685_set_sleep_mode(pca, true); return 0; } static int __maybe_unused pca9685_pwm_runtime_resume(struct device *dev) { struct i2c_client *client = to_i2c_client(dev); struct pca9685 *pca = i2c_get_clientdata(client); pca9685_set_sleep_mode(pca, false); return 0; } static const struct i2c_device_id pca9685_id[] = { { "pca9685", 0 }, { /* sentinel */ }, }; MODULE_DEVICE_TABLE(i2c, pca9685_id); #ifdef CONFIG_ACPI static const struct acpi_device_id pca9685_acpi_ids[] = { { "INT3492", 0 }, { /* sentinel */ }, }; MODULE_DEVICE_TABLE(acpi, pca9685_acpi_ids); #endif #ifdef CONFIG_OF static const struct of_device_id pca9685_dt_ids[] = { { .compatible = "nxp,pca9685-pwm", }, { /* sentinel */ } }; MODULE_DEVICE_TABLE(of, pca9685_dt_ids); #endif static const struct dev_pm_ops pca9685_pwm_pm = { SET_RUNTIME_PM_OPS(pca9685_pwm_runtime_suspend, pca9685_pwm_runtime_resume, NULL) }; static struct i2c_driver pca9685_i2c_driver = { .driver = { .name = "pca9685-pwm", .acpi_match_table = ACPI_PTR(pca9685_acpi_ids), .of_match_table = of_match_ptr(pca9685_dt_ids), .pm = &pca9685_pwm_pm, }, .probe = pca9685_pwm_probe, .remove = pca9685_pwm_remove, .id_table = pca9685_id, }; module_i2c_driver(pca9685_i2c_driver); MODULE_AUTHOR("Steffen Trumtrar <s.trumtrar@pengutronix.de>"); MODULE_DESCRIPTION("PWM driver for PCA9685"); MODULE_LICENSE("GPL");

C

renanmb/Omniverse_legged_robotics/URDF-Descriptions/Mini_pupper/QuadrupedRobot-mini_pupper/Mangdang/EEPROM/at24.c

// SPDX-License-Identifier: GPL-2.0-or-later /* * at24.c - handle most I2C EEPROMs * * Copyright (C) 2005-2007 David Brownell * Copyright (C) 2008 Wolfram Sang, Pengutronix */ #include <linux/acpi.h> #include <linux/bitops.h> #include <linux/capability.h> #include <linux/delay.h> #include <linux/i2c.h> #include <linux/init.h> #include <linux/jiffies.h> #include <linux/kernel.h> #include <linux/mod_devicetable.h> #include <linux/module.h> #include <linux/mutex.h> #include <linux/nvmem-provider.h> #include <linux/of_device.h> #include <linux/pm_runtime.h> #include <linux/property.h> #include <linux/regmap.h> #include <linux/regulator/consumer.h> #include <linux/slab.h> /* Address pointer is 16 bit. */ #define AT24_FLAG_ADDR16 BIT(7) /* sysfs-entry will be read-only. */ #define AT24_FLAG_READONLY BIT(6) /* sysfs-entry will be world-readable. */ #define AT24_FLAG_IRUGO BIT(5) /* Take always 8 addresses (24c00). */ #define AT24_FLAG_TAKE8ADDR BIT(4) /* Factory-programmed serial number. */ #define AT24_FLAG_SERIAL BIT(3) /* Factory-programmed mac address. */ #define AT24_FLAG_MAC BIT(2) /* Does not auto-rollover reads to the next slave address. */ #define AT24_FLAG_NO_RDROL BIT(1) /* * I2C EEPROMs from most vendors are inexpensive and mostly interchangeable. * Differences between different vendor product lines (like Atmel AT24C or * MicroChip 24LC, etc) won't much matter for typical read/write access. * There are also I2C RAM chips, likewise interchangeable. One example * would be the PCF8570, which acts like a 24c02 EEPROM (256 bytes). * * However, misconfiguration can lose data. "Set 16-bit memory address" * to a part with 8-bit addressing will overwrite data. Writing with too * big a page size also loses data. And it's not safe to assume that the * conventional addresses 0x50..0x57 only hold eeproms; a PCF8563 RTC * uses 0x51, for just one example. * * Accordingly, explicit board-specific configuration data should be used * in almost all cases. (One partial exception is an SMBus used to access * "SPD" data for DRAM sticks. Those only use 24c02 EEPROMs.) * * So this driver uses "new style" I2C driver binding, expecting to be * told what devices exist. That may be in arch/X/mach-Y/board-Z.c or * similar kernel-resident tables; or, configuration data coming from * a bootloader. * * Other than binding model, current differences from "eeprom" driver are * that this one handles write access and isn't restricted to 24c02 devices. * It also handles larger devices (32 kbit and up) with two-byte addresses, * which won't work on pure SMBus systems. */ struct at24_client { struct i2c_client *client; struct regmap *regmap; }; struct at24_data { /* * Lock protects against activities from other Linux tasks, * but not from changes by other I2C masters. */ struct mutex lock; unsigned int write_max; unsigned int num_addresses; unsigned int offset_adj; u32 byte_len; u16 page_size; u8 flags; struct nvmem_device *nvmem; struct regulator *vcc_reg; void (*read_post)(unsigned int off, char *buf, size_t count); /* * Some chips tie up multiple I2C addresses; dummy devices reserve * them for us, and we'll use them with SMBus calls. */ struct at24_client client[]; }; /* * This parameter is to help this driver avoid blocking other drivers out * of I2C for potentially troublesome amounts of time. With a 100 kHz I2C * clock, one 256 byte read takes about 1/43 second which is excessive; * but the 1/170 second it takes at 400 kHz may be quite reasonable; and * at 1 MHz (Fm+) a 1/430 second delay could easily be invisible. * * This value is forced to be a power of two so that writes align on pages. */ static unsigned int at24_io_limit = 128; module_param_named(io_limit, at24_io_limit, uint, 0); MODULE_PARM_DESC(at24_io_limit, "Maximum bytes per I/O (default 128)"); /* * Specs often allow 5 msec for a page write, sometimes 20 msec; * it's important to recover from write timeouts. */ static unsigned int at24_write_timeout = 25; module_param_named(write_timeout, at24_write_timeout, uint, 0); MODULE_PARM_DESC(at24_write_timeout, "Time (in ms) to try writes (default 25)"); struct at24_chip_data { u32 byte_len; u8 flags; void (*read_post)(unsigned int off, char *buf, size_t count); }; #define AT24_CHIP_DATA(_name, _len, _flags) \ static const struct at24_chip_data _name = { \ .byte_len = _len, .flags = _flags, \ } #define AT24_CHIP_DATA_CB(_name, _len, _flags, _read_post) \ static const struct at24_chip_data _name = { \ .byte_len = _len, .flags = _flags, \ .read_post = _read_post, \ } static void at24_read_post_vaio(unsigned int off, char *buf, size_t count) { int i; if (capable(CAP_SYS_ADMIN)) return; /* * Hide VAIO private settings to regular users: * - BIOS passwords: bytes 0x00 to 0x0f * - UUID: bytes 0x10 to 0x1f * - Serial number: 0xc0 to 0xdf */ for (i = 0; i < count; i++) { if ((off + i <= 0x1f) || (off + i >= 0xc0 && off + i <= 0xdf)) buf[i] = 0; } } /* needs 8 addresses as A0-A2 are ignored */ AT24_CHIP_DATA(at24_data_24c00, 128 / 8, AT24_FLAG_TAKE8ADDR); /* old variants can't be handled with this generic entry! */ AT24_CHIP_DATA(at24_data_24c01, 1024 / 8, 0); AT24_CHIP_DATA(at24_data_24cs01, 16, AT24_FLAG_SERIAL | AT24_FLAG_READONLY); AT24_CHIP_DATA(at24_data_24c02, 2048 / 8, 0); AT24_CHIP_DATA(at24_data_24cs02, 16, AT24_FLAG_SERIAL | AT24_FLAG_READONLY); AT24_CHIP_DATA(at24_data_24mac402, 48 / 8, AT24_FLAG_MAC | AT24_FLAG_READONLY); AT24_CHIP_DATA(at24_data_24mac602, 64 / 8, AT24_FLAG_MAC | AT24_FLAG_READONLY); /* spd is a 24c02 in memory DIMMs */ AT24_CHIP_DATA(at24_data_spd, 2048 / 8, AT24_FLAG_READONLY | AT24_FLAG_IRUGO); /* 24c02_vaio is a 24c02 on some Sony laptops */ AT24_CHIP_DATA_CB(at24_data_24c02_vaio, 2048 / 8, AT24_FLAG_READONLY | AT24_FLAG_IRUGO, at24_read_post_vaio); AT24_CHIP_DATA(at24_data_24c04, 4096 / 8, 0); AT24_CHIP_DATA(at24_data_24cs04, 16, AT24_FLAG_SERIAL | AT24_FLAG_READONLY); /* 24rf08 quirk is handled at i2c-core */ AT24_CHIP_DATA(at24_data_24c08, 8192 / 8, 0); AT24_CHIP_DATA(at24_data_24cs08, 16, AT24_FLAG_SERIAL | AT24_FLAG_READONLY); AT24_CHIP_DATA(at24_data_24c16, 16384 / 8, 0); AT24_CHIP_DATA(at24_data_24cs16, 16, AT24_FLAG_SERIAL | AT24_FLAG_READONLY); AT24_CHIP_DATA(at24_data_24c32, 32768 / 8, AT24_FLAG_ADDR16); AT24_CHIP_DATA(at24_data_24cs32, 16, AT24_FLAG_ADDR16 | AT24_FLAG_SERIAL | AT24_FLAG_READONLY); AT24_CHIP_DATA(at24_data_24c64, 65536 / 8, AT24_FLAG_ADDR16); AT24_CHIP_DATA(at24_data_24cs64, 16, AT24_FLAG_ADDR16 | AT24_FLAG_SERIAL | AT24_FLAG_READONLY); AT24_CHIP_DATA(at24_data_24c128, 131072 / 8, AT24_FLAG_ADDR16); AT24_CHIP_DATA(at24_data_24c256, 262144 / 8, AT24_FLAG_ADDR16); AT24_CHIP_DATA(at24_data_24c512, 524288 / 8, AT24_FLAG_ADDR16); AT24_CHIP_DATA(at24_data_24c1024, 1048576 / 8, AT24_FLAG_ADDR16); AT24_CHIP_DATA(at24_data_24c2048, 2097152 / 8, AT24_FLAG_ADDR16); /* identical to 24c08 ? */ AT24_CHIP_DATA(at24_data_INT3499, 8192 / 8, 0); static const struct i2c_device_id at24_ids[] = { { "24c00", (kernel_ulong_t)&at24_data_24c00 }, { "24c01", (kernel_ulong_t)&at24_data_24c01 }, { "24cs01", (kernel_ulong_t)&at24_data_24cs01 }, { "24c02", (kernel_ulong_t)&at24_data_24c02 }, { "24cs02", (kernel_ulong_t)&at24_data_24cs02 }, { "24mac402", (kernel_ulong_t)&at24_data_24mac402 }, { "24mac602", (kernel_ulong_t)&at24_data_24mac602 }, { "spd", (kernel_ulong_t)&at24_data_spd }, { "24c02-vaio", (kernel_ulong_t)&at24_data_24c02_vaio }, { "24c04", (kernel_ulong_t)&at24_data_24c04 }, { "24cs04", (kernel_ulong_t)&at24_data_24cs04 }, { "24c08", (kernel_ulong_t)&at24_data_24c08 }, { "24cs08", (kernel_ulong_t)&at24_data_24cs08 }, { "24c16", (kernel_ulong_t)&at24_data_24c16 }, { "24cs16", (kernel_ulong_t)&at24_data_24cs16 }, { "24c32", (kernel_ulong_t)&at24_data_24c32 }, { "24cs32", (kernel_ulong_t)&at24_data_24cs32 }, { "24c64", (kernel_ulong_t)&at24_data_24c64 }, { "24cs64", (kernel_ulong_t)&at24_data_24cs64 }, { "24c128", (kernel_ulong_t)&at24_data_24c128 }, { "24c256", (kernel_ulong_t)&at24_data_24c256 }, { "24c512", (kernel_ulong_t)&at24_data_24c512 }, { "24c1024", (kernel_ulong_t)&at24_data_24c1024 }, { "24c2048", (kernel_ulong_t)&at24_data_24c2048 }, { "at24", 0 }, { /* END OF LIST */ } }; MODULE_DEVICE_TABLE(i2c, at24_ids); static const struct of_device_id at24_of_match[] = { { .compatible = "atmel,24c00", .data = &at24_data_24c00 }, { .compatible = "atmel,24c01", .data = &at24_data_24c01 }, { .compatible = "atmel,24cs01", .data = &at24_data_24cs01 }, { .compatible = "atmel,24c02", .data = &at24_data_24c02 }, { .compatible = "atmel,24cs02", .data = &at24_data_24cs02 }, { .compatible = "atmel,24mac402", .data = &at24_data_24mac402 }, { .compatible = "atmel,24mac602", .data = &at24_data_24mac602 }, { .compatible = "atmel,spd", .data = &at24_data_spd }, { .compatible = "atmel,24c04", .data = &at24_data_24c04 }, { .compatible = "atmel,24cs04", .data = &at24_data_24cs04 }, { .compatible = "atmel,24c08", .data = &at24_data_24c08 }, { .compatible = "atmel,24cs08", .data = &at24_data_24cs08 }, { .compatible = "atmel,24c16", .data = &at24_data_24c16 }, { .compatible = "atmel,24cs16", .data = &at24_data_24cs16 }, { .compatible = "atmel,24c32", .data = &at24_data_24c32 }, { .compatible = "atmel,24cs32", .data = &at24_data_24cs32 }, { .compatible = "atmel,24c64", .data = &at24_data_24c64 }, { .compatible = "atmel,24cs64", .data = &at24_data_24cs64 }, { .compatible = "atmel,24c128", .data = &at24_data_24c128 }, { .compatible = "atmel,24c256", .data = &at24_data_24c256 }, { .compatible = "atmel,24c512", .data = &at24_data_24c512 }, { .compatible = "atmel,24c1024", .data = &at24_data_24c1024 }, { .compatible = "atmel,24c2048", .data = &at24_data_24c2048 }, { /* END OF LIST */ }, }; MODULE_DEVICE_TABLE(of, at24_of_match); static const struct acpi_device_id __maybe_unused at24_acpi_ids[] = { { "INT3499", (kernel_ulong_t)&at24_data_INT3499 }, { "TPF0001", (kernel_ulong_t)&at24_data_24c1024 }, { /* END OF LIST */ } }; MODULE_DEVICE_TABLE(acpi, at24_acpi_ids); /* * This routine supports chips which consume multiple I2C addresses. It * computes the addressing information to be used for a given r/w request. * Assumes that sanity checks for offset happened at sysfs-layer. * * Slave address and byte offset derive from the offset. Always * set the byte address; on a multi-master board, another master * may have changed the chip's "current" address pointer. */ static struct at24_client *at24_translate_offset(struct at24_data *at24, unsigned int *offset) { unsigned int i; if (at24->flags & AT24_FLAG_ADDR16) { i = *offset >> 16; *offset &= 0xffff; } else { i = *offset >> 8; *offset &= 0xff; } return &at24->client[i]; } static struct device *at24_base_client_dev(struct at24_data *at24) { return &at24->client[0].client->dev; } static size_t at24_adjust_read_count(struct at24_data *at24, unsigned int offset, size_t count) { unsigned int bits; size_t remainder; /* * In case of multi-address chips that don't rollover reads to * the next slave address: truncate the count to the slave boundary, * so that the read never straddles slaves. */ if (at24->flags & AT24_FLAG_NO_RDROL) { bits = (at24->flags & AT24_FLAG_ADDR16) ? 16 : 8; remainder = BIT(bits) - offset; if (count > remainder) count = remainder; } if (count > at24_io_limit) count = at24_io_limit; return count; } static ssize_t at24_regmap_read(struct at24_data *at24, char *buf, unsigned int offset, size_t count) { unsigned long timeout, read_time; struct at24_client *at24_client; struct i2c_client *client; struct regmap *regmap; int ret; at24_client = at24_translate_offset(at24, &offset); regmap = at24_client->regmap; client = at24_client->client; count = at24_adjust_read_count(at24, offset, count); /* adjust offset for mac and serial read ops */ offset += at24->offset_adj; timeout = jiffies + msecs_to_jiffies(at24_write_timeout); do { /* * The timestamp shall be taken before the actual operation * to avoid a premature timeout in case of high CPU load. */ read_time = jiffies; ret = regmap_bulk_read(regmap, offset, buf, count); dev_dbg(&client->dev, "read %zu@%d --> %d (%ld)\n", count, offset, ret, jiffies); if (!ret) return count; usleep_range(1000, 1500); } while (time_before(read_time, timeout)); return -ETIMEDOUT; } /* * Note that if the hardware write-protect pin is pulled high, the whole * chip is normally write protected. But there are plenty of product * variants here, including OTP fuses and partial chip protect. * * We only use page mode writes; the alternative is sloooow. These routines * write at most one page. */ static size_t at24_adjust_write_count(struct at24_data *at24, unsigned int offset, size_t count) { unsigned int next_page; /* write_max is at most a page */ if (count > at24->write_max) count = at24->write_max; /* Never roll over backwards, to the start of this page */ next_page = roundup(offset + 1, at24->page_size); if (offset + count > next_page) count = next_page - offset; return count; } static ssize_t at24_regmap_write(struct at24_data *at24, const char *buf, unsigned int offset, size_t count) { unsigned long timeout, write_time; struct at24_client *at24_client; struct i2c_client *client; struct regmap *regmap; int ret; at24_client = at24_translate_offset(at24, &offset); regmap = at24_client->regmap; client = at24_client->client; count = at24_adjust_write_count(at24, offset, count); timeout = jiffies + msecs_to_jiffies(at24_write_timeout); do { /* * The timestamp shall be taken before the actual operation * to avoid a premature timeout in case of high CPU load. */ write_time = jiffies; ret = regmap_bulk_write(regmap, offset, buf, count); dev_dbg(&client->dev, "write %zu@%d --> %d (%ld)\n", count, offset, ret, jiffies); if (!ret) return count; usleep_range(1000, 1500); } while (time_before(write_time, timeout)); return -ETIMEDOUT; } static int at24_read(void *priv, unsigned int off, void *val, size_t count) { struct at24_data *at24; struct device *dev; char *buf = val; int i, ret; at24 = priv; dev = at24_base_client_dev(at24); if (unlikely(!count)) return count; if (off + count > at24->byte_len) return -EINVAL; ret = pm_runtime_get_sync(dev); if (ret < 0) { pm_runtime_put_noidle(dev); return ret; } /* * Read data from chip, protecting against concurrent updates * from this host, but not from other I2C masters. */ mutex_lock(&at24->lock); for (i = 0; count; i += ret, count -= ret) { ret = at24_regmap_read(at24, buf + i, off + i, count); if (ret < 0) { mutex_unlock(&at24->lock); pm_runtime_put(dev); return ret; } } mutex_unlock(&at24->lock); pm_runtime_put(dev); if (unlikely(at24->read_post)) at24->read_post(off, buf, i); return 0; } static int at24_write(void *priv, unsigned int off, void *val, size_t count) { struct at24_data *at24; struct device *dev; char *buf = val; int ret; at24 = priv; dev = at24_base_client_dev(at24); if (unlikely(!count)) return -EINVAL; if (off + count > at24->byte_len) return -EINVAL; ret = pm_runtime_get_sync(dev); if (ret < 0) { pm_runtime_put_noidle(dev); return ret; } /* * Write data to chip, protecting against concurrent updates * from this host, but not from other I2C masters. */ mutex_lock(&at24->lock); while (count) { ret = at24_regmap_write(at24, buf, off, count); if (ret < 0) { mutex_unlock(&at24->lock); pm_runtime_put(dev); return ret; } buf += ret; off += ret; count -= ret; } mutex_unlock(&at24->lock); pm_runtime_put(dev); return 0; } static const struct at24_chip_data *at24_get_chip_data(struct device *dev) { struct device_node *of_node = dev->of_node; const struct at24_chip_data *cdata; const struct i2c_device_id *id; id = i2c_match_id(at24_ids, to_i2c_client(dev)); /* * The I2C core allows OF nodes compatibles to match against the * I2C device ID table as a fallback, so check not only if an OF * node is present but also if it matches an OF device ID entry. */ if (of_node && of_match_device(at24_of_match, dev)) cdata = of_device_get_match_data(dev); else if (id) cdata = (void *)id->driver_data; else cdata = acpi_device_get_match_data(dev); if (!cdata) return ERR_PTR(-ENODEV); return cdata; } static int at24_make_dummy_client(struct at24_data *at24, unsigned int index, struct regmap_config *regmap_config) { struct i2c_client *base_client, *dummy_client; struct regmap *regmap; struct device *dev; base_client = at24->client[0].client; dev = &base_client->dev; dummy_client = devm_i2c_new_dummy_device(dev, base_client->adapter, base_client->addr + index); if (IS_ERR(dummy_client)) return PTR_ERR(dummy_client); regmap = devm_regmap_init_i2c(dummy_client, regmap_config); if (IS_ERR(regmap)) return PTR_ERR(regmap); at24->client[index].client = dummy_client; at24->client[index].regmap = regmap; return 0; } static unsigned int at24_get_offset_adj(u8 flags, unsigned int byte_len) { if (flags & AT24_FLAG_MAC) { /* EUI-48 starts from 0x9a, EUI-64 from 0x98 */ return 0xa0 - byte_len; } else if (flags & AT24_FLAG_SERIAL && flags & AT24_FLAG_ADDR16) { /* * For 16 bit address pointers, the word address must contain * a '10' sequence in bits 11 and 10 regardless of the * intended position of the address pointer. */ return 0x0800; } else if (flags & AT24_FLAG_SERIAL) { /* * Otherwise the word address must begin with a '10' sequence, * regardless of the intended address. */ return 0x0080; } else { return 0; } } static int at24_probe(struct i2c_client *client) { struct regmap_config regmap_config = { }; struct nvmem_config nvmem_config = { }; u32 byte_len, page_size, flags, addrw; const struct at24_chip_data *cdata; struct device *dev = &client->dev; bool i2c_fn_i2c, i2c_fn_block; unsigned int i, num_addresses; struct at24_data *at24; struct regmap *regmap; bool writable; u8 test_byte; int err; i2c_fn_i2c = i2c_check_functionality(client->adapter, I2C_FUNC_I2C); i2c_fn_block = i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_WRITE_I2C_BLOCK); cdata = at24_get_chip_data(dev); if (IS_ERR(cdata)) return PTR_ERR(cdata); err = device_property_read_u32(dev, "pagesize", &page_size); if (err) /* * This is slow, but we can't know all eeproms, so we better * play safe. Specifying custom eeprom-types via device tree * or properties is recommended anyhow. */ page_size = 1; flags = cdata->flags; if (device_property_present(dev, "read-only")) flags |= AT24_FLAG_READONLY; if (device_property_present(dev, "no-read-rollover")) flags |= AT24_FLAG_NO_RDROL; err = device_property_read_u32(dev, "address-width", &addrw); if (!err) { switch (addrw) { case 8: if (flags & AT24_FLAG_ADDR16) dev_warn(dev, "Override address width to be 8, while default is 16\n"); flags &= ~AT24_FLAG_ADDR16; break; case 16: flags |= AT24_FLAG_ADDR16; break; default: dev_warn(dev, "Bad \"address-width\" property: %u\n", addrw); } } err = device_property_read_u32(dev, "size", &byte_len); if (err) byte_len = cdata->byte_len; if (!i2c_fn_i2c && !i2c_fn_block) page_size = 1; if (!page_size) { dev_err(dev, "page_size must not be 0!\n"); return -EINVAL; } if (!is_power_of_2(page_size)) dev_warn(dev, "page_size looks suspicious (no power of 2)!\n"); err = device_property_read_u32(dev, "num-addresses", &num_addresses); if (err) { if (flags & AT24_FLAG_TAKE8ADDR) num_addresses = 8; else num_addresses = DIV_ROUND_UP(byte_len, (flags & AT24_FLAG_ADDR16) ? 65536 : 256); } if ((flags & AT24_FLAG_SERIAL) && (flags & AT24_FLAG_MAC)) { dev_err(dev, "invalid device data - cannot have both AT24_FLAG_SERIAL & AT24_FLAG_MAC."); return -EINVAL; } regmap_config.val_bits = 8; regmap_config.reg_bits = (flags & AT24_FLAG_ADDR16) ? 16 : 8; regmap_config.disable_locking = true; regmap = devm_regmap_init_i2c(client, &regmap_config); if (IS_ERR(regmap)) return PTR_ERR(regmap); at24 = devm_kzalloc(dev, struct_size(at24, client, num_addresses), GFP_KERNEL); if (!at24) return -ENOMEM; mutex_init(&at24->lock); at24->byte_len = byte_len; at24->page_size = page_size; at24->flags = flags; at24->read_post = cdata->read_post; at24->num_addresses = num_addresses; at24->offset_adj = at24_get_offset_adj(flags, byte_len); at24->client[0].client = client; at24->client[0].regmap = regmap; at24->vcc_reg = devm_regulator_get(dev, "vcc"); if (IS_ERR(at24->vcc_reg)) return PTR_ERR(at24->vcc_reg); writable = !(flags & AT24_FLAG_READONLY); if (writable) { at24->write_max = min_t(unsigned int, page_size, at24_io_limit); if (!i2c_fn_i2c && at24->write_max > I2C_SMBUS_BLOCK_MAX) at24->write_max = I2C_SMBUS_BLOCK_MAX; } /* use dummy devices for multiple-address chips */ for (i = 1; i < num_addresses; i++) { err = at24_make_dummy_client(at24, i, &regmap_config); if (err) return err; } /* * We initialize nvmem_config.id to NVMEM_DEVID_AUTO even if the * label property is set as some platform can have multiple eeproms * with same label and we can not register each of those with same * label. Failing to register those eeproms trigger cascade failure * on such platform. */ nvmem_config.id = NVMEM_DEVID_AUTO; if (device_property_present(dev, "label")) { err = device_property_read_string(dev, "label", &nvmem_config.name); if (err) return err; } else { nvmem_config.name = dev_name(dev); } nvmem_config.type = NVMEM_TYPE_EEPROM; nvmem_config.dev = dev; nvmem_config.read_only = !writable; nvmem_config.root_only = !(flags & AT24_FLAG_IRUGO); nvmem_config.owner = THIS_MODULE; nvmem_config.compat = true; nvmem_config.base_dev = dev; nvmem_config.reg_read = at24_read; nvmem_config.reg_write = at24_write; nvmem_config.priv = at24; nvmem_config.stride = 1; nvmem_config.word_size = 1; nvmem_config.size = byte_len; i2c_set_clientdata(client, at24); err = regulator_enable(at24->vcc_reg); if (err) { dev_err(dev, "Failed to enable vcc regulator\n"); return err; } /* enable runtime pm */ pm_runtime_set_active(dev); pm_runtime_enable(dev); at24->nvmem = devm_nvmem_register(dev, &nvmem_config); if (IS_ERR(at24->nvmem)) { pm_runtime_disable(dev); if (!pm_runtime_status_suspended(dev)) regulator_disable(at24->vcc_reg); return PTR_ERR(at24->nvmem); } /* * Perform a one-byte test read to verify that the * chip is functional. */ err = at24_read(at24, 0, &test_byte, 1); if (err) { pm_runtime_disable(dev); if (!pm_runtime_status_suspended(dev)) regulator_disable(at24->vcc_reg); return -ENODEV; } pm_runtime_idle(dev); if (writable) dev_info(dev, "%u byte %s EEPROM, writable, %u bytes/write\n", byte_len, client->name, at24->write_max); else dev_info(dev, "%u byte %s EEPROM, read-only\n", byte_len, client->name); return 0; } static int at24_remove(struct i2c_client *client) { struct at24_data *at24 = i2c_get_clientdata(client); pm_runtime_disable(&client->dev); if (!pm_runtime_status_suspended(&client->dev)) regulator_disable(at24->vcc_reg); pm_runtime_set_suspended(&client->dev); return 0; } static int __maybe_unused at24_suspend(struct device *dev) { struct i2c_client *client = to_i2c_client(dev); struct at24_data *at24 = i2c_get_clientdata(client); return regulator_disable(at24->vcc_reg); } static int __maybe_unused at24_resume(struct device *dev) { struct i2c_client *client = to_i2c_client(dev); struct at24_data *at24 = i2c_get_clientdata(client); return regulator_enable(at24->vcc_reg); } static const struct dev_pm_ops at24_pm_ops = { SET_SYSTEM_SLEEP_PM_OPS(pm_runtime_force_suspend, pm_runtime_force_resume) SET_RUNTIME_PM_OPS(at24_suspend, at24_resume, NULL) }; static struct i2c_driver at24_driver = { .driver = { .name = "at24", .pm = &at24_pm_ops, .of_match_table = at24_of_match, .acpi_match_table = ACPI_PTR(at24_acpi_ids), }, .probe_new = at24_probe, .remove = at24_remove, .id_table = at24_ids, }; static int __init at24_init(void) { if (!at24_io_limit) { pr_err("at24: at24_io_limit must not be 0!\n"); return -EINVAL; } at24_io_limit = rounddown_pow_of_two(at24_io_limit); return i2c_add_driver(&at24_driver); } module_init(at24_init); static void __exit at24_exit(void) { i2c_del_driver(&at24_driver); } module_exit(at24_exit); MODULE_DESCRIPTION("Driver for most I2C EEPROMs"); MODULE_AUTHOR("David Brownell and Wolfram Sang"); MODULE_LICENSE("GPL");

C

renanmb/Omniverse_legged_robotics/URDF-Descriptions/Mini_pupper/QuadrupedRobot-mini_pupper/Mangdang/Adafruit_GPIO/__init__.py

from __future__ import absolute_import from Mangdang.Adafruit_GPIO.GPIO import *

Python

renanmb/Omniverse_legged_robotics/URDF-Descriptions/Mini_pupper/QuadrupedRobot-mini_pupper/Mangdang/Adafruit_GPIO/Platform.py

# Copyright (c) 2014 Adafruit Industries # Author: Tony DiCola # Permission is hereby granted, free of charge, to any person obtaining a copy # of this software and associated documentation files (the "Software"), to deal # in the Software without restriction, including without limitation the rights # to use, copy, modify, merge, publish, distribute, sublicense, and/or sell # copies of the Software, and to permit persons to whom the Software is # furnished to do so, subject to the following conditions: # The above copyright notice and this permission notice shall be included in all # copies or substantial portions of the Software. # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE # SOFTWARE. import platform import re # Platform identification constants. UNKNOWN = 0 RASPBERRY_PI = 1 BEAGLEBONE_BLACK = 2 MINNOWBOARD = 3 JETSON_NANO = 4 def platform_detect(): """Detect if running on the Raspberry Pi or Beaglebone Black and return the platform type. Will return RASPBERRY_PI, BEAGLEBONE_BLACK, or UNKNOWN.""" # Handle Raspberry Pi pi = pi_version() if pi is not None: return RASPBERRY_PI # Handle Beaglebone Black # TODO: Check the Beaglebone Black /proc/cpuinfo value instead of reading # the platform. plat = platform.platform() if plat.lower().find('armv7l-with-debian') > -1: return BEAGLEBONE_BLACK elif plat.lower().find('armv7l-with-ubuntu') > -1: return BEAGLEBONE_BLACK elif plat.lower().find('armv7l-with-glibc2.4') > -1: return BEAGLEBONE_BLACK elif plat.lower().find('tegra-aarch64-with-ubuntu') > -1: return JETSON_NANO # Handle Minnowboard # Assumption is that mraa is installed try: import mraa if mraa.getPlatformName()=='MinnowBoard MAX': return MINNOWBOARD except ImportError: pass # Couldn't figure out the platform, just return unknown. return UNKNOWN def pi_revision(): """Detect the revision number of a Raspberry Pi, useful for changing functionality like default I2C bus based on revision.""" # Revision list available at: http://elinux.org/RPi_HardwareHistory#Board_Revision_History with open('/proc/cpuinfo', 'r') as infile: for line in infile: # Match a line of the form "Revision : 0002" while ignoring extra # info in front of the revsion (like 1000 when the Pi was over-volted). match = re.match('Revision\s+:\s+.*(\w{4})$', line, flags=re.IGNORECASE) if match and match.group(1) in ['0000', '0002', '0003']: # Return revision 1 if revision ends with 0000, 0002 or 0003. return 1 elif match: # Assume revision 2 if revision ends with any other 4 chars. return 2 # Couldn't find the revision, throw an exception. raise RuntimeError('Could not determine Raspberry Pi revision.') def pi_version(): """Detect the version of the Raspberry Pi. Returns either 1, 2 or None depending on if it's a Raspberry Pi 1 (model A, B, A+, B+), Raspberry Pi 2 (model B+), or not a Raspberry Pi. """ # Check /proc/cpuinfo for the Hardware field value. # 2708 is pi 1 # 2709 is pi 2 # 2835 is pi 3 on 4.9.x kernel # Anything else is not a pi. with open('/proc/cpuinfo', 'r') as infile: cpuinfo = infile.read() # Match a line like 'Hardware : BCM2709' match = re.search('^Hardware\s+:\s+(\w+)$', cpuinfo, flags=re.MULTILINE | re.IGNORECASE) if not match: # Couldn't find the hardware, assume it isn't a pi. return None if match.group(1) == 'BCM2708': # Pi 1 return 1 elif match.group(1) == 'BCM2709': # Pi 2 return 2 elif match.group(1) == 'BCM2835': # Pi 3 / Pi on 4.9.x kernel return 3 else: # Something else, not a pi. return None

Python

renanmb/Omniverse_legged_robotics/URDF-Descriptions/Mini_pupper/QuadrupedRobot-mini_pupper/Mangdang/Adafruit_GPIO/GPIO.py

# Copyright (c) 2014 Adafruit Industries # Author: Tony DiCola # # Permission is hereby granted, free of charge, to any person obtaining a copy # of this software and associated documentation files (the "Software"), to deal # in the Software without restriction, including without limitation the rights # to use, copy, modify, merge, publish, distribute, sublicense, and/or sell # copies of the Software, and to permit persons to whom the Software is # furnished to do so, subject to the following conditions: # # The above copyright notice and this permission notice shall be included in # all copies or substantial portions of the Software. # # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN # THE SOFTWARE. import Adafruit_GPIO.Platform as Platform OUT = 0 IN = 1 HIGH = True LOW = False RISING = 1 FALLING = 2 BOTH = 3 PUD_OFF = 0 PUD_DOWN = 1 PUD_UP = 2 class BaseGPIO(object): """Base class for implementing simple digital IO for a platform. Implementors are expected to subclass from this and provide an implementation of the setup, output, and input functions.""" def setup(self, pin, mode, pull_up_down=PUD_OFF): """Set the input or output mode for a specified pin. Mode should be either OUT or IN.""" raise NotImplementedError def output(self, pin, value): """Set the specified pin the provided high/low value. Value should be either HIGH/LOW or a boolean (true = high).""" raise NotImplementedError def input(self, pin): """Read the specified pin and return HIGH/true if the pin is pulled high, or LOW/false if pulled low.""" raise NotImplementedError def set_high(self, pin): """Set the specified pin HIGH.""" self.output(pin, HIGH) def set_low(self, pin): """Set the specified pin LOW.""" self.output(pin, LOW) def is_high(self, pin): """Return true if the specified pin is pulled high.""" return self.input(pin) == HIGH def is_low(self, pin): """Return true if the specified pin is pulled low.""" return self.input(pin) == LOW # Basic implementation of multiple pin methods just loops through pins and # processes each one individually. This is not optimal, but derived classes can # provide a more optimal implementation that deals with groups of pins # simultaneously. # See MCP230xx or PCF8574 classes for examples of optimized implementations. def output_pins(self, pins): """Set multiple pins high or low at once. Pins should be a dict of pin name to pin value (HIGH/True for 1, LOW/False for 0). All provided pins will be set to the given values. """ # General implementation just loops through pins and writes them out # manually. This is not optimized, but subclasses can choose to implement # a more optimal batch output implementation. See the MCP230xx class for # example of optimized implementation. for pin, value in iter(pins.items()): self.output(pin, value) def setup_pins(self, pins): """Setup multiple pins as inputs or outputs at once. Pins should be a dict of pin name to pin type (IN or OUT). """ # General implementation that can be optimized by derived classes. for pin, value in iter(pins.items()): self.setup(pin, value) def input_pins(self, pins): """Read multiple pins specified in the given list and return list of pin values GPIO.HIGH/True if the pin is pulled high, or GPIO.LOW/False if pulled low. """ # General implementation that can be optimized by derived classes. return [self.input(pin) for pin in pins] def add_event_detect(self, pin, edge): """Enable edge detection events for a particular GPIO channel. Pin should be type IN. Edge must be RISING, FALLING or BOTH. """ raise NotImplementedError def remove_event_detect(self, pin): """Remove edge detection for a particular GPIO channel. Pin should be type IN. """ raise NotImplementedError def add_event_callback(self, pin, callback): """Add a callback for an event already defined using add_event_detect(). Pin should be type IN. """ raise NotImplementedError def event_detected(self, pin): """Returns True if an edge has occured on a given GPIO. You need to enable edge detection using add_event_detect() first. Pin should be type IN. """ raise NotImplementedError def wait_for_edge(self, pin, edge): """Wait for an edge. Pin should be type IN. Edge must be RISING, FALLING or BOTH.""" raise NotImplementedError def cleanup(self, pin=None): """Clean up GPIO event detection for specific pin, or all pins if none is specified. """ raise NotImplementedError # helper functions useful to derived classes def _validate_pin(self, pin): # Raise an exception if pin is outside the range of allowed values. if pin < 0 or pin >= self.NUM_GPIO: raise ValueError('Invalid GPIO value, must be between 0 and {0}.'.format(self.NUM_GPIO)) def _bit2(self, src, bit, val): bit = 1 << bit return (src | bit) if val else (src & ~bit) class RPiGPIOAdapter(BaseGPIO): """GPIO implementation for the Raspberry Pi using the RPi.GPIO library.""" def __init__(self, rpi_gpio, mode=None): self.rpi_gpio = rpi_gpio # Suppress warnings about GPIO in use. rpi_gpio.setwarnings(False) # Setup board pin mode. if mode == rpi_gpio.BOARD or mode == rpi_gpio.BCM: rpi_gpio.setmode(mode) elif mode is not None: raise ValueError('Unexpected value for mode. Must be BOARD or BCM.') else: # Default to BCM numbering if not told otherwise. rpi_gpio.setmode(rpi_gpio.BCM) # Define mapping of Adafruit GPIO library constants to RPi.GPIO constants. self._dir_mapping = { OUT: rpi_gpio.OUT, IN: rpi_gpio.IN } self._pud_mapping = { PUD_OFF: rpi_gpio.PUD_OFF, PUD_DOWN: rpi_gpio.PUD_DOWN, PUD_UP: rpi_gpio.PUD_UP } self._edge_mapping = { RISING: rpi_gpio.RISING, FALLING: rpi_gpio.FALLING, BOTH: rpi_gpio.BOTH } def setup(self, pin, mode, pull_up_down=PUD_OFF): """Set the input or output mode for a specified pin. Mode should be either OUTPUT or INPUT. """ self.rpi_gpio.setup(pin, self._dir_mapping[mode], pull_up_down=self._pud_mapping[pull_up_down]) def output(self, pin, value): """Set the specified pin the provided high/low value. Value should be either HIGH/LOW or a boolean (true = high). """ self.rpi_gpio.output(pin, value) def input(self, pin): """Read the specified pin and return HIGH/true if the pin is pulled high, or LOW/false if pulled low. """ return self.rpi_gpio.input(pin) def input_pins(self, pins): """Read multiple pins specified in the given list and return list of pin values GPIO.HIGH/True if the pin is pulled high, or GPIO.LOW/False if pulled low. """ # maybe rpi has a mass read... it would be more efficient to use it if it exists return [self.rpi_gpio.input(pin) for pin in pins] def add_event_detect(self, pin, edge, callback=None, bouncetime=-1): """Enable edge detection events for a particular GPIO channel. Pin should be type IN. Edge must be RISING, FALLING or BOTH. Callback is a function for the event. Bouncetime is switch bounce timeout in ms for callback """ kwargs = {} if callback: kwargs['callback']=callback if bouncetime > 0: kwargs['bouncetime']=bouncetime self.rpi_gpio.add_event_detect(pin, self._edge_mapping[edge], **kwargs) def remove_event_detect(self, pin): """Remove edge detection for a particular GPIO channel. Pin should be type IN. """ self.rpi_gpio.remove_event_detect(pin) def add_event_callback(self, pin, callback): """Add a callback for an event already defined using add_event_detect(). Pin should be type IN. """ self.rpi_gpio.add_event_callback(pin, callback) def event_detected(self, pin): """Returns True if an edge has occured on a given GPIO. You need to enable edge detection using add_event_detect() first. Pin should be type IN. """ return self.rpi_gpio.event_detected(pin) def wait_for_edge(self, pin, edge): """Wait for an edge. Pin should be type IN. Edge must be RISING, FALLING or BOTH. """ self.rpi_gpio.wait_for_edge(pin, self._edge_mapping[edge]) def cleanup(self, pin=None): """Clean up GPIO event detection for specific pin, or all pins if none is specified. """ if pin is None: self.rpi_gpio.cleanup() else: self.rpi_gpio.cleanup(pin) class AdafruitBBIOAdapter(BaseGPIO): """GPIO implementation for the Beaglebone Black using the Adafruit_BBIO library. """ def __init__(self, bbio_gpio): self.bbio_gpio = bbio_gpio # Define mapping of Adafruit GPIO library constants to RPi.GPIO constants. self._dir_mapping = { OUT: bbio_gpio.OUT, IN: bbio_gpio.IN } self._pud_mapping = { PUD_OFF: bbio_gpio.PUD_OFF, PUD_DOWN: bbio_gpio.PUD_DOWN, PUD_UP: bbio_gpio.PUD_UP } self._edge_mapping = { RISING: bbio_gpio.RISING, FALLING: bbio_gpio.FALLING, BOTH: bbio_gpio.BOTH } def setup(self, pin, mode, pull_up_down=PUD_OFF): """Set the input or output mode for a specified pin. Mode should be either OUTPUT or INPUT. """ self.bbio_gpio.setup(pin, self._dir_mapping[mode], pull_up_down=self._pud_mapping[pull_up_down]) def output(self, pin, value): """Set the specified pin the provided high/low value. Value should be either HIGH/LOW or a boolean (true = high). """ self.bbio_gpio.output(pin, value) def input(self, pin): """Read the specified pin and return HIGH/true if the pin is pulled high, or LOW/false if pulled low. """ return self.bbio_gpio.input(pin) def input_pins(self, pins): """Read multiple pins specified in the given list and return list of pin values GPIO.HIGH/True if the pin is pulled high, or GPIO.LOW/False if pulled low. """ # maybe bbb has a mass read... it would be more efficient to use it if it exists return [self.bbio_gpio.input(pin) for pin in pins] def add_event_detect(self, pin, edge, callback=None, bouncetime=-1): """Enable edge detection events for a particular GPIO channel. Pin should be type IN. Edge must be RISING, FALLING or BOTH. Callback is a function for the event. Bouncetime is switch bounce timeout in ms for callback """ kwargs = {} if callback: kwargs['callback']=callback if bouncetime > 0: kwargs['bouncetime']=bouncetime self.bbio_gpio.add_event_detect(pin, self._edge_mapping[edge], **kwargs) def remove_event_detect(self, pin): """Remove edge detection for a particular GPIO channel. Pin should be type IN. """ self.bbio_gpio.remove_event_detect(pin) def add_event_callback(self, pin, callback, bouncetime=-1): """Add a callback for an event already defined using add_event_detect(). Pin should be type IN. Bouncetime is switch bounce timeout in ms for callback """ kwargs = {} if bouncetime > 0: kwargs['bouncetime']=bouncetime self.bbio_gpio.add_event_callback(pin, callback, **kwargs) def event_detected(self, pin): """Returns True if an edge has occured on a given GPIO. You need to enable edge detection using add_event_detect() first. Pin should be type IN. """ return self.bbio_gpio.event_detected(pin) def wait_for_edge(self, pin, edge): """Wait for an edge. Pin should be type IN. Edge must be RISING, FALLING or BOTH. """ self.bbio_gpio.wait_for_edge(pin, self._edge_mapping[edge]) def cleanup(self, pin=None): """Clean up GPIO event detection for specific pin, or all pins if none is specified. """ if pin is None: self.bbio_gpio.cleanup() else: self.bbio_gpio.cleanup(pin) class AdafruitMinnowAdapter(BaseGPIO): """GPIO implementation for the Minnowboard + MAX using the mraa library""" def __init__(self,mraa_gpio): self.mraa_gpio = mraa_gpio # Define mapping of Adafruit GPIO library constants to mraa constants self._dir_mapping = { OUT: self.mraa_gpio.DIR_OUT, IN: self.mraa_gpio.DIR_IN } self._pud_mapping = { PUD_OFF: self.mraa_gpio.MODE_STRONG, PUD_UP: self.mraa_gpio.MODE_HIZ, PUD_DOWN: self.mraa_gpio.MODE_PULLDOWN } self._edge_mapping = { RISING: self.mraa_gpio.EDGE_RISING, FALLING: self.mraa_gpio.EDGE_FALLING, BOTH: self.mraa_gpio.EDGE_BOTH } def setup(self,pin,mode): """Set the input or output mode for a specified pin. Mode should be either DIR_IN or DIR_OUT. """ self.mraa_gpio.Gpio.dir(self.mraa_gpio.Gpio(pin),self._dir_mapping[mode]) def output(self,pin,value): """Set the specified pin the provided high/low value. Value should be either 1 (ON or HIGH), or 0 (OFF or LOW) or a boolean. """ self.mraa_gpio.Gpio.write(self.mraa_gpio.Gpio(pin), value) def input(self,pin): """Read the specified pin and return HIGH/true if the pin is pulled high, or LOW/false if pulled low. """ return self.mraa_gpio.Gpio.read(self.mraa_gpio.Gpio(pin)) def add_event_detect(self, pin, edge, callback=None, bouncetime=-1): """Enable edge detection events for a particular GPIO channel. Pin should be type IN. Edge must be RISING, FALLING or BOTH. Callback is a function for the event. Bouncetime is switch bounce timeout in ms for callback """ kwargs = {} if callback: kwargs['callback']=callback if bouncetime > 0: kwargs['bouncetime']=bouncetime self.mraa_gpio.Gpio.isr(self.mraa_gpio.Gpio(pin), self._edge_mapping[edge], **kwargs) def remove_event_detect(self, pin): """Remove edge detection for a particular GPIO channel. Pin should be type IN. """ self.mraa_gpio.Gpio.isrExit(self.mraa_gpio.Gpio(pin)) def wait_for_edge(self, pin, edge): """Wait for an edge. Pin should be type IN. Edge must be RISING, FALLING or BOTH. """ self.bbio_gpio.wait_for_edge(self.mraa_gpio.Gpio(pin), self._edge_mapping[edge]) def get_platform_gpio(**keywords): """Attempt to return a GPIO instance for the platform which the code is being executed on. Currently supports only the Raspberry Pi using the RPi.GPIO library and Beaglebone Black using the Adafruit_BBIO library. Will throw an exception if a GPIO instance can't be created for the current platform. The returned GPIO object is an instance of BaseGPIO. """ plat = Platform.platform_detect() if plat == Platform.RASPBERRY_PI: import RPi.GPIO return RPiGPIOAdapter(RPi.GPIO, **keywords) elif plat == Platform.BEAGLEBONE_BLACK: import Adafruit_BBIO.GPIO return AdafruitBBIOAdapter(Adafruit_BBIO.GPIO, **keywords) elif plat == Platform.MINNOWBOARD: import mraa return AdafruitMinnowAdapter(mraa, **keywords) elif plat == Platform.JETSON_NANO: import Jetson.GPIO return RPiGPIOAdapter(Jetson.GPIO, **keywords) elif plat == Platform.UNKNOWN: raise RuntimeError('Could not determine platform.')

Python

renanmb/Omniverse_legged_robotics/URDF-Descriptions/Mini_pupper/QuadrupedRobot-mini_pupper/Mangdang/Adafruit_GPIO/SPI.py

# Copyright (c) 2014 Adafruit Industries # Author: Tony DiCola # # Permission is hereby granted, free of charge, to any person obtaining a copy # of this software and associated documentation files (the "Software"), to deal # in the Software without restriction, including without limitation the rights # to use, copy, modify, merge, publish, distribute, sublicense, and/or sell # copies of the Software, and to permit persons to whom the Software is # furnished to do so, subject to the following conditions: # # The above copyright notice and this permission notice shall be included in # all copies or substantial portions of the Software. # # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN # THE SOFTWARE. import operator import time import Mangdang.Adafruit_GPIO as GPIO MSBFIRST = 0 LSBFIRST = 1 class SpiDev(object): """Hardware-based SPI implementation using the spidev interface.""" def __init__(self, port, device, max_speed_hz=500000): """Initialize an SPI device using the SPIdev interface. Port and device identify the device, for example the device /dev/spidev1.0 would be port 1 and device 0. """ import spidev self._device = spidev.SpiDev() self._device.open(port, device) self._device.max_speed_hz=max_speed_hz # Default to mode 0, and make sure CS is active low. self._device.mode = 0 #self._device.cshigh = False def set_clock_hz(self, hz): """Set the speed of the SPI clock in hertz. Note that not all speeds are supported and a lower speed might be chosen by the hardware. """ self._device.max_speed_hz=hz def set_mode(self, mode): """Set SPI mode which controls clock polarity and phase. Should be a numeric value 0, 1, 2, or 3. See wikipedia page for details on meaning: http://en.wikipedia.org/wiki/Serial_Peripheral_Interface_Bus """ if mode < 0 or mode > 3: raise ValueError('Mode must be a value 0, 1, 2, or 3.') self._device.mode = mode def set_bit_order(self, order): """Set order of bits to be read/written over serial lines. Should be either MSBFIRST for most-significant first, or LSBFIRST for least-signifcant first. """ if order == MSBFIRST: self._device.lsbfirst = False elif order == LSBFIRST: self._device.lsbfirst = True else: raise ValueError('Order must be MSBFIRST or LSBFIRST.') def close(self): """Close communication with the SPI device.""" self._device.close() def write(self, data): """Half-duplex SPI write. The specified array of bytes will be clocked out the MOSI line. """ self._device.writebytes(data) def read(self, length): """Half-duplex SPI read. The specified length of bytes will be clocked in the MISO line and returned as a bytearray object. """ return bytearray(self._device.readbytes(length)) def transfer(self, data): """Full-duplex SPI read and write. The specified array of bytes will be clocked out the MOSI line, while simultaneously bytes will be read from the MISO line. Read bytes will be returned as a bytearray object. """ return bytearray(self._device.xfer2(data)) class SpiDevMraa(object): """Hardware SPI implementation with the mraa library on Minnowboard""" def __init__(self, port, device, max_speed_hz=500000): import mraa self._device = mraa.Spi(0) self._device.mode(0) def set_clock_hz(self, hz): """Set the speed of the SPI clock in hertz. Note that not all speeds are supported and a lower speed might be chosen by the hardware. """ self._device.frequency(hz) def set_mode(self,mode): """Set SPI mode which controls clock polarity and phase. Should be a numeric value 0, 1, 2, or 3. See wikipedia page for details on meaning: http://en.wikipedia.org/wiki/Serial_Peripheral_Interface_Bus """ if mode < 0 or mode > 3: raise ValueError('Mode must be a value 0, 1, 2, or 3.') self._device.mode(mode) def set_bit_order(self, order): """Set order of bits to be read/written over serial lines. Should be either MSBFIRST for most-significant first, or LSBFIRST for least-signifcant first. """ if order == MSBFIRST: self._device.lsbmode(False) elif order == LSBFIRST: self._device.lsbmode(True) else: raise ValueError('Order must be MSBFIRST or LSBFIRST.') def close(self): """Close communication with the SPI device.""" self._device.Spi() def write(self, data): """Half-duplex SPI write. The specified array of bytes will be clocked out the MOSI line. """ self._device.write(bytearray(data)) class BitBang(object): """Software-based implementation of the SPI protocol over GPIO pins.""" def __init__(self, gpio, sclk, mosi=None, miso=None, ss=None): """Initialize bit bang (or software) based SPI. Must provide a BaseGPIO class, the SPI clock, and optionally MOSI, MISO, and SS (slave select) pin numbers. If MOSI is set to None then writes will be disabled and fail with an error, likewise for MISO reads will be disabled. If SS is set to None then SS will not be asserted high/low by the library when transfering data. """ self._gpio = gpio self._sclk = sclk self._mosi = mosi self._miso = miso self._ss = ss # Set pins as outputs/inputs. gpio.setup(sclk, GPIO.OUT) if mosi is not None: gpio.setup(mosi, GPIO.OUT) if miso is not None: gpio.setup(miso, GPIO.IN) if ss is not None: gpio.setup(ss, GPIO.OUT) # Assert SS high to start with device communication off. gpio.set_high(ss) # Assume mode 0. self.set_mode(0) # Assume most significant bit first order. self.set_bit_order(MSBFIRST) def set_clock_hz(self, hz): """Set the speed of the SPI clock. This is unsupported with the bit bang SPI class and will be ignored. """ pass def set_mode(self, mode): """Set SPI mode which controls clock polarity and phase. Should be a numeric value 0, 1, 2, or 3. See wikipedia page for details on meaning: http://en.wikipedia.org/wiki/Serial_Peripheral_Interface_Bus """ if mode < 0 or mode > 3: raise ValueError('Mode must be a value 0, 1, 2, or 3.') if mode & 0x02: # Clock is normally high in mode 2 and 3. self._clock_base = GPIO.HIGH else: # Clock is normally low in mode 0 and 1. self._clock_base = GPIO.LOW if mode & 0x01: # Read on trailing edge in mode 1 and 3. self._read_leading = False else: # Read on leading edge in mode 0 and 2. self._read_leading = True # Put clock into its base state. self._gpio.output(self._sclk, self._clock_base) def set_bit_order(self, order): """Set order of bits to be read/written over serial lines. Should be either MSBFIRST for most-significant first, or LSBFIRST for least-signifcant first. """ # Set self._mask to the bitmask which points at the appropriate bit to # read or write, and appropriate left/right shift operator function for # reading/writing. if order == MSBFIRST: self._mask = 0x80 self._write_shift = operator.lshift self._read_shift = operator.rshift elif order == LSBFIRST: self._mask = 0x01 self._write_shift = operator.rshift self._read_shift = operator.lshift else: raise ValueError('Order must be MSBFIRST or LSBFIRST.') def close(self): """Close the SPI connection. Unused in the bit bang implementation.""" pass def write(self, data, assert_ss=True, deassert_ss=True): """Half-duplex SPI write. If assert_ss is True, the SS line will be asserted low, the specified bytes will be clocked out the MOSI line, and if deassert_ss is True the SS line be put back high. """ # Fail MOSI is not specified. if self._mosi is None: raise RuntimeError('Write attempted with no MOSI pin specified.') if assert_ss and self._ss is not None: self._gpio.set_low(self._ss) for byte in data: for i in range(8): # Write bit to MOSI. if self._write_shift(byte, i) & self._mask: self._gpio.set_high(self._mosi) else: self._gpio.set_low(self._mosi) # Flip clock off base. self._gpio.output(self._sclk, not self._clock_base) # Return clock to base. self._gpio.output(self._sclk, self._clock_base) if deassert_ss and self._ss is not None: self._gpio.set_high(self._ss) def read(self, length, assert_ss=True, deassert_ss=True): """Half-duplex SPI read. If assert_ss is true, the SS line will be asserted low, the specified length of bytes will be clocked in the MISO line, and if deassert_ss is true the SS line will be put back high. Bytes which are read will be returned as a bytearray object. """ if self._miso is None: raise RuntimeError('Read attempted with no MISO pin specified.') if assert_ss and self._ss is not None: self._gpio.set_low(self._ss) result = bytearray(length) for i in range(length): for j in range(8): # Flip clock off base. self._gpio.output(self._sclk, not self._clock_base) # Handle read on leading edge of clock. if self._read_leading: if self._gpio.is_high(self._miso): # Set bit to 1 at appropriate location. result[i] |= self._read_shift(self._mask, j) else: # Set bit to 0 at appropriate location. result[i] &= ~self._read_shift(self._mask, j) # Return clock to base. self._gpio.output(self._sclk, self._clock_base) # Handle read on trailing edge of clock. if not self._read_leading: if self._gpio.is_high(self._miso): # Set bit to 1 at appropriate location. result[i] |= self._read_shift(self._mask, j) else: # Set bit to 0 at appropriate location. result[i] &= ~self._read_shift(self._mask, j) if deassert_ss and self._ss is not None: self._gpio.set_high(self._ss) return result def transfer(self, data, assert_ss=True, deassert_ss=True): """Full-duplex SPI read and write. If assert_ss is true, the SS line will be asserted low, the specified bytes will be clocked out the MOSI line while bytes will also be read from the MISO line, and if deassert_ss is true the SS line will be put back high. Bytes which are read will be returned as a bytearray object. """ if self._mosi is None: raise RuntimeError('Write attempted with no MOSI pin specified.') if self._miso is None: raise RuntimeError('Read attempted with no MISO pin specified.') if assert_ss and self._ss is not None: self._gpio.set_low(self._ss) result = bytearray(len(data)) for i in range(len(data)): for j in range(8): # Write bit to MOSI. if self._write_shift(data[i], j) & self._mask: self._gpio.set_high(self._mosi) else: self._gpio.set_low(self._mosi) # Flip clock off base. self._gpio.output(self._sclk, not self._clock_base) # Handle read on leading edge of clock. if self._read_leading: if self._gpio.is_high(self._miso): # Set bit to 1 at appropriate location. result[i] |= self._read_shift(self._mask, j) else: # Set bit to 0 at appropriate location. result[i] &= ~self._read_shift(self._mask, j) # Return clock to base. self._gpio.output(self._sclk, self._clock_base) # Handle read on trailing edge of clock. if not self._read_leading: if self._gpio.is_high(self._miso): # Set bit to 1 at appropriate location. result[i] |= self._read_shift(self._mask, j) else: # Set bit to 0 at appropriate location. result[i] &= ~self._read_shift(self._mask, j) if deassert_ss and self._ss is not None: self._gpio.set_high(self._ss) return result

Python

renanmb/Omniverse_legged_robotics/URDF-Descriptions/Mini_pupper/QuadrupedRobot-mini_pupper/Mangdang/FuelGauge/max1720x_battery.c

/* * Maxim MAX17201/MAX17205 fuel gauge driver * * Author: Mahir Ozturk <mahir.ozturk@maximintegrated.com> * Copyright (C) 2019 Maxim Integrated * * This program is free software; you can redistribute it and/or modify it * under the terms of the GNU General Public License as published by the * Free Software Foundation; either version 2 of the License, or (at your * option) any later version. * * This driver is based on max17042/40_battery.c */ #include <linux/delay.h> #include <linux/err.h> #include <linux/init.h> #include <linux/interrupt.h> #include <linux/i2c.h> #include <linux/module.h> #include <linux/mod_devicetable.h> #include <linux/mutex.h> #include <linux/of.h> #include <linux/power_supply.h> #include <linux/platform_device.h> #include <linux/pm.h> #include <linux/regmap.h> #include <linux/slab.h> #define DRV_NAME "max1720x" /* CONFIG register bits */ #define MAX1720X_CONFIG_ALRT_EN (1 << 2) /* STATUS register bits */ #define MAX1720X_STATUS_BST (1 << 3) #define MAX1720X_STATUS_POR (1 << 1) /* STATUS interrupt status bits */ #define MAX1720X_STATUS_ALRT_CLR_MASK (0x88BB) #define MAX1720X_STATUS_SOC_MAX_ALRT (1 << 14) #define MAX1720X_STATUS_TEMP_MAX_ALRT (1 << 13) #define MAX1720X_STATUS_VOLT_MAX_ALRT (1 << 12) #define MAX1720X_STATUS_SOC_MIN_ALRT (1 << 10) #define MAX1720X_STATUS_TEMP_MIN_ALRT (1 << 9) #define MAX1720X_STATUS_VOLT_MIN_ALRT (1 << 8) #define MAX1720X_STATUS_CURR_MAX_ALRT (1 << 6) #define MAX1720X_STATUS_CURR_MIN_ALRT (1 << 2) /* ProtStatus register bits */ #define MAX1730X_PROTSTATUS_CHGWDT (1 << 15) #define MAX1730X_PROTSTATUS_TOOHOTC (1 << 14) #define MAX1730X_PROTSTATUS_FULL (1 << 13) #define MAX1730X_PROTSTATUS_TOOCOLDC (1 << 12) #define MAX1730X_PROTSTATUS_OVP (1 << 11) #define MAX1730X_PROTSTATUS_OCCP (1 << 10) #define MAX1730X_PROTSTATUS_QOVFLW (1 << 9) #define MAX1730X_PROTSTATUS_RESCFAULT (1 << 7) #define MAX1730X_PROTSTATUS_PERMFAIL (1 << 6) #define MAX1730X_PROTSTATUS_DIEHOT (1 << 5) #define MAX1730X_PROTSTATUS_TOOHOTD (1 << 4) #define MAX1730X_PROTSTATUS_UVP (1 << 3) #define MAX1730X_PROTSTATUS_ODCP (1 << 2) #define MAX1730X_PROTSTATUS_RESDFAULT (1 << 1) #define MAX1730X_PROTSTATUS_SHDN (1 << 0) #define MAX1720X_VMAX_TOLERANCE 50 /* 50 mV */ #define MODELGAUGE_DATA_I2C_ADDR 0x36 #define NONVOLATILE_DATA_I2C_ADDR 0x0B struct max1720x_platform_data { /* * rsense in miliOhms. * default 10 (if rsense = 0) as it is the recommended value by * the datasheet although it can be changed by board designers. */ unsigned int rsense; int volt_min; /* in mV */ int volt_max; /* in mV */ int temp_min; /* in DegreC */ int temp_max; /* in DegreeC */ int soc_max; /* in percent */ int soc_min; /* in percent */ int curr_max; /* in mA */ int curr_min; /* in mA */ }; struct max1720x_priv { struct i2c_client *client; struct device *dev; struct regmap *regmap; struct power_supply *battery; struct max1720x_platform_data *pdata; struct work_struct init_worker; struct attribute_group *attr_grp; const u8 *regs; u8 nvmem_high_addr; int cycles_reg_lsb_percent; int (*get_charging_status)(void); int (*get_battery_health)(struct max1720x_priv *priv, int *health); }; enum chip_id { ID_MAX1720X, ID_MAX1730X, }; enum register_ids { STATUS_REG = 0, VALRTTH_REG, TALRTTH_REG, SALRTTH_REG, ATRATE_REG, REPCAP_REG, REPSOC_REG, TEMP_REG, VCELL_REG, CURRENT_REG, AVGCURRENT_REG, TTE_REG , CYCLES_REG, DESIGNCAP_REG, AVGVCELL_REG, MAXMINVOLT_REG, CONFIG_REG, TTF_REG , VERSION_REG, FULLCAPREP_REG, VEMPTY_REG, QH_REG , IALRTTH_REG, PROTSTATUS_REG, ATTTE_REG, VFOCV_REG, }; static int max1720x_get_battery_health(struct max1720x_priv *priv, int *health); static int max1730x_get_battery_health(struct max1720x_priv *priv, int *health); static int (*get_battery_health_handlers[]) (struct max1720x_priv *priv, int *health) = { [ID_MAX1720X] = max1720x_get_battery_health, [ID_MAX1730X] = max1730x_get_battery_health, }; /* Register addresses */ static const u8 max1720x_regs[] = { [STATUS_REG] = 0x00, [VALRTTH_REG] = 0x01, [TALRTTH_REG] = 0x02, [SALRTTH_REG] = 0x03, [ATRATE_REG] = 0x04, [REPCAP_REG] = 0x05, [REPSOC_REG] = 0x06, [TEMP_REG] = 0x08, [VCELL_REG] = 0x09, [CURRENT_REG] = 0x0A, [AVGCURRENT_REG] = 0x0B, [TTE_REG] = 0x11, [CYCLES_REG] = 0x17, [DESIGNCAP_REG] = 0x18, [AVGVCELL_REG] = 0x19, [MAXMINVOLT_REG] = 0x1B, [CONFIG_REG] = 0x1D, [TTF_REG] = 0x20, [VERSION_REG] = 0x21, [FULLCAPREP_REG] = 0x35, [VEMPTY_REG] = 0x3A, [QH_REG] = 0x4D, [IALRTTH_REG] = 0xB4, [ATTTE_REG] = 0xDD, [VFOCV_REG] = 0xFB, }; static const u8 max1730x_regs[] = { [STATUS_REG] = 0x00, [VALRTTH_REG] = 0x01, [TALRTTH_REG] = 0x02, [SALRTTH_REG] = 0x03, [ATRATE_REG] = 0x04, [REPCAP_REG] = 0x05, [REPSOC_REG] = 0x06, [TEMP_REG] = 0x1B, [VCELL_REG] = 0x1A, [CURRENT_REG] = 0x1C, [AVGCURRENT_REG] = 0x1D, [TTE_REG] = 0x11, [CYCLES_REG] = 0x17, [DESIGNCAP_REG] = 0x18, [AVGVCELL_REG] = 0x19, [MAXMINVOLT_REG] = 0x08, [CONFIG_REG] = 0x1D, [TTF_REG] = 0x20, [VERSION_REG] = 0x21, [FULLCAPREP_REG] = 0x10, [VEMPTY_REG] = 0x3A, [QH_REG] = 0x4D, [IALRTTH_REG] = 0xAC, [PROTSTATUS_REG] = 0xD9, [ATTTE_REG] = 0xDD, [VFOCV_REG] = 0xFB, }; static const u8* chip_regs[] = { [ID_MAX1720X] = max1720x_regs, [ID_MAX1730X] = max1730x_regs, }; static const u8 nvmem_high_addrs[] = { [ID_MAX1720X] = 0xDF, [ID_MAX1730X] = 0xEF, }; static const int cycles_reg_lsb_percents[] = { [ID_MAX1720X] = 25, [ID_MAX1730X] = 16, }; static enum power_supply_property max1720x_battery_props[] = { POWER_SUPPLY_PROP_PRESENT, POWER_SUPPLY_PROP_CYCLE_COUNT, POWER_SUPPLY_PROP_VOLTAGE_MAX, POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN, POWER_SUPPLY_PROP_VOLTAGE_NOW, POWER_SUPPLY_PROP_VOLTAGE_AVG, POWER_SUPPLY_PROP_VOLTAGE_OCV, POWER_SUPPLY_PROP_CAPACITY, POWER_SUPPLY_PROP_CAPACITY_ALERT_MIN, POWER_SUPPLY_PROP_CAPACITY_ALERT_MAX, POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN, POWER_SUPPLY_PROP_CHARGE_FULL, POWER_SUPPLY_PROP_CHARGE_NOW, POWER_SUPPLY_PROP_CHARGE_COUNTER, POWER_SUPPLY_PROP_TEMP, POWER_SUPPLY_PROP_TEMP_ALERT_MIN, POWER_SUPPLY_PROP_TEMP_ALERT_MAX, POWER_SUPPLY_PROP_HEALTH, POWER_SUPPLY_PROP_CURRENT_NOW, POWER_SUPPLY_PROP_CURRENT_AVG, POWER_SUPPLY_PROP_STATUS, POWER_SUPPLY_PROP_TIME_TO_EMPTY_AVG, POWER_SUPPLY_PROP_TIME_TO_FULL_AVG, }; static inline int max1720x_raw_voltage_to_uvolts(struct max1720x_priv *priv, int lsb) { return lsb * 10000 / 65536; /* 78.125uV per bit */ } static inline int max1720x_raw_current_to_uamps(struct max1720x_priv *priv, int curr) { return curr * 15625 / ((int)priv->pdata->rsense * 10); } static inline int max1720x_raw_capacity_to_uamph(struct max1720x_priv *priv, int cap) { return cap * 5000 / (int)priv->pdata->rsense; } static ssize_t max1720x_log_show(struct device *dev, struct device_attribute *attr, char *buf) { struct max1720x_priv *priv = dev_get_drvdata(dev); int rc = 0, reg = 0; u32 val = 0; for (reg = 0; reg < 0xE0; reg++) { regmap_read(priv->regmap, reg, &val); rc += (int)snprintf(buf+rc, PAGE_SIZE-rc, "0x%04X,", val); if (reg == 0x4F) reg += 0x60; if (reg == 0xBF) reg += 0x10; } rc += (int)snprintf(buf+rc, PAGE_SIZE-rc, "\n"); return rc; } static ssize_t max1720x_nvmem_show(struct device *dev, struct device_attribute *attr, char *buf) { struct max1720x_priv *priv = dev_get_drvdata(dev); int rc = 0, reg = 0; u32 val = 0; int ret; int i; /* * Device has a separate slave address for accessing non-volatile memory * region, so we are temporarily changing i2c client address. */ priv->client->addr = NONVOLATILE_DATA_I2C_ADDR; for (reg = 0x80; reg < priv->nvmem_high_addr; reg += 16) { rc += snprintf(buf+rc, PAGE_SIZE-rc, "Page %02Xh: ", (reg + 0x100) >> 4); for (i = 0; i < 16; i++) { ret = regmap_read(priv->regmap, reg + i, &val); if (ret) { dev_err(dev, "NV memory reading failed (%d)\n", ret); return 0; } rc += snprintf(buf+rc, PAGE_SIZE-rc, "0x%04X ", val); } rc += snprintf(buf+rc, PAGE_SIZE-rc, "\n"); } priv->client->addr = MODELGAUGE_DATA_I2C_ADDR; return rc; } static ssize_t max1720x_atrate_show(struct device *dev, struct device_attribute *attr, char *buf) { struct max1720x_priv *priv = dev_get_drvdata(dev); u32 val = 0; int ret; ret = regmap_read(priv->regmap, priv->regs[ATRATE_REG], &val); if (ret) { return 0; } return sprintf(buf, "%d", (short)val); } static ssize_t max1720x_atrate_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) { struct max1720x_priv *priv = dev_get_drvdata(dev); s32 val = 0; int ret; if (kstrtos32(buf, 0, &val)) return -EINVAL; ret = regmap_write(priv->regmap, priv->regs[ATRATE_REG], val); if (ret < 0) return ret; return count; } static ssize_t max1720x_attte_show(struct device *dev, struct device_attribute *attr, char *buf) { struct max1720x_priv *priv = dev_get_drvdata(dev); u32 val = 0; int ret; ret = regmap_read(priv->regmap, priv->regs[ATTTE_REG], &val); if (ret) { return 0; } return sprintf(buf, "%d", (short)val); } static DEVICE_ATTR(log, S_IRUGO, max1720x_log_show, NULL); static DEVICE_ATTR(nvmem, S_IRUGO, max1720x_nvmem_show, NULL); static DEVICE_ATTR(atrate, S_IRUGO | S_IWUSR, max1720x_atrate_show, max1720x_atrate_store); static DEVICE_ATTR(attte, S_IRUGO, max1720x_attte_show, NULL); static struct attribute *max1720x_attr[] = { &dev_attr_log.attr, &dev_attr_nvmem.attr, &dev_attr_atrate.attr, &dev_attr_attte.attr, NULL }; static struct attribute_group max1720x_attr_group = { .attrs = max1720x_attr, }; static int max1720x_get_temperature(struct max1720x_priv *priv, int *temp) { int ret; u32 data; struct regmap *map = priv->regmap; ret = regmap_read(map, priv->regs[TEMP_REG], &data); if (ret < 0) return ret; *temp = sign_extend32(data, 15); /* The value is converted into centigrade scale */ /* Units of LSB = 1 / 256 degree Celsius */ *temp = (*temp * 10) >> 8; return 0; } static int max1720x_set_temp_lower_limit(struct max1720x_priv *priv, int temp) { int ret; u32 data; struct regmap *map = priv->regmap; ret = regmap_read(map, priv->regs[TALRTTH_REG], &data); if (ret < 0) return ret; /* Input in deci-centigrade, convert to centigrade */ temp /= 10; data &= 0xFF00; data |= (temp & 0xFF); ret = regmap_write(map, priv->regs[TALRTTH_REG], data); if (ret < 0) return ret; return 0; } static int max1720x_get_temperature_alert_min(struct max1720x_priv *priv, int *temp) { int ret; u32 data; struct regmap *map = priv->regmap; ret = regmap_read(map, priv->regs[TALRTTH_REG], &data); if (ret < 0) return ret; /* Convert 1DegreeC LSB to 0.1DegreeC LSB */ *temp = sign_extend32(data & 0xff, 7) * 10; return 0; } static int max1720x_set_temp_upper_limit(struct max1720x_priv *priv, int temp) { int ret; u32 data; struct regmap *map = priv->regmap; ret = regmap_read(map, priv->regs[TALRTTH_REG], &data); if (ret < 0) return ret; /* Input in deci-centigrade, convert to centigrade */ temp /= 10; data &= 0xFF; data |= ((temp << 8) & 0xFF00); ret = regmap_write(map, priv->regs[TALRTTH_REG], data); if (ret < 0) return ret; return 0; } static int max1720x_get_temperature_alert_max(struct max1720x_priv *priv, int *temp) { int ret; u32 data; struct regmap *map = priv->regmap; ret = regmap_read(map, priv->regs[TALRTTH_REG], &data); if (ret < 0) return ret; /* Convert 1DegreeC LSB to 0.1DegreeC LSB */ *temp = sign_extend32(data >> 8, 7) * 10; return 0; } static int max1720x_get_battery_health(struct max1720x_priv *priv, int *health) { int temp, vavg, vbatt, ret; u32 val; ret = regmap_read(priv->regmap, priv->regs[AVGVCELL_REG], &val); if (ret < 0) goto health_error; /* bits [0-3] unused */ vavg = max1720x_raw_voltage_to_uvolts(priv, val); /* Convert to millivolts */ vavg /= 1000; ret = regmap_read(priv->regmap, priv->regs[VCELL_REG], &val); if (ret < 0) goto health_error; /* bits [0-3] unused */ vbatt = max1720x_raw_voltage_to_uvolts(priv, val); /* Convert to millivolts */ vbatt /= 1000; if (vavg < priv->pdata->volt_min) { *health = POWER_SUPPLY_HEALTH_DEAD; goto out; } if (vbatt > priv->pdata->volt_max + MAX1720X_VMAX_TOLERANCE) { *health = POWER_SUPPLY_HEALTH_OVERVOLTAGE; goto out; } ret = max1720x_get_temperature(priv, &temp); if (ret < 0) goto health_error; if (temp <= priv->pdata->temp_min) { *health = POWER_SUPPLY_HEALTH_COLD; goto out; } if (temp >= priv->pdata->temp_max) { *health = POWER_SUPPLY_HEALTH_OVERHEAT; goto out; } *health = POWER_SUPPLY_HEALTH_GOOD; out: return 0; health_error: return ret; } static int max1730x_get_battery_health(struct max1720x_priv *priv, int *health) { int ret; u32 val; ret = regmap_read(priv->regmap, priv->regs[PROTSTATUS_REG], &val); if (ret < 0) return ret; if ((val & MAX1730X_PROTSTATUS_RESCFAULT) || (val & MAX1730X_PROTSTATUS_RESDFAULT)) { *health = POWER_SUPPLY_HEALTH_UNKNOWN; } else if ((val & MAX1730X_PROTSTATUS_TOOHOTC) || (val & MAX1730X_PROTSTATUS_TOOHOTD) || (val & MAX1730X_PROTSTATUS_DIEHOT)) { *health = POWER_SUPPLY_HEALTH_OVERHEAT; } else if ((val & MAX1730X_PROTSTATUS_UVP) || (val & MAX1730X_PROTSTATUS_PERMFAIL) || (val & MAX1730X_PROTSTATUS_SHDN)) { *health = POWER_SUPPLY_HEALTH_DEAD; } else if (val & MAX1730X_PROTSTATUS_TOOCOLDC) { *health = POWER_SUPPLY_HEALTH_COLD; } else if (val & MAX1730X_PROTSTATUS_OVP) { *health = POWER_SUPPLY_HEALTH_OVERVOLTAGE; } else if ((val & MAX1730X_PROTSTATUS_QOVFLW) || (val & MAX1730X_PROTSTATUS_OCCP) || (val & MAX1730X_PROTSTATUS_ODCP)) { *health = POWER_SUPPLY_HEALTH_UNSPEC_FAILURE; } else if (val & MAX1730X_PROTSTATUS_CHGWDT) { *health = POWER_SUPPLY_HEALTH_WATCHDOG_TIMER_EXPIRE; } else { *health = POWER_SUPPLY_HEALTH_GOOD; } return 0; } static int max1720x_get_min_capacity_alert_th(struct max1720x_priv *priv, unsigned int *th) { int ret; struct regmap *map = priv->regmap; ret = regmap_read(map, priv->regs[SALRTTH_REG], th); if (ret < 0) return ret; *th &= 0xFF; return 0; } static int max1720x_set_min_capacity_alert_th(struct max1720x_priv *priv, unsigned int th) { int ret; unsigned int data; struct regmap *map = priv->regmap; ret = regmap_read(map, priv->regs[SALRTTH_REG], &data); if (ret < 0) return ret; data &= 0xFF00; data |= (th & 0xFF); ret = regmap_write(map, priv->regs[SALRTTH_REG], data); if (ret < 0) return ret; return 0; } static int max1720x_get_max_capacity_alert_th(struct max1720x_priv *priv, unsigned int *th) { int ret; struct regmap *map = priv->regmap; ret = regmap_read(map, priv->regs[SALRTTH_REG], th); if (ret < 0) return ret; *th >>= 8; return 0; } static int max1720x_set_max_capacity_alert_th(struct max1720x_priv *priv, unsigned int th) { int ret; unsigned int data; struct regmap *map = priv->regmap; ret = regmap_read(map, priv->regs[SALRTTH_REG], &data); if (ret < 0) return ret; data &= 0xFF; data |= ((th & 0xFF) << 8); ret = regmap_write(map, priv->regs[SALRTTH_REG], data); if (ret < 0) return ret; return 0; } static int max1720x_get_property(struct power_supply *psy, enum power_supply_property psp, union power_supply_propval *val) { struct max1720x_priv *priv = power_supply_get_drvdata(psy); struct regmap *regmap = priv->regmap; struct max1720x_platform_data *pdata = priv->pdata; unsigned int reg; int ret; switch (psp) { case POWER_SUPPLY_PROP_PRESENT: ret = regmap_read(regmap, priv->regs[STATUS_REG], &reg); if (ret < 0) return ret; if (reg & MAX1720X_STATUS_BST) val->intval = 0; else val->intval = 1; break; case POWER_SUPPLY_PROP_CYCLE_COUNT: ret = regmap_read(regmap, priv->regs[CYCLES_REG], &reg); if (ret < 0) return ret; val->intval = reg * 100 / priv->cycles_reg_lsb_percent; break; case POWER_SUPPLY_PROP_VOLTAGE_MAX: ret = regmap_read(regmap, priv->regs[MAXMINVOLT_REG], &reg); if (ret < 0) return ret; val->intval = reg >> 8; val->intval *= 20000; /* Units of LSB = 20mV */ break; case POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN: ret = regmap_read(regmap, priv->regs[VEMPTY_REG], &reg); if (ret < 0) return ret; val->intval = reg >> 7; val->intval *= 10000; /* Units of LSB = 10mV */ break; case POWER_SUPPLY_PROP_STATUS: if (pdata && priv->get_charging_status) val->intval = priv->get_charging_status(); else val->intval = POWER_SUPPLY_STATUS_UNKNOWN; break; case POWER_SUPPLY_PROP_VOLTAGE_NOW: ret = regmap_read(regmap, priv->regs[VCELL_REG], &reg); if (ret < 0) return ret; val->intval = max1720x_raw_voltage_to_uvolts(priv, reg); break; case POWER_SUPPLY_PROP_VOLTAGE_AVG: ret = regmap_read(regmap, priv->regs[AVGVCELL_REG], &reg); if (ret < 0) return ret; val->intval = max1720x_raw_voltage_to_uvolts(priv, reg); break; case POWER_SUPPLY_PROP_VOLTAGE_OCV: ret = regmap_read(regmap, priv->regs[VFOCV_REG], &reg); if (ret < 0) return ret; val->intval = max1720x_raw_voltage_to_uvolts(priv, reg); break; case POWER_SUPPLY_PROP_CAPACITY: ret = regmap_read(regmap, priv->regs[REPSOC_REG], &reg); if (ret < 0) return ret; val->intval = reg >> 8; /* RepSOC LSB: 1/256 % */ break; case POWER_SUPPLY_PROP_CAPACITY_ALERT_MIN: ret = max1720x_get_min_capacity_alert_th(priv, &val->intval); if (ret < 0) return ret; break; case POWER_SUPPLY_PROP_CAPACITY_ALERT_MAX: ret = max1720x_get_max_capacity_alert_th(priv, &val->intval); if (ret < 0) return ret; break; case POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN: ret = regmap_read(regmap, priv->regs[DESIGNCAP_REG], &reg); if (ret < 0) return ret; val->intval = max1720x_raw_capacity_to_uamph(priv, reg); break; case POWER_SUPPLY_PROP_CHARGE_FULL: ret = regmap_read(regmap, priv->regs[FULLCAPREP_REG], &reg); if (ret < 0) return ret; val->intval = max1720x_raw_capacity_to_uamph(priv, reg); break; case POWER_SUPPLY_PROP_CHARGE_COUNTER: ret = regmap_read(regmap, priv->regs[QH_REG], &reg); if (ret < 0) return ret; /* This register is signed as oppose to other capacity type * registers. */ val->intval = max1720x_raw_capacity_to_uamph(priv, sign_extend32(reg, 15)); break; case POWER_SUPPLY_PROP_CHARGE_NOW: ret = regmap_read(regmap, priv->regs[REPCAP_REG], &reg); if (ret < 0) return ret; val->intval = max1720x_raw_capacity_to_uamph(priv, reg); break; case POWER_SUPPLY_PROP_TEMP: ret = max1720x_get_temperature(priv, &val->intval); if (ret < 0) return ret; break; case POWER_SUPPLY_PROP_TEMP_ALERT_MIN: ret = max1720x_get_temperature_alert_min(priv, &val->intval); if (ret < 0) return ret; break; case POWER_SUPPLY_PROP_TEMP_ALERT_MAX: ret = max1720x_get_temperature_alert_max(priv, &val->intval); if (ret < 0) return ret; break; case POWER_SUPPLY_PROP_HEALTH: if (priv->get_battery_health != 0) { ret = priv->get_battery_health(priv, &val->intval); if (ret < 0) return ret; } else { val->intval = POWER_SUPPLY_HEALTH_UNKNOWN; } break; case POWER_SUPPLY_PROP_CURRENT_NOW: ret = regmap_read(regmap, priv->regs[CURRENT_REG], &reg); if (ret < 0) return ret; val->intval = max1720x_raw_current_to_uamps(priv, sign_extend32(reg, 15)); break; case POWER_SUPPLY_PROP_CURRENT_AVG: ret = regmap_read(regmap, priv->regs[AVGCURRENT_REG], &reg); if (ret < 0) return ret; val->intval = max1720x_raw_current_to_uamps(priv, sign_extend32(reg, 15)); break; case POWER_SUPPLY_PROP_TIME_TO_EMPTY_AVG: ret = regmap_read(regmap, priv->regs[TTE_REG], &reg); if (ret < 0) return ret; val->intval = (reg * 45) >> 3; /* TTE LSB: 5.625 sec */ break; case POWER_SUPPLY_PROP_TIME_TO_FULL_AVG: ret = regmap_read(regmap, priv->regs[TTF_REG], &reg); if (ret < 0) return ret; val->intval = (reg * 45) >> 3; /* TTF LSB: 5.625 sec */ break; default: return -EINVAL; } return 0; } static int max1720x_set_property(struct power_supply *psy, enum power_supply_property psp, const union power_supply_propval *val) { struct max1720x_priv *priv = power_supply_get_drvdata(psy); int ret = 0; switch (psp) { case POWER_SUPPLY_PROP_TEMP_ALERT_MIN: ret = max1720x_set_temp_lower_limit(priv, val->intval); if (ret < 0) dev_err(priv->dev, "temp alert min set fail:%d\n", ret); break; case POWER_SUPPLY_PROP_TEMP_ALERT_MAX: ret = max1720x_set_temp_upper_limit(priv, val->intval); if (ret < 0) dev_err(priv->dev, "temp alert max set fail:%d\n", ret); break; case POWER_SUPPLY_PROP_CAPACITY_ALERT_MIN: ret = max1720x_set_min_capacity_alert_th(priv, val->intval); if (ret < 0) dev_err(priv->dev, "capacity alert min set fail:%d\n", ret); break; case POWER_SUPPLY_PROP_CAPACITY_ALERT_MAX: ret = max1720x_set_max_capacity_alert_th(priv, val->intval); if (ret < 0) dev_err(priv->dev, "capacity alert max set fail:%d\n", ret); break; default: return -EINVAL; } return ret; } static int max1720x_property_is_writeable(struct power_supply *psy, enum power_supply_property psp) { int ret; switch (psp) { case POWER_SUPPLY_PROP_TEMP_ALERT_MIN: case POWER_SUPPLY_PROP_TEMP_ALERT_MAX: case POWER_SUPPLY_PROP_CAPACITY_ALERT_MIN: case POWER_SUPPLY_PROP_CAPACITY_ALERT_MAX: ret = 1; break; default: ret = 0; } return ret; } static irqreturn_t max1720x_irq_handler(int id, void *dev) { struct max1720x_priv *priv = dev; u32 val; /* Check alert type */ regmap_read(priv->regmap, priv->regs[STATUS_REG], &val); if (val & MAX1720X_STATUS_SOC_MAX_ALRT) dev_info(priv->dev, "Alert: SOC MAX!\n"); if (val & MAX1720X_STATUS_SOC_MIN_ALRT) dev_info(priv->dev, "Alert: SOC MIN!\n"); if (val & MAX1720X_STATUS_TEMP_MAX_ALRT) dev_info(priv->dev, "Alert: TEMP MAX!\n"); if (val & MAX1720X_STATUS_TEMP_MIN_ALRT) dev_info(priv->dev, "Alert: TEMP MIN!\n"); if (val & MAX1720X_STATUS_VOLT_MAX_ALRT) dev_info(priv->dev, "Alert: VOLT MAX!\n"); if (val & MAX1720X_STATUS_VOLT_MIN_ALRT) dev_info(priv->dev, "Alert: VOLT MIN!\n"); if (val & MAX1720X_STATUS_CURR_MAX_ALRT) dev_info(priv->dev, "Alert: CURR MAX!\n"); if (val & MAX1720X_STATUS_CURR_MIN_ALRT) dev_info(priv->dev, "Alert: CURR MIN!\n"); /* Clear alerts */ regmap_write(priv->regmap, priv->regs[STATUS_REG], val & MAX1720X_STATUS_ALRT_CLR_MASK); power_supply_changed(priv->battery); return IRQ_HANDLED; } static void max1720x_set_alert_thresholds(struct max1720x_priv *priv) { struct max1720x_platform_data *pdata = priv->pdata; struct regmap *regmap = priv->regmap; u32 val; /* Set VAlrtTh */ val = (pdata->volt_min / 20); val |= ((pdata->volt_max / 20) << 8); regmap_write(regmap, priv->regs[VALRTTH_REG], val); /* Set TAlrtTh */ val = pdata->temp_min & 0xFF; val |= ((pdata->temp_max & 0xFF) << 8); regmap_write(regmap, priv->regs[TALRTTH_REG], val); /* Set SAlrtTh */ val = pdata->soc_min; val |= (pdata->soc_max << 8); regmap_write(regmap, priv->regs[SALRTTH_REG], val); /* Set IAlrtTh */ val = (pdata->curr_min * pdata->rsense / 400) & 0xFF; val |= (((pdata->curr_max * pdata->rsense / 400) & 0xFF) << 8); regmap_write(regmap, priv->regs[IALRTTH_REG], val); } static int max1720x_init(struct max1720x_priv *priv) { struct regmap *regmap = priv->regmap; int ret; unsigned int reg; u32 fgrev; ret = regmap_read(regmap, priv->regs[VERSION_REG], &fgrev); if (ret < 0) return ret; dev_info(priv->dev, "IC Version: 0x%04x\n", fgrev); /* Optional step - alert threshold initialization */ max1720x_set_alert_thresholds(priv); /* Clear Status.POR */ ret = regmap_read(regmap, priv->regs[STATUS_REG], &reg); if (ret < 0) return ret; ret = regmap_write(regmap, priv->regs[STATUS_REG], reg & ~MAX1720X_STATUS_POR); if (ret < 0) return ret; return 0; } static void max1720x_init_worker(struct work_struct *work) { struct max1720x_priv *priv = container_of(work, struct max1720x_priv, init_worker); max1720x_init(priv); } static struct max1720x_platform_data *max1720x_parse_dt(struct device *dev) { struct device_node *np = dev->of_node; struct max1720x_platform_data *pdata; int ret; pdata = devm_kzalloc(dev, sizeof(*pdata), GFP_KERNEL); if (!pdata) return NULL; ret = of_property_read_u32(np, "talrt-min", &pdata->temp_min); if (ret) pdata->temp_min = -128; /* DegreeC */ /* Disable alert */ ret = of_property_read_u32(np, "talrt-max", &pdata->temp_max); if (ret) pdata->temp_max = 127; /* DegreeC */ /* Disable alert */ ret = of_property_read_u32(np, "valrt-min", &pdata->volt_min); if (ret) pdata->volt_min = 0; /* mV */ /* Disable alert */ ret = of_property_read_u32(np, "valrt-max", &pdata->volt_max); if (ret) pdata->volt_max = 5100; /* mV */ /* Disable alert */ ret = of_property_read_u32(np, "ialrt-min", &pdata->curr_min); if (ret) pdata->curr_min = -5120; /* mA */ /* Disable alert */ ret = of_property_read_u32(np, "ialrt-max", &pdata->curr_max); if (ret) pdata->curr_max = 5080; /* mA */ /* Disable alert */ ret = of_property_read_u32(np, "salrt-min", &pdata->soc_min); if (ret) pdata->soc_min = 0; /* Percent */ /* Disable alert */ ret = of_property_read_u32(np, "salrt-max", &pdata->soc_max); if (ret) pdata->soc_max = 255; /* Percent */ /* Disable alert */ ret = of_property_read_u32(np, "rsense", &pdata->rsense); if (ret) pdata->rsense = 10; return pdata; } static const struct regmap_config max1720x_regmap = { .reg_bits = 8, .val_bits = 16, .val_format_endian = REGMAP_ENDIAN_NATIVE, }; static const struct power_supply_desc max1720x_fg_desc = { .name = "max1720x_battery", .type = POWER_SUPPLY_TYPE_BATTERY, .properties = max1720x_battery_props, .num_properties = ARRAY_SIZE(max1720x_battery_props), .get_property = max1720x_get_property, .set_property = max1720x_set_property, .property_is_writeable = max1720x_property_is_writeable, }; static int max1720x_probe(struct i2c_client *client, const struct i2c_device_id *id) { struct i2c_adapter *adapter = to_i2c_adapter(client->dev.parent); struct max1720x_priv *priv; struct power_supply_config psy_cfg = {}; int ret; if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_WORD_DATA)) return -EIO; priv = devm_kzalloc(&client->dev, sizeof(*priv), GFP_KERNEL); if (!priv) return -ENOMEM; priv->regs = chip_regs[id->driver_data]; priv->nvmem_high_addr = nvmem_high_addrs[id->driver_data]; priv->cycles_reg_lsb_percent = cycles_reg_lsb_percents[id->driver_data]; priv->get_battery_health = get_battery_health_handlers[id->driver_data]; if (client->dev.of_node) priv->pdata = max1720x_parse_dt(&client->dev); else priv->pdata = client->dev.platform_data; priv->dev = &client->dev; i2c_set_clientdata(client, priv); priv->client = client; priv->regmap = devm_regmap_init_i2c(client, &max1720x_regmap); if (IS_ERR(priv->regmap)) return PTR_ERR(priv->regmap); INIT_WORK(&priv->init_worker, max1720x_init_worker); schedule_work(&priv->init_worker); psy_cfg.drv_data = priv; priv->battery = power_supply_register(&client->dev, &max1720x_fg_desc, &psy_cfg); if (IS_ERR(priv->battery)) { ret = PTR_ERR(priv->battery); dev_err(&client->dev, "failed to register battery: %d\n", ret); goto err_supply; } if (client->irq) { ret = devm_request_threaded_irq(priv->dev, client->irq, NULL, max1720x_irq_handler, IRQF_TRIGGER_FALLING | IRQF_ONESHOT, priv->battery->desc->name, priv); if (ret) { dev_err(priv->dev, "Failed to request irq %d\n", client->irq); goto err_irq; } else { regmap_update_bits(priv->regmap, priv->regs[CONFIG_REG], MAX1720X_CONFIG_ALRT_EN, MAX1720X_CONFIG_ALRT_EN); } } /* Create max1720x sysfs attributes */ priv->attr_grp = &max1720x_attr_group; ret = sysfs_create_group(&priv->dev->kobj, priv->attr_grp); if (ret) { dev_err(priv->dev, "Failed to create attribute group [%d]\n", ret); priv->attr_grp = NULL; goto err_attr; } return 0; err_irq: power_supply_unregister(priv->battery); err_supply: cancel_work_sync(&priv->init_worker); err_attr: sysfs_remove_group(&priv->dev->kobj, priv->attr_grp); return ret; } static int max1720x_remove(struct i2c_client *client) { struct max1720x_priv *priv = i2c_get_clientdata(client); cancel_work_sync(&priv->init_worker); sysfs_remove_group(&priv->dev->kobj, priv->attr_grp); power_supply_unregister(priv->battery); return 0; } #ifdef CONFIG_PM_SLEEP static int max1720x_suspend(struct device *dev) { struct i2c_client *client = to_i2c_client(dev); if (client->irq) { disable_irq(client->irq); enable_irq_wake(client->irq); } return 0; } static int max1720x_resume(struct device *dev) { struct i2c_client *client = to_i2c_client(dev); if (client->irq) { disable_irq_wake(client->irq); enable_irq(client->irq); } return 0; } static SIMPLE_DEV_PM_OPS(max1720x_pm_ops, max1720x_suspend, max1720x_resume); #define MAX1720X_PM_OPS (&max1720x_pm_ops) #else #define MAX1720X_PM_OPS NULL #endif /* CONFIG_PM_SLEEP */ #ifdef CONFIG_OF static const struct of_device_id max1720x_match[] = { { .compatible = "maxim,max17201", }, { .compatible = "maxim,max17205", }, { .compatible = "maxim,max17301", }, { .compatible = "maxim,max17302", }, { .compatible = "maxim,max17303", }, { }, }; MODULE_DEVICE_TABLE(of, max1720x_match); #endif static const struct i2c_device_id max1720x_id[] = { { "max17201", ID_MAX1720X }, { "max17205", ID_MAX1720X }, { "max17301", ID_MAX1730X }, { "max17302", ID_MAX1730X }, { "max17303", ID_MAX1730X }, { }, }; MODULE_DEVICE_TABLE(i2c, max1720x_id); static struct i2c_driver max1720x_i2c_driver = { .driver = { .name = DRV_NAME, .of_match_table = of_match_ptr(max1720x_match), .pm = MAX1720X_PM_OPS, }, .probe = max1720x_probe, .remove = max1720x_remove, .id_table = max1720x_id, }; module_i2c_driver(max1720x_i2c_driver); MODULE_LICENSE("GPL"); MODULE_AUTHOR("Mahir Ozturk <mahir.ozturk@maximintegrated.com>"); MODULE_DESCRIPTION("Maxim MAX17201/5 and MAX17301/2/3 Fuel Gauge driver");

C

renanmb/Omniverse_legged_robotics/URDF-Descriptions/Mini_pupper/QuadrupedRobot-mini_pupper/Mangdang/LCD/ST7789.py

# ST7789 IPS LCD (320x240) driver import numbers import time import numpy as np import sys import os from PIL import Image from PIL import ImageDraw sys.path.append("/home/ubuntu/Robotics/QuadrupedRobot") sys.path.extend([os.path.join(root, name) for root, dirs, _ in os.walk("/home/ubuntu/Robotics/QuadrupedRobot") for name in dirs]) import Mangdang.Adafruit_GPIO as GPIO import Mangdang.Adafruit_GPIO.SPI as SPI from Mangdang.LCD.gif import AnimatedGif SPI_CLOCK_HZ = 31200000 # 31.2 MHz # Constants for interacting with display registers. ST7789_TFTWIDTH = 320 ST7789_TFTHEIGHT = 240 ST7789_NOP = 0x00 ST7789_SWRESET = 0x01 ST7789_RDDID = 0x04 ST7789_RDDST = 0x09 ST7789_RDDPM = 0x0A ST7789_RDDMADCTL = 0x0B ST7789_RDDCOLMOD = 0x0C ST7789_RDDIM = 0x0D ST7789_RDDSM = 0x0E ST7789_RDDSDR = 0x0F ST7789_SLPIN = 0x10 ST7789_SLPOUT = 0x11 ST7789_PTLON = 0x12 ST7789_NORON = 0x13 ST7789_INVOFF = 0x20 ST7789_INVON = 0x21 ST7789_GAMSET = 0x26 ST7789_DISPOFF = 0x28 ST7789_DISPON = 0x29 ST7789_CASET = 0x2A ST7789_RASET = 0x2B ST7789_RAMWR = 0x2C ST7789_RAMRD = 0x2E ST7789_PTLAR = 0x30 ST7789_VSCRDEF = 0x33 ST7789_TEOFF = 0x34 ST7789_TEON = 0x35 ST7789_MADCTL = 0x36 ST7789_VSCRSADD = 0x37 ST7789_IDMOFF = 0x38 ST7789_IDMON = 0x39 ST7789_COLMOD = 0x3A ST7789_RAMWRC = 0x3C ST7789_RAMRDC = 0x3E ST7789_TESCAN = 0x44 ST7789_RDTESCAN = 0x45 ST7789_WRDISBV = 0x51 ST7789_RDDISBV = 0x52 ST7789_WRCTRLD = 0x53 ST7789_RDCTRLD = 0x54 ST7789_WRCACE = 0x55 ST7789_RDCABC = 0x56 ST7789_WRCABCMB = 0x5E ST7789_RDCABCMB = 0x5F ST7789_RDABCSDR = 0x68 ST7789_RDID1 = 0xDA ST7789_RDID2 = 0xDB ST7789_RDID3 = 0xDC ST7789_RAMCTRL = 0xB0 ST7789_RGBCTRL = 0xB1 ST7789_PORCTRL = 0xB2 ST7789_FRCTRL1 = 0xB3 ST7789_GCTRL = 0xB7 ST7789_DGMEN = 0xBA ST7789_VCOMS = 0xBB ST7789_LCMCTRL = 0xC0 ST7789_IDSET = 0xC1 ST7789_VDVVRHEN = 0xC2 ST7789_VRHS = 0xC3 ST7789_VDVSET = 0xC4 ST7789_VCMOFSET = 0xC5 ST7789_FRCTR2 = 0xC6 ST7789_CABCCTRL = 0xC7 ST7789_REGSEL1 = 0xC8 ST7789_REGSEL2 = 0xCA ST7789_PWMFRSEL = 0xCC ST7789_PWCTRL1 = 0xD0 ST7789_VAPVANEN = 0xD2 ST7789_CMD2EN = 0xDF5A6902 ST7789_PVGAMCTRL = 0xE0 ST7789_NVGAMCTRL = 0xE1 ST7789_DGMLUTR = 0xE2 ST7789_DGMLUTB = 0xE3 ST7789_GATECTRL = 0xE4 ST7789_PWCTRL2 = 0xE8 ST7789_EQCTRL = 0xE9 ST7789_PROMCTRL = 0xEC ST7789_PROMEN = 0xFA ST7789_NVMSET = 0xFC ST7789_PROMACT = 0xFE # Colours for convenience ST7789_BLACK = 0x0000 # 0b 00000 000000 00000 ST7789_BLUE = 0x001F # 0b 00000 000000 11111 ST7789_GREEN = 0x07E0 # 0b 00000 111111 00000 ST7789_RED = 0xF800 # 0b 11111 000000 00000 ST7789_CYAN = 0x07FF # 0b 00000 111111 11111 ST7789_MAGENTA = 0xF81F # 0b 11111 000000 11111 ST7789_YELLOW = 0xFFE0 # 0b 11111 111111 00000 ST7789_WHITE = 0xFFFF # 0b 11111 111111 11111 def color565(r, g, b): """Convert red, green, blue components to a 16-bit 565 RGB value. Components should be values 0 to 255. """ return ((r & 0xF8) << 8) | ((g & 0xFC) << 3) | (b >> 3) def image_to_data(image): """Generator function to convert a PIL image to 16-bit 565 RGB bytes.""" # NumPy is much faster at doing this. NumPy code provided by: # Keith (https://www.blogger.com/profile/02555547344016007163) pb = np.array(image.convert('RGB')).astype('uint16') color = ((pb[:,:,0] & 0xF8) << 8) | ((pb[:,:,1] & 0xFC) << 3) | (pb[:,:,2] >> 3) return np.dstack(((color >> 8) & 0xFF, color & 0xFF)).flatten().tolist() class ST7789(object): """Representation of an ST7789 IPS LCD.""" def __init__(self, rst, dc, led): """Create an instance of the display using SPI communication. Must provide the GPIO pin number for the D/C pin and the SPI driver. Can optionally provide the GPIO pin number for the reset pin as the rst parameter. """ SPI_PORT = 0 SPI_DEVICE = 0 SPI_MODE = 0b11 SPI_SPEED_HZ = 40000000 self._spi = SPI.SpiDev(SPI_PORT, SPI_DEVICE, max_speed_hz=SPI_SPEED_HZ) self._rst = rst self._dc = dc self._led = led self._gpio = None self.width = ST7789_TFTWIDTH self.height = ST7789_TFTHEIGHT if self._gpio is None: self._gpio = GPIO.get_platform_gpio() # Set DC as output. self._gpio.setup(self._dc, GPIO.OUT) # Setup reset as output (if provided). if self._rst is not None: self._gpio.setup(self._rst, GPIO.OUT) # Turn on the backlight LED self._gpio.setup(self._led, GPIO.OUT) # Set SPI to mode 0, MSB first. self._spi.set_mode(SPI_MODE) self._spi.set_bit_order(SPI.MSBFIRST) self._spi.set_clock_hz(SPI_CLOCK_HZ) # Create an image buffer. self.buffer = Image.new('RGB', (self.width, self.height)) def send(self, data, is_data=True, chunk_size=4096): """Write a byte or array of bytes to the display. Is_data parameter controls if byte should be interpreted as display data (True) or command data (False). Chunk_size is an optional size of bytes to write in a single SPI transaction, with a default of 4096. """ # Set DC low for command, high for data. self._gpio.output(self._dc, is_data) # Convert scalar argument to list so either can be passed as parameter. if isinstance(data, numbers.Number): data = [data & 0xFF] # Write data a chunk at a time. for start in range(0, len(data), chunk_size): end = min(start+chunk_size, len(data)) self._spi.write(data[start:end]) def command(self, data): """Write a byte or array of bytes to the display as command data.""" self.send(data, False) def data(self, data): """Write a byte or array of bytes to the display as display data.""" self.send(data, True) def reset(self): """Reset the display, if reset pin is connected.""" if self._rst is not None: self._gpio.set_high(self._rst) time.sleep(0.100) self._gpio.set_low(self._rst) time.sleep(0.100) self._gpio.set_high(self._rst) time.sleep(0.100) def _init(self): # Initialize the display. Broken out as a separate function so it can # be overridden by other displays in the future. time.sleep(0.012) self.command(0x11) time.sleep(0.150) self.command(0x36) self.data(0xA0) self.data(0x00) self.command(0x3A) self.data(0x05) self.command(0xB2) self.data(0x0C) self.data(0x0C) self.data(0x00) self.data(0x33) self.data(0x33) self.command(0xB7) self.data(0x35) ## ---------------------------------ST7789S Power setting - ---------------------------- self.command(0xBB) self.data(0x29) # self.command(0xC0) # self.data(0x2C) self.command(0xC2) self.data(0x01) self.command(0xC3) self.data(0x19) self.command(0xC4) self.data(0x20) self.command(0xC5) self.data(0x1A) self.command(0xC6) self.data(0x1F) ## 0x0F:60Hz # self.command(0xCA) # self.data(0x0F) # # self.command(0xC8) # self.data(0x08) # # self.command(0x55) # self.data(0x90) self.command(0xD0) self.data(0xA4) self.data(0xA1) ## --------------------------------ST7789S gamma setting - ----------------------------- self.command(0xE0) self.data(0xD0) self.data(0x08) self.data(0x0E) self.data(0x09) self.data(0x09) self.data(0x05) self.data(0x31) self.data(0x33) self.data(0x48) self.data(0x17) self.data(0x14) self.data(0x15) self.data(0x31) self.data(0x34) self.command(0xE1) self.data(0xD0) self.data(0x08) self.data(0x0E) self.data(0x09) self.data(0x09) self.data(0x15) self.data(0x31) self.data(0x33) self.data(0x48) self.data(0x17) self.data(0x14) self.data(0x15) self.data(0x31) self.data(0x34) self.command(0x21) self.command(0x29) time.sleep(0.100) # 100 ms self._gpio.set_high(self._led) def begin(self): """Initialize the display. Should be called once before other calls that interact with the display are called. """ self.reset() self._init() def set_window(self, x0=0, y0=0, x1=None, y1=None): """Set the pixel address window for proceeding drawing commands. x0 and x1 should define the minimum and maximum x pixel bounds. y0 and y1 should define the minimum and maximum y pixel bound. If no parameters are specified the default will be to update the entire display from 0,0 to width-1,height-1. """ if x1 is None: x1 = self.width-1 if y1 is None: y1 = self.height-1 self.command(ST7789_CASET) # Column addr set self.data(x0 >> 8) self.data(x0) # XSTART self.data(x1 >> 8) self.data(x1) # XEND self.command(ST7789_RASET) # Row addr set self.data(y0 >> 8) self.data(y0) # YSTART self.data(y1 >> 8) self.data(y1) # YEND self.command(ST7789_RAMWR) # write to RAM #def display(self, image=None): def display(self, image=None, x0=0, y0=0, x1=None, y1=None): """Write the display buffer or provided image to the hardware. If no image parameter is provided the display buffer will be written to the hardware. If an image is provided, it should be RGB format and the same dimensions as the display hardware. """ # By default write the internal buffer to the display. if image is None: image = self.buffer # Set address bounds to entire display. #self.set_window() if x1 is None: x1 = self.width-1 if y1 is None: y1 = self.height-1 self.set_window(x0, y0, x1, y1) #image.thumbnail((x1-x0+1, y1-y0+1), Image.ANTIALIAS) # Convert image to array of 16bit 565 RGB data bytes. # Unfortunate that this copy has to occur, but the SPI byte writing # function needs to take an array of bytes and PIL doesn't natively # store images in 16-bit 565 RGB format. pixelbytes = list(image_to_data(image)) # Write data to hardware. self.data(pixelbytes) def clear(self, color=(0,0,0)): """Clear the image buffer to the specified RGB color (default black).""" width, height = self.buffer.size self.buffer.putdata([color]*(width*height)) def draw(self): """Return a PIL ImageDraw instance for 2D drawing on the image buffer.""" return ImageDraw.Draw(self.buffer)

Python

renanmb/Omniverse_legged_robotics/URDF-Descriptions/Mini_pupper/QuadrupedRobot-mini_pupper/Mangdang/LCD/gif.py

import os import time from PIL import Image from PIL import ImageOps class Frame: def __init__(self, duration=0): self.duration = duration self.image = None class AnimatedGif: def __init__(self, display, width=None, height=None, folder=None): self._frame_count = 0 self._loop = 0 self._index = 0 self._duration = 0 self._gif_files = [] self._frames = [] self._gif_folder = folder if width is not None: self._width = width else: self._width = display.width if height is not None: self._height = height else: self._height = display.height self.display = display if folder is not None: self.load_files(folder) self.preload() def advance(self): self._index = (self._index + 1) % len(self._gif_files) def back(self): self._index = (self._index - 1 + len(self._gif_files)) % len(self._gif_files) def load_files(self, folder): gif_files = [f for f in os.listdir(folder) if f.endswith(".gif")] for gif_file in gif_files: image = Image.open(folder + gif_file) # Only add animated Gifs if image.is_animated: self._gif_files.append(gif_file) #print("Found", self._gif_files) if not self._gif_files: print("No Gif files found in current folder") exit() # pylint: disable=consider-using-sys-exit def preload(self): image = Image.open(self._gif_folder + self._gif_files[self._index]) #print("Loading {}...".format(self._gif_files[self._index])) if "duration" in image.info: self._duration = image.info["duration"] else: self._duration = 0 if "loop" in image.info: self._loop = image.info["loop"] else: self._loop = 1 self._frame_count = image.n_frames del self._frames[:] for frame in range(self._frame_count): image.seek(frame) # Create blank image for drawing. # Make sure to create image with mode 'RGB' for full color. frame_object = Frame(duration=self._duration) if "duration" in image.info: frame_object.duration = image.info["duration"] frame_object.image = ImageOps.pad( # pylint: disable=no-member image.convert("RGB"), (self._width, self._height), method=Image.NEAREST, color=(0, 0, 0), centering=(0.5, 0.5), ) self._frames.append(frame_object) def play(self): # Check if we have loaded any files first if not self._gif_files: print("There are no Gif Images loaded to Play") return False #while True: for frame_object in self._frames: start_time = time.time() self.display.display(frame_object.image) while time.time() < (start_time + frame_object.duration / 1000): pass if self._loop == 1: return True if self._loop > 0: self._loop -= 1 def run(self): while True: auto_advance = self.play() if auto_advance: self.advance()

Python

renanmb/Omniverse_legged_robotics/URDF-Descriptions/Mini_pupper/QuadrupedRobot-mini_pupper/PupperCommand/joystick.py

from UDPComms import Publisher, Subscriber, timeout from PS4Joystick import Joystick import time ## you need to git clone the PS4Joystick repo and run `sudo bash install.sh` ## Configurable ## MESSAGE_RATE = 20 PUPPER_COLOR = {"red":0, "blue":0, "green":255} joystick_pub = Publisher(8830,65530) joystick_subcriber = Subscriber(8840, timeout=0.01) joystick = Joystick() joystick.led_color(**PUPPER_COLOR) while True: values = joystick.get_input() left_y = -values["left_analog_y"] right_y = -values["right_analog_y"] right_x = values["right_analog_x"] left_x = values["left_analog_x"] L2 = values["l2_analog"] R2 = values["r2_analog"] R1 = values["button_r1"] L1 = values["button_l1"] square = values["button_square"] x = values["button_cross"] circle = values["button_circle"] triangle = values["button_triangle"] dpadx = values["dpad_right"] - values["dpad_left"] dpady = values["dpad_up"] - values["dpad_down"] msg = { "ly": left_y, "lx": left_x, "rx": right_x, "ry": right_y, "L2": L2, "R2": R2, "R1": R1, "L1": L1, "dpady": dpady, "dpadx": dpadx, "x": x, "square": square, "circle": circle, "triangle": triangle, "message_rate": MESSAGE_RATE, } joystick_pub.send(msg) try: msg = joystick_subcriber.get() joystick.led_color(**msg["ps4_color"]) except timeout: pass time.sleep(1 / MESSAGE_RATE)

Python

renanmb/Omniverse_legged_robotics/URDF-Descriptions/Mini_pupper/QuadrupedRobot-mini_pupper/PupperCommand/README.md

# PupperCommand ## Installation ```shell git clone https://github.com/stanfordroboticsclub/PupperCommand.git cd PupperCommand sudo bash install.sh ``` Then clone https://github.com/stanfordroboticsclub/PS4Joystick/ and follow the installation instructions in the README. ## Starting the joystick publisher 1. The ```install.sh``` script makes the Raspberry Pi automatically look to pair and connect to PS4 joysticks on boot. 2. So once the Raspberry Pi turns on, put the PS4 controller into pairing mode by holding the share and PS button at the same time. The light should start blinking in bursts of two. 3. By around 10 seconds, the joystick should have paired with the Raspberry Pi and the front light on the joystick will change to whatever color you specify in the ```joystick.py``` script. ## Debugging To see if the controller is publishing to the Rover topic use: ```shell rover peek 8830 ``` You can also check the status of the system daemon (systemd) running the ```joystick.py``` script by doing ```shell sudo systemctl status joystick ``` If it shows that the service failed, you can try ```shell sudo systemctl stop joystick sudo systemctl start joystick ``` ## Notes If a packet is lost over the joystick connection, the PS4Joystick code will raise an exception and cause the program to exit. Systemd will then restart the ```joystick.py``` script, which means you will have to re-pair the joystick (hold share + ps4 button until double blinking).

Markdown

renanmb/Omniverse_legged_robotics/URDF-Descriptions/Mini_pupper/QuadrupedRobot-mini_pupper/Legacy/ImageOps.py

# # The Python Imaging Library. # $Id$ # # standard image operations # # History: # 2001-10-20 fl Created # 2001-10-23 fl Added autocontrast operator # 2001-12-18 fl Added Kevin's fit operator # 2004-03-14 fl Fixed potential division by zero in equalize # 2005-05-05 fl Fixed equalize for low number of values # # Copyright (c) 2001-2004 by Secret Labs AB # Copyright (c) 2001-2004 by Fredrik Lundh # # See the README file for information on usage and redistribution. # from . import Image import operator import functools import warnings # # helpers def _border(border): if isinstance(border, tuple): if len(border) == 2: left, top = right, bottom = border elif len(border) == 4: left, top, right, bottom = border else: left = top = right = bottom = border return left, top, right, bottom def _color(color, mode): if isStringType(color): from . import ImageColor color = ImageColor.getcolor(color, mode) return color def _lut(image, lut): if image.mode == "P": # FIXME: apply to lookup table, not image data raise NotImplementedError("mode P support coming soon") elif image.mode in ("L", "RGB"): if image.mode == "RGB" and len(lut) == 256: lut = lut + lut + lut return image.point(lut) else: raise IOError("not supported for this image mode") # # actions def autocontrast(image, cutoff=0, ignore=None): """ Maximize (normalize) image contrast. This function calculates a histogram of the input image, removes **cutoff** percent of the lightest and darkest pixels from the histogram, and remaps the image so that the darkest pixel becomes black (0), and the lightest becomes white (255). :param image: The image to process. :param cutoff: How many percent to cut off from the histogram. :param ignore: The background pixel value (use None for no background). :return: An image. """ histogram = image.histogram() lut = [] for layer in range(0, len(histogram), 256): h = histogram[layer:layer+256] if ignore is not None: # get rid of outliers try: h[ignore] = 0 except TypeError: # assume sequence for ix in ignore: h[ix] = 0 if cutoff: # cut off pixels from both ends of the histogram # get number of pixels n = 0 for ix in range(256): n = n + h[ix] # remove cutoff% pixels from the low end cut = n * cutoff // 100 for lo in range(256): if cut > h[lo]: cut = cut - h[lo] h[lo] = 0 else: h[lo] -= cut cut = 0 if cut <= 0: break # remove cutoff% samples from the hi end cut = n * cutoff // 100 for hi in range(255, -1, -1): if cut > h[hi]: cut = cut - h[hi] h[hi] = 0 else: h[hi] -= cut cut = 0 if cut <= 0: break # find lowest/highest samples after preprocessing for lo in range(256): if h[lo]: break for hi in range(255, -1, -1): if h[hi]: break if hi <= lo: # don't bother lut.extend(list(range(256))) else: scale = 255.0 / (hi - lo) offset = -lo * scale for ix in range(256): ix = int(ix * scale + offset) if ix < 0: ix = 0 elif ix > 255: ix = 255 lut.append(ix) return _lut(image, lut) def colorize(image, black, white, mid=None, blackpoint=0, whitepoint=255, midpoint=127): """ Colorize grayscale image. This function calculates a color wedge which maps all black pixels in the source image to the first color and all white pixels to the second color. If **mid** is specified, it uses three-color mapping. The **black** and **white** arguments should be RGB tuples or color names; optionally you can use three-color mapping by also specifying **mid**. Mapping positions for any of the colors can be specified (e.g. **blackpoint**), where these parameters are the integer value corresponding to where the corresponding color should be mapped. These parameters must have logical order, such that **blackpoint** <= **midpoint** <= **whitepoint** (if **mid** is specified). :param image: The image to colorize. :param black: The color to use for black input pixels. :param white: The color to use for white input pixels. :param mid: The color to use for midtone input pixels. :param blackpoint: an int value [0, 255] for the black mapping. :param whitepoint: an int value [0, 255] for the white mapping. :param midpoint: an int value [0, 255] for the midtone mapping. :return: An image. """ # Initial asserts assert image.mode == "L" if mid is None: assert 0 <= blackpoint <= whitepoint <= 255 else: assert 0 <= blackpoint <= midpoint <= whitepoint <= 255 # Define colors from arguments black = _color(black, "RGB") white = _color(white, "RGB") if mid is not None: mid = _color(mid, "RGB") # Empty lists for the mapping red = [] green = [] blue = [] # Create the low-end values for i in range(0, blackpoint): red.append(black[0]) green.append(black[1]) blue.append(black[2]) # Create the mapping (2-color) if mid is None: range_map = range(0, whitepoint - blackpoint) for i in range_map: red.append(black[0] + i * (white[0] - black[0]) // len(range_map)) green.append(black[1] + i * (white[1] - black[1]) // len(range_map)) blue.append(black[2] + i * (white[2] - black[2]) // len(range_map)) # Create the mapping (3-color) else: range_map1 = range(0, midpoint - blackpoint) range_map2 = range(0, whitepoint - midpoint) for i in range_map1: red.append(black[0] + i * (mid[0] - black[0]) // len(range_map1)) green.append(black[1] + i * (mid[1] - black[1]) // len(range_map1)) blue.append(black[2] + i * (mid[2] - black[2]) // len(range_map1)) for i in range_map2: red.append(mid[0] + i * (white[0] - mid[0]) // len(range_map2)) green.append(mid[1] + i * (white[1] - mid[1]) // len(range_map2)) blue.append(mid[2] + i * (white[2] - mid[2]) // len(range_map2)) # Create the high-end values for i in range(0, 256 - whitepoint): red.append(white[0]) green.append(white[1]) blue.append(white[2]) # Return converted image image = image.convert("RGB") return _lut(image, red + green + blue) def pad(image, size, method=Image.NEAREST, color=None, centering=(0.5, 0.5)): """ Returns a sized and padded version of the image, expanded to fill the requested aspect ratio and size. :param image: The image to size and crop. :param size: The requested output size in pixels, given as a (width, height) tuple. :param method: What resampling method to use. Default is :py:attr:`PIL.Image.NEAREST`. :param color: The background color of the padded image. :param centering: Control the position of the original image within the padded version. (0.5, 0.5) will keep the image centered (0, 0) will keep the image aligned to the top left (1, 1) will keep the image aligned to the bottom right :return: An image. """ im_ratio = image.width / image.height dest_ratio = float(size[0]) / size[1] if im_ratio == dest_ratio: out = image.resize(size, resample=method) else: out = Image.new(image.mode, size, color) if im_ratio > dest_ratio: new_height = int(image.height / image.width * size[0]) if new_height != size[1]: image = image.resize((size[0], new_height), resample=method) y = int((size[1] - new_height) * max(0, min(centering[1], 1))) out.paste(image, (0, y)) else: new_width = int(image.width / image.height * size[1]) if new_width != size[0]: image = image.resize((new_width, size[1]), resample=method) x = int((size[0] - new_width) * max(0, min(centering[0], 1))) out.paste(image, (x, 0)) return out def crop(image, border=0): """ Remove border from image. The same amount of pixels are removed from all four sides. This function works on all image modes. .. seealso:: :py:meth:`~PIL.Image.Image.crop` :param image: The image to crop. :param border: The number of pixels to remove. :return: An image. """ left, top, right, bottom = _border(border) return image.crop( (left, top, image.size[0]-right, image.size[1]-bottom) ) def scale(image, factor, resample=Image.NEAREST): """ Returns a rescaled image by a specific factor given in parameter. A factor greater than 1 expands the image, between 0 and 1 contracts the image. :param image: The image to rescale. :param factor: The expansion factor, as a float. :param resample: An optional resampling filter. Same values possible as in the PIL.Image.resize function. :returns: An :py:class:`~PIL.Image.Image` object. """ if factor == 1: return image.copy() elif factor <= 0: raise ValueError("the factor must be greater than 0") else: size = (int(round(factor * image.width)), int(round(factor * image.height))) return image.resize(size, resample) def deform(image, deformer, resample=Image.BILINEAR): """ Deform the image. :param image: The image to deform. :param deformer: A deformer object. Any object that implements a **getmesh** method can be used. :param resample: An optional resampling filter. Same values possible as in the PIL.Image.transform function. :return: An image. """ return image.transform( image.size, Image.MESH, deformer.getmesh(image), resample ) def equalize(image, mask=None): """ Equalize the image histogram. This function applies a non-linear mapping to the input image, in order to create a uniform distribution of grayscale values in the output image. :param image: The image to equalize. :param mask: An optional mask. If given, only the pixels selected by the mask are included in the analysis. :return: An image. """ if image.mode == "P": image = image.convert("RGB") h = image.histogram(mask) lut = [] for b in range(0, len(h), 256): histo = [_f for _f in h[b:b+256] if _f] if len(histo) <= 1: lut.extend(list(range(256))) else: step = (functools.reduce(operator.add, histo) - histo[-1]) // 255 if not step: lut.extend(list(range(256))) else: n = step // 2 for i in range(256): lut.append(n // step) n = n + h[i+b] return _lut(image, lut) def expand(image, border=0, fill=0): """ Add border to the image :param image: The image to expand. :param border: Border width, in pixels. :param fill: Pixel fill value (a color value). Default is 0 (black). :return: An image. """ left, top, right, bottom = _border(border) width = left + image.size[0] + right height = top + image.size[1] + bottom out = Image.new(image.mode, (width, height), _color(fill, image.mode)) out.paste(image, (left, top)) return out def fit(image, size, method=Image.NEAREST, bleed=0.0, centering=(0.5, 0.5)): """ Returns a sized and cropped version of the image, cropped to the requested aspect ratio and size. This function was contributed by Kevin Cazabon. :param image: The image to size and crop. :param size: The requested output size in pixels, given as a (width, height) tuple. :param method: What resampling method to use. Default is :py:attr:`PIL.Image.NEAREST`. :param bleed: Remove a border around the outside of the image from all four edges. The value is a decimal percentage (use 0.01 for one percent). The default value is 0 (no border). Cannot be greater than or equal to 0.5. :param centering: Control the cropping position. Use (0.5, 0.5) for center cropping (e.g. if cropping the width, take 50% off of the left side, and therefore 50% off the right side). (0.0, 0.0) will crop from the top left corner (i.e. if cropping the width, take all of the crop off of the right side, and if cropping the height, take all of it off the bottom). (1.0, 0.0) will crop from the bottom left corner, etc. (i.e. if cropping the width, take all of the crop off the left side, and if cropping the height take none from the top, and therefore all off the bottom). :return: An image. """ # by Kevin Cazabon, Feb 17/2000 # kevin@cazabon.com # http://www.cazabon.com # ensure centering is mutable centering = list(centering) if not 0.0 <= centering[0] <= 1.0: centering[0] = 0.5 if not 0.0 <= centering[1] <= 1.0: centering[1] = 0.5 if not 0.0 <= bleed < 0.5: bleed = 0.0 # calculate the area to use for resizing and cropping, subtracting # the 'bleed' around the edges # number of pixels to trim off on Top and Bottom, Left and Right bleed_pixels = (bleed * image.size[0], bleed * image.size[1]) live_size = (image.size[0] - bleed_pixels[0] * 2, image.size[1] - bleed_pixels[1] * 2) # calculate the aspect ratio of the live_size live_size_ratio = float(live_size[0]) / live_size[1] # calculate the aspect ratio of the output image output_ratio = float(size[0]) / size[1] # figure out if the sides or top/bottom will be cropped off if live_size_ratio >= output_ratio: # live_size is wider than what's needed, crop the sides crop_width = output_ratio * live_size[1] crop_height = live_size[1] else: # live_size is taller than what's needed, crop the top and bottom crop_width = live_size[0] crop_height = live_size[0] / output_ratio # make the crop crop_left = bleed_pixels[0] + (live_size[0]-crop_width) * centering[0] crop_top = bleed_pixels[1] + (live_size[1]-crop_height) * centering[1] crop = ( crop_left, crop_top, crop_left + crop_width, crop_top + crop_height ) # resize the image and return it return image.resize(size, method, box=crop) def flip(image): """ Flip the image vertically (top to bottom). :param image: The image to flip. :return: An image. """ return image.transpose(Image.FLIP_TOP_BOTTOM) def grayscale(image): """ Convert the image to grayscale. :param image: The image to convert. :return: An image. """ return image.convert("L") def invert(image): """ Invert (negate) the image. :param image: The image to invert. :return: An image. """ lut = [] for i in range(256): lut.append(255-i) return _lut(image, lut) def mirror(image): """ Flip image horizontally (left to right). :param image: The image to mirror. :return: An image. """ return image.transpose(Image.FLIP_LEFT_RIGHT) def posterize(image, bits): """ Reduce the number of bits for each color channel. :param image: The image to posterize. :param bits: The number of bits to keep for each channel (1-8). :return: An image. """ lut = [] mask = ~(2**(8-bits)-1) for i in range(256): lut.append(i & mask) return _lut(image, lut) def solarize(image, threshold=128): """ Invert all pixel values above a threshold. :param image: The image to solarize. :param threshold: All pixels above this greyscale level are inverted. :return: An image. """ lut = [] for i in range(256): if i < threshold: lut.append(i) else: lut.append(255-i) return _lut(image, lut) # -------------------------------------------------------------------- # PIL USM components, from Kevin Cazabon. def gaussian_blur(im, radius=None): """ PIL_usm.gblur(im, [radius])""" warnings.warn( 'PIL.ImageOps.gaussian_blur is deprecated. ' 'Use PIL.ImageFilter.GaussianBlur instead. ' 'This function will be removed in a future version.', DeprecationWarning ) if radius is None: radius = 5.0 im.load() return im.im.gaussian_blur(radius) def gblur(im, radius=None): """ PIL_usm.gblur(im, [radius])""" warnings.warn( 'PIL.ImageOps.gblur is deprecated. ' 'Use PIL.ImageFilter.GaussianBlur instead. ' 'This function will be removed in a future version.', DeprecationWarning ) return gaussian_blur(im, radius) def unsharp_mask(im, radius=None, percent=None, threshold=None): """ PIL_usm.usm(im, [radius, percent, threshold])""" warnings.warn( 'PIL.ImageOps.unsharp_mask is deprecated. ' 'Use PIL.ImageFilter.UnsharpMask instead. ' 'This function will be removed in a future version.', DeprecationWarning ) if radius is None: radius = 5.0 if percent is None: percent = 150 if threshold is None: threshold = 3 im.load() return im.im.unsharp_mask(radius, percent, threshold) def usm(im, radius=None, percent=None, threshold=None): """ PIL_usm.usm(im, [radius, percent, threshold])""" warnings.warn( 'PIL.ImageOps.usm is deprecated. ' 'Use PIL.ImageFilter.UnsharpMask instead. ' 'This function will be removed in a future version.', DeprecationWarning ) return unsharp_mask(im, radius, percent, threshold) def box_blur(image, radius): """ Blur the image by setting each pixel to the average value of the pixels in a square box extending radius pixels in each direction. Supports float radius of arbitrary size. Uses an optimized implementation which runs in linear time relative to the size of the image for any radius value. :param image: The image to blur. :param radius: Size of the box in one direction. Radius 0 does not blur, returns an identical image. Radius 1 takes 1 pixel in each direction, i.e. 9 pixels in total. :return: An image. """ warnings.warn( 'PIL.ImageOps.box_blur is deprecated. ' 'Use PIL.ImageFilter.BoxBlur instead. ' 'This function will be removed in a future version.', DeprecationWarning ) image.load() return image._new(image.im.box_blur(radius))

Python

renanmb/Omniverse_legged_robotics/URDF-Descriptions/Mini_pupper/QuadrupedRobot-mini_pupper/StanfordQuadruped/calibrate_tool.py

import re import tkinter as tk import tkinter.messagebox from tkinter import * import _thread import time import os import sys import numpy as np from pupper.HardwareInterface import HardwareInterface ################################################################### OverLoadCurrentMax = 1500000 OverLoadHoldCounterMax = 100 # almost 3s ServoCalibrationFilePath = '/sys/bus/i2c/devices/3-0050/eeprom' servo1_en = 25 servo2_en = 21 hw_version="" ################################################################### class LegPositionScale: def __init__(self,root,location_x,location_y,leg_name): self.LocationX = location_x self.LocationY = location_y delt_x = 40 delt_y = 45 self.Value1 = DoubleVar() self.Value2 = DoubleVar() self.Value3 = DoubleVar() self.title = Label(root,text = leg_name,font = ('bold',16)) self.label1 = Label(root,text = 'Hip') self.slider1 = Scale(root,from_=-100,to=100,variable = self.Value1,length = 120,orient = HORIZONTAL) self.label2 = Label(root,text = 'Thigh') self.slider2 = Scale(root,from_=-55,to=145,variable = self.Value2,length = 120,orient = HORIZONTAL) self.label3 = Label(root,text = 'Calf') self.slider3 = Scale(root,from_=-145,to=55,variable = self.Value3,length = 120,orient = HORIZONTAL) self.label1.place(x=location_x, y=location_y + 20) self.label2.place(x=location_x, y=location_y + delt_y*1+ 20) self.label3.place(x=location_x, y=location_y + delt_y*2+ 20) self.slider1.place(x=location_x + delt_x, y=location_y ) self.slider2.place(x=location_x + delt_x, y=location_y + delt_y*1) self.slider3.place(x=location_x + delt_x, y=location_y + delt_y*2) self.title.place(x=location_x + 70, y=location_y + delt_y*3) def setValue(self,value): self.slider1.set(value[0]) self.slider2.set(value[1]) self.slider3.set(value[2]) return True def getValue(self): value = [] value.append(self.Value1.get()) value.append(self.Value2.get()) value.append(self.Value3.get()) return value class CalibrationTool: def __init__(self,title, width, height): self.Run = True self.FileAllLines = [] #leg slider value self.Leg1SlidersValue = [0,0,0] self.Leg2SlidersValue = [0,0,0] self.Leg3SlidersValue = [0,0,0] self.Leg4SlidersValue = [0,0,0] # calibration data self.Matrix_EEPROM = np.array([[0, 0, 0, 0], [45, 45, 45, 45], [-45, -45, -45, -45]]) self.ServoStandardLAngle = [[0,0,0,0],[45,45,45,45],[-45,-45,-45,-45]] self.ServoNeutralLAngle = [[0,0,0,0],[45,45,45,45],[-45,-45,-45,-45]] self.NocalibrationServoAngle = [[0,0,0,0],[45,45,45,45],[-45,-45,-45,-45]] self.CalibrationServoAngle = [[0,0,0,0],[45,45,45,45],[-45,-45,-45,-45]] #build main window self.MainWindow = tk.Tk() screenwidth = self.MainWindow.winfo_screenwidth() screenheight = self.MainWindow.winfo_screenheight() size = '%dx%d+%d+%d' % (width, height, (screenwidth - width) / 2, (screenheight - height) / 2) self.MainWindow.geometry(size) self.MainWindow.title('MiniPupper') #Mini Pupper Calibration Tool self.MainWindow.update() #init title self.Title = Label(self.MainWindow,text = title,font = ('bold',30)) self.Title.place(x=140,y=15) #init robot image self.photo = tk.PhotoImage(file= '/home/ubuntu/Robotics/QuadrupedRobot/Doc/imgs/MiniPupper.Calibration.png') self.MainImg = Label(self.MainWindow,image = self.photo) self.MainImg.place(x=230,y=60) #init read update button self.ResetButton = Button(self.MainWindow,text = ' Reset ',font = ('bold',20),command=self.ResetButtonEvent) self.UpdateButton = Button(self.MainWindow,text = 'Update',font = ('bold',20),command=self.updateButtonEvent) self.RestoreButton = Button(self.MainWindow,text = 'Restore',font = ('bold',7),command=self.RestoreButtonEvent) self.ResetButton.place(x=600,y=100) self.UpdateButton.place(x=600,y=200) self.RestoreButton.place(x=160,y=80) #build 4 legs sliders self.Leg1Calibration = LegPositionScale(self.MainWindow,20,300, 'Leg 1') self.Leg2Calibration = LegPositionScale(self.MainWindow,220,300,'Leg 2') self.Leg3Calibration = LegPositionScale(self.MainWindow,420,300,'Leg 3') self.Leg4Calibration = LegPositionScale(self.MainWindow,620,300,'Leg 4') self.Leg1Calibration.setValue([self.ServoNeutralLAngle[0][0],self.ServoNeutralLAngle[1][0],self.ServoNeutralLAngle[2][0]]) self.Leg2Calibration.setValue([self.ServoNeutralLAngle[0][1],self.ServoNeutralLAngle[1][1],self.ServoNeutralLAngle[2][1]]) self.Leg3Calibration.setValue([self.ServoNeutralLAngle[0][2],self.ServoNeutralLAngle[1][2],self.ServoNeutralLAngle[2][2]]) self.Leg4Calibration.setValue([self.ServoNeutralLAngle[0][3],self.ServoNeutralLAngle[1][3],self.ServoNeutralLAngle[2][3]]) def setLegSlidersValue(self,value): self.Leg1Calibration.setValue(value[0]) self.Leg2Calibration.setValue(value[1]) self.Leg3Calibration.setValue(value[2]) self.Leg4Calibration.setValue(value[3]) return value def readCalibrationFile(self): #read all lines text from EEPROM try: with open(ServoCalibrationFilePath, "rb") as nv_f: arr1 = np.array(eval(nv_f.readline())) arr2 = np.array(eval(nv_f.readline())) matrix = np.append(arr1, arr2) arr3 = np.array(eval(nv_f.readline())) matrix = np.append(matrix, arr3) matrix.resize(3,4) self.Matrix_EEPROM = matrix print("Get nv calibration params: \n" , self.Matrix_EEPROM) except: matrix = np.array([[0, 0, 0, 0], [45, 45, 45, 45], [-45, -45, -45, -45]]) self.Matrix_EEPROM = matrix #update for i in range(3): for j in range(4): self.NocalibrationServoAngle[i][j] = self.Matrix_EEPROM[i,j] self.CalibrationServoAngle[i][j] = self.Matrix_EEPROM[i,j] return True def updateCalibrationMatrix(self,angle): for i in range(3): for j in range(4): self.Matrix_EEPROM[i,j] = angle[i][j] return True def writeCalibrationFile(self): #write matrix to EEPROM buf_matrix = np.zeros((3, 4)) for i in range(3): for j in range(4): buf_matrix[i,j]= self.Matrix_EEPROM[i,j] # Format array object string for np.array p1 = re.compile("([0-9]\.) ( *)") # pattern to replace the space that follows each number with a comma partially_formatted_matrix = p1.sub(r"\1,\2", str(buf_matrix)) p2 = re.compile("(\]\n)") # pattern to add a comma at the end of the first two lines formatted_matrix_with_required_commas = p2.sub("],\n", partially_formatted_matrix) with open(ServoCalibrationFilePath, "w") as nv_f: _tmp = str(buf_matrix) _tmp = _tmp.replace('.' , ',') _tmp = _tmp.replace('[' , '') _tmp = _tmp.replace(']' , '') print(_tmp, file = nv_f) nv_f.close() return True def getLegSlidersValue(self): value = [[0,0,0,0],[0,0,0,0],[0,0,0,0]] self.Leg1SlidersValue = self.Leg1Calibration.getValue() self.Leg2SlidersValue = self.Leg2Calibration.getValue() self.Leg3SlidersValue = self.Leg3Calibration.getValue() self.Leg4SlidersValue = self.Leg4Calibration.getValue() value[0] = [self.Leg1SlidersValue[0],self.Leg2SlidersValue[0],self.Leg3SlidersValue[0],self.Leg4SlidersValue[0]] value[1] = [self.Leg1SlidersValue[1],self.Leg2SlidersValue[1],self.Leg3SlidersValue[1],self.Leg4SlidersValue[1]] value[2] = [self.Leg1SlidersValue[2],self.Leg2SlidersValue[2],self.Leg3SlidersValue[2],self.Leg4SlidersValue[2]] self.ServoNeutralLAngle = value return value def ResetButtonEvent(self): value = [[0,0,0],[0,0,0],[0,0,0],[0,0,0]] for i in range(3): for j in range(4): value[j][i] = self.ServoStandardLAngle[i][j] self.setLegSlidersValue(value) return True def updateButtonEvent(self): # update angle matrix value = self.getLegSlidersValue() angle = [[0,0,0,0],[0,0,0,0],[0,0,0,0]] for i in range(3): for j in range(4): angle[i][j] = self.ServoStandardLAngle[i][j] - value[i][j] +MainWindow.NocalibrationServoAngle[i][j] # limit angle for i in range(3): for j in range(4): if angle[i][j] > 90: angle[i][j] = 90 elif angle[i][j] < -90: angle[i][j] = -90 # popup message box result = tk.messagebox.askquestion('Info:','****** Angle Matrix ******\n' +str(angle[0])+'\n' +str(angle[1])+'\n' +str(angle[2])+'\n' +'****************************\n' +' Update Matrix?') # update matrix if result == 'yes': self.updateCalibrationMatrix(angle) self.writeCalibrationFile() print('******** Angle Matrix ********') print(angle[0]) print(angle[1]) print(angle[2]) print('******************************') return True def RestoreButtonEvent(self): # update angle matrix value = self.getLegSlidersValue() angle = [[0,0,0,0],[45,45,45,45],[-45,-45,-45,-45]] # popup message box result = tk.messagebox.askquestion('Warning','Are you sure you want to Restore Factory Setting!?') # update matrix if result == 'yes': self.updateCalibrationMatrix(angle) self.writeCalibrationFile() print('******** Angle Matrix ********') print(angle[0]) print(angle[1]) print(angle[2]) print('******************************') sys.exit() for i in range(3): for j in range(4): self.NocalibrationServoAngle[i][j] = angle[i][j] #self.CalibrationServoAngle[i][j] = angle[i][j] value = [[0,0,0],[0,0,0],[0,0,0],[0,0,0]] for i in range(3): for j in range(4): value[j][i] = self.ServoStandardLAngle[i][j] self.setLegSlidersValue(value) return True def runMainWindow(self): self.MainWindow.mainloop() return True def stopMainWindow(self): self.Run = False return True OverLoadHoldCounter = 0 def OverLoadDetection(): overload = False global OverLoadHoldCounter r = os.popen("cat /sys/class/power_supply/max1720x_battery/current_now") feedback = str(r.readlines()) current_now = int(feedback[3:len(feedback)-4]) if (current_now > OverLoadCurrentMax): OverLoadHoldCounter = OverLoadHoldCounter + 1 if (OverLoadHoldCounter > OverLoadHoldCounterMax): OverLoadHoldCounter = OverLoadHoldCounterMax os.popen("echo 0 > /sys/class/gpio/gpio"+ str(servo1_en) + "/value") os.popen("echo 0 > /sys/class/gpio/gpio"+ str(servo2_en) + "/value") overload = True else: overload = False else: OverLoadHoldCounter = OverLoadHoldCounter - 10 if (OverLoadHoldCounter < 0): OverLoadHoldCounter = 0 os.popen("echo 1 > /sys/class/gpio/gpio" + str(servo1_en) + "/value") os.popen("echo 1 > /sys/class/gpio/gpio" + str(servo2_en) + "/value") overload = False return overload def updateServoValue(MainWindow,servo): while MainWindow.Run: #update leg slider value value = MainWindow.getLegSlidersValue() # overload detection overload = OverLoadDetection() if overload == True: tk.messagebox.showwarning('Warning','Servos overload, please check !!!') else: #control servo joint_angles = np.zeros((3, 4)) joint_angles2 = np.zeros((3, 4)) for i in range(3): for j in range(4): joint_angles[i,j] = (value[i][j] - (MainWindow.NocalibrationServoAngle[i][j] - MainWindow.CalibrationServoAngle[i][j]))*0.01745 servo.set_actuator_postions(joint_angles) time.sleep(0.01) ############################################## with open("/home/ubuntu/.hw_version", "r") as hw_f: hw_version = hw_f.readline() if hw_version == 'P1\n': ServoCalibrationFilePath = "/home/ubuntu/.nv_fle" servo1_en = 19 servo2_en = 26 else: servo1_en = 25 servo2_en = 21 os.system("sudo systemctl stop robot") os.system("echo 1 > /sys/class/gpio/gpio" + str(servo1_en) + "/value") os.system("echo 1 > /sys/class/gpio/gpio" + str(servo2_en) + "/value") MainWindow = CalibrationTool('MiniPupper Calibration Tool',800,500) MainWindow.readCalibrationFile() hardware_interface = HardwareInterface() try: _thread.start_new_thread( updateServoValue, ( MainWindow, hardware_interface,) ) except: print ('Thread Error') MainWindow.runMainWindow() MainWindow.stopMainWindow() os.system("sudo systemctl start robot") os.system("echo 1 > /sys/class/gpio/gpio"+ str(servo1_en) + "/value") os.system("echo 1 > /sys/class/gpio/gpio"+ str(servo2_en) + "/value")

Python

renanmb/Omniverse_legged_robotics/URDF-Descriptions/Mini_pupper/QuadrupedRobot-mini_pupper/StanfordQuadruped/run_robot.py

import os import sys import threading import time import numpy as np from PIL import Image from multiprocessing import Process import multiprocessing sys.path.append("/home/ubuntu/Robotics/QuadrupedRobot") sys.path.extend([os.path.join(root, name) for root, dirs, _ in os.walk("/home/ubuntu/Robotics/QuadrupedRobot") for name in dirs]) from Mangdang.LCD.ST7789 import ST7789 from Mangdang.LCD.gif import AnimatedGif from src.Controller import Controller from src.JoystickInterface import JoystickInterface from src.State import State from pupper.MovementGroup import MovementLib from src.MovementScheme import MovementScheme from pupper.HardwareInterface import HardwareInterface from pupper.Config import Configuration from pupper.Kinematics import four_legs_inverse_kinematics quat_orientation = np.array([1, 0, 0, 0]) cartoons_folder = "/home/ubuntu/Robotics/QuadrupedRobot/Mangdang/LCD/cartoons/" current_show = "" with open("/home/ubuntu/.hw_version", "r") as hw_f: hw_version = hw_f.readline() if hw_version == 'P1\n': disp = ST7789(14, 15, 47) else : disp = ST7789(27, 24, 26) def pic_show(disp, pic_name, _lock): """ Show the specify picture Parameter: disp : display instance pic_name : picture name to show Return : None """ if pic_name == "": return global current_show if pic_name == current_show: return image=Image.open(cartoons_folder + pic_name) image.resize((320,240)) _lock.acquire() disp.display(image) _lock.release() current_show = pic_name def animated_thr_fun(_disp, duration, is_connect, current_leg, _lock): """ The thread funcation to show sleep animated gif Parameter: None Returen: None """ try: gif_player = AnimatedGif(_disp, width=320, height=240, folder=cartoons_folder) last_time = time.time() last_joint_angles = np.zeros(3) while True: if is_connect.value == 1 : #if ((current_leg[0]==last_joint_angles[0]) and (current_leg[1]==last_joint_angles[1]) and (current_leg[2]==last_joint_angles[2])) == False : if ((current_leg[0]==last_joint_angles[0]) and (current_leg[1]==last_joint_angles[1])) == False : last_time = time.time() last_joint_angles[0] = current_leg[0] last_joint_angles[1] = current_leg[1] #last_joint_angles[2] = current_leg[2] if (time.time() - last_time) > duration : _lock.acquire() gif_player.play() _lock.release() time.sleep(0.5) else : last_time = time.time() time.sleep(1.5) except KeyboardInterrupt: _lock.release() pass def cmd_dump(cmd): """ debug interface to show all info about PS4 command Parameter: None return : None """ print("\nGet PS4 command :") print("horizontal_velocity: ", cmd.horizontal_velocity) print("yaw_rate ", cmd.yaw_rate) print("height", cmd.height) print("pitch ", cmd.pitch) print("roll ", cmd.roll) print("activation ", cmd.activation) print("hop_event ", cmd.hop_event) print("trot_event ", cmd.trot_event) print("activate_event ", cmd.activate_event) def main(): """Main program """ # Create config config = Configuration() hardware_interface = HardwareInterface() # show logo global disp disp.begin() disp.clear() image=Image.open(cartoons_folder + "logo.png") image.resize((320,240)) disp.display(image) shutdown_counter = 0 # counter for shuudown cmd # Start animated process duration = 10 is_connect = multiprocessing.Value('l', 0) current_leg = multiprocessing.Array('d', [0, 0, 0]) lock = multiprocessing.Lock() animated_process = Process(target=animated_thr_fun, args=(disp, duration, is_connect, current_leg, lock)) #animated_process.start() #Create movement group scheme movement_ctl = MovementScheme(MovementLib) # Create controller and user input handles controller = Controller( config, four_legs_inverse_kinematics, ) state = State() print("Creating joystick listener...") joystick_interface = JoystickInterface(config) print("Done.") last_loop = time.time() print("Summary of gait parameters:") print("overlap time: ", config.overlap_time) print("swing time: ", config.swing_time) print("z clearance: ", config.z_clearance) print("x shift: ", config.x_shift) # Wait until the activate button has been pressed while True: print("Waiting for L1 to activate robot.") while True: command = joystick_interface.get_command(state) joystick_interface.set_color(config.ps4_deactivated_color) if command.activate_event == 1: break time.sleep(0.1) print("Robot activated.") is_connect.value = 1 joystick_interface.set_color(config.ps4_color) pic_show(disp, "walk.png", lock) while True: now = time.time() if now - last_loop < config.dt: continue last_loop = time.time() # Parse the udp joystick commands and then update the robot controller's parameters command = joystick_interface.get_command(state) #cmd_dump(command) _pic = "walk.png" if command.yaw_rate ==0 else "turnaround.png" if command.trot_event == True: _pic = "walk_r1.png" pic_show(disp, _pic, lock) if command.activate_event == 1: is_connect.value = 0 pic_show(disp, "notconnect.png", lock) print("Deactivating Robot") break state.quat_orientation = quat_orientation # movement scheme movement_switch = command.dance_switch_event gait_state = command.trot_event dance_state = command.dance_activate_event shutdown_signal = command.shutdown_signal #shutdown counter if shutdown_signal == True: shutdown_counter = shutdown_counter + 1 # press shut dow button more 3s(0.015*200), shut down system if shutdown_counter >= 200: print('shutdown system now') os.system('systemctl stop robot') os.system('shutdown -h now') # gait and movement control if gait_state == True or dance_state == True: # if triger tort event, reset the movement number to 0 movement_ctl.resetMovementNumber() movement_ctl.runMovementScheme(movement_switch) food_location = movement_ctl.getMovemenLegsLocation() attitude_location = movement_ctl.getMovemenAttitude() robot_speed = movement_ctl.getMovemenSpeed() controller.run(state,command,food_location,attitude_location,robot_speed) # Update the pwm widths going to the servos hardware_interface.set_actuator_postions(state.joint_angles) current_leg[0]= state.joint_angles[0][0] current_leg[1]= state.joint_angles[1][0] #current_leg[2]= state.joint_angles[2][0] try: main() except KeyboardInterrupt: pass

Python

renanmb/Omniverse_legged_robotics/URDF-Descriptions/Mini_pupper/QuadrupedRobot-mini_pupper/StanfordQuadruped/src/MovementScheme.py

from ActuatorControl import ActuatorControl LocationStanding = [[ 0.06,0.06,-0.06,-0.06],[-0.05, 0.05,-0.05,0.05],[ -0.07,-0.07,-0.07,-0.07]] DeltLocationMax = 0.001 AttitudeMinMax = [[-20,20],[-20,20],[-100,100]] class SequenceInterpolation: def __init__(self,name,dimension): self.Name = name self.Dimension = dimension self.InterpolationNumber = 1 self.ExecuteTick = 0 self.SequenceExecuteCounter = 0 self.PhaseNumberMax = 1 self.SequencePoint = [[0,0,0]] # interpolation point data self.PointPhaseStart = 0 self.PointPhaseStop = 1 self.TnterpolationDelt = [0,0,0] self.PointNow = [0,0,0] self.PointPrevious = [0,0,0] def setCycleType(self,cycle_type,cycle_index): if cycle_type == 'Forever': self.SequenceExecuteCounter = 9999 elif cycle_type == 'Multiple': self.SequenceExecuteCounter = cycle_index else: self.SequenceExecuteCounter = 1 return True def setInterpolationNumber(self,interpolation_number): self.InterpolationNumber = interpolation_number return True def setSequencePoint(self,sequence): self.SequencePoint = sequence self.PhaseNumberMax = len(sequence) # init now and pre point phase for xyz in range(self.Dimension): self.PointNow[xyz] = sequence[0][xyz] self.PointPrevious[xyz] = sequence[0][xyz] # init start point phase self.PointPhaseStart = 0 # init stop point phase self.PointPhaseStop = self.PointPhaseStart + 1 if self.PointPhaseStop >= len(sequence): self.PointPhaseStop = self.PointPhaseStart return True def updatePointPhase(self): # update start point phase self.PointPhaseStart = self.PointPhaseStart + 1 if self.PointPhaseStart >= self.PhaseNumberMax: if self.SequenceExecuteCounter >0: self.PointPhaseStart = 0 else: self.SequenceExecuteCounter = 0 self.PointPhaseStart = self.PointPhaseStart - 1 # update stop point phase self.PointPhaseStop = self.PointPhaseStart + 1 if self.PointPhaseStop >= self.PhaseNumberMax: self.SequenceExecuteCounter = self.SequenceExecuteCounter - 1 if self.SequenceExecuteCounter >0: self.PointPhaseStop = 0 else: self.SequenceExecuteCounter = 0 self.PointPhaseStop = self.PointPhaseStop - 1 self.PointPhaseStop = 0 return True def updateInterpolationDelt(self): #get start and stop point point_start = self.SequencePoint[self.PointPhaseStart] point_stop = self.SequencePoint[self.PointPhaseStop] for xyz in range(self.Dimension): diff = point_stop[xyz] - point_start[xyz] self.TnterpolationDelt[xyz] = - diff/self.InterpolationNumber return True def getNewPoint(self): #update movement tick self.ExecuteTick = self.ExecuteTick + 1 if self.ExecuteTick >= self.InterpolationNumber: self.ExecuteTick = 0 self.updatePointPhase() self.updateInterpolationDelt() self.PointNow[0] = self.PointPrevious[0] + self.TnterpolationDelt[0] self.PointNow[1] = self.PointPrevious[1] + self.TnterpolationDelt[1] self.PointNow[2] = self.PointPrevious[2] + self.TnterpolationDelt[2] self.PointPrevious = self.PointNow return self.PointNow class Movements: def __init__(self,name,speed_enable,attitude_enable,legs_enable,actuator_enable): self.MovementName = name self.SpeedEnable = speed_enable self.AttitudeEnable = attitude_enable self.LegsEnable = legs_enable self.ActuatorEnable = actuator_enable self.ExitToStand = True self.SpeedMovements = SequenceInterpolation('speed',2) self.AttitudeMovements = SequenceInterpolation('attitude',3) self.LegsMovements = [] self.LegsMovements.append(SequenceInterpolation('leg1',3)) self.LegsMovements.append(SequenceInterpolation('leg2',3)) self.LegsMovements.append(SequenceInterpolation('leg3',3)) self.LegsMovements.append(SequenceInterpolation('leg4',3)) self.ActuatorsMovements = SequenceInterpolation('actuators',1) # init state value self.SpeedInit = [0,0,0] # x, y speed self.AttitudeInit = [0,0,0] # roll pitch yaw rate self.LegsLocationInit = [[0,0,0,0],[0,0,0,0],[0,0,0,0]] # x,y,z for 4 legs self.ActuatorsAngleInit = [0,0,0] # angle for 3 actuators # output self.SpeedOutput = [0,0,0] # x, y speed self.AttitudeOutput = [0,0,0] # roll pitch yaw rate self.LegsLocationOutput = [[0,0,0,0],[0,0,0,0],[0,0,0,0]] # x,y,z for 4 legs self.ActuatorsAngleOutput = [0,0,0] # angle for 3 actuators def setInterpolationNumber(self,number): self.ActuatorsMovements.setInterpolationNumber(number) for leg in range(4): self.LegsMovements[leg].setInterpolationNumber(number) self.AttitudeMovements.setInterpolationNumber(number) self.SpeedMovements.setInterpolationNumber(number) return True def setExitstate(self,state): if state != 'Stand': self.ExitToStand = False return True def setSpeedSequence(self,sequence,cycle_type,cycle_index): self.SpeedMovements.setSequencePoint(sequence) self.SpeedMovements.setCycleType(cycle_type,cycle_index) self.SpeedInit = sequence[0] def setAttitudeSequence(self,sequence,cycle_type,cycle_index): self.AttitudeMovements.setSequencePoint(sequence) self.AttitudeMovements.setCycleType(cycle_type,cycle_index) self.AttitudeInit = sequence[0] def setLegsSequence(self,sequence,cycle_type,cycle_index): for leg in range(4): self.LegsMovements[leg].setSequencePoint(sequence[leg]) self.LegsMovements[leg].setCycleType(cycle_type,cycle_index) # init location self.LegsLocationInit[0][leg] = sequence[leg][0][0] self.LegsLocationInit[1][leg] = sequence[leg][0][1] self.LegsLocationInit[2][leg] = sequence[leg][0][2] def setActuatorsSequence(self,sequence,cycle_type,cycle_index): self.ActuatorsMovements.setSequencePoint(sequence) self.ActuatorsMovements.setCycleType(cycle_type,cycle_index) self.ActuatorsAngleInit = sequence[0] def runMovementSequence(self): if self.SpeedEnable == 'SpeedEnable': self.SpeedOutput = self.SpeedMovements.getNewPoint() if self.AttitudeEnable == 'AttitudeEnable': self.AttitudeOutput = self.AttitudeMovements.getNewPoint() if self.LegsEnable == 'LegsEnable': for leg in range(4): leg_loaction = self.LegsMovements[leg].getNewPoint() for xyz in range(3): self.LegsLocationOutput[xyz][leg] = leg_loaction[xyz] if self.ActuatorEnable == 'ActuatorEnable': self.ActuatorsAngleOutput = self.ActuatorsMovements.getNewPoint() def getSpeedOutput(self, state = 'Normal'): if state == 'Init': return self.SpeedInit else: return self.SpeedOutput def getAttitudeOutput(self, state = 'Normal'): if state == 'Init': return self.AttitudeInit else: return self.AttitudeOutput def getLegsLocationOutput(self, state = 'Normal'): if state == 'Init': return self.LegsLocationInit else: return self.LegsLocationOutput def getActuatorsAngleOutput(self, state = 'Normal'): if state == 'Init': return self.ActuatorsAngleInit else: return self.ActuatorsAngleOutput def getMovementName(self): return self.MovementName class MovementScheme: def __init__(self,movements_lib): self.movements_lib = movements_lib self.movements_now = movements_lib[0] self.movements_pre = movements_lib[0] self.movement_now_name = movements_lib[0].getMovementName() self.movement_now_number = 0 self.ststus = 'Movement' # 'Entry' 'Movement' 'Exit' self.entry_down = False self.exit_down = False self.tick = 0 self.legs_location_pre = LocationStanding self.legs_location_now = LocationStanding self.attitude_pre = [0,0,0] self.attitude_now = [0,0,0] self.speed_pre = [0,0,0] self.speed_now = [0,0,0] self.actuators_pre = [0,0,0] self.actuators_now = [0,0,0] self.actuator = [] self.actuator.append(ActuatorControl(1)) self.actuator.append(ActuatorControl(2)) self.actuator.append(ActuatorControl(3)) def updateMovementType(self): self.movements_pre = self.movements_lib[self.movement_now_number] self.movement_now_number = self.movement_now_number + 1 if self.movement_now_number>= len(self.movements_lib): self.movement_now_number = 0 self.entry_down = False self.exit_down = False self.movements_now = self.movements_lib[self.movement_now_number] return self.movements_now.getMovementName() def resetMovementNumber(self): self.movements_pre = self.movements_lib[self.movement_now_number] self.movement_now_number = 0 self.entry_down = False self.exit_down = False self.movements_now = self.movements_lib[0] return True def updateMovement(self,movement_type): # movement state transition if movement_type != self.movement_now_name: self.ststus = 'Exit' elif(self.entry_down): self.ststus = 'Movement' elif(self.exit_down): self.ststus = 'Entry' self.movement_now_name = movement_type # update system tick self.tick = self.tick+ 1 # movement execute if self.ststus == 'Entry': location_ready = self.movements_now.getLegsLocationOutput('Init') self.legs_location_now,self.entry_down = self.updateMovementGradient(self.legs_location_pre,location_ready) self.legs_location_pre = self.legs_location_now if self.ststus == 'Exit': if self.movements_pre.ExitToStand == False: self.legs_location_now,self.exit_down = self.updateMovementGradient(self.location_pre,LocationStanding) self.legs_location_pre = self.legs_location_now else: self.legs_location_now = self.legs_location_pre self.exit_down = True elif self.ststus == 'Movement': self.updateMovemenScheme(self.tick) self.legs_location_pre = self.legs_location_now self.attitude_pre = self.attitude_now return self.legs_location_now def updateMovementGradient(self,location_now,location_target): loaction_gradient = location_now gradient_done = False gradient_done_counter = 0 #legs gradient for xyz_index in range(3): for leg_index in range(4): diff = location_now[xyz_index][leg_index] - location_target[xyz_index][leg_index] if diff > DeltLocationMax: loaction_gradient[xyz_index][leg_index] = location_now[xyz_index][leg_index] - DeltLocationMax elif diff < -DeltLocationMax: loaction_gradient[xyz_index][leg_index] = location_now[xyz_index][leg_index] + DeltLocationMax else : loaction_gradient[xyz_index][leg_index] = location_target[xyz_index][leg_index] gradient_done_counter = gradient_done_counter + 1 # movement gradient is down if gradient_done_counter == 12: gradient_done = True return loaction_gradient, gradient_done def updateMovemenScheme(self,tick): # run movement self.movements_now.runMovementSequence() # legs movement self.legs_location_now = self.movements_now.getLegsLocationOutput('normal') # speed movement self.speed_now = self.movements_now.getSpeedOutput('normal') # attitude movement self.attitude_now = self.movements_now.getAttitudeOutput('normal') # attitude movement self.actuators_now = self.movements_now.getActuatorsAngleOutput('normal') # attitude process ''' for rpy in range(3): #limite attitude angle if attitude_now[rpy] < AttitudeMinMax[rpy][0]: attitude_now[rpy] = AttitudeMinMax[rpy][0] elif attitude_now[rpy] > AttitudeMinMax[rpy][1]: attitude_now[rpy] = AttitudeMinMax[rpy][1] ''' # speed process return True def runMovementScheme(self,transition): # update movement movement_name = '' if transition == True: movement_name = self.updateMovementType() self.updateMovement(movement_name) return True def getMovemenSpeed(self): speed_now = [0,0,0] for xyz in range(3): speed_now[xyz] = -self.speed_now[xyz] return speed_now def getMovemenLegsLocation(self): return self.legs_location_now def getMovemenAttitude(self): attitude_now_rad = [0,0,0] for rpy in range(3): #angle to radin attitude_now_rad[rpy] = -self.attitude_now[rpy] / 57.3 return attitude_now_rad def getMovemenActuators(self): return self.actuators_now

Python

renanmb/Omniverse_legged_robotics/URDF-Descriptions/Mini_pupper/QuadrupedRobot-mini_pupper/StanfordQuadruped/src/ActuatorControl.py

import os import sys import time class ActuatorControl: def __init__(self,pwm_number): self.pwm_number = pwm_number def updateDutyCycle(self,angle): duty_cycle = int((1.11*angle+50)*10000) return duty_cycle def updateActuatorAngle(self,angle): if self.pwm_number == 1: actuator_name = 'pwm1' elif self.pwm_number == 2: actuator_name = 'pwm2' elif self.pwm_number == 3: actuator_name = 'pwm3' duty_cycle = self.updateDutyCycle(angle) file_node = '/sys/class/pwm/pwmchip0/' + actuator_name+ '/duty_cycle' f = open(file_node, "w") f.write(str(duty_cycle)) #test = ActuatorControl(3) #time.sleep(10) #for index in range(30): # test.updateActuatorAngle(index*3) # time.sleep(0.1) # test.updateActuatorAngle(0)

Python

renanmb/Omniverse_legged_robotics/URDF-Descriptions/Mini_pupper/QuadrupedRobot-mini_pupper/StanfordQuadruped/pupper/ServoCalibration.py

# WARNING: This file is machine generated. Edit at your own risk. import numpy as np MICROS_PER_RAD = 11.111 * 180.0 / np.pi

Python

renanmb/Omniverse_legged_robotics/URDF-Descriptions/Mini_pupper/QuadrupedRobot-mini_pupper/StanfordQuadruped/pupper/MovementGroup.py

from src.MovementScheme import Movements def appendDanceMovement(): ''' #demo 1 dance_scheme = Movements('stand','SpeedDisable','AttitudeDisable','LegsEnable','ActuatorDisable') dance_scheme.setExitstate('Stand') dance_all_legs = [] dance_all_legs.append([[ 0.06,-0.05,-0.065]]) # leg1 dance_all_legs.append([[ 0.06, 0.05,-0.065]]) # leg2 dance_all_legs.append([[-0.06,-0.05,-0.065]]) # leg3 dance_all_legs.append([[-0.06, 0.05,-0.065]]) # leg4 dance_scheme.setInterpolationNumber(50) dance_scheme.setLegsSequence(dance_all_legs,'Forever',5) MovementLib.append(dance_scheme) # append dance ''' #demo 2 dance_scheme = Movements('push-up','SpeedEnable','AttitudeDisable','LegsEnable','ActuatorDisable') dance_scheme.setExitstate('Stand') dance_all_legs = [] dance_all_legs.append([[ 0.06,-0.05,-0.04],[ 0.06,-0.05,-0.07],[ 0.06,-0.05,-0.04],[ 0.06,-0.05,-0.04],[ 0.06,-0.05,-0.04]]) # leg1 dance_all_legs.append([[ 0.06, 0.05,-0.04],[ 0.06, 0.05,-0.07],[ 0.06, 0.05,-0.04],[ 0.06, 0.05,-0.04],[ 0.06, 0.05,-0.04]]) # leg2 dance_all_legs.append([[-0.06,-0.05,-0.04],[-0.06,-0.05,-0.07],[-0.06,-0.05,-0.04],[-0.06,-0.05,-0.04],[-0.06,-0.05,-0.04]]) # leg3 dance_all_legs.append([[-0.06, 0.05,-0.04],[-0.06, 0.05,-0.07],[-0.06, 0.05,-0.04],[-0.06, 0.05,-0.04],[-0.06, 0.05,-0.04]]) # leg4 dance_speed = [[0,0,0],[0,0,0],[0,0,0],[0.25,0,0,0],[0.25,0,0,0]] # speed_, speed_y, no_use dance_attitude = [[0,0,0],[10,0,0],[0,0,0]] # roll, pitch, yaw rate dance_scheme.setInterpolationNumber(70) dance_scheme.setLegsSequence(dance_all_legs,'Forever',1) dance_scheme.setSpeedSequence(dance_speed,'Forever',1) dance_scheme.setAttitudeSequence(dance_attitude,'Forever',1) MovementLib.append(dance_scheme) # append dance MovementLib = [] appendDanceMovement()

Python

renanmb/Omniverse_legged_robotics/URDF-Descriptions/Mini_pupper/QuadrupedRobot-mini_pupper/StanfordQuadruped/pupper/HardwareInterface.py

import os import sys sys.path.append("/home/ubuntu/Robotics/QuadrupedRobot/") sys.path.extend([os.path.join(root, name) for root, dirs, _ in os.walk("/home/ubuntu/Robotics/QuadrupedRobot") for name in dirs]) from Mangdang import PWMController from pupper.Config import ServoParams, PWMParams #from __future__ import division import numpy as np class HardwareInterface: def __init__(self): self.pwm_params = PWMParams() self.servo_params = ServoParams() def set_actuator_postions(self, joint_angles): send_servo_commands(self.pwm_params, self.servo_params, joint_angles) def set_actuator_position(self, joint_angle, axis, leg): send_servo_command(self.pwm_params, self.servo_params, joint_angle, axis, leg) def pwm_to_duty_cycle(pulsewidth_micros, pwm_params): """Converts a pwm signal (measured in microseconds) to a corresponding duty cycle on the gpio pwm pin Parameters ---------- pulsewidth_micros : float Width of the pwm signal in microseconds pwm_params : PWMParams PWMParams object Returns ------- float PWM duty cycle corresponding to the pulse width """ pulsewidth_micros = int(pulsewidth_micros / 1e6 * pwm_params.freq * pwm_params.range) if np.isnan(pulsewidth_micros): return 0 return int(np.clip(pulsewidth_micros, 0, 4096)) def angle_to_pwm(angle, servo_params, axis_index, leg_index): """Converts a desired servo angle into the corresponding PWM command Parameters ---------- angle : float Desired servo angle, relative to the vertical (z) axis servo_params : ServoParams ServoParams object axis_index : int Specifies which joint of leg to control. 0 is abduction servo, 1 is inner hip servo, 2 is outer hip servo. leg_index : int Specifies which leg to control. 0 is front-right, 1 is front-left, 2 is back-right, 3 is back-left. Returns ------- float PWM width in microseconds """ angle_deviation = ( angle - servo_params.neutral_angles[axis_index, leg_index] ) * servo_params.servo_multipliers[axis_index, leg_index] pulse_width_micros = ( servo_params.neutral_position_pwm + servo_params.micros_per_rad * angle_deviation ) return pulse_width_micros def angle_to_duty_cycle(angle, pwm_params, servo_params, axis_index, leg_index): duty_cycle_f = angle_to_pwm(angle, servo_params, axis_index, leg_index) * 1e3 if np.isnan(duty_cycle_f): return 0 return int(duty_cycle_f) def initialize_pwm(pi, pwm_params): pi.set_pwm_freq(pwm_params.freq) def send_servo_commands(pwm_params, servo_params, joint_angles): for leg_index in range(4): for axis_index in range(3): duty_cycle = angle_to_duty_cycle( joint_angles[axis_index, leg_index], pwm_params, servo_params, axis_index, leg_index, ) # write duty_cycle to pwm linux kernel node file_node = "/sys/class/pwm/pwmchip0/pwm" + str(pwm_params.pins[axis_index, leg_index]) + "/duty_cycle" f = open(file_node, "w") f.write(str(duty_cycle)) def send_servo_command(pwm_params, servo_params, joint_angle, axis, leg): duty_cycle = angle_to_duty_cycle(joint_angle, pwm_params, servo_params, axis, leg) file_node = "/sys/class/pwm/pwmchip0/pwm" + str(pwm_params.pins[axis, leg]) + "/duty_cycle" f = open(file_node, "w") f.write(str(duty_cycle)) def deactivate_servos(pi, pwm_params): for leg_index in range(4): for axis_index in range(3): pi.set_pwm(pwm_params.pins[axis_index, leg_index], 0, 0)

Python