Ejemplo n.º 1
0
        public static void Execute(string ip, int port, bool human = false)
        {
            _pressedKey = "";
            var items = new[]
            {
                "B", "C", "D", "F", "G", "H", "J", "K", "L",
                "M", "N", "P", "Q", "R", "S", "T", "V", "W",
                "X", "Y", "Z"
            };

            using (var actr = new ActRClient(ip, port))
            {
                actr.StartTraceMonitoring();
                actr.LoadActrModel("ACT-R:tutorial;unit2;demo2-model.lisp");
                actr.Reset();

                var numberList = new List <dynamic>();
                for (var i = 0; i < items.Length; ++i)
                {
                    numberList.Add(i);
                }
                var indexes = actr.PermuteList(numberList.ToArray());

                var targetItem = items[(long)indexes[0]];

                var window = actr.OpenExpWindow("Letter difference", true);

                actr.AddTextToWindow(window, targetItem, 125, 150);

                AbstractAddCommandRequest addCommandRequest = new AddCommandRequest(KeyPressAction,
                                                                                    "unit2-key-press",
                                                                                    "unit2-key-press",
                                                                                    "Assignment 2 task output-key monitor");

                actr.AddDispatcherCommand(addCommandRequest);
                var modelDispatcherMonitor = new MonitorRequest("output-key", "unit2-key-press");
                actr.AddDispatcherMonitor(modelDispatcherMonitor);

                if (!human)
                {
                    actr.InstallDevice(window);
                    actr.Run(10, true);
                }
                else
                {
                    while (_pressedKey.Equals(""))
                    {
                        Thread.Sleep(1);
                    }
                }

                //actr.RemoveDispatcherMonitor("output-key", "unit2-key-press");
                actr.RemoveDispatcherMonitor(modelDispatcherMonitor);
                actr.RemoveDispatcherCommand("unit2-key-press");

                actr.StopTraceMonitoring();
                Console.WriteLine(targetItem.ToLower().Equals(_pressedKey.ToLower()));
            }
        }
Ejemplo n.º 2
0
        public async Task <bool> AddCommand(AddCommandRequest request)
        {
            try
            {
                var result = await _client.PostAsync("AddCommand", HttpClientHelper.GetJsonData(request));

                return(result.IsSuccessStatusCode);
            }
            catch (Exception e)
            {
                return(HttpClientHelper.LogError <bool>(_logger, e,
                                                        new object[] { request.Aliases, request.InformationText, request.HelpText, request.Username }));
            }
        }
        public IActionResult AddCommand([FromBody] AddCommandRequest request)
        {
            try
            {
                _chatCommandService.AddCommand(request.Aliases, request.InformationText, request.HelpText,
                                               request.Username);

                return(Ok());
            }
            catch (Exception e)
            {
                _logger.LogError(e, "Error encountered when adding a custom command", new  { request.Aliases, request.InformationText, request.HelpText, request.Username });
            }

            return(BadRequest());
        }
        /// <summary>
        /// Adds the command.
        /// </summary>
        /// <param name="request">The request.</param>
        /// <returns></returns>
        /// <exception cref="Exception"></exception>
        public async Task <Command> AddCommand(AddCommandRequest request)
        {
            var device = await _unitOfWork.GetRepository <Device>().FindAsync(x => x.Id == request.DeviceId);

            var application = await _unitOfWork.GetRepository <Application>().FindAsync(x => x.Id == request.ApplicationId);

            if (device == null || application == null)
            {
                throw new Exception(ErrorMessages.NotFounDeviceOrApp);
            }

            var command = _mapper.Map <Command>(request);

            _unitOfWork.GetRepository <Command>().Add(command);
            await _unitOfWork.CommitAsync();

            return(command);
        }
        public async Task <IActionResult> AddCommand([FromBody] AddCommandRequest request)
        {
            var response = await _commandService.AddCommand(request);

            return(Ok(new ApiOkResponse(response)));
        }
Ejemplo n.º 6
0
        private static double Trial(ActRClient actr, bool runInRealTime, double onset)
        {
            _answers   = new List <string>();
            _responses = new List <string>();

            actr.Reset();

            int freq;

            var row = actr.ActrRandom(3);

            var window = actr.OpenExpWindow("Sperling Experiment", runInRealTime);

            var letters = new dynamic[]
            {
                "B",
                "C",
                "D",
                "F",
                "G",
                "H",
                "J",
                "K",
                "L",
                "M",
                "N",
                "P",
                "Q",
                "R",
                "S",
                "T",
                "V",
                "W",
                "X",
                "Y",
                "Z"
            };

            letters = actr.PermuteList(letters);
            for (var i = 0; i < 3; ++i)
            {
                for (var j = 0; j < 4; ++j)
                {
                    var txt = letters[i + j * 4];
                    if (i == row)
                    {
                        _answers.Add((string)txt);
                    }
                    actr.AddTextToWindow(window, (string)txt, 75 + j * 50, 101 + i * 50);
                }
            }

            actr.InstallDevice(window);
            switch (row)
            {
            case 0:
                freq = 2000;
                break;

            case 1:
                freq = 1000;
                break;

            default:
                freq = 500;
                break;
            }

            actr.NewToneSound(freq, 0.5, onset);
            actr.ScheduleEventRelative(
                900 + actr.ActrRandom(200), "clear-exp-window",
                new dynamic[] { window.Title });

            AbstractAddCommandRequest addCommandRequest = new AddCommandRequest(list => KeyPressAction(list),
                                                                                "sperling-response",
                                                                                "KeyPressAction",
                                                                                "Sperling task key press response monitor");

            actr.AddDispatcherCommand(addCommandRequest);
            var modelDispatcherMonitor = new MonitorRequest("output-key", "sperling-response");

            actr.AddDispatcherMonitor(modelDispatcherMonitor);

            actr.Run(30, runInRealTime);

            actr.RemoveDispatcherMonitor("output-key", "sperling-response");
            actr.RemoveDispatcherCommand("KeyPressAction");

            var score = 0;

            foreach (var s in _responses)
            {
                if (_answers.Contains(s.ToUpper()))
                {
                    ++score;
                }
            }

            Console.Write("answers: [");
            foreach (var a in _answers)
            {
                Console.Write("'" + a + "'");
            }
            Console.Write("]\n");
            Console.Write("responses: [");
            foreach (var r in _responses)
            {
                Console.Write("'" + r + "'");
            }
            Console.Write("]\n");
            return(score);
        }