V.O.W.C (Voice Operated Wheel Chair)

ABSTRACT

According to IBGE data from 2015, 6.2% of the Brazilian population has some kind of disability. The study also shows that 1.3% (about 2.6 million) of the population have some type of physical disability and almost half of this total (46.8%) have an intense or very intense degree of limitation. Only 18.4% of this group attend rehabilitation services. Most of them need a wheelchair to get around, they are the so-called wheelchair users. Many have an active life, work and study, and therefore need to move around the cities.There are currently different models, types and configurations of wheelchairs that allow a real gain in quality of life for people who have mobility restrictions, improving their quality of life. The wheelchairs are divided into two large groups the manual and motorized chairs. The first type is more usual, and also the cheapest, moves only with human strength. The second type has a motorization to perform the movements. Thus, the user does not have to make the effort to get around, being a great option for those who have greater commitment of the superior members.Prices range from R$ 300,00 to R$ 8,000.00. Seeking a more modern and affordable alternative that the V.O.W.C was created

Iremos demonstrar neste Instructibles o conceito do desenvolvimento de um protótipo de reconhecimento de voz do usuário com mobilidade reduzida e ilustrar de maneira gráfica a movimentação de uma cadeira de rodas baseado na instrução reconhecida.

Para desenvolver este projeto, foram utilizados:

Hardware

1. DragonBoard410c - $75.00 (o manual da mesma encontra-se disponível aqui) (imagem em anexo)
2. Audio Mezzanine Board - $4.99 (maiores detalhes da mesma encontram-se disponíveis aqui) (imagem em anexo)

3. Microfone (USB ou com adaptador USB)

4. Fonte de Alimentação

Software:

1. Windows IoT Core
2. Microsoft Visual Studio 2017
3. DragonBoard Update Tool

Step 1: Preparando O Ambiente De Desenvolvimento

Para dar início ao processo de desenvolvimento, é necessária a instalação do Windows 10 IoT Core na DragonBoard 410c, todo este processo de instalação pode ser encontrado com bastante detalhe aqui.

Após o término da instalação é realizada a configuração da DragonBoard, onde esta é realizada através da ferramenta Windows IoT Core DashBoard.

Através do IoT DashBoard, é possível acessar a ferramenta de configuração do Windows 10 IoT Core, o Device Portal. O Device Portal é acessado através do endereç IP da placa na porta 8080, no nosso caso http://192.168.1.6:8080. O login padrão é administrator e a senha p@ssw0rd.

A IDE de desenvolvimento usada foi o Visual Studio 2017 Community (disponível aqui). Após usa instalação, é também necessária a instalação do IoT Core Templates, disponível aqui.

Uma observação válida é que o uso do Windows IoT tem como requisito mínimo a versão 2017 do visual Studio e o Sistema Operacional da máquina onde será feito o desenvolvimento deve ser o Windows 10.

Terminadas as instalações, podemos iniciar o desenvolvimento utilizando dos mesmos recursos que um projeto UWP, ou seja, XAML para desenhar as interfaces gráficas e C# para o código propriamente dito.

Step 2: Realizando a Detecção De Voz

Conforme mencionado anteriormente, o intuito deste projeto é facilitar a vida de usuários com mobilidade reduzida utilizando o reconhecimento de voz para mover a cadeira de rodas.

Visando facilitar este processo, foram configurados comandos simples como "anda"/"andar" e "vira"/"virar" combinados com comandos de direção: "frente", "trás", "direita" e "esquerda" para que combinados determinem para qual direção a cadeira deve se movimentar.

Para a captação do áudio foram realizados testes utilizando tanto os microfones onboard da Audio Mezzanine Board, quanto um microfone usb, que é detectado automaticamente pela DragonBoard.

Para interpretarmos o que foi dito, utilizamos a biblioteca Windows.Media.SpeechRecognition, sendo esta por sua vez nativa e portanto não requerendo a instalação de bibliotecas adicionais.

Uma vez reconhecida e interpretada, a interface gráfica do aplicativo mostra ao usuário através de setas e campos de texto quais foram os termos entendidos e ilustra para qual direção a cadeira se moveu, além de contar com uma animação de uma cadeira em movimento.

Para delimitar quais comandos e ações devem ser interpretadas, é necessário que se crie um arquivo XML contendo a gramática do aplicativo, este arquivo encontra-se em anexo.

Já no nosso arquivo c#, declaramos constantes que conterão o caminho para o arquivo de gramática, assim como os comandos que serão interepretados.

private const string SRGS_FILE = "Gramatica\\gramatica.xml";
        private const string TAG_CMD = "cmd";
        private const string TAG_DEVICE = "device";
        private const string CMD_PARAR = "PARAR";
        private const string CMD_PARA = "PARA";
        private const string CMD_ANDAR = "ANDAR";
        private const string CMD_ANDA = "ANDA";
        private const string CMD_VIRAR = "VIRAR";
        private const string CMD_VIRA = "VIRA";
        private const string DEVICE_FRENTE = "FRENTE";
        private const string DEVICE_TRAS = "TRAS";
        private const string DEVICE_ESQEUERDA = "ESQUERDA";
        private const string DEVICE_DIREITA = "DIREITA";

A partir daí, criamos um método para iniciar o reconhecimento de voz, e adicionamos uma chamada para este método no construtor da página.

public MainPage()
        {
            this.InitializeComponent();
            var appView = Windows.UI.ViewManagement.ApplicationView.GetForCurrentView();
            appView.Title = "V.O.W.C.";
            InicializaVoz();
        }

/// 

        /// Método que inicia o reconhecimento de voz
        /// 
        public async void InicializaVoz()
        {
            bool hasPermission = await CheckMicrophonePermission();
            if (hasPermission)
            {
                var idioma = new Windows.Globalization.Language("en-US");
                recognizer = new SpeechRecognizer(idioma);
                //recognizer.StateChanged += RecognizerStateChanged;
                recognizer.ContinuousRecognitionSession.ResultGenerated += RecognizerResultGenerated;
                string fileName = String.Format(SRGS_FILE);
                StorageFile grammarContentFile = await Package.Current.InstalledLocation.GetFileAsync(fileName);
                SpeechRecognitionGrammarFileConstraint grammarConstraint = new SpeechRecognitionGrammarFileConstraint(grammarContentFile);
                recognizer.Constraints.Add(grammarConstraint);
                SpeechRecognitionCompilationResult compilationResult = await recognizer.CompileConstraintsAsync();
                if (compilationResult.Status == SpeechRecognitionResultStatus.Success)
                {
                    await recognizer.ContinuousRecognitionSession.StartAsync();
                    Debug.WriteLine("reconhecendo");
                }
                else
                {
                    Debug.WriteLine("Status: " + compilationResult.Status);
                }
            }
            else
            {
                Debug.WriteLine("Sem permissão");
            }
        }

A partir do método acima, o aplicativo começa a escutar o que está sendo dito, e uma vez que identificar algum termo conhecido para ele, chama por sua vez o método abaixo, contendo os termos que foram reconhecidos, para que possam ser interpretados

/// 

        /// Método que a partir do resultado interpretado pelo app, toma as ações devidas
        /// 
        /// 

        /// 

        private async void RecognizerResultGenerated(SpeechContinuousRecognitionSession session, SpeechContinuousRecognitionResultGeneratedEventArgs args)
        {
            int count = args.Result.SemanticInterpretation.Properties.Count;
            String cmd = args.Result.SemanticInterpretation.Properties.ContainsKey(TAG_CMD) ? args.Result.SemanticInterpretation.Properties[TAG_CMD][0].ToString() : "";
            String device = args.Result.SemanticInterpretation.Properties.ContainsKey(TAG_DEVICE) ? args.Result.SemanticInterpretation.Properties[TAG_DEVICE][0].ToString() : "";
            await Windows.ApplicationModel.Core.CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(CoreDispatcherPriority.Normal,
            () =>
            {
                Thickness margin = imgCadeira.Margin;
                if (cmd != string.Empty && device != string.Empty)
                    txbCommandRecognized.Text = cmd + " " + device;
                else
                    txbCommandRecognized.Text = "Comando não reconhecido!";
            });
            switch (cmd)
            {
                case CMD_ANDAR:
                case CMD_ANDA:
                    {
                        switch (device)
                        {
                            case DEVICE_FRENTE:
                                Move(DEVICE_FRENTE);
                                break;
                            case DEVICE_TRAS:
                                Move(DEVICE_TRAS);
                                break;
                        }
                    }
                    break;
                case CMD_VIRAR:
                case CMD_VIRA:
                    {
                        switch (device)
                        {
                            case DEVICE_DIREITA:
                                Move(DEVICE_DIREITA);
                                break;
                            case DEVICE_ESQEUERDA:
                                Move(DEVICE_ESQEUERDA);
                                break;
                        }
                    }
                    break;
                default:
                    txbCommandRecognized.Text = "Comando não reconhecido!";
                    break;
            }
        }

Conforme podemos notar, uma vez reconhecidos os comandos enviados, este método chama um outro método de nome "Move()" passando como parâmetro a constante referente à direção em que a cadeira deve ser movida. Por se tratar apenas de um protótipo, este método apenas desloca a imagem da cadeira na tela, mas em implementações futuras este método será substituído por um que comunique efetivamente com uma cadeira real e faça sua locomoção, bastando que apenas esta parte do código seja alterada para o total funcionamento da solução.

Um erro commum que pode ocorrer ao tentarmos executar o aplicativo diz respeito à falta de permissão de acesso ao microfone. Para evitar que isto ocorra, devemos adicionar tal permissão ao nosso aplicativo através do arquivo Package.appmanifest, localizado no SolutionExplorer juntamente com os demais arquivos do projeto. Uma vez aberto tal arquivo, devemos selecionar a aba Capabilities e na lista exibida à esquerda, selecionarmos o checkbox "Microphone" (imagem em anexo)..

Para ajudar a evitar que se tal permissão encontra-se habilitada, foi criado um método auxiliar que verifica se o aplicativo possui permissão para capturar o áudio do usuário:

/// 

        /// Método para verificar se o app possui a mermissão para escutar o microfone
        /// 
        /// 
        public static async Task CheckMicrophonePermission()
        {
            try
            {
                MediaCaptureInitializationSettings settings = new MediaCaptureInitializationSettings();
                settings.StreamingCaptureMode = StreamingCaptureMode.Audio;
                settings.MediaCategory = MediaCategory.Speech;
                MediaCapture capture = new MediaCapture();
                await capture.InitializeAsync(settings);
            }
            catch (UnauthorizedAccessException)
            {
                return false;
            }
            return true;
        }

O código completo da solução está disponível no GitHub aqui

Step 3: Considerações Finais

O projeto V.O.C.W. no momento é apenas um protótipo que ilustra uma solução possível para cadeirantes com mobilidade reduzida também em seus membros superiores, porém o projeto passará por manutenções evolutivas, visando entregar uma solução completa e acessível para os usuários de seu público alvo.

Proposto como trabalho final de uma disciplina de IoT do curso de pós graduação de Desenvolvimento para Dispositivos Móveis, este projeto nos permitiu um primeiro contato com desenvolvimento para dispositivos físicos, como foi o caso da DragonBoard, e do uso aplicado de tecnologias de reconhecimento de voz, através de um framework disponível em uma IDE que já possuíamos familiaridade (Visual Studio).

Em nome de toda a equipe, gostaria de agradecer à PUC-MG e ao nosso professor Ilo Rivero pelo apoio no desenvolvimento do projeto.

Matheus Schneider ,Beatriz Tavares, Carlos Teles, Leandro Murta, Marcelo Dominato