static private void set_pin(OutputPinConfiguration pin, int state_to_be, int pinstate)
{
if (pinstate != state_to_be)
{
connection.Toggle(pin);
}
}
public static void Main3(string[] args)
{
var driver = GpioConnectionSettings.DefaultDriver;
led1 = ConnectorPin.P1Pin11.Output();
led2 = ConnectorPin.P1Pin13.Output();
buttonPin = ProcessorPin.Pin18;
var filename = @"/usr/share/scratch/Media/Sounds/Electronic/Whoop.wav";
var stream = new MemoryStream();
using (var file = new FileStream(filename, FileMode.Open, FileAccess.Read, FileShare.Read)) {
file.CopyTo(stream);
}
//var player = new SoundPlayer (stream);
var isPlaying = false;
driver.Allocate(buttonPin, PinDirection.Input);
driver.Allocate(led1.Pin, PinDirection.Output);
driver.Allocate(led2.Pin, PinDirection.Output);
bool toggle = true;
while (true)
{
var pressed = !driver.Read(buttonPin);
if (pressed)
{
if (!isPlaying)
{
isPlaying = true;
//stream.Position = 0;
//player.Dispose ();
//player.Stream.Seek (0, SeekOrigin.Begin);
//player.Play ();
Task.Run(() => {
player.Stream.Position = 0;
player.PlaySync();
// isPlaying = false;
});
}
driver.Write(led1.Pin, toggle);
toggle = !toggle;
driver.Write(led2.Pin, toggle);
Console.WriteLine("pushed");
}
else
{
if (isPlaying)
{
player.Stop();
isPlaying = false;
}
driver.Write(led1.Pin, false);
driver.Write(led2.Pin, false);
}
System.Threading.Thread.Sleep(200);
}
driver.Release(ProcessorPin.Pin18);
}
static bool ConnectPort(string[] args)
{
//Connect to the right UART port (may be USB in Windows/Unix/Mac or a Raspberry Mainboard)
if (g_bIoTBoard)
{
//Define pins to control baudrate (GPIO2 on Pin21) and force a HW reset of the MWSUB3G (Pin12)
OutputPinConfiguration pinGPIO2 = ConnectorPin.P1Pin21.Output();
m_pinConnection = new GpioConnection(pinGPIO2);
OutputPinConfiguration pinRESET = ConnectorPin.P1Pin12.Output();
m_pinConnection.Add(pinRESET);
//Reset sequence
m_pinConnection[pinRESET] = false;
Thread.Sleep(100);
m_pinConnection[pinGPIO2] = true; //true for 500Kbps, change to false for 2400bps low speed
m_pinConnection[pinRESET] = true;
Thread.Sleep(2500); //wait for initialization firmware code to finish startup
//Open COM port from Raspberry mainboard
string sCOMPort = "/dev/ttyAMA0";
g_objRFE.ConnectPort(sCOMPort, g_nBaudrate, true);
Console.WriteLine("Connected to port " + sCOMPort);
}
else if (args.Contains("/p:AUTO", StringComparer.Ordinal))
{
//This is any non-IoT platform with a single device connected to USB
if (g_objRFE.GetConnectedPorts())
{
if (g_objRFE.ValidCP2101Ports.Length == 1)
{
bool bForceBaudrate = (RFECommunicator.IsRaspberry() && g_nBaudrate > 115200);
g_objRFE.ConnectPort(g_objRFE.ValidCP2101Ports[0], g_nBaudrate, RFECommunicator.IsUnixLike() && !RFECommunicator.IsMacOS(), bForceBaudrate);
}
}
if (g_objRFE.PortConnected)
{
Console.WriteLine("Connected to port " + g_objRFE.ValidCP2101Ports[0]);
}
else
{
Console.WriteLine("ERROR: no port available, please review your connection");
return(false);
}
}
else
{
//Use specified port from command line
int nPos = Array.FindIndex(args, x => x.StartsWith("/p:"));
if (nPos >= 0)
{
string sCOMPort = args[nPos].Replace("/p:", "");
Console.WriteLine("Trying manual port: " + sCOMPort);
g_objRFE.ConnectPort(sCOMPort, g_nBaudrate, RFECommunicator.IsUnixLike() && !RFECommunicator.IsMacOS());
Console.WriteLine("Connected to port " + sCOMPort);
}
}
return(g_objRFE.PortConnected);
}
public void Setup()
{
redLed = ConnectorPin.P1Pin12.Output();
yellowLed = ConnectorPin.P1Pin16.Output();
greenLed = ConnectorPin.P1Pin18.Output();
leds = new OutputPinConfiguration[] { redLed, greenLed, yellowLed };
conn = new GpioConnection(leds);
}
public void Setup()
{
_redLed = ConnectorPin.P1Pin12.Output();
_yellowLed = ConnectorPin.P1Pin16.Output();
_greenLed = ConnectorPin.P1Pin18.Output();
_leds = new OutputPinConfiguration[] { _redLed, _greenLed, _yellowLed };
_conn = new GpioConnection(_leds);
_conn[_greenLed] = true;
_conn[_yellowLed] = true;
_conn[_redLed] = true;
}
private void Blink(OutputPinConfiguration _ledPin, int count)
{
// GpioConnection.Blink does not work (on rpi2 at least?), so this is my own implementation
bool enable = true;
for (int i = 0; i < count * 2; i++)
{
_conn[_ledPin] = enable;
Thread.Sleep(250);
enable = !enable;
}
_conn[_ledPin] = false;
}
public Lighting(ConfigurationObject.DevicesConfig.LightingConfig config, GpioConnection gpioConnection)
: base(gpioConnection)
{
Description = config.Description;
Floor = config.Floor;
_timerEnabled = config.TimerEnabled;
_offTime = config.OffTime;
_onTime = config.OnTime;
_switchPin = config.SwitchPin.Output().Disable();
_switchPin.Name = config.Description;
_deviceStatus = config.DeviceStatus;
Disabled = config.Disabled;
}
static void Main(string[] args)
{
OutputPinConfiguration pin12 = ConnectorPin.P1Pin12.Output();
pin12.Enabled = false;
using (GpioConnection connection = new GpioConnection(pin12))
{
while (!Console.KeyAvailable)
{
connection.Toggle(pin12);
Thread.Sleep(250);
}
}
}
static StatusLED()
{
try
{ RED_PIN = ConnectorPin.P1Pin12.Output();
GREEN_PIN = ConnectorPin.P1Pin16.Output();
BLUE_PIN = ConnectorPin.P1Pin21.Output();
pins = new OutputPinConfiguration[3];
pins [0] = RED_PIN;
pins [1] = GREEN_PIN;
pins [2] = BLUE_PIN;
cnx = new GpioConnection(pins);
cnx.Open(); }
catch {
}
}
public CommandExecuter(Settings setting)
{
this.setting = setting;
servo = new ProcessStartInfo("/bin/bash");
servo.UseShellExecute = false;
servo.CreateNoWindow = true;
servo.RedirectStandardOutput = true;
servo.RedirectStandardError = true;
#if !DEBUG
pin1 = ConnectorPin.P1Pin38.Output();
pin2 = ConnectorPin.P1Pin40.Output();
connection = new GpioConnection(pin1, pin2);
#endif
}
/// <summary>
/// Add a gpio to the global connection if not already added setting direction
/// </summary>
/// <param name="processorPin"></param>
/// <param name="output"></param>
public static void Add(ProcessorPin processorPin, bool output)
{
//if (!CommonHelper.IsBoard)
// return;
if (output)
{
OutputPinConfiguration opc = processorPin.Output();
ConnectionGlobalPinAdd(opc);
}
else
{
InputPinConfiguration ipc = processorPin.Input();
ConnectionGlobalPinAdd(ipc);
}
}
private static void InitBoardGpio()
{
try
{
_pin11 = ConnectorPin.P1Pin11.Output();
_gpio = new GpioConnection(_pin11);
}
catch (Exception ex)
{
Logger.Error("Error initializing GPIO: " + ex.Message);
if (ex.InnerException != null)
{
Logger.Error(ex.InnerException.Message);
}
}
}
public Shutter(ConfigurationObject.DevicesConfig.ShutterConfig config, GpioConnection gpioConnection)
: base(gpioConnection)
{
Description = config.Description;
Floor = config.Floor;
EmergencyEnabled = config.EmergencyEnabled;
CompleteWayInSeconds = config.CompleteWayInSeconds;
_timerEnabled = config.TimerEnabled;
_onTime = config.OpenTime;
_offTime = config.CloseTime;
_openPin = config.OpenPin.Output().Disable();
_closePin = config.ClosePin.Output().Disable();
_openPin.Name = $"{config.Description}_openPin";
_closePin.Name = $"{config.Description}_closePin";
_deviceStatus = config.DeviceStatus;
Disabled = config.Disabled;
}
public FormBatteryGauge()
{
//ushort d = 0x7fff;
//byte[] byteArray = BitConverter.GetBytes(d).Reverse().ToArray();
//var p = 0.34E-3;
InitializeComponent();
_LTC2943Service = new LTC2943Service();
_LTC2943Service.OnGaugeChanged += _LTC2943Service_OnGaugeChanged;
_LTC2943Service.OnUnderCharge += _LTC2943Service_OnUnderCharge;
_gpioConnectionGlobalPin = new GpioConnection();
OutputPinConfiguration opc = ProcessorPin.Gpio06.Output();
_gpioConnectionGlobalPin.Add(opc);
_modemResetPin = _gpioConnectionGlobalPin.Pins[ProcessorPin.Gpio06];
}
public clsRinger(OutputPinConfiguration RingerPower, OutputPinConfiguration RingerOscillator, float[] RingPattern = null)
{
if (RingPattern == null)
{
RingPattern = ringPattern_UK;
}
ringPattern = RingPattern;
RingerPowerPin = RingerPower;
RingerOscillatorPin = RingerOscillator;
var GPIOconfig = new GpioConnectionSettings();
GPIO = new GpioConnection(GPIOconfig, RingerPowerPin, RingerOscillatorPin);
RingerThread = new Thread(Ring);
RingerThread.IsBackground = true;
RingerThread.Name = "Ringer Thread";
}
static void Main()
{
Console.WriteLine("Initializing GPIO Connection...");
//create a connection to the desired GPIO pins
//refer to the pinouts diagram for the correct pin
OutputPinConfiguration red = ConnectorPin.P1Pin36.Output();
OutputPinConfiguration green = ConnectorPin.P1Pin32.Output();
var connection = new GpioConnection(green, red);
Console.Write("1. Who is the President of the United States? ");
Console.WriteLine("a. Puff Daddy");
Console.WriteLine("b. Hillary Clinton");
Console.WriteLine("c. Barack Obama");
Console.WriteLine("d. George Bush");
string ans = Console.ReadLine().ToLower();
/*if (ans == "c") {
* OutputPinConfiguration led = green;
* }else {
* OutputPinConfiguration led = red;
* }*/
OutputPinConfiguration led = ans == "c" ? green : red;
for (int ctr = 0; ctr < 10; ctr++)
{
connection.Toggle(led);
Thread.Sleep(150);
}
/*Console.WriteLine("Answer: ");*/
/*Console.Write("2. Summer Solstice is the shortest day of the year.");
* Console.WriteLine("a. True");
* Console.WriteLine("b. False");
* string ans = Console.ReadLine().ToLower();
*
* OutputPinConfiguration led = ans == "a" ? green : red;*/
//TODO: Add program code here
connection.Close();
}
/// <summary>
/// Initializes a new instance of the <see cref="Max9744Device" /> class.
/// </summary>
/// <param name="i2cAddress">The i2c address.</param>
/// <param name="mutePin">The mute pin.</param>
/// <param name="shutdownPin">The shutdown pin.</param>
/// <param name="sdaPin">The sda pin.</param>
/// <param name="sclPin">The SCL pin.</param>
/// <param name="gpioConnectionDriverFactory">The gpio connection driver factory.</param>
/// <param name="i2CDeviceConnectionReporter">The i2 c device connection reporter.</param>
public Max9744Device(
byte i2cAddress,
ConnectorPin mutePin,
ConnectorPin shutdownPin,
ProcessorPin sdaPin,
ProcessorPin sclPin,
IGpioConnectionDriverFactory? gpioConnectionDriverFactory,
II2cDeviceConnectionReporter? i2CDeviceConnectionReporter = null)
{
this.gpioConnectionDriverFactory = GpioConnectionDriverFactory.EnsureGpioConnectionDriverFactory(gpioConnectionDriverFactory);
this.gpioConnectionDriver = this.gpioConnectionDriverFactory.Get();
// connect volume via i2c
this.i2CDriver = new I2cDriver(sdaPin, sclPin);
this.connection = this.i2CDriver.Connect(i2cAddress, i2CDeviceConnectionReporter);
// connect shutdown via gpio
this.mutePin = mutePin.Output().Revert();
this.shutdownPin = shutdownPin.Output().Revert();
this.gpioConnection = new GpioConnection(this.gpioConnectionDriverFactory, this.shutdownPin, this.mutePin);
}
private void Run(string[] args)
{
Console.WriteLine("Press any key to exit...");
var leds = new OutputPinConfiguration[]
{
ProcessorPin.Pin17.Output(),
ProcessorPin.Pin18.Output(),
ProcessorPin.Pin27.Output(),
};
using (var connection = new GpioConnection(leds))
{
while (!Console.KeyAvailable)
{
foreach (var led in leds)
{
connection.Pins[led].Toggle();
System.Threading.Thread.Sleep(500);
connection.Pins[led].Toggle();
}
}
}
}
private void ToogleGPIO(ProcessorPin selectedGPIO)
{
OutputPinConfiguration _gpio = selectedGPIO.Output();
try
{
if (_connectionGlobalPin == null)
{
_connectionGlobalPin = new GpioConnection(_gpio);
}
if (!_connectionGlobalPin.Contains(_gpio))
{
_connectionGlobalPin.Add(_gpio);
}
_connectionGlobalPin.Pins[_gpio].Enabled = !_connectionGlobalPin.Pins[_gpio].Enabled;
CommonHelper.Logger.Info("GPIO {0}: enabled", _connectionGlobalPin.Pins[_gpio].Enabled);
}
catch (Exception e)
{
CommonHelper.Logger.Error(e, "GPIO Error : {0}", e.Message);
}
}
static void Main(string[] args)
{
//create instance of settings object to get settings from config file
Properties.Settings settings = new Properties.Settings();
//set idleTimout to value from PLCupdater.exe.config file
idleTimeout = settings.idleTimeout;
//Initialize timer to shutdown device when idle
timer = new Timer(new TimerCallback(idleShutdown), null, idleTimeout, Timeout.Infinite);
//flag to prevent triggering update while one is already in progress
bool updating = false;
//pin definitions
//blue LED on pin 12, provision as a low-level pin
ProcessorPin blueLED = ConnectorPin.P1Pin12.ToProcessor();
//red LED on pin 18, provision as a low-level pin
ProcessorPin redLED = ConnectorPin.P1Pin18.ToProcessor();
//green LED on pin 16, provision as a managed output
OutputPinConfiguration greenLED = ConnectorPin.P1Pin16.Output();
//create a low-level connection driver for red LED and blue LED
IGpioConnectionDriver driver = GpioConnectionSettings.DefaultDriver;
driver.Allocate(redLED, PinDirection.Output);
driver.Allocate(blueLED, PinDirection.Output);
//turn blue LED on to indicate program is ready
driver.Write(blueLED, true);
//create instance of DF1 protocol serial connection class
DF1Comm.DF1Comm df1 = new DF1Comm.DF1Comm();
//create high-level connection for green LED and buttons
//allows for blinking LEDs and OnStatusChanged events for buttons
GpioConnection gpioConnection = new GpioConnection(greenLED);
//Program A download on pin 15, reverse input so that it's normally open instead of normally closed
//Download program A to PLC when pressed
InputPinConfiguration A_Down = ConnectorPin.P1Pin15.Input()
.Revert()
.OnStatusChanged(a =>
{
//if the button is pressed and update is not currently running, start update
if (a && !updating)
{
//set updating flag to true
updating = true;
//start update to transfer program A to the PLC using serial port from the config
DownloadProgram(df1, driver, gpioConnection, redLED, greenLED, settings.FileA, settings.SerialPort);
//set updating flag back to false
updating = false;
}
});
//Program B download on pin 7, reverse input so that it's normally open instead of normally closed
//Download program B to PLC when pressed
InputPinConfiguration B_Down = ConnectorPin.P1Pin7.Input()
.Revert()
.OnStatusChanged(a =>
{
//if the button is pressed and update is not currently running, start update
if (a && !updating)
{
//set updating flag to true
updating = true;
//start update to transfer program A to the PLC using serial port from the config
DownloadProgram(df1, driver, gpioConnection, redLED, greenLED, settings.FileB, settings.SerialPort);
//set updating flag back to false
updating = false;
}
});
//Progam A upload on pin 13, reverse input so that it's normally open instead of normally closed
//Upload program A from PLC when pressed
var A_Up = ConnectorPin.P1Pin13.Input()
.Revert()
.OnStatusChanged(b =>
{
//if the button is pressed and update is not currently running, start update
if (b && !updating)
{
//set updating flag to true
updating = true;
//start update to transfer program B to the PLC using serial port from the config
//DownloadProgram(df1, driver, gpioConnection, redLED, greenLED, settings.FileB, settings.SerialPort);
UploadProgram(df1, driver, gpioConnection, redLED, greenLED, settings.FileA, settings.SerialPort);
//set updating flag back to false
updating = false;
}
});
//Progam B upload on pin 11, reverse input so that it's normally open instead of normally closed
//Upload program B from PLC when pressed
var B_Up = ConnectorPin.P1Pin11.Input()
.Revert()
.OnStatusChanged(b =>
{
//if the button is pressed and update is not currently running, start update
if (b && !updating)
{
//set updating flag to true
updating = true;
//start update to transfer program B to the PLC using serial port from the config
//DownloadProgram(df1, driver, gpioConnection, redLED, greenLED, settings.FileB, settings.SerialPort);
UploadProgram(df1, driver, gpioConnection, redLED, greenLED, settings.FileB, settings.SerialPort);
//set updating flag back to false
updating = false;
}
});
//add the button configurations to the high-level connection
gpioConnection.Add(A_Up);
gpioConnection.Add(B_Up);
gpioConnection.Add(A_Down);
gpioConnection.Add(B_Down);
//prevent program from exiting
Console.ReadKey();
}
private static void UploadProgram(DF1Comm.DF1Comm df1, IGpioConnectionDriver driver, GpioConnection gpioConnection, ProcessorPin redLED, OutputPinConfiguration greenLED, string filename, string serialPort)
{
startIdleTimer();
//turn on red LED while update is in progress
driver.Write(redLED, true);
//set serial port on DF1 class to serial port specified, e.g. "/dev/ttyUSB0"
df1.ComPort = serialPort;
//detectBaudRate(df1);
//Create new PLCFileDetails object
System.Collections.ObjectModel.Collection <DF1Comm.DF1Comm.PLCFileDetails> PLCFiles = new System.Collections.ObjectModel.Collection <DF1Comm.DF1Comm.PLCFileDetails>();
//byte collection to hold raw data to send to PLC
System.Collections.ObjectModel.Collection <byte> data = new System.Collections.ObjectModel.Collection <byte>();
//try to upload the PLCfiles from the PLC
try
{
PLCFiles = df1.UploadProgramData();
try
{
fileWriter = new System.IO.StreamWriter(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, filename));
for (int i = 0; i < PLCFiles.Count; i++)
{
fileWriter.WriteLine(String.Format("{0:x2}", PLCFiles[i].FileType));
fileWriter.WriteLine(String.Format("{0:x2}", PLCFiles[i].FileNumber));
for (int j = 0; j < PLCFiles[i].data.Length; j++)
{
fileWriter.Write(String.Format("{0:x2}", PLCFiles[i].data[j]));
}
fileWriter.WriteLine();
}
fileWriter.Close();
}
catch (Exception ex)
{
Console.WriteLine("Could not save PLC file. " + ex.Message + " " + ex.StackTrace);
rapidBlink(driver, redLED);
startIdleTimer();
if (fileWriter != null)
{
fileWriter.Close();
}
return;
}
}
//write the error to the console if an error occurs uploading the program
catch (Exception ex)
{
Console.WriteLine("Could not upload PLC file. " + ex.Message + " " + ex.StackTrace);
rapidBlink(driver, redLED);
startIdleTimer();
return;
}
//turn off red LED when upload is complete
driver.Write(redLED, false);
//write a success message to the console if completed without errors
Console.WriteLine("Successful Upload");
//turn on green LED for 5 seconds when update is complete
gpioConnection.Blink(greenLED, TimeSpan.FromSeconds(5));
//reset the idle shutdown timer
startIdleTimer();
return;
}
public Led(OutputPinConfiguration outputPin, IGpioConnectionDriver driver = null)
{
PinConfig = outputPin;
Driver = driver ?? GpioConnectionSettings.DefaultDriver;
Driver.Allocate(PinConfig.Pin, PinDirection.Output);
}
public void Connect()
{
pinConfig = ConnectorPin.P1Pin18.Output();
connection = new GpioConnection(pinConfig);
}
public GpioCaller()
{
led1 = ConnectorPin.P1Pin11.Output();
connection = new GpioConnection(led1);
}
private static void Main(string[] args)
{
Console.CursorVisible = false;
var driver = GpioConnectionSettings.DefaultDriver;
led1 = ConnectorPin.P1Pin11.Output();
led2 = ConnectorPin.P1Pin13.Output();
buttonPin = ProcessorPin.Pin18;
var filename = @"/usr/share/scratch/Media/Sounds/Electronic/ComputerBeeps1.wav";
var stream = new MemoryStream();
using (var file = new FileStream(filename, FileMode.Open, FileAccess.Read, FileShare.Read)) {
file.CopyTo(stream);
}
stream.Position = 0;
//player = new SoundPlayer (filename);
var isPlaying = false;
driver.Allocate(buttonPin, PinDirection.Input);
driver.Allocate(led1.Pin, PinDirection.Output);
driver.Allocate(led2.Pin, PinDirection.Output);
const ConnectorPin triggerPin = ConnectorPin.P1Pin10;
const ConnectorPin echoPin = ConnectorPin.P1Pin08;
Console.WriteLine("HC-SR04 Sample: measure distance");
Console.WriteLine();
Console.WriteLine("\tTrigger: {0}", triggerPin);
Console.WriteLine("\tEcho: {0}", echoPin);
Console.WriteLine();
var interval = GetInterval(args);
//var driver = GpioConnectionSettings.DefaultDriver;
bool toggle = true;
using (var connection = new HcSr04Connection(
driver.Out(triggerPin.ToProcessor()),
driver.In(echoPin.ToProcessor()))) {
while (true)
{
try {
var distance = connection.GetDistance().Centimeters;
if (distance < 100)
{
if (!isPlaying)
{
isPlaying = true;
Task.Run(() => {
stream.Position = 0;
//player = new SoundPlayer(
lock (stream) {
using (player = new SoundPlayer(stream)) {
try {
player.PlaySync();
} catch (Exception ex) {
Console.WriteLine(ex.ToString());
}
Timer.Sleep(TimeSpan.FromSeconds(3));
}
}
isPlaying = false;
});
}
driver.Write(led1.Pin, toggle);
toggle = !toggle;
driver.Write(led2.Pin, toggle);
}
else
{
if (isPlaying)
{
//lock (player) {
// player.Stop ();
//}
//player.Dispose();
// isPlaying = false;
}
driver.Write(led1.Pin, false);
driver.Write(led2.Pin, false);
}
//Console.WriteLine(string.Format(CultureInfo.InvariantCulture, "{0:0.0}cm", distance).PadRight(16));
//Console.CursorTop--;
} catch (TimeoutException e) {
Console.WriteLine("(Timeout): " + e.Message);
}
Timer.Sleep(interval);
}
}
Console.CursorVisible = true;
}
//Downloads program to PLC using specified file name and serial port
private static void DownloadProgram(DF1Comm.DF1Comm df1, IGpioConnectionDriver driver, GpioConnection gpioConnection, ProcessorPin redLED, OutputPinConfiguration greenLED, string filename, string serialPort)
{
startIdleTimer();
//turn on red LED while update is in progress
driver.Write(redLED, true);
//set serial port on DF1 class to serial port specified, e.g. "/dev/ttyUSB0"
df1.ComPort = serialPort;
//detectBaudRate(df1);
//Create new PLCFileDetails object
System.Collections.ObjectModel.Collection <DF1Comm.DF1Comm.PLCFileDetails> PLCFiles = new System.Collections.ObjectModel.Collection <DF1Comm.DF1Comm.PLCFileDetails>();
//Create new PLCFile with the defaults
DF1Comm.DF1Comm.PLCFileDetails PLCFile = default(DF1Comm.DF1Comm.PLCFileDetails);
//try reading the program file using the filename specified
try
{
//create fileReader to read from file
fileReader = new System.IO.StreamReader(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, filename));
//initialize string to hold contents of each line
string line = null;
//byte collection to hold raw data to send to PLC
System.Collections.ObjectModel.Collection <byte> data = new System.Collections.ObjectModel.Collection <byte>();
//loop until the end of the file is reached
//data is read in chunks of 3 lines
//the first line is the FileType
//the second line is the FileNumber
//and the third line is the data
//these are converted into a PLCFile and added to the PLCFiles collection
while (!(fileReader.EndOfStream))
{
//get the contents of the first line
line = fileReader.ReadLine();
//convert hex ascii to byte for FileType
PLCFile.FileType = Convert.ToByte(line, 16);
//get the contents of the second line
line = fileReader.ReadLine();
//convert hex ascii to byte for FileNumber
PLCFile.FileNumber = Convert.ToByte(line, 16);
//get the contents of the third line
line = fileReader.ReadLine();
//clear the data collection
data.Clear();
//loop through the entire line two characters at a time
for (int i = 0; i <= line.Length / 2 - 1; i++)
{
//convert each two character ascii hex byte into a byte and add to data collection
data.Add(Convert.ToByte(line.Substring(i * 2, 2), 16));
}
//create byte array the same length as data collection
byte[] dataC = new byte[data.Count];
//copy data collection to byte array
data.CopyTo(dataC, 0);
//assign byte array to PLCFile data property
PLCFile.data = dataC;
//add the PLCFile to the PLCFiles collection
PLCFiles.Add(PLCFile);
}
//try to download the PLCfiles to the PLC
try
{
df1.DownloadProgramData(PLCFiles);
//set the PLC back to Run mode when download is complete
df1.SetRunMode();
}
//write the error to the console if an error occurs downloading the program
catch (Exception ex)
{
Console.WriteLine("Error Downloading Program. " + ex.Message + " " + ex.StackTrace);
rapidBlink(driver, redLED);
startIdleTimer();
return;
}
//turn off red LED when update is complete
driver.Write(redLED, false);
//write a success message to the console if completed without errors
Console.WriteLine("Successful Download");
//turn on green LED for 5 seconds when update is complete
gpioConnection.Blink(greenLED, TimeSpan.FromSeconds(5));
//reset the idle shutdown timer
startIdleTimer();
fileReader.Close();
return;
}
//catch errors reading the program file
catch (Exception ex)
{
//write the error to the console if an error occurs reading the program file
Console.WriteLine("Error Reading Program File for Download. " + ex.Message + " " + ex.StackTrace);
//blink red LED to indicate problem with upload
rapidBlink(driver, redLED);
//reset the idle shutdown timer
startIdleTimer();
if (fileReader != null)
{
fileReader.Close();
}
return;
}
}
