public MainPageModel()
{
UpdateWeather()
.Subscribe(list =>
{
LastUpdatedList = list;
CityWeatherList = list;
});
// Add some pseudo time based event
var TickEvent = Observable.Interval(TimeSpan.FromMilliseconds(5000));
TickEvent
.Subscribe(_ => Debug.WriteLine("Timer Event"));
// Create Commands -----------------------------------------------
UpdateCommand = ReactiveCommand.CreateFromObservable(() => UpdateWeather());
UpdateCommand
.Subscribe(list => CityWeatherList = list);
UpdateCommand.ThrownExceptions.Subscribe(exception => Debug.WriteLine(exception.Message));
DoSomeImportantOtherTaskCommand = ReactiveCommand.CreateFromTask(async() => await DoSomethingImportant());
TickEvent
.InvokeCommand(DoSomeImportantOtherTaskCommand);
//we want to prevent that any command is executed while one of the others is running
CanFilter = DoSomeImportantOtherTaskCommand.IsExecuting
.Merge(UpdateCommand.IsExecuting)
.DistinctUntilChanged()
.Select(b => !b);
CanFilter.Subscribe(b => Debug.WriteLine("CanFilter: " + b));
FilterCommand = ReactiveCommand.CreateFromTask <string>(async name => await FilterCities(name), CanFilter);
// Filter changes ------------------------------------------------------------------------------
IObservable <string> TextChanging = this.WhenAnyValue(x => x.SearchText)
.Throttle(TimeSpan.FromMilliseconds(500));
TextChanging
.InvokeCommand(FilterCommand);
}
/// <summary>
/// Ruft das Html dieser Spalte für die Kopf-Zeile der Tabelle ab.
/// </summary>
/// <param name="helper">Der HtnmlHelper zum Render mit einer Liste der Einträge der Tabelle als Model.</param>
/// <returns></returns>
public string GetHeadHtml(HtmlHelper <IEnumerable <TGridModel> > helper)
{
TagBuilder headTagBuilder = new TagBuilder("th");
/*Add Attributes*/
foreach (var attribute in _attributes.Keys)
{
headTagBuilder.MergeAttribute(attribute, _attributes[attribute]);
}
foreach (var attribute in _attributesHead.Keys)
{
headTagBuilder.MergeAttribute(attribute, _attributesHead[attribute]);
}
headTagBuilder.MergeAttribute(Grid <TModel, TGridModel> .ATTRIBUTE_COLUMN_NAME, ColumnId);
headTagBuilder.MergeAttribute(Grid <TModel, TGridModel> .ATTRIBUTE_COLUMN_CAN_SORT, CanOrderByColumn.ToString());
headTagBuilder.MergeAttribute(Grid <TModel, TGridModel> .ATTRIBUTE_COLUMN_CAN_FILTER, CanFilter.ToString());
// TODO
headTagBuilder.MergeAttribute(Grid <TModel, TGridModel> .ATTRIBUTE_COLUMN_SAVE_FILTER, true.ToString());
headTagBuilder.MergeAttribute(Grid <TModel, TGridModel> .ATTRIBUTE_COLUMN_SAVE_FILTER_KEY, string.Format("Filter#{0}", GetActualSaveFilterKey(Grid.GridId + "#" + ColumnId)));
/*Der Inhalt entspricht dem Titel*/
headTagBuilder.InnerHtml = GetHeadContent(helper, helper.ViewData.Model);
return(headTagBuilder.ToString());
}
private parseResult parseCanMessage(ref List <byte> ls, ref int idx, out canMessage2 msg)
{
// reset a message
msg = null;
// min length is: marker + 3 id + dlc
const int minPossibleLen = 5;
// check the lenght
if (ls.Count - idx < minPossibleLen)
{
return(parseResult.parseBuffTooLow);
}
// get a marker
byte marker = ls[idx];
int frameIdLen = 0;
bool is29bitId = false;
if (marker == 't')
{
frameIdLen = 3; // 11 bit message
}
else if (marker == 'T') // 29 bit message
{
frameIdLen = 8; // marker + 8b can id + dlc + dlc*2 + 4b timestamp (optionally) + endbyte
is29bitId = true;
}
else
{
return(parseResult.parseWrongParam);
}
int posCanId = 1;
int posDlc = posCanId + frameIdLen;
int posData = posDlc + 1;
if (ls.Count - idx <= posDlc)
{
return(parseResult.parseBuffTooLow);
}
// get dlc
int dlc = char2int(ls[posDlc + idx]);
if (dlc < 0 || dlc > 8)
{
return(parseResult.parseWrongFormat);
}
// calc expecting frame len and try to get eof
// marker + can id + dlc + dlc*2 data + 4b timestamp + endbyte
int expLen = 1 + frameIdLen + 1 + dlc * 2 + 4 + 1;
if (ls.Count - idx < expLen)
{
return(parseResult.parseBuffTooLow);
}
if (ls[expLen - 1 + idx] != '\r')
{
// it is possible that timestamp is disabled
// check it
int lenWithNoTs = expLen - 4;
if (ls[lenWithNoTs - 1 + idx] == '\r')
{
//ls.RemoveRange(0, lenWithNoTs);
idx += lenWithNoTs;
return(parseResult.parseNoTimeStamp);
}
return(parseResult.parseWrongFormat);
}
// the frame looks great, parse it
int canId = 0;
for (int i = 0; i < frameIdLen; i++)
{
canId |= char2int(ls[posCanId + i + idx]) << ((frameIdLen - 1 - i) * 4);
}
if (CanFilter.Contains(canId, dlc, is29bitId))
{
idx += expLen;
return(parseResult.parseFiltered);
}
byte[] data = new byte[dlc];
for (int i = 0; i < dlc; i++)
{
int b = char2int(ls[posData + idx + i * 2]) << 4 | char2int(ls[posData + idx + i * 2 + 1]);
data[i] = (byte)b;
}
int posTs = posData + dlc * 2;
int ts = 0;
for (int i = 0; i < 4; i++)
{
ts |= char2int(ls[posTs + i + idx]) << ((4 - 1 - i) * 4);
}
// there is a bug with timestamps:
// t 1 0 0 8 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 2 5 F E
// t 1 0 0 8 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 2 5 0 0
// t 1 0 0 8 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 2 6 0 0
// t 1 0 0 8 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 2 6 0 1
// timestamp correction
if (ts_prev >= 0 && ts < ts_prev)
{
if (((ts & 0x00FF) == 0) && ((ts & 0xF000) == (ts_prev & 0xF000)))
{
// looks like correction is required
// how much should we add? 0x100
int tmp = ts;
ts += 0x100;
//Debug.WriteLine(string.Format("Ts correction: prev {0}, cur {1}, new {2}",
// ts_prev, tmp, ts));
}
}
// create a message
msg = new canMessage2(canId, is29bitId, data, ts);
// calculate an absolute ts value
int ts_since_start = 0;
long now = DateTimeOffset.Now.ToUnixTimeMilliseconds();
if (ts_unix_prev > 0)
{
ts_since_start = ts - ts_offset;
ts_since_start += 60000 * ts_mul;
long unix_diff = now - ts_unix_prev;
// update mul
if (unix_diff > 60000)
{
while (unix_diff > 60000)
{
ts_mul++;
ts_since_start += 60000;
unix_diff -= 60000;
}
}
else if (ts < ts_prev)
{
ts_mul++;
ts_since_start += 60000;
}
}
else
{
ts_offset = ts;
}
// set
msg.timestamp_absolute = ts_since_start;
// update
ts_unix_prev = now;
ts_prev = ts;
//Debug.WriteLine(string.Format("TS = {0}, can = {1}", ts_since_start, ts));
// remove bytes
idx += expLen;
return(parseResult.parseOk);
}
