private void NewStreamHandler(INetworkStream stream)
{
var sw = new Stopwatch();
sw.Start();
if (NegotiateTimeout != Timeout.InfiniteTimeSpan)
{
stream.SetDeadline(DateTime.Now.Add(NegotiateTimeout));
}
var result = Mux.Negotiate(((IReadWriter)stream).AsSystemStream());
sw.Stop();
if (NegotiateTimeout != Timeout.InfiniteTimeSpan)
{
stream.SetDeadline(default(DateTime));
}
stream.Protocol = result.Protocol;
// reporter
Task.Factory.StartNew(() => result.Handler.Handle(result.Protocol, ((IReadWriter)stream).AsSystemStream()));
}
public HttpServer(string host, Mux mux)
{
this.Mux = mux;
this.Host = host;
this.Listener = new HttpListener();
Listener.Prefixes.Add(Host);
}
public static void Main(string[] args)
{
// Instance of Bone.Mux()
var router = new Mux();
// Route /index
router.Get("/index", (HttpListenerContext ctx) => {
ResponseHandler.Write(ctx, "Hello " + ctx.Request.UserHostName.ToString());
});
// Route /index/test
router.Post("/index/test", (HttpListenerContext ctx) => {
byte[] body = new byte[] {};
ctx.Request.InputStream.Read(body, 0, (int)ctx.Request.Length);
Console.WriteLine(body);
});
// Route /home
router.Get("/home", (HttpListenerContext ctx) => {
ResponseHandler.Write(ctx, "Hello from the other side");
});
router.Get("/home/:var", (HttpListenerContext ctx) => {
ResponseHandler.Write(ctx, string.Format("You Send {0}", ctx.Request.QueryString.Get(":var")));
});
// Start Bone.HttpServer()
var server = new HttpServer("http://localhost:8080/", router);
server.Listen();
}
/// <summary>
/// アナログ値（バイナリ）を取得する。
/// </summary>
/// <param name="mux">入力マルチプレクサ</param>
/// <param name="dataRate">データーレート</param>
/// <param name="pga">ゲイン</param>
/// <returns>アナログ値（バイナリ）</returns>
public int ReadRaw(Mux mux, DataRate dataRate = DataRate.Sps128, Pga pga = Pga.Fs2048mV)
{
ReadOnlySpan <byte> config = stackalloc byte[]
{
(byte)Register.Config,
(byte)(((byte)SingleShotCoversion.Begin << 7) | ((byte)mux << 4) | ((byte)pga << 1) | (byte)Mode.PowerDownSingleShot),
(byte)(((byte)dataRate << 5) | (byte)ComparatorQueue.Disable)
};
Write(config);
ReadOnlySpan <byte> conversion = stackalloc byte[] { (byte)Register.Conversion };
WriteEx(I2cMasterFlags.Start, conversion);
switch (dataRate)
{
case DataRate.Sps8:
Thread.Sleep(126);
break;
case DataRate.Sps16:
Thread.Sleep(64);
break;
case DataRate.Sps32:
Thread.Sleep(33);
break;
case DataRate.Sps64:
Thread.Sleep(17);
break;
case DataRate.Sps128:
Thread.Sleep(9);
break;
case DataRate.Sps250:
Thread.Sleep(5);
break;
case DataRate.Sps475:
Thread.Sleep(4);
break;
case DataRate.Sps860:
Thread.Sleep(3);
break;
default:
throw new ArgumentOutOfRangeException(nameof(dataRate));
}
Span <byte> readBuffer = stackalloc byte[2];
ReadEx(I2cMasterFlags.RepeatedStart | I2cMasterFlags.Stop, readBuffer);
return((short)((readBuffer[0] << 8) | readBuffer[1]));
}
}
}
public void SetStreamHandler(ProtocolId pid, StreamHandler handler)
{
Mux.AddHandler(pid, (p, rwc) =>
{
var ns = (INetworkStream)rwc;
ns.Protocol = p;
handler(ns);
return(true);
});
}
internal void DeleteMux(Mux mux)
{
var wr = NewWebRequest("api/idnode/delete");
wr.Method = "POST";
var param = "uuid=";
var obj = new Newtonsoft.Json.Linq.JArray();
obj.Add(mux.UUID);
var byteArray = Encoding.UTF8.GetBytes(param + System.Web.HttpUtility.UrlEncode(obj.ToString()));
SetRequestStream(wr, byteArray);
wr.GetResponse();
}
internal void UpdateMux(Mux mux)
{
var wr = NewWebRequest("api/idnode/save");
wr.Method = "POST";
var param = "node=";
var obj = new Newtonsoft.Json.Linq.JObject();
obj["uuid"] = mux.UUID;
obj["iptv_muxname"] = mux.Name;
obj["iptv_url"] = mux.Url;
var byteArray = Encoding.UTF8.GetBytes(param + System.Web.HttpUtility.UrlEncode(obj.ToString()));
SetRequestStream(wr, byteArray);
wr.GetResponse();
}
public List <Mux> GetMuxes()
{
var lst = new List <Mux>();
var wr = CreateRequest("api/mpegts/mux/grid", new GridRequestParameters {
Start = 0, Limit = int.MaxValue
});
var obj = GetJSON(wr);
foreach (var ent in obj["entries"])
{
var m = new Mux();
m.Enabled = ent.Value <bool>("enabled");
m.UUID = ent.Value <string>("uuid");
m.NetworkName = ent.Value <string>("networkname");
m.NetworkUUID = ent.Value <string>("network_uuid");
m.Name = ent.Value <string>("name");
m.Url = ent.Value <string>("iptv_url");
lst.Add(m);
}
return(lst);
}
internal static ExecutionReport Export(string fileName, ConcurrentDictionary <string, ConcurrentDictionary <char, List <AccEntry <int> > > > results, string header, Mux mux = Mux.Join, string separator = "\t")
{
int intervalCount = 0;
_stopWatch.Restart();
if (mux == Mux.Join)
{
if (!File.Exists(fileName))
{
File.Delete(fileName);
}
using (File.Create(fileName)) { }
using (var writter = new StreamWriter(fileName))
{
writter.WriteLine(header);
foreach (var chr in results)
{
foreach (var strand in chr.Value)
{
strand.Value.Sort();
foreach (var interval in strand.Value)
{
writter.WriteLine(chr.Key + separator + interval.Left.ToString() + separator + interval.Right.ToString() + separator + interval.Accumulation.ToString() + separator + strand.Key);
intervalCount++;
}
}
}
}
}
else
{
string chrFile;
foreach (var chr in results)
{
chrFile = Path.GetDirectoryName(fileName) + Path.DirectorySeparatorChar + Path.GetFileNameWithoutExtension(fileName) + "_" + chr.Key + Path.GetExtension(fileName);
if (!File.Exists(chrFile))
{
File.Delete(chrFile);
}
using (File.Create(chrFile)) { }
using (var writter = new StreamWriter(chrFile))
{
writter.WriteLine(header);
foreach (var strand in chr.Value)
{
strand.Value.Sort();
foreach (var interval in strand.Value)
{
writter.WriteLine(chr.Key + separator + interval.Left.ToString() + separator + interval.Right.ToString() + separator + interval.Accumulation.ToString() + separator + strand.Key);
intervalCount++;
}
}
}
}
}
_stopWatch.Stop();
return(new ExecutionReport(intervalCount, _stopWatch.Elapsed));
}
public void RemoveStreamHandler(ProtocolId pid)
{
Mux.RemoveHandler((string)pid);
}
public VHDLDocument Watermark(WatermarkOptions options)
{
var doc = options.WotermarikingDocument.Document;
var IOBuffesLayer = new IOBuffesLayer(_document);
IOBuffesLayer.Parse();
options.WatermarkSettings.ForEach(x => x.Signal = IOBuffesLayer.WhetherEquivalent(x.Signal));
options.SignatureOutputSettings.ForEach(x => x.Signal = IOBuffesLayer.WhetherEquivalent(x.Signal));
List <WatermarkBit> watermarkBits = new List <WatermarkBit>();
options.SignatureOutputSettings.ForEach(ports =>
{
for (int j = 0; j < ports.SignatureCode.Length; j++)
{
if (ports.SignatureCode[j] != '-')
{
var newWB = new WatermarkBit()
{
IsOne = ports.SignatureCode[j] == '1',
Signal =
doc.Router.AssignmentSignal(null, ports.Signal, ports.Signal.Enumeration?.GetBit(j))
};
newWB.Signal.IsSource = false;
watermarkBits.Add(newWB);
}
}
});
//var wbit2 = watermarkBits.FirstOrDefault();
//var routes2 = doc.Router.GetRoutes(wbit2.Signal.Defenition);
//var d = routes2.Signals.Where(signal => signal.IsSource == null).ToList();
//var e = routes2.Signals.Where(signal => signal.IsSource != null && !signal.IsSource.Value).ToList();
//var c = routes2.Signals.Where(signal => signal.IsSource != null && signal.IsSource.Value).ToList();
//-----------------DECODER----------------------------------------
var isWatermark = _document.Router.InserSignalDefenition("IS_WATERMARK", "STD_LOGIC");
var decoder = new Decoder(doc, isWatermark);
var decoderSettings = options.WatermarkSettings.Where(x => x.IsUsed)
.Select(a => new DecoderSignalCode(doc.Router.AssignmentSignal(decoder, a.Signal), a.ActivaionCode))
.ToList();
decoder.CodedSignals.AddRange(decoderSettings);
_document.AddVHDLInBehaviorSection(decoder.ToString());
//-----------------DECODER----------------------------------------
//----------------------Lut work----------------------------------
/**var signatureBus = _document.Router.CreateBus("WATERMARKED_OUT");
* int i = 0;
* options.WotermarikingDocument.FreeLuts.ForEach(lut =>
* {
* ChangeLutConstIputs(lut, isWatermark, options.WotermarikingDocument.ConstValueGenerators);
* ChangeLutInitVector(lut, true);
* var newLutOutput = signatureBus.GetWire(i);
*
* InjectLutOutput(lut, newLutOutput.Defenition);
* i++;
* });
* var watermarkedSignalDefenition = signatureBus.BuildSignal();**/
LUTComponents components = new LUTComponents(doc);
var lutForExtenion = _document.Maps
.Where(map => LUT.IsLUT(map.Entity) && !options.WotermarikingDocument.FreeLuts.Contains(map))
.Select(map => MapLUT.FromMap(map)).ToList();
lutForExtenion.ForEach(lut => lut.ExtendLUT(components)); //Extends lut
var freeInputs = lutForExtenion.Select(x => x.GetFreeInput()).ToList();
List <MapLUT> lutsForInsertion = new List <MapLUT>(lutForExtenion); //Merge all luts
//lutsForInsertion.AddRange(); //AddFreeLut
lutsForInsertion.ForEach(lut =>
{
var watermarkBit = watermarkBits.FirstOrDefault(wb => wb.LUT == null);
if (watermarkBit != null)
{
var port = lut.GetFreeInput(); //TODO
lut.AddLutAssigment(Assignment.Create(lut, port, isWatermark));
lut.ConstValuePort(port, watermarkBit.IsOne);
watermarkBit.LUT = lut;
}
});
//-----------------------------------------------------------------------------------------
watermarkBits.GroupBy(x => x.Signal.Defenition).ToList().ForEach(def =>
{
var ficitonSignal = _document.Router
.InserSignalDefenition(
"FO" + Helper.NewGuidName(),
def.Key.ValueType,
def.Key.Enumeration?.CloneEnumeration());
doc.Router.RedirectAllSources(def.Key, ficitonSignal);
def.ToList().ForEach(wbit =>
{
wbit.RealSignal = doc.Router.GetRoutes(ficitonSignal)
.Signals.FirstOrDefault(x => (x.Enumeration == null && wbit.Signal.Enumeration == null) ||
(x.Enumeration == null && wbit.Signal.Enumeration == null && x.Enumeration.IsSameBus(wbit.Signal.Enumeration)));
Mux mux = new Mux();
mux.To = wbit.Signal;
mux.Condition = doc.Router.AssignmentSignal(mux, isWatermark) + " = '1'";
mux.Else = wbit.RealSignal;
mux.Then = wbit.LUT.GetOutput();
mux.Insert(_document);
});
});
return(_document);
}
private static void PerformAction()
{
switch (mMenu.MenuSelection)
{
case MenuSelection.PrintLabel:
//Tell MUX what channel to write to...
Debug.Print("Set Mux to Channel 0...");
Mux.SetPort(MuxChannel.C0);
Debug.Print("Write Default label to Serial Port...");
mPrinterSerialPort.WriteString(Label.DefaultLabel);
break;
case MenuSelection.Job:
mMenu.DataRecieved = RecievedData.ScannerJobAndSuffix;
//Tell MUX what channel to listen on...
Debug.Print("Set Mux to Channel 1...");
Mux.SetPort(MuxChannel.C1);
Debug.Print("Wait for Job Number from Scanner...");
break;
case MenuSelection.Operation:
mMenu.DataRecieved = RecievedData.ScannerOperation;
//Tell MUX what channel to listen on...
Debug.Print("Set Mux to Channel 1...");
Mux.SetPort(MuxChannel.C1);
Debug.Print("Wait for Operation from Scanner...");
break;
case MenuSelection.ViewPieceWeight:
mMenu.DataRecieved = RecievedData.None;
Debug.Print("Set Menu to Adjust Piece Weight...");
mMenu.MenuSelection = MenuSelection.AdjustPieceWeight;
break;
case MenuSelection.ViewNetWeightAdjustment:
mMenu.DataRecieved = RecievedData.None;
Debug.Print("Set Menu to Adjust Net Weight...");
mMenu.MenuSelection = MenuSelection.AdjustNetWeight;
break;
case MenuSelection.ViewBackLightColor:
mMenu.DataRecieved = RecievedData.None;
Debug.Print("Set Menu to Adjust Background Color...");
mMenu.MenuSelection = MenuSelection.ChangeBackLightColor;
break;
case MenuSelection.ViewNetworkInfo:
mMenu.DataRecieved = RecievedData.None;
Debug.Print("Set Menu to Display Network Info...");
mMenu.MenuSelection = MenuSelection.DisplayNetworkInfo;
Settings.RetrieveNetworkSettings(Microsoft.SPOT.Net.NetworkInformation.NetworkInterface.GetAllNetworkInterfaces()[0]);
break;
case MenuSelection.Reboot:
mMenu.MenuSelection = MenuSelection.Rebooting;
mMenu.DisplayInformation(Settings);
BlinkOnboardLED(3, 300);
Debug.Print("Rebooting...");
PowerState.RebootDevice(false);
break;
}
mMenu.DisplayInformation(Settings);
}
public RedisDb(string connectString)
{
Mux = ConnectionMultiplexer.Connect(connectString);
Db = Mux.GetDatabase();
}
