/// <summary>
/// Gets a value wether the specified digital pin is sampled in this frame.
/// </summary>
public bool HadDigitalPinSample(Pins pin)
{
byte position = digitalPinMaskDictionary[pin];
int mask = (int)System.Math.Pow(2, position);
return (mask & DigitalMask) != 0;
}
public int AnalogRead(Pins pin)
{
Response result = Post(Functions.analogread,
String.Format(payloadRead, HttpUtility.UrlEncode(AccessToken), HttpUtility.UrlEncode(pin.ToString())));
return result.ReturnValue;
}
public RelayDeviceBase(Pins relayXBeePin1, Pins relayXBeePin2, Pins relayXBeePin3)
{
switchStates = new byte[3];
xbeeConfiguration.Add(relayXBeePin1);
xbeeConfiguration.Add(relayXBeePin2);
xbeeConfiguration.Add(relayXBeePin3);
}
/// <summary>
/// Gets a value whether the specified digital pin is high.
/// </summary>
/// <param name="pin"></param>
/// <returns></returns>
public bool IsDigitalPinHigh(Pins pin)
{
byte position = digitalPinMaskDictionary[pin];
int digitalIO = Samples[0] * 256 + Samples[1];
int mask = (int)System.Math.Pow(2, position);
return (mask & digitalIO) != 0;
}
//TODO: [Enhancement] Avoid async void calls!
private async void LoadMotelsLocations()
{
foreach (var item in await _getAllMotels.Invoke())
{
var pinItem = new Pin
{
Position = new Position(item.Latitude, item.Longitude),
Icon = BitmapDescriptorFactory.FromBundle(markerIcon),
Label = item.Name,
Address = addressLabel
};
//TODO: [Enhancement] Map from Domain to UI Model using AutoMapper
Locations.Add(new MotelLocation
{
Pin = pinItem,
Motel = item
});
Pins.Add(pinItem);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="Subcircuit"/> class.
/// </summary>
/// <param name="name">The name.</param>
public Subcircuit(string name, Circuit definition, IEnumerable <IPin> pins)
: base(name)
{
_ckt = definition ?? throw new ArgumentNullException(nameof(definition));
if (!_ckt.Solved)
{
_ckt.Solve();
}
// Find the pins in the subcircuit
foreach (var pin in pins)
{
if (pin is RotatingPin rpin)
{
Pins.Add(new[] { $"{pin.Owner.Name}_{pin.Name}" }, pin.Description, new Vector2(rpin.X.Value, rpin.Y.Value), new Vector2(rpin.NormalX.Value, rpin.NormalY.Value));
}
else if (pin is TranslatingPin tpin)
{
Pins.Add(new[] { $"{pin.Owner.Name}_{pin.Name}" }, pin.Description, new Vector2(tpin.X.Value, tpin.Y.Value));
}
}
}
void OnPinListCommand(User user, string[] args)
{
if (args.Length > 1)
{
user.SendChatMessage(Messages.Usage, "/pin list [TYPE]");
return;
}
Pin[] pins = Pins.GetAll();
if (args.Length == 1)
{
PinType type;
if (!Util.TryParseEnum(args[0], out type))
{
user.SendChatMessage(Messages.InvalidPinType, args[0]);
return;
}
pins = pins.Where(pin => pin.Type == type).ToArray();
}
if (pins.Length == 0)
{
user.SendChatMessage("There are no matching pins.");
return;
}
var sb = new StringBuilder();
sb.AppendLine(String.Format("There are <color=#ffd479>{0}</color> matching map pins:", pins.Length));
foreach (Pin pin in pins.OrderBy(pin => pin.GetDistanceFrom(user.Player)))
{
int distance = (int)Math.Floor(pin.GetDistanceFrom(user.Player));
sb.AppendLine(String.Format(" <color=#ffd479>{0} ({1}):</color> {2} (<color=#ffd479>{3}m</color> away)", pin.Name, pin.Type.ToString().ToLowerInvariant(), pin.AreaId, distance));
}
user.SendChatMessage(sb);
}
private void Completed()
{
IsBusy = false;
foreach (var item in Motels)
{
var pinItem = new Pin
{
Position = new Position(item.Latitude, item.Longitude),
Icon = BitmapDescriptorFactory.FromBundle(markerIcon),
Label = item.Name,
Address = addressLabel
};
//TODO: [Enhancement] Map from Domain to UI Model using AutoMapper
Locations.Add(new MotelLocation
{
Pin = pinItem,
Motel = item
});
Pins.Add(pinItem);
}
}
private void AddTappedLocationAndRaise(Position position)
{
if (!_allowedToAddPoint)
{
return;
}
Pins.Add(new TKCustomMapPin {
Position = position, DefaultPinColor = Color.Teal
});
if (Pins.Count <= 1)
{
return; // can't make a line with 1 pin
}
var previous = Pins.Reverse().Skip(1).First();
Polylines.Add(new TKPolyline {
LineCoordinates = new List <Position> {
previous.Position, position
}, Color = Color.Teal, LineWidth = 2
});
}
// ===========================================================================
// = Public Methods
// ===========================================================================
public void ClearSearchResults()
{
// Clear search results.
var pinsToRemove = Pins
.Select((X, I) => new { Index = I, Object = X })
.Where(X => X.Object.IsSearchResult)
.Select(X => X.Index)
.OrderByDescending(X => X)
.ToList();
foreach (var index in pinsToRemove)
{
Pins.RemoveAt(index);
}
SearchResults.Clear();
if (pinsToRemove.Count > 0)
{
RaiseChanged();
}
}
public void StartActionMultithreadAddPinWithNewBoard(ref PinInterestUser objPinUser12)
{
Pins obj = new Pins();
try
{
PinInterestUser objPinUser = (PinInterestUser)objPinUser12;
try
{
lstThreadsAddPinWithNewBoard.Add(Thread.CurrentThread);
lstThreadsAddPinWithNewBoard.Distinct().ToList();
Thread.CurrentThread.IsBackground = true;
}
catch (Exception ex)
{ };
PinInterestUser objPinUseaddpin = objPinUser;
UserPins = ClGlobul.lst_AddnewPinWithNewBoard.FindAll(P => P.Email == objPinUseaddpin.Username).ToList();
if (UserPins.Count == 0)
{
UserPins = ClGlobul.lst_AddnewPinWithNewBoard;
}
foreach (Pins pin in UserPins)
{
if (pin.Niche == objPinUser12.Niches)
{
Thread thread = new Thread(() => ThreadRepinMethod(pin, objPinUser));
thread.Start();
Thread.Sleep(ThreadDelay * 1000);
}
}
}
catch (Exception ex)
{
GlobusLogHelper.log.Error(" Error :" + ex.StackTrace);
}
}
void Calculate(List <Xamarin.Forms.GoogleMaps.Position> list)
{
OnCalculate?.Invoke(this, default(EventArgs));
Polylines.Clear();
var polyline = new Xamarin.Forms.GoogleMaps.Polyline();
foreach (var p in list)
{
polyline.Positions.Add(p);
}
Polylines.Add(polyline);
MoveToRegion(MapSpan.FromCenterAndRadius(new Position(polyline.Positions[0].Latitude, polyline.Positions[0].Longitude), Xamarin.Forms.GoogleMaps.Distance.FromMiles(0.50f)));
var pin = new Xamarin.Forms.GoogleMaps.Pin
{
Type = PinType.Place,
Position = new Position(polyline.Positions.First().Latitude, polyline.Positions.First().Longitude),
Label = "First",
Address = "First",
Tag = string.Empty,
Icon = (Device.RuntimePlatform == Device.Android) ? BitmapDescriptorFactory.FromBundle("ic_taxi.png") : BitmapDescriptorFactory.FromView(new Image()
{
Source = "ic_taxi.png", WidthRequest = 25, HeightRequest = 25
})
};
Pins.Add(pin);
var pin1 = new Xamarin.Forms.GoogleMaps.Pin
{
Type = PinType.Place,
Position = new Position(polyline.Positions.Last().Latitude, polyline.Positions.Last().Longitude),
Label = "Last",
Address = "Last",
Tag = string.Empty
};
Pins.Add(pin1);
}
private void OnMapClicked(object sender, MapClickedEventArgs e)
{
if (!AreaWithin(e.Position))
{
Application.Current.MainPage.DisplayAlert("Warning", "We cannot service your chosen region", "Okay");
return;
}
if (BindingContext is SelectLocationPageViewModel selectLocationVm)
{
selectLocationVm.SelectedLocation = new Location {
lat = e.Position.Latitude, lng = e.Position.Longitude
};
selectLocationVm.SelectionMode = SelectLocationPageViewModel.AddressSelectionMode.Click;
}
if (RoutePins.Count > 1)
{
for (int i = 1; i < RoutePins.Count; i++)
{
RoutePins.RemoveAt(i);
}
Pins.RemoveAt(1);
}
var pin = new CustomPin
{
Label = "Selected Address",
Position = e.Position,
Type = PinType.SavedPin,
ImageUrl = "location_person.png"
};
RoutePins.Add(pin);
Pins.Add(pin);
MoveToRegion(MapSpan.FromCenterAndRadius(e.Position, Distance.FromKilometers(2)));
}
protected ArduinoPin ConfigurePin(int pinNumber, PinMode pinMode, long initialValue = -1)
{
ArduinoPin pin = new ArduinoPin();
pin.PinNumber = pinNumber;
pin.Mode = pinMode;
pin.InitialValue = initialValue;
pin.CurrentValue = -1;
//Check that it doesn't conflict with existing pins
if (!IsPinCompatible(pin))
{
throw new Exception("Cannot configure pin as it is not compatible with existing pins");
}
if (Pins == null)
{
Pins = new List <ArduinoPin>();
}
Pins.Add(pin);
return(pin);
}
private void OnCollectionChanged(object sender, NotifyCollectionChangedEventArgs e)
{
if (e.Action == NotifyCollectionChangedAction.Reset)
{
Pins.Clear();
}
if (e.OldItems != null)
{
foreach (Pin pin in e.OldItems)
{
Pins.Remove(pin);
}
}
if (e.NewItems != null)
{
foreach (Pin pin in e.NewItems)
{
Pins.Add(pin);
}
}
}
private void CustomPins_CollectionChanged(object sender, System.Collections.Specialized.NotifyCollectionChangedEventArgs e)
{
if (e.NewItems != null && e.NewItems.Count > 0)
{
if (Pins != null)
{
foreach (var item in e.NewItems)
{
Pins.Add(item as CustomPin);
((CustomPin)item).Clicked += CustomPin_Clicked;
}
//var firstItem = e.NewItems[0] as CustomPin;
////var moveTo = new MapSpan(firstItem.Position, firstItem.Position.Latitude, firstItem.Position.Longitude);
//var moveTo = MapSpan.FromCenterAndRadius(firstItem.Position, Distance.FromMiles(10));
//MoveToRegion(moveTo);
}
}
if (CustomPins.Count == 0)
{
Pins.Clear();
}
}
private async Task OnLongclickedCommand(Position point)
{
var lat = point.Latitude;
var lng = point.Longitude;
var pin = Pins.LastOrDefault(x => x.Position == point);
if (pin == null)
{
PromptResult result = await UserDialogs.Instance.PromptAsync(string.Format("{0}, {1}", lat, lng), AppResources.DoYouWantToAddNewPin, AppResources.OK, AppResources.Cancel, AppResources.Name);
if (result.Ok)
{
Pins.Add(new Pin()
{
Position = new Position(lat, lng),
Type = PinType.SavedPin,
Label = result.Text,
Tag = string.Empty
});
await _pinService.SaveOrUpdatePinAsync(Pins.Last().ToPinModel());
}
}
}
private void AddTrigger(MidiTrigger trigger)
{
var toRemove = TriggerCollection.Where(x => x.Trigger.PinNumber == trigger.PinNumber).ToList();
toRemove.ForEach(x => TriggerCollection.Remove(x));
TriggerCollection.Add(new MidiTriggerViewModel(_eventAggregator, DrumManager, trigger));
var seriesToRemove = CurrentValuePlot.Series.Where(x => x.Tag as Pins? == trigger.PinNumber).ToList();
seriesToRemove.ForEach(x => CurrentValuePlot.Series.Remove(x));
var newSeries = new LineSeries
{
Title = trigger.PinNumber.ToString(),
Tag = trigger.PinNumber
};
int insertIndex = 0;
for (int i = CurrentValuePlot.Series.Count - 1; i >= 0; i--)
{
Pins currentPin = (Pins)CurrentValuePlot.Series[i].Tag;
if (currentPin < trigger.PinNumber)
{
insertIndex = i + 1;
break;
}
}
CurrentValuePlot.Series.Insert(insertIndex, newSeries);
//public active / inactive
_eventAggregator.GetEvent <TriggerActiveChangedEvent>()
.Publish(new KeyValuePair <Pins, bool>(trigger.PinNumber, trigger.Type != TriggerType.Disabled));
}
public async Task CreateOrUpdatePinAsync(RequestorModel requestor, PinModel pin)
{
var isNew = false;
if (!requestor.PinType.HasValue)
{
requestor.PinType = 0;
}
var found = await _dbContext.Pins.SingleOrDefaultAsync(x => x.HouseholdId == requestor.HouseholdId && x.ProfileId == x.ProfileId && x.PinType == requestor.PinType);
if (found is null)
{
found = new Pins()
{
OpcoId = requestor.OpCoId,
HouseholdId = requestor.HouseholdId,
ProfileId = requestor.ProfileId,
PinType = requestor.PinType.Value
};
isNew = true;
}
found.PinHash = pin.PinHash;
found.PinLocked = pin.PinLocked;
found.PinSalt = pin.PinSalt;
found.LockReason = pin.LockReason;
if (isNew)
{
await _dbContext.Pins.AddAsync(found);
}
await _dbContext.SaveChangesAsync();
var key = _cacheKeyGenerator.GenerateKeyForPin(requestor.OpCoId, requestor.HouseholdId, requestor.ProfileId, requestor.PinType);
_redisClient.Db0.Database.StringSet(key, SerializePinModel(pin));
}
/// <inheritdoc/>
protected override void Draw(SvgDrawing drawing)
{
drawing.Segments(new[]
{
new Vector2(0, 8), new Vector2(0, 6),
new Vector2(-6, 6), new Vector2(6, 6),
new Vector2(-6, 4), new Vector2(6, 4)
});
drawing.Polyline(new[] { new Vector2(-8, 0), new Vector2(-4, 0), new Vector2(-4, 4) });
drawing.Polyline(new[] { new Vector2(8, 0), new Vector2(4, 0), new Vector2(4, 4) });
if (Pins.IsUsed("b"))
{
drawing.Line(new Vector2(0, 4), new Vector2(0, 0));
if (!string.IsNullOrEmpty(Label))
{
drawing.Text(Label, new Vector2(-3, -3), new Vector2(-1, -1));
}
}
else if (!string.IsNullOrEmpty(Label))
{
drawing.Text(Label, new Vector2(0, -3), new Vector2(0, -1));
}
}
public Pca9632(I2C i2c)
{
dev = new SMBusDevice(0x62, i2c);
mode1.Ai = RegisterAutoIncrement.AutoIncrementAllRegisters;
mode1.Sleep = false;
dev.WriteByteDataAsync((byte)Registers.Mode1, mode1.ToByte()).Wait();
// clear PWM values
dev.WriteBufferDataAsync((byte)Registers.Pwm0 | 0x80, new byte[4] {
0x00, 0x00, 0x00, 0x00
}).Wait();
ledOut.Ldr0 = LedOutputState.LedPwm;
ledOut.Ldr1 = LedOutputState.LedPwm;
ledOut.Ldr2 = LedOutputState.LedPwm;
ledOut.Ldr3 = LedOutputState.LedPwm;
dev.WriteByteDataAsync((byte)Registers.LedOut, ledOut.ToByte()).Wait();
Pins.Add(new Pin(this, 0));
Pins.Add(new Pin(this, 1));
Pins.Add(new Pin(this, 2));
Pins.Add(new Pin(this, 3));
}
/// <inheritdoc />
protected override void Draw(SvgDrawing drawing)
{
drawing.Segments(new[]
{
new Vector2(-8, 0), new Vector2(-6, 0),
new Vector2(6, 0), new Vector2(8, 0)
});
drawing.Circle(new Vector2(-5, 0), 1);
drawing.Circle(new Vector2(5, 0), 1);
if (Closed.IsZero())
{
drawing.Line(new Vector2(-4, 0), new Vector2(4, 0));
}
else
{
drawing.Line(new Vector2(-4, 0), new Vector2(4, 4));
}
if (Pins.IsUsed("c"))
{
if (Closed.IsZero())
{
drawing.Line(new Vector2(0, 0), new Vector2(0, 6));
}
else
{
drawing.Line(new Vector2(0, 2), new Vector2(0, 6));
}
}
if (!string.IsNullOrWhiteSpace(Label))
{
drawing.Text(Label, new Vector2(0, -6), new Vector2(0, -1));
}
}
private void Update(ref State currentState, StringBuilder data)
{
if (data.Length == 0)
{
currentState = State.Idle;
return;
}
switch (currentState)
{
case State.Idle:
switch (data.ToString())
{
case "str_length:":
currentState = State.StrLength;
break;
case "var_data:":
currentState = State.VarData;
break;
case "Format:":
currentState = State.Format;
break;
case "Parts:":
currentState = State.Parts;
break;
case "Pins:":
currentState = State.Pins;
break;
case "Nails:":
currentState = State.Nails;
break;
default:
break; // leave in idle state
}
break;
case State.StrLength: // XXX: wtf is this?
break;
case State.VarData: // XXX: wtf is this?
break;
case State.Format: // update contour
{
var str = BoardUtil.SplitLine(data, 2);
var newVert = new Vector2(int.Parse(str[0]), int.Parse(str[1]));
if (TopContour.Count > 0 && TopContour[TopContour.Count - 1] == newVert)
{
break;
}
TopContour.Add(newVert);
break;
}
case State.Parts: // update partsTest
{
var str = BoardUtil.SplitLine(data, 3);
var part = new Part();
part.Name = str[0];
if (part.Name == "...")
{
part.Name = string.Empty;
}
part.Side = BoardUtil.GetSide(int.Parse(str[1]));
part.FirstPin = prevPartLastPin + 1;
part.PinCount = int.Parse(str[2]) - part.FirstPin;
prevPartLastPin = part.FirstPin + part.PinCount - 1;
if (part.Name.Length == 0 && part.PinCount == 1)
{
nailParts.Add(part);
break;
}
Parts.Add(part);
break;
}
case State.Pins: // update pins
{
var str = BoardUtil.SplitLine(data, 5);
var pin = new Pin();
pin.Location = new Vector2(int.Parse(str[0]), int.Parse(str[1]));
pin.Net = int.Parse(str[2]);
//pin.PartIndex = int.Parse(str[3]);
pin.Name = str[4];
Pins.Add(pin);
break;
}
case State.Nails: // update nails
{
// net, x, y, side?, name
var str = BoardUtil.SplitLine(data, 5);
var nail = new Nail();
nail.Location = new Vector2(int.Parse(str[1]), int.Parse(str[2]));
nail.Net = int.Parse(str[0]);
nail.Side = BoardUtil.GetSide(int.Parse(str[3]));
nail.Name = str[4];
if (nail.Name == "...")
{
nail.Name = string.Empty;
}
Nails.Add(nail);
break;
}
}
}
private void Update(ref State currentState, string data)
{
if (data.Length == 0)
{
currentState = State.Idle;
return;
}
switch (currentState)
{
case State.Idle:
{
var str = BoardUtil.SplitLine(data.ToLowerInvariant());
switch (str[0])
{
case "brdout:":
currentState = State.Format;
break;
case "nets:":
currentState = State.Nets;
netNames = new string[int.Parse(str[1])];
break;
case "parts:":
currentState = State.Parts;
Parts.Capacity = int.Parse(str[1]);
break;
case "pins:":
currentState = State.Pins;
Pins.Capacity = int.Parse(str[1]);
break;
case "nails:":
currentState = State.Nails;
Nails.Capacity = int.Parse(str[1]);
break;
default:
break; // leave in idle state
}
break;
}
case State.Format: // update contour
{
var str = BoardUtil.SplitLine(data);
if (str.Length != 2)
{
throw new InvalidDataException();
}
var newVert = new Vector2(int.Parse(str[0]), int.Parse(str[1]));
if (TopContour.Count > 0 && TopContour[TopContour.Count - 1] == newVert)
{
break;
}
TopContour.Add(newVert);
break;
}
case State.Nets:
{
var str = BoardUtil.SplitLine(data);
int id = int.Parse(str[0]) - 1;
netNames[id] = str[1];
break;
}
case State.Parts: // update partsTest
{
// 0 1 2 3 4 5 6
// J3200 6765 430 9462 1386 8754 1
// name ? ? ? ? fp side
var str = BoardUtil.SplitLine(data);
if (str.Length != 7)
{
throw new InvalidDataException();
}
var part = new Part();
part.Name = str[0];
if (part.Name == "...")
{
part.Name = string.Empty;
}
part.Side = BoardUtil.GetSide(int.Parse(str[6]));
part.FirstPin = int.Parse(str[5]);
if (prevPart != null)
{
prevPart.PinCount = part.FirstPin - prevPart.FirstPin;
}
Parts.Add(part);
prevPart = part;
break;
}
case State.Pins: // update pins
{
var str = BoardUtil.SplitLine(data); // X Y net side
if (str.Length != 4)
{
throw new InvalidDataException();
}
var pin = new Pin();
pin.Location = new Vector2(int.Parse(str[0]), int.Parse(str[1]));
pin.Net = int.Parse(str[2]);
pin.Side = BoardUtil.GetSide(int.Parse(str[3]));
if (pin.Side == (BoardSide.Top))
{
pin.Location = new Vector2(pin.Location.X, -pin.Location.Y);
}
if (pin.Net == 0)
{
if (prevNet == 0)
{
throw new InvalidDataException();
}
pin.Net = prevNet;
}
//pin.PartIndex = int.Parse(str[3]);
pin.Name = netNames[pin.Net - 1];
Pins.Add(pin);
prevNet = pin.Net;
break;
}
case State.Nails: // update nails
{
// net, x, y, side?, name
// id, x, y, net, side
var str = BoardUtil.SplitLine(data);
if (str.Length != 5)
{
throw new InvalidDataException();
}
var nail = new Nail();
nail.Id = int.Parse(str[0]);
nail.Location = new Vector2(int.Parse(str[1]), int.Parse(str[2]));
nail.Net = int.Parse(str[3]);
nail.Side = BoardUtil.GetSide(int.Parse(str[4]));
if (nail.Side == (BoardSide.Top))
{
nail.Location = new Vector2(nail.Location.X, -nail.Location.Y);
}
nail.Name = netNames[nail.Net];
if (nail.Name == "...")
{
nail.Name = string.Empty;
}
Nails.Add(nail);
break;
}
}
}
public GetStates DigitalRead(Pins pin)
{
Response result = Post(Functions.digitalread,
String.Format(payloadRead, HttpUtility.UrlEncode(AccessToken), HttpUtility.UrlEncode(pin.ToString())));
switch (result.ReturnValue)
{
case 0:
return GetStates.LOW;
case 1:
return GetStates.HIGH;
default:
return GetStates.FAIL;
}
}
public override string ToString()
{
return(string.Format($"{string.Join("--", Pins.Select(p => $"{p.p1}/{p.p2}"))} :{Strength}"));
}
public void ThreadRepinMethod(Pins pin, PinInterestUser objPinUser)
{
try
{
try
{
lstThreadsAddPinWithNewBoard.Add(Thread.CurrentThread);
lstThreadsAddPinWithNewBoard.Distinct().ToList();
Thread.CurrentThread.IsBackground = true;
}
catch (Exception ex)
{ };
Board = Regex.Split(pin.Board, ":")[0];
if (!string.IsNullOrEmpty(Board))
{
//Board = pin.Board;
BoardNumber = objAddNewPinManager.GetBoardId(Board, ref objPinUser);
if (string.IsNullOrEmpty(BoardNumber))
{
GlobusLogHelper.log.Info(" => [ " + Board + " Not Found. Creating Board ]");
BoardNumber = CreateBoard_new(Board, "Other", ref objPinUser);
BoardNumber = objAddNewPinManager.GetBoardId(Board, ref objPinUser);
}
}
else
{
if (objPinUser.Boards.Count <= 0)
{
objAddNewPinManager.GetBoards(ref objPinUser);
}
if (objPinUser.Boards.Count > 0)
{
Random Boardrnd = new Random();
int BoardNum = 0;
try
{
BoardNum = Boardrnd.Next(0, objPinUser.Boards.Count - 1);
BoardNumber = objPinUser.Boards[BoardNum];
}
catch (Exception ex)
{
//GlobusFileHelper.AppendStringToTextfileNewLine("Error --> StartNewPinCreationMultiThreaded() 1--> " + ex.Message, ApplicationData.ErrorLogFile);
}
}
}
ImageUrl = pin.ImageUrl;
Desc = pin.Description;
string Data = objAddNewPinManager.NewPin(BoardNumber, Desc, ImageUrl, ref objPinUser);
if (Data.Equals("true"))
{
#region AccountReport
string module = "AddPinWithNewBoard";
string status = "Added";
objqm.insertAccRePort(objPinUser.Username, module, "", Board, "", Desc, "", ImageUrl, status, "", "", DateTime.Now);
objAddPinWithBoardDelegate();
#endregion
//GlobusLogHelper.log.Info(" => [ Pin Added To " + Board + " From " + objPinUser.Username + " ]");
try
{
string CSV_Header = "Date" + "," + "UserName" + "," + "Board" + "," + "Description" + "," + "ImageUrl";
string CSV_Data = System.DateTime.Now.ToString() + "," + objPinUser.Username + "," + Board.Replace(",", " ").Replace("'", "") + "," + Desc.Replace(",", " ").Replace("'", "") + "," + ImageUrl.Replace(",", " ").Replace("'", "");
PDGlobals.ExportDataCSVFile(CSV_Header, CSV_Data, Pinpath + "\\NewPin.csv");
}
catch (Exception ex)
{
}
}
else
{
GlobusLogHelper.log.Info(" => [ Pin Not Added To " + Board + " From " + objPinUser.Username + " ]");
}
}
catch (Exception ex)
{
//GlobusFileHelper.AppendStringToTextfileNewLine("Error --> StartNewPinCreationMultiThreaded() 2 --> " + ex.Message, ApplicationData.ErrorLogFile);
}
finally
{
try
{
if (countThreadControllerAddPinWithNewBoard > Nothread_AddPinWithNewBoard)
{
lock (AddPinWithNewBoardObjThread)
{
Monitor.Pulse(AddPinWithNewBoardObjThread);
}
AddPinWithNewBoarddata_count--;
}
}
catch (Exception ex)
{
GlobusLogHelper.log.Error(" Error : " + ex.StackTrace);
}
countThreadControllerAddPinWithNewBoard--;
GlobusLogHelper.log.Info(" => [ PROCESS COMPLETED " + " For " + objPinUser.Username + " ]");
GlobusLogHelper.log.Info("---------------------------------------------------------------------------------------------------------------------------");
}
}
/// <summary>
/// Clones the object.
/// </summary>
/// <returns>A clone of the object.</returns>
public override SpiceObject Clone()
{
var clone = new SubCircuit(Name, (Statements)Statements.Clone(), (ParameterCollection)Pins.Clone(), LineInfo);
foreach (AssignmentParameter defaultParameter in DefaultParameters)
{
clone.DefaultParameters.Add((AssignmentParameter)defaultParameter.Clone());
}
return(clone);
}
public void Clear()
{
Pins.Clear();
Polylines.Clear();
}
public GetStates DigitalWrite(Pins pin, SetStates state)
{
Response result = Post(Functions.digitalwrite,
String.Format(payloadWrite,
HttpUtility.UrlEncode(AccessToken),
HttpUtility.UrlEncode(pin.ToString()), HttpUtility.UrlEncode(state.ToString())));
switch (result.ReturnValue)
{
case -1:
return GetStates.FAIL;
default:
if (state == SetStates.HIGH) return GetStates.HIGH;
return GetStates.LOW;
}
}
public bool AnalogWrite(Pins pin, Int16 val)
{
if (val > 255) val = 255;
if (val < 0) val = 0;
Response result = Post(Functions.analogwrite,
String.Format(payloadWrite,
HttpUtility.UrlEncode(AccessToken),
HttpUtility.UrlEncode(pin.ToString()), HttpUtility.UrlEncode(val.ToString())));
switch (result.ReturnValue)
{
case -1:
return false;
default:
return true;
}
}
private void OnDisable()
{
Pins.ForEach(x => x.SetActive(false));
}
public MidiTrigger(Pins pinNumber)
{
PinNumber = pinNumber;
}
public FadeCommand(Pins pin, byte intensity, byte step, byte delay)
{
Pin = pin;
Intensity = intensity;
Step = step;
Delay = delay;
}
internal void GetGeolocation()
{
var position1 = new Position(-21.380965, -42.690077);
var pin1 = new Pin
{
Type = PinType.Place,
Position = position1,
Label = "Igreja PIB Cataguases",
Address = "Rua Moreira Lima"
};
Pins.Add(pin1);
var position2 = new Position(-21.383045, -42.690513);
var pin2 = new Pin
{
Type = PinType.Place,
Position = position2,
Label = "Casa do Leandro",
Address = "Rua Joaquim Augusto de Almeida",
};
Pins.Add(pin2);
var position3 = new Position(-21.383358, -42.706201);
var pin3 = new Pin
{
Type = PinType.Place,
Position = position3,
Label = "Celula bairro Granjaria",
Address = "Granjaria"
};
Pins.Add(pin3);
var position4 = new Position(-21.374916, -42.690923);
var pin4 = new Pin
{
Type = PinType.Place,
Position = position4,
Label = "Celula bairro Thome",
Address = "Thome"
};
Pins.Add(pin4);
var position5 = new Position(-21.366249, -42.674797);
var pin5 = new Pin
{
Type = PinType.Place,
Position = position5,
Label = "Celula bairro Pampulha",
Address = "Pampulha"
};
Pins.Add(pin5);
var position6 = new Position(-21.262636, -42.681063);
var pin6 = new Pin
{
Type = PinType.Place,
Position = position6,
Label = "Celula bairro Gloria",
Address = "Gloria"
};
Pins.Add(pin6);
var position7 = new Position(-21.262636, -42.681063);
var pin7 = new Pin
{
Type = PinType.Place,
Position = position7,
Label = "Celula bairro Bom Pastor",
Address = "Bom Pastor"
};
Pins.Add(pin7);
var position8 = new Position(-21.391686, -42.681219);
var pin8 = new Pin
{
Type = PinType.Place,
Position = position8,
Label = "Celula Vila Reis",
Address = "Vila Reis"
};
Pins.Add(pin8);
var position9 = new Position(-21.405012, -42.700488);
var pin9 = new Pin
{
Type = PinType.Place,
Position = position9,
Label = "Celula Paraiso",
Address = "Paraiso"
};
Pins.Add(pin9);
}
private async Task OnTextChangedCommand()
{
if (!string.IsNullOrEmpty(SearchText))
{
Pins.Clear();
var Text = SearchText.ToLower();
var PinModels = (await _pinService.GetPinsAsync(App.CurrentUserId))
.Where(x => x.IsFavorite == true && (x.Name.ToLower().Contains(Text) ||
x.Description.ToLower().Contains(Text) || x.Latitude.ToString().Contains(Text) ||
x.Longtitude.ToString().Contains(Text)));
if (PinModels != null)
{
var Filter = CategoryList.Where(x => x.IsSelected == true);
var categoryFilter = new List <int>();
foreach (var category in Filter)
{
categoryFilter.Add(category.ID);
}
if (categoryFilter.Count != 0)
{
ICommand TappedCommand = new Command(ToMapPagePin);
var pins = PinModels.Where(x => categoryFilter.Contains(x.CategoryID));
foreach (PinModel model in pins)
{
Pins.Add(model.ToViewViewModel(TappedCommand));
}
}
else
{
ICommand TappedCommand = new Command(ToMapPagePin);
foreach (PinModel model in PinModels)
{
Pins.Add(model.ToViewViewModel(TappedCommand));
}
}
}
else
{
//do nothing
}
}
else
{
var PinModels = await _pinService.GetPinsAsync(App.CurrentUserId);
if (PinModels != null)
{
var Filter = CategoryList.Where(x => x.IsSelected == true);
var categoryFilter = new List <int>();
foreach (var category in Filter)
{
categoryFilter.Add(category.ID);
}
if (categoryFilter.Count != 0)
{
Pins.Clear();
ICommand TappedCommand = new Command(ToMapPagePin);
var pinModels = PinModels.Where(x => categoryFilter.Contains(x.CategoryID));
foreach (PinModel model in pinModels)
{
Pins.Add(model.ToViewViewModel(TappedCommand));
}
}
else
{
await LoadPinsFromDataBaseAsync();
}
}
else
{
//do nothing
}
}
}
public SineSignal(Pins pin)
{
_xDiff = ((byte)pin) * 3000000.0;
}
/// <summary>
/// Initializes a new instance of the <see cref="Capacitor"/> class.
/// </summary>
/// <param name="name">The name.</param>
public Capacitor(string name)
: base(name)
{
Pins.Add(new[] { "p", "a" }, "The positive pin.", new Vector2(-5, 0), new Vector2(-1, 0));
Pins.Add(new[] { "n", "b" }, "The negative pin.", new Vector2(5, 0), new Vector2(1, 0));
}
public bool SetPortState(Pins pins,PinState pinState)
{
const int DELAY=100;
bool Status=false;
byte ByteToBeOred=0;
if(pinState==PinState.Hi)
ByteToBeOred=1;
switch (pins)
{
case Pins.CS:
Status=myBusPirate.SendUartDataAndCheckReply(new byte[] {(byte)(BPC_ChipSelectPort|ByteToBeOred)} ,DELAY);
break;
case Pins.Clock:
Status=myBusPirate.SendUartDataAndCheckReply(new byte[] {(byte)(BPC_ClockStatus|ByteToBeOred)} ,DELAY);
break;
case Pins.Data:
Status=myBusPirate.SendUartDataAndCheckReply(new byte[] {(byte)(BPC_DataStatus|ByteToBeOred)} ,DELAY);
break;
default:
Status=false;
break;
}
return Status;
}
