Não se deixe enganar pelo nome da ferramenta. O MSRS (Microsoft® Robotics Studio) é muito mais do que uma forma de brincar com robôs. Lançado há praticamente dois anos pelo Microsoft Research e virtualmente ignorado por desenvolvedores de aplicativos comerciais do dia-a-dia, o MSRS permite criar aplicativos baseados em serviços destinados a uma ampla gama de dispositivos de hardware. O kit de ferramentas inclui um runtime que deve ser instantaneamente reconhecido por desenvolvedores do WCF (Windows® Communication Framework). Além disso, ele conta com uma ferramenta VPL (Visual Programming Language) e um VSE (Visual Simulation Environment).
O MSRS oferece um runtime orientado a serviços, além das ferramentas necessárias à criação e à implantação de aplicativos baseados na robótica. Ele inclui ferramentas de criação visuais, tutoriais e documentação projetadas para iniciar desenvolvedores novatos no mundo da robótica. Desenvolvedores comerciais devem comprar o kit de ferramentas por uma pequena tarifa, mas entusiastas e pesquisadores acadêmicos podem baixar e usá-lo gratuitamente.
O runtime do MSRS é composto de dois runtimes de nível inferior que permanecem acima do CLR 2.0. Esses dois runtimes são DSS (Decentralized Software Services) e CCR (Coordination and Concurrency Runtime). O DSS é um runtime leve, orientado a serviços, baseado nos princípios REST (Representation State Transfer), usados na capacitação da Web. O CCR é uma biblioteca do Microsoft .NET Framework que oferece suporte ao processamento assíncrono. Isso é extremamente importante em aplicações da robótica, uma vez que os dados são constantemente enviados e recebidos em vários sensores e atuadores.
Além do runtime, o kit de ferramentas do MSRS inclui uma ferramenta VPL que permite criar aplicações da robótica simplesmente arrastando e soltando elementos em uma superfície de design. O MSRS também inclui um VSE que permite fazer testes com simulações complexas que envolvem vários robôs e obstáculos. Trata-se da parte do MSRS que abordarei neste artigo. Analisarei o ambiente de simulação visual e percorrerei as etapas da criação de uma simulação usando uma nova entidade robótica. A boa notícia é que você não precisa de um robô para trabalhar com o código deste artigo. É isso o que torna as simulações tão atraentes: elas dão uma oportunidade de aprendizado sem que haja investimento em hardware caro.
O que é uma simulação?
Caso você não esteja familiarizado com simulações, imagine um flip book – um pequeno livro com uma imagem em cada página que se "move" quando você o folheia rapidamente. As simulações funcionam de maneira semelhante. Uma simulação contém uma ou mais entidades, e cada uma delas é renderizada dentro de um quadro. O quadro equivale a uma página do flip book. A taxa na qual os quadros são renderizados depende da placa gráfica da máquina host.
A diferença fundamental entre o flip book e uma simulação é que o primeiro é estático ou previsível e a segunda, não. Cada quadro de uma simulação é renderizado dinamicamente, e as forças encontradas por uma entidade em cada um deles nem sempre são conhecidas previamente. É isso o que torna as simulações tão úteis. É possível criar um cenário com um robô e ver como este interagiria com o mundo.
Introdução
Caso você ainda não tenha feito isso, agora seria um momento apropriado para baixar e instalar o kit de ferramentas do MSRS (disponível em go.microsoft.com/fwlink/?LinkId=113902). O site do MSRS atualmente oferece uma instalação atualizada da versão 1.5. Ele inclui a versão completa do MSRS 1.5, além de todas as atualizações disponíveis.
O MSRS fornece modelos para o Visual Studio® 2005, mas mesmo que a máquina esteja executando o Visual Studio 2008, ainda assim é possível executar os exemplos incluídos neste artigo. A máquina de desenvolvimento precisará de uma placa gráfica compatível com DirectX® 9.0. Mais especificamente, a placa deve oferecer suporte a sombreador de vértices VS_2_0 ou superior e a sombreador de pixels PS_2_0 ou superior. A maioria dos desktops e dos laptops de alta definição capazes de executar jogos gráficos atuais já contará com isso.
Caso você não tenha certeza quanto ao que a placa gráfica oferece suporte, é possível ir até go.microsoft.com/fwlink/?LinkId=113904 e obter uma lista de placas gráficas, além dos sombreadores para os quais elas oferecem suporte. Além disso, é possível instalar o MSRS e usar o menu de ajuda no VSE para exibir os sombreadores de pixel e vértice suportados. Caso tente executar um dos simuladores incluídos no MSRS ou neste artigo e a tela fique em branco, é sinal de que a placa gráfica não é compatível.
O MSRS usa o mecanismo AGEIA PhysX para fornecer a física ao ambiente de simulação. Sem ela, a simulação seria inútil, porque não representaria de maneira alguma o mundo que estivesse tentando simular. Por exemplo, as entidades poderiam flutuar sem gravidade. Se ler a documentação que acompanha o MSRS, você verá que ela menciona o uso de uma placa aceleradora fornecida pela AGEIA (consulte ageia.com). Não é necessário que você compre e instale essa placa física para trabalhar com as simulações deste artigo. A física continuará disponível para simulação por meio do mecanismo de software AGEIA PhysX.
Executando uma simulação
A essa altura, você já deve estar ansioso para ver uma simulação. Para criar a sua própria simulação, você deve tentar executar uma das simulações fornecidas com o MSRS. Uma vez instalado, o MSRS cria uma pasta de menus que contém sete simulações. A primeira simulação desta pasta, ambiente de simulação básica, renderizará uma cena semelhante à da Figura 1.
Figura 1 Ambiente de simulação básica (Clique na imagem para uma visão ampliada)
Você pode achar que a simulação básica inclui apenas duas entidades: um globo terrestre e uma caixa. Na verdade, a cena da simulação também inclui entidades que representam a câmera principal, o chão, o céu e o sol. É possível ver quais entidades estão incluídas clicando-se em Mode e Edit no menu do VSE.
O modo de edição, mostrado na Figura 2, inclui um painel à esquerda em que é possível modificar as propriedades associadas a cada entidade. Essas propriedades controlam tudo, desde o nome da entidade até sua posição no ambiente de simulação. Além disso, elas também permitem controlar com precisão como a entidade é renderizada, o que afeta sua aparência na simulação.
Figura 2 Modo de edição para modificar as propriedades da entidade (Clique na imagem para uma visão ampliada)
Caso retorne ao modo de execução, você pode se mover em meio à simulação usando o mouse ou as teclas de direção. Isso altera o ponto de vista da câmera principal, que é a exibição da simulação. Outro ponto importante a ser mencionado é que o VSE permite a renderização da cena em modos diferentes. O modo virtual é o padrão, além de ser uma exibição realista da cena de simulação. No entanto, o item de menu Render permite optar pelos modos de arame, física, combinado ou sem renderização.
A opção No Rendering está incluída porque a renderização é apenas um aspecto de uma simulação. O que é mais importante a respeito da execução de uma simulação é a interação com várias entidades. Como renderizar entidades dentro de uma cena de simulação é caro em termos de recursos, a opção No Rendering pode ser útil quando existe um grande número de entidades envolvidas.
Entidades e tipos de entidade
Um tipo de entidade permite definir uma nova instância de um determinado tipo de entidade. Por exemplo, o globo terrestre incluído no ambiente de simulação básica é um tipo de entidade de forma única. O tipo de entidade funciona como um modelo para a nova entidade ao especificar propriedades associadas a um tipo específico de entidade. Os valores dessas propriedades podem ser alterados assim que a entidade é criada, mas o tipo de entidade define as propriedades incluídas.
O VSE exige um tipo de entidade para adicionar uma entidade a uma simulação. Por exemplo, para adicionar um robô como, por exemplo, Create by iRobot, você adicionaria uma nova entidade no VSE clicando em Entity e em New, ainda no modo de edição. Isso abrirá a caixa de diálogo New Entity (consulte a Figura 3).
Figura 3 Inserir nova entidade na caixa de diálogo New Entity
Create by iRobot é um dos robôs para os quais o MSRS fornece um tipo de entidade. Isso significa que é possível adicionar um novo robô Create à simulação apenas usando a caixa de diálogo New Entity. Na caixa de diálogo New Entity, você selecionaria iRobotCreate como Type e digitaria um nome exclusivo como, por exemplo, "Create Entity". Assim que você pressionasse OK, o robô Create seria exibido na cena de simulação.
Adicionando programaticamente uma nova entidade
O MSRS oferece mais de uma forma para criar e trabalhar com simulações. Além do VSE, é possível adicionar entidades programaticamente a uma simulação criando um projeto de serviço DSS. O MSRS fornece um modelo do Visual Studio que pode ser usado para criar um novo serviço DSS. Assim que o MSRS estiver instalado, basta selecionar Simple Dss Service (1.5) como modelo durante a criação de um novo projeto do Visual Studio (consulte a Figura 4).
Figura 4 Criar novo serviço DSS no modelo do Visual Studio 2005 (Clique na imagem para uma visão ampliada)
Criar um novo serviço DSS usando o modelo resultará na criação de dois arquivos de classe. A classe de implementação que, por padrão, apresenta o mesmo nome do projeto, é onde o código será adicionado para criar uma nova entidade. As simulações criadas programaticamente exigirão acesso a assemblies não incluídos no modelo Simple DSS Service. Por isso, você precisará adicionar referências aos assemblies listados na Figura 5.
Figura 5 Assemblies incluídos no projeto de simulação
Nome do assembly Descrição
PhysicsEngine Fornece acesso ao mecanismo de física do software AGEIA subjacente.
RoboticsCommon Fornece acesso ao namespace PhysicalModel, usado para definir as características físicas dos robôs.
SimulationCommon Fornece acesso a definições de tipo usadas durante o trabalho com os mecanismos de simulação e de física.
SimulationEngine Fornece acesso ao mecanismo de simulação.
SimulationEngine.proxy Representa um proxy para o mecanismo de simulação, usado durante o carregamento do mecanismo de simulação como parceiro.
Depois de adicionar as referências, você precisará adicionar as seguintes declarações de namespace ao arquivo da classe de implementação:
using Microsoft.Robotics.Simulation;
using Microsoft.Robotics.Simulation.Engine;
using engineproxy = Microsoft.Robotics.Simulation.Engine.Proxy;
using Microsoft.Robotics.Simulation.Physics;
using Microsoft.Robotics.PhysicalModel;
Para compreender o código necessário à simulação, você deve primeiro examinar os tutoriais de simulação fornecidos com o MSRS. Os exemplos fornecidos no diretório de tutoriais \samples\simulation da instalação do MSRS correspondem às simulações disponíveis no menu instalado do MSRS. Por exemplo, o ambiente de simulação básica é o mesmo do projeto SimulationTutorial1.
Caso você abra o projeto SimulationTutorial1 usando o Visual Studio 2005, é possível exibir o código usado para criar o ambiente de simulação básica. A primeira coisa a ser observada é o método Start, chamado automaticamente quando um serviço é iniciado:
protected override void Start()
{
base.Start();
// Orient sim camera view point
SetupCamera();
// Add objects (entities) in our simulated world
PopulateWorld();
}
O método Start é onde você adiciona código para definir o ambiente de simulação. No projeto SimulationTutorial1, isso envolve configurar a câmera e complementar a cena de simulação com objetos de entidade.
Além da câmera principal, o ambiente de simulação básica contém entidades usadas para representar o céu, o chão, a caixa e o globo terrestre. O código para inserir todo o globo terrestre, ou esfera texturizada, está listado na Figura 6.
Figura 6 Inserir o globo terrestre
void AddTexturedSphere(Vector3 position)
{
SingleShapeEntity entity = new SingleShapeEntity(
new SphereShape(
new SphereShapeProperties(10, // mass in kg
new Pose(), // pose of shape within entity
1)), //default radius
position);
entity.State.Assets.Mesh = "earth.obj";
entity.SphereShape.SphereState.Material =
new MaterialProperties("sphereMaterial", 0.5f, 0.4f, 0.5f);
// Name the entity
entity.State.Name = "detailed sphere";
// Insert entity in simulation.
SimulationEngine.GlobalInstancePort.Insert(entity);
}
A primeira linha do código no método AddTexturedSphere cria uma instância de SingleShapeEntity. Esse tipo representa uma entidade com uma forma geométrica única como, por exemplo, uma esfera, sendo útil quando você precisa adicionar uma entidade cuja geometria física é bem simples. Nesse caso, estou criando uma entidade cuja massa é de 10 quilogramas, ou aproximadamente quatro libras e meia.
A malha atribuída a essa entidade é um arquivo de objeto, que apresenta uma extensão de arquivo .obj. O arquivo de objeto é criado com uma ferramenta de edição gráfica 3D e exportado para um formato de objeto alias. O MSRS exige que o arquivo de objeto da malha esteja nesse formato. A última coisa que você faz no método AddTexturedSphere é inserir a entidade de esfera no ambiente de simulação.
Definindo uma nova entidade no VSE
Agora criemos uma nova entidade de robô para representar o Boe-Bot da Parallax. O Boe-Bot é um pequeno robô equipado com rodas que oferece suporte a um sistema de comando diferencial com duas rodas (para ver uma foto, consulte a Figura 7). Para obter mais informações sobre o Boe-Bot, visite o site da Parallax em parallax.com.
Figura 7 Boe-Bot da Parallax (Clique na imagem para uma visão ampliada)
Boe-Bot é uma das muitas plataformas de robô para as quais o MSRS prontamente oferece suporte. Isso significa que a instalação do MSRS inclui os serviços básicos usados para operar o sistema de acionamento do Boe-Bot e os sensores de contato internos. Embora o inclua os serviços de plataforma do Boe-Bot, o MSRS não inclui, de fato, um tipo de entidade do Boe-Bot.
Criando uma classe de entidade
Para criar um novo tipo de entidade para o Boe-Bot, preciso adicionar uma classe que deriva de DifferentialDriveEntity. Derivando da classe DifferentialDriveEntity, posso reutilizar o código que define como o Boe-Bot deve se comportar quando estiver se movendo em meio a uma simulação. O código usado para criar o tipo de entidade BoeBot é mostrado na Figura 8.
Figura 8 Tipo de entidade Create BoeBot
[DataContract]
public class BoeBot : DifferentialDriveEntity
{
Port _notifications =
new Port();
// Default constructor, used for creating the entity from XML
public BoeBot() { }
// Custom constructor for building model from hardcoded values.
// Used to create entity programmatically
public BoeBot(Vector3 initialPos)
{
MASS = 0.454f; //in kilograms (around 1 pound)
// the default settings approximate the BoeBot chassis
CHASSIS_DIMENSIONS = new Vector3(0.09f, //meters wide
0.09f, //meters high
0.13f); //meters long
FRONT_WHEEL_MASS = 0.01f;
CHASSIS_CLEARANCE = 0.015f;
FRONT_WHEEL_RADIUS = 0.025f;
CASTER_WHEEL_RADIUS = 0.0125f;
FRONT_WHEEL_WIDTH = 0.01f;
CASTER_WHEEL_WIDTH = 0.008f;
FRONT_AXLE_DEPTH_OFFSET = 0.01f; // distance from center of robot
base.State.Name = "BoeBot";
base.State.MassDensity.Mass = MASS;
base.State.Pose.Position = initialPos;
// chassis position
BoxShapeProperties motorBaseDesc =
new BoxShapeProperties("BoeBot Body", MASS,
new Pose(new Vector3(
0, // Use 0 for X axis offset
CHASSIS_CLEARANCE + CHASSIS_DIMENSIONS.Y / 2,
0.03f)), // minor offset in the z/depth axis
CHASSIS_DIMENSIONS);
motorBaseDesc.Material =
new MaterialProperties("high friction", 0.0f, 1.0f, 20.0f);
motorBaseDesc.Name = "Chassis";
ChassisShape = new BoxShape(motorBaseDesc);
// rear wheel is also called the castor
CASTER_WHEEL_POSITION = new Vector3(0, // center of chassis
CASTER_WHEEL_RADIUS, // distance from ground
CHASSIS_DIMENSIONS.Z / 2); // at the rear of the robot
RIGHT_FRONT_WHEEL_POSITION = new Vector3(
+CHASSIS_DIMENSIONS.X / 2,// left of center
FRONT_WHEEL_RADIUS, // distance from ground of axle
FRONT_AXLE_DEPTH_OFFSET); // distance from center, on z-axis
LEFT_FRONT_WHEEL_POSITION = new Vector3(
-CHASSIS_DIMENSIONS.X / 2,// right of center
FRONT_WHEEL_RADIUS, // distance from ground of axle
FRONT_AXLE_DEPTH_OFFSET); // distance from center, on z-axis
MotorTorqueScaling = 30;
// specify a default mesh
State.Assets.Mesh = "boe-bot.bos";
}
O construtor da classe BoeBot é usado para definir os valores de muitas variáveis definidas na classe DifferentialDriveEntity. Por exemplo, Mass está definido com um valor igual a 0,454, o que representa a massa em quilogramas. Além disso, o chassi do Boe-Bot está definido em termos de largura, comprimento e altura. Essas medidas foram obtidas pesando o robô real e medindo-o com uma fita métrica.
A posição do Boe-Bot é definida por meio de um conjunto de coordenadas passadas quando a entidade é criada. Essas coordenadas representam os pontos de eixo X, Y e Z. O mecanismo de simulação do MSRS usa um sistema de coordenadas à direita, o que afeta o sentido no qual o eixo Z aponta.
O construtor BoeBot também define a posição do chassi e das rodas dentro da entidade. A classe DifferentialDriveSystem supõe que o robô terá duas rodas principais e uma pequena roda traseira usada principalmente para fins de equilíbrio. Será atribuída potência aos motores à esquerda e à direita, que controlam as rodas principais. A diferença entre os níveis de potência atribuídos a cada roda determina se ela se move para frente, para trás, para esquerda ou para direita. Trata-se do mesmo método usado para comandar o robô físico.
O que torna a simulação tão atraente é o fato de que, em teoria, não importa se o robô é virtual ou físico. O código usado para ligar o robô e receber dados dos sensores será o mesmo. Alguns códigos usados no projeto de simulação podem ser reutilizados em meio ao trabalho com o robô real. Agora, você talvez tenha percebido que disse "em teoria". Isso porque a simulação não pode simular um ambiente do mundo real por completo. A simulação não pode levar em conta o barulho – algo inesperado como, por exemplo, obstáculos colocados no lugar errado.
O que a simulação pode fazer é dar uma oportunidade realista de testar um novo design de robô ou simular a interação de vários robôs. Isso pode ser muito útil em ambientes acadêmicos nos quais os recursos são limitados e o número de alunos é alto.
Criando uma malha
Cada entidade pode ser associada a uma malha, que é o que faz a entidade parecer real. Por exemplo, no caso do globo, a malha é o que faz com que a entidade do globo seja exibida como o planeta Terra. Especificamente, não é necessário associar uma entidade a uma malha, mas no caso das entidades complexas como robôs um objeto de malha é preferencial.
Praticamente qualquer ferramenta de edição gráfica 3D pode ser usada na criação da malha. Neste artigo, tive a sorte de contar com um colega, Steve Grand, que criou uma malha do Boe-Bot para mim usando um pacote 3D chamado SoftImage (consulte softimage.com para obter mais informações sobre essa ferramenta). Os arquivos associados a essa malha estão incluídos no arquivo .zip para download que acompanha este artigo. Para acompanhar o artigo, baixe o arquivo .zip, extraia os arquivos e copie o conteúdo da pasta Boe-Bot para o diretório /store/media associado à instalação do MSRS local.
O SoftImage é capaz de exportar a imagem para o formato .obj. Nem todos os pacotes são capazes de fazer isso. Por exemplo, o SolidWorks (consulte solidworks.com) é um pacote 3D recomendado pelo MSRS no wiki do Channel9 (go.microsoft.com/fwlink/?LinkId=114031). Infelizmente, como o SolidWorks não é capaz de exportar para o formato .obj, ele recomenda uma ferramenta chamada Blender (blender.org) para que seja feita a conversão propriamente dita. Tenha isso em mente ao selecionar um pacote gráfico para criar o arquivo de malha.
Os detalhes envolvidos na criação da malha do Boe-Bot estão além do escopo deste artigo, mas você deve saber que ela foi criada unindo-se várias formas de malha em poligonais. Por exemplo, o chassi de metal começou como uma forma de cubo, modificada para representar o tamanho e a forma do Boe-Bot. Em seguida, as formas cilíndricas adicionais foram acrescentadas para representar as rodas. Uma hierarquia foi estabelecida para associar as rodas ao chassi e permitir que todo o objeto funcionasse como uma forma única. O resultado (como visto na Figura 9) é uma imagem que representa o Boe-Bot físico.
Figura 9 Usando SoftImage para criar o arquivo de malha do Boe-Bot (Clique na imagem para uma visão ampliada)
Converter a malha em formato binário
O MSRS oferece uma ferramenta de linha de comando capaz de converter um arquivo .obj em um arquivo binário otimizado com uma extensão de arquivo .bos. O benefício desse tipo de arquivo é ser carregado mais rapidamente do que o arquivo .obj. A ferramenta de linha de comando, chamada Obj2bos.exe, pode ser acessada usando o item de menu do prompt de comando incluído na instalação do MSRS.
Durante o trabalho com uma malha, é importante se lembrar de que os materiais são usados para colorir objetos físicos e de que cada entidade pode ser associada a um ou mais materiais. Por isso, quando você criar o arquivo .obj, é provável que ele inclua arquivos de material adicionais com extensões .mtl. Ele também pode incluir arquivos de imagem usados para criar texturas. Para usar a ferramenta de conversão da malha, esses arquivos devem ser copiados para o mesmo local do arquivo .obj.
O arquivo .obj e todos os arquivos associados devem ser colocados no diretório /store/media associado à instalação do MSRS local. Os arquivos associados à malha do Boe-Bot, incluídos no download do código, são: Aluminum.png, Boe-bot.mtl, Boe-bot.obj, BoebotWheel.png e Pcb.png. Uma vez colocado no diretório de mídia, abra o prompt de comando do MSRS e digite o seguinte:
Obj2bos.exe /i:"store\media\Boe-bot.obj"
A ferramenta de conversão criará um arquivo chamado Boe-bot.bos, que permanecerá no diretório de mídia. Deixe o arquivo lá, porque ele será referenciado mais tarde.
Criando um serviço de simulação
Agora estou pronto para criar o serviço de simulação do Boe-Bot. Caso você esteja acompanhando com o download do código complementar a este artigo, verifique se já instalou o MSRS e colocou o código baixado na pasta \samples da instalação do MSRS local.
Se estiver criando o projeto desde o começo, você precisará criar um novo serviço DSS usando o modelo do Visual Studio 2005. É possível nomear o projeto SimulatedBoeBot. Além das referências a assembly mencionadas anteriormente, você precisará adicionar uma referência a Microsoft.Xna.Framework e adicionar as seguintes referências a namespace na parte superior do arquivo de classe SimulatedBoeBot.cs:
using xna = Microsoft.Xna.Framework;
using xnagrfx = Microsoft.Xna.Framework.Graphics;
using xnaprof = Microsoft.Robotics.Simulation.MeshLoader;
A estrutura Xna é usada pelo MSRS para renderizar as entidades. As referências a Xna serão usadas no código que define o tipo de entidade Boe-Bot. Todos os tipos de entidade incluídos no MSRS estão no namespace Microsoft.Robotics.Simulation.Engine.
Complementando a cena da simulação
Uma das tarefas principais de qualquer serviço de simulação é inserir entidades na cena da simulação. Como isso deve ser feito durante a inicialização do serviço, normalmente uma chamada para um método chamado PopulateWorld é adicionada ao método Start. Na simulação do Boe-Bot, o método PopulateWorld será semelhante a:
private void PopulateWorld()
{
AddSky();
AddGround();
AddBoeBot(new Vector3(1, 0, 1));
AddBox(new Vector3(2, 1, 1));
}
Os métodos AddSky e AddGround são usados para configurar o ambiente em que BoeBot residirá. Em relação ao método AddSky, um tipo SkyDomeEntity é criado e inserido na simulação. Uma luz direcional, que deve representar o sol, também é inserida na simulação (o código desse método é mostrado na Figura 10).
Figura 10 Adicionar o céu
void AddSky() {
// Add a sky using a static texture. We will use the sky texture
// to do per pixel lighting on each simulation visual entity
SkyDomeEntity sky = new SkyDomeEntity("skydome.dds",
"sky_diff.dds");
SimulationEngine.GlobalInstancePort.Insert(sky);
// Add a directional light to simulate the sun.
LightSourceEntity sun = new LightSourceEntity();
sun.State.Name = "Sun";
sun.Type = LightSourceEntityType.Directional;
sun.Color = new Vector4(0.8f, 0.8f, 0.8f, 1);
sun.Direction = new Vector3(0.5f, -.75f, 0.5f);
SimulationEngine.GlobalInstancePort.Insert(sun);
}
O método AddGround usa o tipo HeightFieldEntity para criar um grande plano horizontal cuja elevação é zero. Uma imagem de textura, fornecida com a instalação do MSRS, é usada para representar o chão. O código desse método é visto da seguinte forma:
void AddGround()
{
// create a large horizontal plane, at zero elevation.
HeightFieldEntity ground = new HeightFieldEntity(
"simple ground", // name
"03RamieSc.dds", // texture image
new MaterialProperties("ground",
0.2f, // restitution
0.5f, // dynamic friction
0.5f) // static friction
);
SimulationEngine.GlobalInstancePort.Insert(ground);
}
A próxima coisa a ser adicionada é a entidade Boe-Bot. O método AddBoeBot aceita um parâmetro de entrada Vector3, usado para representar a posição do robô. A posição será passada para o construtor de entidade do BoeBot, criada anteriormente. O método AddBoeBot também iniciará o serviço de controle do Boe-Bot simulado como uma entidade parceira. O código desse método é mostrado aqui:
void AddBoeBot(Vector3 pos)
{
BoeBot boeBot = new BoeBot(pos);
boeBot.State.Name = "SimulatedBoeBot";
// Start simulated Boe-Bot Drive service
CreateService(
drive.Contract.Identifier,
Microsoft.Robotics.Simulation.Partners.CreateEntityPartner(
"http://localhost/" + boeBot.State.Name));
SimulationEngine.GlobalInstancePort.Insert(boeBot);
}
A última entidade a ser adicionada é uma caixa sólida para representar um obstáculo. O método AddBox criará uma entidade em forma de caixa usando o tipo SingleShapeEntity. Consulte a Figura 11 para observar o código desse método.
Figura 11 Criar uma entidade em forma de caixa
void AddBox(Vector3 position)
{
Vector3 dimensions =
new Vector3(0.2f, 0.2f, 0.2f); // meters
// create simple movable entity, with a single shape
SingleShapeEntity box = new SingleShapeEntity(
new BoxShape(
new BoxShapeProperties(
100, // mass in kilograms.
new Pose(), // relative pose
dimensions)), // dimensions
position);
box.State.MassDensity.Mass = 0;
box.State.MassDensity.Density = 0;
// Name the entity. All entities must have unique names
box.State.Name = "box";
// Insert entity in simulation.
SimulationEngine.GlobalInstancePort.Insert(box);
}
Criando um manifesto
A maioria dos serviços estabelecerá parcerias com os demais para acessar os dados e a funcionalidade necessários ao serviço. Esses serviços parceiros são referenciados na parte superior da classe de implementação usando o atributo Partner. Por exemplo, o serviço de simulação do Boe-Bot estabelecerá uma parceria com o serviço do mecanismo de simulação. O código para incluir essa declaração de parceiro é semelhante a este:
//Simulation Engine Port
[Partner("Engine",
Contract = engineproxy.Contract.Identifier,
CreationPolicy = PartnerCreationPolicy.UseExistingOrCreate)]
private engineproxy.SimulationEnginePort _engineStub =
new engineproxy.SimulationEnginePort();
Os serviços DSS usam um arquivo baseado em XML conhecido como manifesto para listar os serviços parceiros associados a um serviço básico. Isso informa ao runtime do MSRS como o serviço básico deve ser carregado e interagir com esses serviços parceiros. Muito embora o manifesto seja um arquivo baseado em XML e possa ser editado com um editor de texto, é melhor usar o editor DSS Manifest incluído no MSRS. O editor DSS Manifest é uma ferramenta visual que permite arrastar e soltar serviços parceiros na superfície de design. Para usar o editor DSS Manifest, você precisará compilar com êxito o serviço básico. Isso criará os arquivos de assembly usados pelo editor DSS Manifest.
Assim que o editor DSS Manifest for carregado, uma lista de todos os serviços disponíveis será incluída no painel à esquerda. Para começar, você precisará localizar o serviço básico na lista dos serviços disponíveis e arrastar uma instância dela para a superfície de design. Se você fizer isso com o serviço de simulação do Boe-Bot, a superfície de design incluirá um nó para o serviço SimulatedBoeBot e um subnó para o serviço do mecanismo de simulação.
A instalação do MSRS inclui vários serviços na pasta \samples. Um deles, SimpleDashboard, pode ser usado como um painel de controle em robôs simulados. O SimpleDashboard permite iniciar os demais serviços usados para controlar a funcionalidade específica do robô. Por exemplo, o código no serviço SimulatedBoeBot apenas complementa a cena da simulação com entidades, e uma delas é Boe-Bot. Não há nenhum código no serviço que efetivamente movimente o robô. Você empresta esse código do serviço Drive.
Para carregar e usar o painel simples, você deve adicioná-lo ao manifesto, localizando uma instância de SimpleDashboard na lista de serviços e arrastando-a para a parte inferior da superfície de design. O resultado final deve ser semelhante ao da Figura 12. A última coisa a se fazer é salvar o manifesto no diretório de projeto do serviço SimulatedBoeBot e substituir o manifesto chamado SimulatedBoeBot.mainfest.xml.
Figura 12 Versão final do manifesto no editor DSS Manifest (Clique na imagem para uma visão ampliada)
Executando a simulação
Agora você está pronto para executar o serviço SimulatedBoeBot. Isso pode ser feito com um simples clique em Debug and Run no menu do Visual Studio 2005. Inicialmente, uma janela de prompt de comando deve ser exibida.
Assim que o serviço for carregado, duas janelas adicionais deverão ser exibidas. A interface de Simple Dashboard é um formulário do Windows que inclui várias caixas de grupo. O lado direito do formulário (consulte a Figura 13) inclui uma caixa de grupo intitulada Remote Node. Para começar, você precisará digitar o nome da máquina local (localhost) na caixa de texto machine e clicar em Connect. Isso iniciará uma conexão com o serviço SimulatedBoeBot e carregará serviços de parceiro de entidade como, por exemplo, o serviço de comando mostrado na caixa de listagem do diretório.
Figura 13 Comandar o Boe-Bot em um mundo virtual (Clique na imagem para uma visão ampliada)
O serviço de comando é usado para enviar potência às rodas que controlam o Boe-Bot. Isso permite movimentá-lo em toda a simulação usando o controle de joystick virtual ou um joystick real conectado ao computador. Inicialmente, você precisará clicar duas vezes no item SimulatedBoeBot exibido na caixa de listagem. Em seguida, é possível usar o mouse para arrastar o controle de joystick virtual arredondado localizado no canto superior esquerdo do formulário Simple Dashboard.
Talvez demore um pouco até que você se acostume com o uso do controle de joystick virtual (consulte a Figure 14 para ver como deve ser a simulação). Experimente movimentar o Boe-Bot e ver como ele reage ao colidir com o obstáculo de caixa. Agora é possível ir até o modo de edição, selecionar uma das entidades e ajustar algumas das propriedades para ver como a entidade é afetada. Passe algum tempo testando o ambiente de simulação para ter uma idéia de como ele funciona.
Figura 14 Operar um Boe-Bot simulado em um mundo virtual (Clique na imagem para uma visão ampliada)
Criando uma entidade sem um comando diferencial
Neste artigo, abordei como criar uma nova entidade de robô chamada Boe-Bot. Como o Boe-Bot usa um sistema de comando diferencial para controlar as rodas do robô, consegui criar um tipo de entidade derivado da classe DifferentialDriveEntity. Isso me permitiu reutilizar o código fornecido pelo MSRS e controlar um robô que usa esse tipo de sistema de comando.
Se você quisesse simular um robô que usasse um sistema de comando diferente, você precisaria primeiro adicionar uma classe que representasse esse sistema. Por exemplo, alguns robôs usam o que é conhecido como sistema de comando para triciclo. Nesse caso, uma única roda dianteira é usada para mover o robô, e as duas rodas laterais conectadas a um motor separado são usadas para virá-lo em uma direção.
Para permitir esse tipo de sistema no mundo simulado ou físico, você precisaria criar uma classe que levasse em conta esse tipo de sistema de comando. As etapas para isso estão além do escopo deste artigo, mas o MSRS permite a você fornecer esse tipo de cenário. Esse tipo de possibilidade de expansão faz parte daquilo que torna o MSRS tão importante para os pesquisadores na área da robótica. O MSRS pode ser expendido para oferecer suporte a qualquer tipo de plataforma de hardware.
Sara Morgan é MVP Microsoft 2007 no Office Communications Server. Seu primeiro livro, Building Intelligent .NET Applications, foi publicado em 2005. Além de ser co-autora de vários kits de treinamento Microsoft, ela publicou recentemente Programming Microsoft Robotics Studio. Atualmente, ela é engenheira de software na área de
robótica da CoroWare.com.
Nenhum comentário:
Postar um comentário