/// <summary>
/// Power off the device if GPIO controller and power enable pin is provided.
/// </summary>
public void PowerOff()
{
if (_powerEnablePin == -1)
{
throw new InvalidOperationException("Cannot power off without providing GPIO controller and power enable pin.");
}
_gpioController?.Write(_powerEnablePin, PinValue.Low);
}
private void OpenPinAndWrite(int pin, PinValue value)
{
_controller?.OpenPin(pin, PinMode.Output);
_controller?.Write(pin, value);
}
/// <summary>
/// Read through One-Wire
/// </summary>
internal virtual void ReadThroughOneWire()
{
byte readVal = 0;
uint count;
// keep data line HIGH
_controller.SetPinMode(_pin, PinMode.Output);
_controller.Write(_pin, PinValue.High);
DelayHelper.DelayMilliseconds(20, true);
// send trigger signal
_controller.Write(_pin, PinValue.Low);
// wait at least 18 milliseconds
// here wait for 18 milliseconds will cause sensor initialization to fail
DelayHelper.DelayMilliseconds(20, true);
// pull up data line
_controller.Write(_pin, PinValue.High);
// wait 20 - 40 microseconds
DelayHelper.DelayMicroseconds(30, true);
_controller.SetPinMode(_pin, PinMode.InputPullUp);
// DHT corresponding signal - LOW - about 80 microseconds
count = _loopCount;
while (_controller.Read(_pin) == PinValue.Low)
{
if (count-- == 0)
{
IsLastReadSuccessful = false;
return;
}
}
// HIGH - about 80 microseconds
count = _loopCount;
while (_controller.Read(_pin) == PinValue.High)
{
if (count-- == 0)
{
IsLastReadSuccessful = false;
return;
}
}
// the read data contains 40 bits
for (int i = 0; i < 40; i++)
{
// beginning signal per bit, about 50 microseconds
count = _loopCount;
while (_controller.Read(_pin) == PinValue.Low)
{
if (count-- == 0)
{
IsLastReadSuccessful = false;
return;
}
}
// 26 - 28 microseconds represent 0
// 70 microseconds represent 1
_stopwatch.Restart();
count = _loopCount;
while (_controller.Read(_pin) == PinValue.High)
{
if (count-- == 0)
{
IsLastReadSuccessful = false;
return;
}
}
_stopwatch.Stop();
// bit to byte
// less than 40 microseconds can be considered as 0, not necessarily less than 28 microseconds
// here take 30 microseconds
readVal <<= 1;
if (!(_stopwatch.ElapsedTicks * 1000000F / Stopwatch.Frequency <= 30))
{
readVal |= 1;
}
if (((i + 1) % 8) == 0)
{
_readBuff[i / 8] = readVal;
}
}
_lastMeasurement = Environment.TickCount;
if ((_readBuff[4] == ((_readBuff[0] + _readBuff[1] + _readBuff[2] + _readBuff[3]) & 0xFF)))
{
IsLastReadSuccessful = (_readBuff[0] != 0) || (_readBuff[2] != 0);
}
else
{
IsLastReadSuccessful = false;
}
}
/// <summary>
/// Effectively the start button for the AWS software. Initialises everything and begins
/// AWS operation.
/// </summary>
public async Task Startup()
{
LogMessage("Startup ------------");
try { await config.LoadAsync(); }
catch (Exception ex)
{
LogException(ex);
return;
}
gpio = new GpioController(PinNumberingScheme.Logical);
gpio.OpenPin(config.dataLedPin, PinMode.Output);
gpio.Write(config.dataLedPin, PinValue.Low);
gpio.OpenPin(config.errorLedPin, PinMode.Output);
gpio.Write(config.errorLedPin, PinValue.Low);
try
{
clock = new Clock(config.clockTickPin, gpio);
clock.Open();
if (clock.IsTimeValid)
{
LogMessage("Clock time is " +
clock.Time.ToString("yyyy-MM-dd HH:mm:ss"));
}
else
{
gpio.Write(config.errorLedPin, PinValue.High);
LogMessage("Clock time is not valid");
return;
}
}
catch (Exception ex)
{
gpio.Write(config.errorLedPin, PinValue.High);
LogException(ex);
return;
}
if (!StartupFileSystem())
{
return;
}
dataLogger = new DataLogger(config, clock, gpio);
dataLogger.DataLogged += DataLogger_DataLogged;
if (!dataLogger.Open())
{
for (int i = 0; i < 5; i++)
{
gpio.Write(config.errorLedPin, PinValue.High);
Thread.Sleep(250);
gpio.Write(config.errorLedPin, PinValue.Low);
Thread.Sleep(250);
}
}
Thread.Sleep(1500);
gpio.Write(config.dataLedPin, PinValue.High);
gpio.Write(config.errorLedPin, PinValue.High);
Thread.Sleep(2500);
gpio.Write(config.dataLedPin, PinValue.Low);
gpio.Write(config.errorLedPin, PinValue.Low);
Thread.Sleep(1500);
try
{
dataLogger.Start();
}
catch
{
gpio.Write(config.errorLedPin, PinValue.High);
LogMessage("Failed to start data logger");
return;
}
Console.ReadKey();
}
/// <summary>
/// Initializes the ModuleClient and sets up the callback to receive
/// messages containing temperature information
/// </summary>
static async Task Init()
{
_deviceId = System.Environment.GetEnvironmentVariable("IOTEDGE_DEVICEID");
_moduleId = Environment.GetEnvironmentVariable("IOTEDGE_MODULEID");
Console.WriteLine();
Console.WriteLine(" _ _ _ _ _ _ __ _ ");
Console.WriteLine(" (_)___| |_ ___ ___ __| |__ _ ___ ___| |__ ___ ___ _ _| (_)/ _| |_ ");
Console.WriteLine(" | / _ \\ _|___/ -_) _` / _` / -_)___| '_ \\/ -_) -_) '_| | | _| _|");
Console.WriteLine(" |_\\___/\\__| \\___\\__,_\\__, \\___| |_.__/\\___\\___|_| |_|_|_| \\__|");
Console.WriteLine(" |___/ ");
Console.WriteLine();
Console.WriteLine(" Copyright © 2020 - josa josa josa");
Console.WriteLine(" ");
MqttTransportSettings mqttSetting = new MqttTransportSettings(TransportType.Mqtt_Tcp_Only);
ITransportSettings[] settings = { mqttSetting };
//// Open a connection to the Edge runtime
ModuleClient ioTHubModuleClient = await ModuleClient.CreateFromEnvironmentAsync(settings);
// Attach callback for Twin desired properties updates
await ioTHubModuleClient.SetDesiredPropertyUpdateCallbackAsync(onDesiredPropertiesUpdate, ioTHubModuleClient);
// Execute callback method for Twin desired properties updates
var twin = await ioTHubModuleClient.GetTwinAsync();
await onDesiredPropertiesUpdate(twin.Properties.Desired, ioTHubModuleClient);
Console.WriteLine("Device twin initialized.");
await ioTHubModuleClient.OpenAsync();
Console.WriteLine($"Module '{_deviceId}'-'{_moduleId}' initialized.");
Console.WriteLine("Attached routing output: output1.");
//// Initialize GPIO
_controller = new GpioController();
_controller.OpenPin(UpRelayPin, PinMode.Output);
_controller.OpenPin(DownRelayPin, PinMode.Output);
_controller.OpenPin(FloodedPin, PinMode.Input);
_controller.Write(UpRelayPin, PinValue.High); //by default high
_controller.Write(DownRelayPin, PinValue.High); //by default high
Console.WriteLine("Default GPIO relays Initialized.");
//// Direct methods
await ioTHubModuleClient.SetMethodHandlerAsync(
"Up",
UpMethodCallBack,
ioTHubModuleClient);
Console.WriteLine("Attached method handler: Up.");
await ioTHubModuleClient.SetMethodHandlerAsync(
"Down",
DownMethodCallBack,
ioTHubModuleClient);
Console.WriteLine("Attached method handler: Down.");
await ioTHubModuleClient.SetMethodHandlerAsync(
"Ambiant",
AmbiantValuesMethodCallBack,
ioTHubModuleClient);
Console.WriteLine("Attached method handler: Ambiant.");
await ioTHubModuleClient.SetMethodHandlerAsync(
"Circus",
CircusMethodCallBack,
ioTHubModuleClient);
Console.WriteLine("Attached method handler: Circus.");
await ioTHubModuleClient.SetMethodHandlerAsync(
"Advertise",
AdvertiseMethodCallBack,
ioTHubModuleClient);
Console.WriteLine("Attached method handler: Advertise.");
await ioTHubModuleClient.SetMethodHandlerAsync(
"FindEmptySlot",
FindEmptySlotMethodCallBack,
ioTHubModuleClient);
Console.WriteLine("Attached method handler: FindEmptySlot.");
await ioTHubModuleClient.SetMethodHandlerAsync(
"MarkPosition",
MarkPositionMethodCallBack,
ioTHubModuleClient);
Console.WriteLine("Attached method handler: MarkPosition.");
await ioTHubModuleClient.SetMethodHandlerAsync(
"BottleHolders",
BottleHoldersMethodCallBack,
ioTHubModuleClient);
Console.WriteLine("Attached method handler: BottleHolders.");
await ioTHubModuleClient.SetMethodHandlerAsync(
"Roulette",
RouletteMethodCallBack,
ioTHubModuleClient);
Console.WriteLine("Attached method handler: Roulette.");
SetupI2CRead();
SetupI2CWrite();
//// start reading beer state
if (_mcp23xxxRead != null)
{
var thread = new Thread(() => ThreadBody(ioTHubModuleClient));
thread.Start();
}
if (_liftState == LiftState.Unknown)
{
// move the lift down (initial state) in case of 'unknown' state
await DownMethodCallBack(null, ioTHubModuleClient);
}
}
/// <summary>
/// Start a reading
/// </summary>
/// <returns>
/// <c>true</c> if read is successfull, otherwise <c>false</c>.
/// </returns>
public bool ReadData()
{
// Set the max value for waiting micro second
// 27 = debug
// 99 = release
byte waitMS = 99;
#if DEBUG
waitMS = 27;
#endif
_stopwatch.Start();
PinValue lststate = PinValue.High;
uint counter = 0;
byte j = 0, i;
for (i = 0; i < 5; i++)
{
_dht11Val[i] = 0;
}
// write on the pin
_controller.SetPinMode(_pin, PinMode.Output);
_controller.Write(_pin, PinValue.Low);
//wait 18 milliseconds
Wait(18);
_controller.Write(_pin, PinValue.High);
// Wait about 40 microseconds
Wait(0.03);
_controller.SetPinMode(_pin, PinMode.Input);
for (i = 0; i < MAX_TIME; i++)
{
counter = 0;
while (_controller.Read(_pin) == lststate)
{
counter++;
// This wait about 1 microsecond
// No other way to do it for such a precision
for (byte wt = 0; wt < waitMS; wt++)
{
;
}
if (counter == MAX_WAIT)
{
break;
}
}
lststate = _controller.Read(_pin);
if (counter == MAX_WAIT)
{
break;
}
// top 3 transistions are ignored
if ((i >= 4) && (i % 2 == 0))
{
_dht11Val[j / 8] <<= 1;
if (counter > 16)
{
_dht11Val[j / 8] |= 1;
}
j++;
}
}
_stopwatch.Stop();
if ((j >= 40) && (_dht11Val[4] == ((_dht11Val[0] + _dht11Val[1] + _dht11Val[2] + _dht11Val[3]) & 0xFF)))
{
IsLastReadSuccessful = (_dht11Val[0] != 0) || (_dht11Val[2] != 0);
}
else
{
IsLastReadSuccessful = false;
}
return(IsLastReadSuccessful);
}
public void Write(PinValue pinValue)
{
_controller.Write(_pinNumber, pinValue);
}
protected void PowerUp() => gpioController.Write(pinNumber, PinValue.High);
public static void Main()
{
//var gcode = " G1 X5453 Y3423.423";
//var code = GCode.FromLine(gcode);
//Console.WriteLine("Hello, .NET on PI!");
//return;
var controller = new GpioController(PinNumberingScheme.Board);
var stopwatch = Stopwatch.StartNew();
//Thread.SpinWait();
var thread = new Thread(() => { });
thread.Priority = ThreadPriority.Highest;
thread.Name = "Stepper Worker";
const int dirPin = 15;
const int dirPin2 = 18;
const int stepPin = 13;
const int stepPin2 = 16;
controller.OpenPin(dirPin, PinMode.Output);
controller.OpenPin(dirPin2, PinMode.Output);
controller.OpenPin(stepPin, PinMode.Output);
controller.OpenPin(stepPin2, PinMode.Output);
controller.Write(dirPin, PinValue.High);
controller.Write(dirPin2, PinValue.High);
controller.Write(stepPin, PinValue.Low);
controller.Write(stepPin2, PinValue.Low);
while (true)
{
Console.Write("high=");
var delay1 = int.Parse(Console.ReadLine() !) * 1000;
Console.Write("dir?");
var dir = string.IsNullOrEmpty(Console.ReadLine());
controller.Write(dirPin, dir);
controller.Write(dirPin2, dir);
for (var i = 0; i < 400 * 20; i++)
{
controller.Write(stepPin, PinValue.High);
controller.Write(stepPin2, PinValue.High);
Sleep(delay1);
controller.Write(stepPin, PinValue.Low);
controller.Write(stepPin2, PinValue.Low);
Sleep(delay1);
//Console.Write('.');
}
Console.WriteLine();
}
controller.ClosePin(dirPin);
controller.ClosePin(stepPin);
//controller.OpenPin(kotiPin, PinMode.Output);
// for (var index = 0;; index++)
// {
// var pinValue = index % 2 == 0 ? PinValue.High : PinValue.Low;
// Console.WriteLine(pinValue);
// controller.Write(kotiPin, pinValue);
// Thread.Sleep(TimeSpan.FromSeconds(1));
// }
void Sleep(int delayTicks)
{
var now = stopwatch.ElapsedTicks;
while (stopwatch.ElapsedTicks - now < delayTicks)
{
GC.KeepAlive(stopwatch);
}
}
}
public void Forward()
{
_controller.Write(_in1, PinValue.Low);
_controller.Write(_in2, PinValue.High);
}
private PinValue WriteByte(byte data)
{
// We send data by 8 bits
for (byte i = 0; i < 8; i++)
{
_controller.Write(_pinClk, PinValue.Low);
DelayHelper.DelayMicroseconds(ClockWidthMicroseconds, true);
// LSB first
if ((data & 0x01) == 0x01)
{
_controller.Write(_pinDio, PinValue.High);
}
else
{
_controller.Write(_pinDio, PinValue.Low);
}
// LSB first
data >>= 1;
_controller.Write(_pinClk, PinValue.High);
DelayHelper.DelayMicroseconds(ClockWidthMicroseconds, true);
}
// Wait for the acknowledge
_controller.Write(_pinClk, PinValue.Low);
_controller.Write(_pinDio, PinValue.High);
_controller.Write(_pinClk, PinValue.High);
DelayHelper.DelayMicroseconds(ClockWidthMicroseconds, true);
_controller.SetPinMode(_pinDio, PinMode.Input);
// Wait 1 µs, it's the waiting time between clk up and down
// That's according to the documentation
DelayHelper.DelayMicroseconds(ClockWidthMicroseconds, true);
var ack = _controller.Read(_pinDio);
if (ack == PinValue.Low)
{
// We get acknowledge from the device
_controller.SetPinMode(_pinDio, PinMode.Output);
_controller.Write(_pinDio, PinValue.Low);
}
_controller.Write(_pinClk, PinValue.High);
DelayHelper.DelayMicroseconds(ClockWidthMicroseconds, true);
_controller.Write(_pinClk, PinValue.Low);
DelayHelper.DelayMicroseconds(ClockWidthMicroseconds, true);
_controller.SetPinMode(_pinDio, PinMode.Output);
return(ack);
}
