public static void Init(string componentName, string logsDirectory)
{
Ensure.NotNull(componentName, "componentName");
if (_initialized)
{
throw new InvalidOperationException("Cannot initialize twice");
}
_initialized = true;
_logsDirectory = logsDirectory;
Environment.SetEnvironmentVariable("EVENTSTORE_INT-COMPONENT-NAME", componentName, EnvironmentVariableTarget.Process);
AppDomain.CurrentDomain.UnhandledException += (s, e) =>
{
var exc = e.ExceptionObject as Exception;
if (exc != null)
{
GlobalLogger.FatalException(exc, "Global Unhandled Exception occurred.");
}
else
{
GlobalLogger.Fatal("Global Unhandled Exception object: {0}.", e.ExceptionObject);
}
GlobalLogger.Flush(TimeSpan.FromMilliseconds(500));
};
}
/// <summary>
/// OnShutdown(): Called when the System is shutting down
/// - Put code here when you need special handling
/// of code that deals with a system shutdown, such
/// as saving special data before shutdown.
/// </summary>
protected override void OnShutdown()
{
_log.Info("Service shutdown.");
OnStop();
_log.Flush();
base.OnShutdown();
}
/// <summary>
/// Save mod settings and fire OnSave event.
/// </summary>
public override void SaveData()
{
using (PROFILE ? Profiler.Measure(nameof(Mod), nameof(SaveData)) : null) {
Log.Flush();
_profilerLog.Flush();
WriteProfileResults();
}
}
public void StartGame(SocketUser user)
{
if (State != GameState.None)
{
//TODO: log game already in progress
_log.LogF($"A game is already in progress or a lobby has already been started.");
return;
}
_log.LogF($"A lobby has been started. Join by typing `{Const.Comm.JOIN}` or start playing the game by typing `{Const.Comm.PLAY}`.");
_log.Flush();
State = GameState.JoinPhase;
JoinGame(user);
}
public static void Init(string componentName, string logsDirectory, bool isStructured,
string configurationDirectory)
{
Ensure.NotNull(componentName, "componentName");
if (_initialized)
{
throw new InvalidOperationException("Cannot initialize twice");
}
var potentialNLogConfigurationFilePaths = new[] {
Path.Combine(Locations.ApplicationDirectory, EVENTSTORE_LOG_FILENAME),
Path.Combine(configurationDirectory, EVENTSTORE_LOG_FILENAME)
}.Distinct();
var configFilePath = potentialNLogConfigurationFilePaths.FirstOrDefault(x => File.Exists(x));
if (!String.IsNullOrEmpty(configFilePath))
{
var originalFormatter = NLog.Config.ConfigurationItemFactory.Default.ValueFormatter;
ConfigurationItemFactory.Default.ValueFormatter =
new NLogValueFormatter(originalFormatter, isStructured);
NLog.LogManager.Configuration = new NLog.Config.XmlLoggingConfiguration(configFilePath);
}
else
{
Console.Error.WriteLine(
"Event Store's Logging ({0}) configuration file was not found in:\n{1}.\nFalling back to defaults.",
EVENTSTORE_LOG_FILENAME,
String.Join(",\n", potentialNLogConfigurationFilePaths));
SetDefaultLog();
}
_initialized = true;
_logsDirectory = logsDirectory;
_isStructured = isStructured;
Environment.SetEnvironmentVariable("EVENTSTORE_INT-COMPONENT-NAME", componentName,
EnvironmentVariableTarget.Process);
AppDomain.CurrentDomain.UnhandledException += (s, e) => {
var exc = e.ExceptionObject as Exception;
if (exc != null)
{
GlobalLogger.FatalException(exc, "Global Unhandled Exception occurred.");
}
else
{
GlobalLogger.Fatal("Global Unhandled Exception object: {e}.", e.ExceptionObject);
}
GlobalLogger.Flush(TimeSpan.FromMilliseconds(500));
};
}
protected override void Awake()
{
try
{
base.Awake();
// Application settings go here
Application.runInBackground = true;
Application.targetFrameRate = 60;
// Set up required components, and just the bare minimum of MVC actors. We don't have config data yet, so
// anything that requires real data off the network should be registered in StartupCommand or later
mGuiManager = new RuntimeGuiManager(mLogger);
mLogger.AddReporter(new DebugLogReporter());
mGameFacade = GameFacade.Instance; // Nulls out the reference on application exit for editor integration
// Register Required Mediators
GameFacade.Instance.RegisterMediator(new LoggerMediator(mLogger));
GameFacade.Instance.RegisterMediator(new InputManagerMediator());
GameFacade.Instance.RegisterMediator(new SchedulerMediator(this.Scheduler));
GameFacade.Instance.RegisterMediator((IMediator)mGuiManager);
RuntimeConsole runtimeConsole = new RuntimeConsole(mGuiManager);
runtimeConsole.AddCommand("showTasks", ((Scheduler)this.Scheduler).ShowTasks);
((Scheduler)this.Scheduler).Logger = mLogger;
GameFacade.Instance.RegisterMediator(runtimeConsole);
mLogger.AddReporter(runtimeConsole);
mLogger.Log("SceneInit.Awake", LogLevel.Info);
ConnectionProxy connectionProxy = new ConnectionProxy();
GameFacade.Instance.RegisterProxy(connectionProxy);
// Get configuration data before doing anything else. This sends STARTUP_COMMAND when done getting the config data
ConfigManagerClient configManager = new ConfigManagerClient();
GameFacade.Instance.RegisterProxy(configManager);
configManager.InitAndStartup();
}
catch (System.Exception ex)
{
// Catch all here is to avoid browser crashes on exit if something becomes unstable.
mLogger.Log(ex.ToString(), LogLevel.Error);
}
finally
{
mLogger.Flush();
}
}
public void Dispose()
{
lock (senderList.SyncRoot)
{
foreach (DedicatedMessageSender dmSender in senderList)
{
if (dmSender.IsAlive)
{
try
{
_ncacheLog.Flush();
#if !NETCORE
dmSender.Abort();
#else
dmSender.Interrupt();
#endif
}
catch (Exception)
{
}
}
}
senderList.Clear();
mq.close(false);
}
}
public void Execute(GeneratorExecutionContext context)
{
var receiver = context.SyntaxReceiver;
_location = GetPackageLocation(context);
using ILogger log = CreateLogger(context);
log.SetLocation(_location);
var allDocuments = GetGraphQLFiles(context);
var allConfigurations = GetGraphQLConfigs(context);
log.Flush();
foreach (var config in allConfigurations)
{
var clientContext = new ClientGeneratorContext(
context,
log,
config.Extensions.StrawberryShake,
config.Documents,
IOPath.GetDirectoryName(config.Location) !,
allDocuments);
if (clientContext.GetDocuments().Count > 0)
{
log.Begin(config, clientContext);
Execute(clientContext);
log.End();
}
}
}
private void RunTestInternal(TestCase xamlTestCase)
{
try
{
_context.SetTestName(xamlTestCase.Name);
Setup(xamlTestCase.SetupSteps);
Execute(xamlTestCase.ExecutionSteps);
TearDown(xamlTestCase.CleanupSteps);
}
finally
{
if (null != _logger)
{
_logger.Flush();
_logger.Close();
}
xamlTestCase.Cleanup(_context);
}
if (null != _executionException)
{
throw _executionException;
}
}
protected ProgramBase(string[] args)
{
Application.RegisterExitAction(Exit);
try {
var options = EventStoreOptions.Parse <TOptions>(args, Opts.EnvPrefix,
Path.Combine(Locations.DefaultConfigurationDirectory, DefaultFiles.DefaultConfigFile),
MutateEffectiveOptions);
if (options.Help)
{
Console.WriteLine("Options:");
Console.WriteLine(EventStoreOptions.GetUsage <TOptions>());
_skipRun = true;
}
else if (options.Version)
{
Console.WriteLine("EventStore version {0} ({1}/{2}, {3})",
VersionInfo.Version, VersionInfo.Branch, VersionInfo.Hashtag, VersionInfo.Timestamp);
_skipRun = true;
}
else
{
PreInit(options);
Init(options);
Create(options);
_startupSource.SetResult(true);
}
} catch (OptionException exc) {
Console.Error.WriteLine("Error while parsing options:");
Console.Error.WriteLine(FormatExceptionMessage(exc));
Console.Error.WriteLine();
Console.Error.WriteLine("Options:");
Console.Error.WriteLine(EventStoreOptions.GetUsage <TOptions>());
_startupSource.SetException(exc);
} catch (ApplicationInitializationException ex) {
var msg = String.Format("Application initialization error: {0}", FormatExceptionMessage(ex));
if (LogManager.Initialized)
{
Log.FatalException(ex, msg);
}
else
{
Console.Error.WriteLine(msg);
}
_startupSource.SetException(ex);
} catch (Exception ex) {
var msg = "Unhandled exception while starting application:";
if (LogManager.Initialized)
{
Log.FatalException(ex, msg);
}
else
{
Console.Error.WriteLine(msg);
Console.Error.WriteLine(FormatExceptionMessage(ex));
}
_startupSource.SetException(ex);
} finally {
Log.Flush();
}
}
public void Flush()
{
if (_logger != null)
{
_logger.Flush();
}
}
private void Dispose(bool disposing)
{
if (disposing)
{
FileSystem?.Dispose();
Logger?.Flush();
}
}
protected virtual void Dispose(bool disposing)
{
if (disposing)
{
FileSystem?.Dispose();
Logger?.Flush();
}
}
public int Run(string[] args)
{
try
{
Application.RegisterExitAction(Exit);
var options = EventStoreOptions.Parse <TOptions>(args, Opts.EnvPrefix, Path.Combine(Locations.DefaultConfigurationDirectory, DefaultFiles.DefaultConfigFile));
if (options.Help)
{
Console.WriteLine("Options:");
Console.WriteLine(EventStoreOptions.GetUsage <TOptions>());
}
else if (options.Version)
{
Console.WriteLine("EventStore version {0} ({1}/{2}, {3})",
VersionInfo.Version, VersionInfo.Branch, VersionInfo.Hashtag, VersionInfo.Timestamp);
Application.ExitSilent(0, "Normal exit.");
}
else
{
PreInit(options);
Init(options);
CommitSuicideIfInBoehmOrOnBadVersionsOfMono(options);
Create(options);
Start();
_exitEvent.Wait();
}
}
catch (OptionException exc)
{
Console.Error.WriteLine("Error while parsing options:");
Console.Error.WriteLine(FormatExceptionMessage(exc));
Console.Error.WriteLine();
Console.Error.WriteLine("Options:");
Console.Error.WriteLine(EventStoreOptions.GetUsage <TOptions>());
}
catch (ApplicationInitializationException ex)
{
Log.FatalException(ex, "Application initialization error: {0}", FormatExceptionMessage(ex));
Application.Exit(ExitCode.Error, FormatExceptionMessage(ex));
}
catch (Exception ex)
{
Console.WriteLine(ex);
Log.FatalException(ex, "Unhandled exception while starting application:\n{0}", FormatExceptionMessage(ex));
Application.Exit(ExitCode.Error, FormatExceptionMessage(ex));
}
finally
{
Log.Flush();
}
Application.ExitSilent(_exitCode, "Normal exit.");
return(_exitCode);
}
public int Run(string[] args)
{
var options = new TOptions();
try
{
Application.RegisterExitAction(Exit);
options.Parse(args);
if (options.ShowHelp)
{
Console.WriteLine("Options:");
Console.WriteLine(options.GetUsage());
}
else if (options.ShowVersion)
{
Console.WriteLine("EventStore version {0} ({1}/{2}, {3})",
VersionInfo.Version, VersionInfo.Branch, VersionInfo.Hashtag, VersionInfo.Timestamp);
Application.ExitSilent(0, "Normal exit.");
}
else
{
Init(options);
CommitSuicideIfInBoehmOrOnBadVersionsOfMono(options);
Create(options);
Start();
_exitEvent.Wait();
}
}
catch (OptionException exc)
{
Console.Error.WriteLine("Error while parsing options:");
Console.Error.WriteLine(FormatExceptionMessage(exc));
Console.Error.WriteLine();
Console.Error.WriteLine("Options:");
Console.Error.WriteLine(options.GetUsage());
}
catch (ApplicationInitializationException ex)
{
Log.FatalException(ex, "Application initialization error: {0}", FormatExceptionMessage(ex));
Application.Exit(ExitCode.Error, FormatExceptionMessage(ex));
}
catch (Exception ex)
{
Log.FatalException(ex, "Unhandled exception while starting application:\n{0}", FormatExceptionMessage(ex));
Application.Exit(ExitCode.Error, FormatExceptionMessage(ex));
}
finally
{
Log.Flush();
}
Application.ExitSilent(_exitCode, "Normal exit.");
return(_exitCode);
}
public static void Create(Project project, ILogger logger, CancellationToken cancelletionToken = default(CancellationToken))
{
logger.WriteLineInfo("----------------------------------");
logger.WriteLineInfo(" CAR METADATA file v0.1");
logger.WriteLineInfo(" The Ohio State University, 2017");
logger.WriteLineInfo("----------------------------------");
logger.WriteLineInfo(" ");
logger.WriteLineInfo(" ");
int pi = 0;
foreach (DataStream dataStream in project.DataStreams)
{
pi++;
cancelletionToken.ThrowIfCancellationRequested();
logger.WriteProgress((double)pi / (double)project.DataStreams.Count() * 100.0);
dataStream.WriteMetadata(logger);
}
PrintSummary(project, logger);
logger.WriteLineInfo(" ");
logger.WriteLineInfo("Checking: ");
// Checking Nikon's Novatel MARKTIMEA
ImageDataStream nikonDataStream = (ImageDataStream)project.GetDataStreamByShortName("NIKON");
NovatelDataStream novatelDataStream = (NovatelDataStream)project.GetDataStreamByShortName("NOVATEL");
CheckEvents(nikonDataStream, novatelDataStream, EvenMarkerDataLine.MarkerEventPort.Unknown, logger);
/*if ((nikonDataStream != null) && (novatelDataStream != null))
* {
* if (nikonDataStream.NumOfFiles != novatelDataStream.MarkerEvents.Count())
* {
* logger.WriteLineInfo("WRONG -- Number of #MARKTIME events from the Novatel ASC and the number of Nikon images are different!");
* logger.WriteLineWarning("Number of #MARKTIME events from the Novatel ASC and the number of Nikon images are different!");
* }
* else
* {
* logger.WriteLineInfo("OK -- Number of #MARKTIME events from the Novatel ASC and the number of Nikon images !");
* }
* }*/
// Checking Sony's Septentrio MARKTIME
ImageDataStream son1DataStream = (ImageDataStream)project.GetDataStreamByShortName("SON1");
ImageDataStream son2DataStream = (ImageDataStream)project.GetDataStreamByShortName("SON2");
GPSDataStream septDataStream = (GPSDataStream)project.GetDataStreamByShortName("SEPT");
CheckEvents(son1DataStream, septDataStream, EvenMarkerDataLine.MarkerEventPort.EventA, logger);
CheckEvents(son2DataStream, septDataStream, EvenMarkerDataLine.MarkerEventPort.EventB, logger);
logger.Flush();
}
/// <summary>
/// OnStop(): Put your stop code here
/// - Stop threads, set final data, etc.
/// </summary>
protected override void OnStop()
{
_log.Info("Service stop.");
_collector.Stop();
_log.Flush();
base.OnStop();
}
private static void Main(string[] args)
{
using (var typeContainer = TypeContainer.Get <ITypeContainer>())
{
Startup.Register(typeContainer);
Startup.ConfigureLogger(ClientType.GameServer);
Network.Startup.Register(typeContainer);
logger = (TypeContainer.GetOrNull <ILogger>() ?? NullLogger.Default).As("OctoAwesome.GameServer");
AppDomain.CurrentDomain.UnhandledException += (s, e) =>
{
File.WriteAllText(
Path.Combine(".", "logs", $"server-dump-{DateTime.Now:ddMMyy_hhmmss}.txt"),
e.ExceptionObject.ToString());
logger.Fatal($"Unhandled Exception: {e.ExceptionObject}", e.ExceptionObject as Exception);
logger.Flush();
};
manualResetEvent = new ManualResetEvent(false);
logger.Info("Server start");
var fileInfo = new FileInfo(Path.Combine(".", "settings.json"));
Settings settings;
if (!fileInfo.Exists)
{
logger.Debug("Create new Default Settings");
settings = new Settings()
{
FileInfo = fileInfo
};
settings.Save();
}
else
{
logger.Debug("Load Settings");
settings = new Settings(fileInfo);
}
typeContainer.Register(settings);
typeContainer.Register <ISettings, Settings>(settings);
typeContainer.Register <ServerHandler>(InstanceBehaviour.Singleton);
typeContainer.Get <ServerHandler>().Start();
Console.CancelKeyPress += (s, e) => manualResetEvent.Set();
manualResetEvent.WaitOne();
settings.Save();
}
}
private void KillProcessTree()
{
try
{
logger.Flush(); // Save log to file as soon as possible. Without it, the file log will be empty if the process has already died.
process.KillTree(); // we need to kill entire process tree, not just the process itself
}
catch
{
// we don't care about exceptions here, it's shutdown and we just try to cleanup whatever we can
}
}
public static void Init(string componentName)
{
Ensure.NotNull(componentName, "componentName");
if (Initialized)
{
throw new InvalidOperationException("Cannot initialize twice");
}
Initialized = true;
AppDomain.CurrentDomain.UnhandledException += (s, e) =>
{
var exc = e.ExceptionObject as Exception;
if (exc != null)
{
GlobalLogger.FatalException(exc, "Global Unhandled Exception occurred.");
}
else
{
GlobalLogger.Fatal("Global Unhandled Exception object: {0}.", e.ExceptionObject);
}
GlobalLogger.Flush(TimeSpan.FromMilliseconds(500));
};
}
/// <inheritdoc />
public override void Dispose()
{
base.Dispose();
if (_disposed)
{
return;
}
FileSystem?.Dispose();
Logger?.Flush();
_disposed = true;
}
public string Process(IPEndPoint localEndPoint, ILogger logger, string text)
{
TcpClient client = new TcpClient();
NetworkStream netStream = null;
var returnValue = string.Empty;
try
{
client.Connect(localEndPoint);
logger.Cache(LoggerThreshold.Debug, "Client connected to server");
netStream = client.GetStream();
var writeBuffer = Encoding.UTF8.GetBytes(text);
netStream.Write(writeBuffer, 0, writeBuffer.Length);
logger.Cache(LoggerThreshold.Debug, $"Client wrote [{text}]");
var result = new StringBuilder();
var readBuffer = new byte[256];
var totalBytes = 0;
do
{
var bytesRead = netStream.Read(readBuffer, 0, readBuffer.Length);
result.Append(Encoding.UTF8.GetString(readBuffer, 0, bytesRead));
totalBytes += bytesRead;
}while (client.Available > 0);
logger.Cache(LoggerThreshold.Debug, $"Client has read [{result.ToString()}]");
returnValue = result.ToString();
}
catch (Exception ex)
{
logger.Cache(LoggerThreshold.Error, ex.ToString());
}
if (netStream != null)
{
netStream.Close();
}
if (client.Connected)
{
client.Close();
}
logger.Cache(LoggerThreshold.Debug, "Client disconected from server");
logger.Flush();
return(returnValue);
}
private static void RegisterGlobalExceptionHandler()
{
AppDomain.CurrentDomain.UnhandledException += (s, e) =>
{
var exc = e.ExceptionObject as Exception;
if (exc != null)
{
GlobalLogger.FatalException(exc, "Global Unhandled Exception occurred.");
}
else
{
GlobalLogger.Fatal("Global Unhandled Exception object: {0}.", e.ExceptionObject);
}
GlobalLogger.Flush(TimeSpan.FromMilliseconds(500));
};
}
private void CurrentDomain_UnhandledException(object sender, UnhandledExceptionEventArgs e)
{
string message;
if (e.ExceptionObject != null)
{
message = e.ExceptionObject.ToString();
}
else
{
message = "Process Crash";
}
_nsqLogger.Output(LogLevel.Critical, message);
_nsqLogger.Flush();
}
public static void Init(ILogger globalLogger)
{
AppDomain.CurrentDomain.UnhandledException += (s, e) =>
{
var exc = e.ExceptionObject as Exception;
if (exc != null)
{
globalLogger.FatalException(exc, "Global Unhandled Exception occurred.");
}
else
{
globalLogger.Fatal("Global Unhandled Exception object: {0}.", e.ExceptionObject);
}
globalLogger.Flush(TimeSpan.FromMilliseconds(500));
};
}
private Tuple <ILogger, TestLogDestination> CreateLogger()
{
ILogger logger = Logger.CreateInstance();
TestLogDestination dest = new TestLogDestination();
logger.AddLogDestination(dest);
logger.Start();
logger.Flush();
Thread.Sleep(1000);
dest.Messages.Clear();
return(new Tuple <ILogger, TestLogDestination>(logger, dest));
}
public override void Test()
{
var args = $"{Path.Combine(TempDirectory, _testTemplateName)} -perf -host:vs -roslynonly -rootsuffix:{_rootSuffix}";
ShellOutVital(TaoPath, args, TempDirectory);
var logDirectory = Path.Combine(TempDirectory, _testName, "PerfResults");
var xcopyArgs = $"{logDirectory} {Path.Combine(MyBinaries(), "..", "..", "ToArchive")} /s /i /y";
ShellOutVital("xcopy", xcopyArgs);
foreach (var xml in Directory.EnumerateFiles(logDirectory, "*.xml"))
{
Benchview.UploadBenchviewReport(xml, _benchviewUploadName);
}
_logger.Flush();
}
private void ProcessFinishedItems(IEnumerable <IWorkItem> finishedWorkItems)
{
foreach (IWorkItem workItem in finishedWorkItems)
{
IWorkItemProgress result = workItem.GetCurrentProgress();
if (result.Progress == Progress.Completed)
{
logger.LogWorkItemComplete(workItem);
}
else
{
logger.LogWorkItemFailed(workItem);
}
workItem.Dispose();
}
logger.Flush();
}
private static GatewayService CreateGateway(AMQPConfig amqpConfig)
{
try
{
var _gatewayQueue = new GatewayQueue <QueuedItem>();
var _AMPQSender = new AMQPSender <string>(
amqpConfig.AMQPSAddress,
amqpConfig.EventHubName,
amqpConfig.EventHubMessageSubject,
amqpConfig.EventHubDeviceId,
amqpConfig.EventHubDeviceDisplayName,
_Logger
);
var _batchSenderThread = new BatchSenderThread <QueuedItem, string>(
_gatewayQueue,
_AMPQSender,
null,
m => m.JsonData,
_Logger);
_batchSenderThread.Start();
GatewayService service = new GatewayService(
_gatewayQueue,
_batchSenderThread
)
{
Logger = _Logger
};
service.OnDataInQueue += (data) => _batchSenderThread.Process();
_Logger.Flush();
return(service);
}
catch (Exception ex)
{
_Logger.LogError("Exception on creating Gateway: " + ex.Message);
}
return(null);
}
public void Translate() {
ILogger lexicalLogger = CreateLogger(LogLexer);
ILogger treeLogger = CreateLogger(LogSyntaxTree);
LexicalAnalyser lexer = new LexicalAnalyser(sourceFilepath, lexicalLogger);
CilEmitter emitter = new CilEmitter(programName);
try {
PerformTranslation(lexer, emitter, treeLogger);
}
catch (ParseException exc) {
Console.WriteLine("Error during translation : \n" + exc.Message);
}
finally {
lexicalLogger.Flush();
treeLogger.Flush();
}
}
public ControllerWithLoopTimeDebug(MotorMixer mixer, AxesController pid, Gyro gyro, Radio radio, ControllerLoopSettings loopSettings, MotorSettings motorSettings, ILogger logger)
{
long lastRadioTime = 0;
long lastSensorTime = 0;
long lastControlTime = 0;
long lastMotorTime = 0;
long lastTelemetryTime = 0;
float currentRadioFrequency = 0;
float currentSensorFrequency = 0;
float currentControlFrequency = 0;
float currentMotorFrequency = 0;
bool systemArmed = false;
SerialPort serialPort = new SerialPort("COM1",115200);
serialPort.Open();
while (true)
{
long currentTime = DateTime.Now.Ticks;
if (currentTime >= (lastRadioTime + loopSettings.RadioLoopPeriod))
{
currentRadioFrequency = loopSettings.LoopUnit / (float)(currentTime - lastRadioTime);
radio.Update();
systemArmed = radio.Throttle > motorSettings.MinimumOutput;
if (!systemArmed)
logger.Flush();
lastRadioTime = currentTime;
}
currentTime = DateTime.Now.Ticks;
if (currentTime >= (lastSensorTime + loopSettings.SensorLoopPeriod))
{
currentSensorFrequency = loopSettings.LoopUnit / (float)(currentTime - lastSensorTime);
gyro.Update();
lastSensorTime = currentTime;
}
currentTime = DateTime.Now.Ticks;
if (currentTime >= (lastControlTime + loopSettings.ControlAlgorithmPeriod))
{
currentControlFrequency = loopSettings.LoopUnit / (float)(currentTime - lastControlTime);
if (systemArmed)
pid.Update(radio.Axes, gyro.Axes, (float)(currentTime - lastControlTime) / loopSettings.LoopUnit);
lastControlTime = currentTime;
}
currentTime = DateTime.Now.Ticks;
if (currentTime >= (lastMotorTime + loopSettings.MotorLoopPeriod))
{
currentMotorFrequency = loopSettings.LoopUnit / (float)(currentTime - lastMotorTime);
if (systemArmed)
mixer.Update(radio.Throttle, pid.Axes);
else
mixer.SetSafe();
lastMotorTime = currentTime;
}
currentTime = DateTime.Now.Ticks;
if (currentTime >= (lastTelemetryTime + loopSettings.TelemetryLoopPeriod))
{
float currentTelemetryFrequency = loopSettings.LoopUnit / (float)(currentTime - lastTelemetryTime);
byte[] buffer = System.Text.Encoding.UTF8.GetBytes( "\r" + currentTime +
"\tR: " + currentRadioFrequency +
"\tS: " + currentSensorFrequency +
"\tC: " + currentControlFrequency +
"\tM: " + currentMotorFrequency +
"\tT: " + currentTelemetryFrequency + "\t");
serialPort.Write(buffer, 0, buffer.Length);
lastTelemetryTime = currentTime;
}
}
}
public Controller(MotorMixer mixer, AxesController pid, Gyro gyro, Accelerometer accelerometer, Radio radio, ControllerLoopSettings loopSettings, MotorSettings motorSettings, ILogger logger)
{
TelemetryData telemetryData = new TelemetryData();
long previousTime = DateTime.Now.Ticks;
long lastRadioTime = 0;
long lastSensorTime = 0;
long lastControlTime = 0;
long lastMotorTime = 0;
long lastTelemetryTime = 0;
bool systemArmed = false;
Thread.Sleep(1000);
gyro.Zero();
accelerometer.Zero();
while (true)
{
long currentTime = DateTime.Now.Ticks;
if (currentTime >= (lastRadioTime + loopSettings.RadioLoopPeriod))
{
lastRadioTime = currentTime;
radio.Update();
systemArmed = radio.Throttle > motorSettings.MinimumOutput;
if (!systemArmed)
logger.Flush();
}
currentTime = DateTime.Now.Ticks;
if (systemArmed && (currentTime >= (lastSensorTime + loopSettings.SensorLoopPeriod)))
{
lastSensorTime = currentTime;
gyro.Update();
accelerometer.Update();
}
currentTime = DateTime.Now.Ticks;
if (systemArmed && (currentTime >= (lastControlTime + loopSettings.ControlAlgorithmPeriod)))
{
lastControlTime = currentTime;
pid.Update(radio.Axes, gyro.Axes, (float) (currentTime - previousTime)/loopSettings.LoopUnit);
previousTime = currentTime;
}
currentTime = DateTime.Now.Ticks;
if (currentTime >= (lastMotorTime + loopSettings.MotorLoopPeriod))
{
if (systemArmed)
mixer.Update(radio.Throttle, pid.Axes);
else
mixer.SetSafe();
lastMotorTime = currentTime;
}
currentTime = DateTime.Now.Ticks;
if (systemArmed && (currentTime >= (lastTelemetryTime + loopSettings.TelemetryLoopPeriod)))
{
telemetryData.Update(gyro.Axes, radio.Axes, pid.Axes, currentTime);
lastTelemetryTime = currentTime;
logger.Write(telemetryData);
}
if (!systemArmed)
pid.ZeroIntegral();
}
}
public ControllerWithAccelerometerDebug(MotorMixer mixer, AxesController pid, Gyro gyro, Accelerometer accelerometer, Radio radio, ControllerLoopSettings loopSettings, MotorSettings motorSettings, ILogger logger)
{
long lastRadioTime = 0;
long lastSensorTime = 0;
long lastControlTime = 0;
long lastMotorTime = 0;
long lastTelemetryTime = 0;
bool systemArmed = false;
Thread.Sleep(1000);
gyro.Zero();
accelerometer.Zero();
var serialPort = new SerialPort("COM1",115200);
serialPort.Open();
while (true)
{
long currentTime = DateTime.Now.Ticks;
if (currentTime >= (lastRadioTime + loopSettings.RadioLoopPeriod))
{
radio.Update();
systemArmed = radio.Throttle > motorSettings.MinimumOutput;
if (!systemArmed)
logger.Flush();
lastRadioTime = currentTime;
}
currentTime = DateTime.Now.Ticks;
if (currentTime >= (lastSensorTime + loopSettings.SensorLoopPeriod))
{
gyro.Update();
accelerometer.Update();
lastSensorTime = currentTime;
}
currentTime = DateTime.Now.Ticks;
if (currentTime >= (lastControlTime + loopSettings.ControlAlgorithmPeriod))
{
if (systemArmed)
pid.Update(radio.Axes, gyro.Axes, (float)(currentTime - lastControlTime) / loopSettings.LoopUnit);
lastControlTime = currentTime;
}
currentTime = DateTime.Now.Ticks;
if (currentTime >= (lastMotorTime + loopSettings.MotorLoopPeriod))
{
if (systemArmed)
mixer.Update(radio.Throttle, pid.Axes);
else
mixer.SetSafe();
lastMotorTime = currentTime;
}
currentTime = DateTime.Now.Ticks;
if (currentTime >= (lastTelemetryTime + loopSettings.TelemetryLoopPeriod))
{
byte[] buffer= new byte[12];
BitConverter.ToBytes(ref buffer, 0, accelerometer.Axes.Pitch);
BitConverter.ToBytes(ref buffer, 4, accelerometer.Axes.Roll);
BitConverter.ToBytes(ref buffer, 8, accelerometer.Axes.Yaw);
serialPort.Write(buffer, 0, buffer.Length);
lastTelemetryTime = currentTime;
}
}
}
public ControllerWithGyroDebug(MotorMixer mixer, AxesController pid, Gyro gyro, Accelerometer accelerometer,Radio radio, ControllerLoopSettings loopSettings, MotorSettings motorSettings, ILogger logger)
{
long lastRadioTime = 0;
long lastSensorTime = 0;
long lastControlTime = 0;
long lastMotorTime = 0;
long lastTelemetryTime = 0;
bool systemArmed = false;
var serialPort = new SerialPort("COM1",115200);
serialPort.Open();
while (true)
{
long currentTime = DateTime.Now.Ticks;
if (currentTime >= (lastRadioTime + loopSettings.RadioLoopPeriod))
{
radio.Update();
systemArmed = radio.Throttle > motorSettings.MinimumOutput;
if (!systemArmed)
logger.Flush();
lastRadioTime = currentTime;
}
currentTime = DateTime.Now.Ticks;
if (currentTime >= (lastSensorTime + loopSettings.SensorLoopPeriod))
{
gyro.Update();
lastSensorTime = currentTime;
}
currentTime = DateTime.Now.Ticks;
if (currentTime >= (lastControlTime + loopSettings.ControlAlgorithmPeriod))
{
if (systemArmed)
pid.Update(radio.Axes, gyro.Axes, (float)(currentTime - lastControlTime) / loopSettings.LoopUnit);
lastControlTime = currentTime;
}
currentTime = DateTime.Now.Ticks;
if (currentTime >= (lastMotorTime + loopSettings.MotorLoopPeriod))
{
if (systemArmed)
mixer.Update(radio.Throttle, pid.Axes);
else
mixer.SetSafe();
lastMotorTime = currentTime;
}
currentTime = DateTime.Now.Ticks;
if (currentTime >= (lastTelemetryTime + loopSettings.TelemetryLoopPeriod))
{
Debug.Print(
//byte[] buffer = System.Text.Encoding.UTF8.GetBytes( //"\r" + currentTime +
//"\tR:" + radio.Axes.Pitch +);
"\rP:" + gyro.Axes.Pitch +
"\rR:" + gyro.Axes.Roll +
"\rY:" + gyro.Axes.Yaw
//"\tP" + pid.Axes.Pitch
);
//serialPort.Write(buffer, 0, buffer.Length);
lastTelemetryTime = currentTime;
}
}
}
