|
#region Fields
public event EventHandler<SerialDataEventArgs> NewSerialDataRecieved;
#endregion
Does this answer your question? sorry, I'm still confused about the very different coding compared to C 
If it helps: I've found most of the code in "SerialPortListener" (an older) project on codeproject.com and I hoped to be able to learn from it ... but it seems it not easy doing self-studies
|
|
|
|
|
OK - lets try from a different angle...
What "hooked up" to that event - which method (or function in C parlance)?
Somewhere, there will be a line similar to:
classInstance.NewSerialDataRecieved += ... This could be in your code, or it could have been added automatically to the xxx.designer.cs file when you added the handler via the form designer / properties pane...Events
Show the method and I'll pick out the relevant bits! 
Bad command or file name. Bad, bad command! Sit! Stay! Staaaay...
|
|
|
|
|
OK - you can just post the code here, it's easier to read!
If you breakpoint the _spManager_NewSerialDataRecieved method, does it hit it all?
And does your SerialPortManager class open the port at any time?
Bad command or file name. Bad, bad command! Sit! Stay! Staaaay...
|
|
|
|
|
Yes , the incoming data are displayed completely in the GUI-Textwindow as soon as they arrive.
So I thought it must be easy to hook on
// Send data to whom ever interested
if (NewSerialDataRecieved != null)
NewSerialDataRecieved(this, new SerialDataEventArgs(data));
on this, but I don't see where I find the data ...
// tbData
//
this.tbData.Anchor = ((System.Windows.Forms.AnchorStyles)((((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Bottom)
| System.Windows.Forms.AnchorStyles.Left)
| System.Windows.Forms.AnchorStyles.Right)));
this.tbData.Location = new System.Drawing.Point(12, 260);
this.tbData.Multiline = true;
this.tbData.Name = "tbData";
this.tbData.ScrollBars = System.Windows.Forms.ScrollBars.Vertical;
this.tbData.Size = new System.Drawing.Size(431, 199);
this.tbData.TabIndex = 13;
//
I think the above is the part where the data are written to screen ,,,,
This might be the function where the data-array is filled with bytes ...
/// <summary>
/// EventArgs used to send bytes recieved on serial port
/// </summary>
public class SerialDataEventArgs : EventArgs
{
public SerialDataEventArgs(byte[] dataInByteArray)
{
Data = dataInByteArray;
}
/// <summary>
/// Byte array containing data from serial port
/// </summary>
public byte[] Data;
}
I'm loosing the ground under my feet ...
|
|
|
|
|
Um...tbData is a TextBox?
So it has a Text property?
And this bit of code:
string str = Encoding.ASCII.GetString(e.Data);
tbData.AppendText(str);
Should append the new data to the existing text in the textbox (and it's in an Invoke, so cross threading isn't a problem - well done!)
So put a breakpoint on the line:
int maxTextLength = 1000;
And step through to look at what is happening - you should see the raw data in e.Data as soon as it hits the breakpoint.
Bad command or file name. Bad, bad command! Sit! Stay! Staaaay...
|
|
|
|
|
Thank you so far - I'll be off 'til thursday for an business trip.
I think I will need your help and patience  again.
Bye
Werner
|
|
|
|
|
I'm not planning on going anywhere!
Bad command or file name. Bad, bad command! Sit! Stay! Staaaay...
|
|
|
|
|
public static List<DefCurrency> AllCurrency
{
get
{
using (var db = new RPDBEntities())
{
return db.DefCurrencies.Select(b => new DAL.DTO.DefCurrencyDTO()
{
CreatedBy = b.CreatedBy,
CreatedDate = b.CreatedDate,
CurrencyCode = b.CurrencyCode,
CurrencyName = b.CurrencyName,
CurrencySign = b.CurrencySign,
DecimalPlaces = b.DecimalPlaces
}).ToList();
}
}
my controller class code is:
public List<DefCurrency> GetAllCurrency()
{
List<DefCurrency> myCurrencies = DefCurrency.AllCurrency;
return myCurrencies;
}
i am getting entities from DefCurrencyDTO class but conflict is between list i made in DefCurrency class
Nouman Arshad
modified 19-May-15 9:11am.
|
|
|
|
|
Well, one problem I see is that you're supposed to be returning a ``List<DefCurrency>`` but that's not what your code is doing. You're returning a ``List<DefCurrentDTO>``.
|
|
|
|
|
When looking at your code it's not clear whether there are two or three different types involved:
Are the elements of db.DefCurrencies of type DefCurrency, DefCurrencyDTO or some third type?
If they are of type DefCurrency, it would be trivial: You could just replace it by return db.DefCurrencies.ToList()
If they are of type DefCurrencyDTO or some third type you shouldn't do a "select new DefCurrencyDTO" but "select new DefCurrency".
(Having to deal with three different types in one method would be somewhat strange.)
For mapping types you could use something like Automapper[^] to make your life a bit easier and your code better maintainable.
If the brain were so simple we could understand it, we would be so simple we couldn't. — Lyall Watson
modified 19-May-15 9:14am.
|
|
|
|
|
|
Please take another look at my previous message, I just edited it.
For information on how to use Automapper please refer to its homepage which you find with the Google search I provided you - there's a "getting started guide" linked. And the Google search also shows you a Codeproject-article on using Automapper.
If the brain were so simple we could understand it, we would be so simple we couldn't. — Lyall Watson
|
|
|
|
|
I'm trying to get the list of com port name and the device's name connected to it. (eg: I want to automatically find the COM port for a specific USB device of Fastrack modem M1206B series). In the case where it finds multiple possible ports and i want only finds the port depending on what other usb devices are connected. I tried the following where I get only the list of com ports.
[CODE]
string[] ports = SerialPort.GetPortNames();
foreach (string port in ports)
{
cboCOM.Items.Add(port);
}
[/CODE]
But I need get COMPort only finds the port depending on what other usb devices are connected.
|
|
|
|
|
Not having done anything with USB devices, would this document help? A USB Library to Detect USB Devices[^]
Every day, thousands of innocent plants are killed by vegetarians.
Help end the violence EAT BACON
|
|
|
|
|
|
I used the Nokia E63 and run your code example but still not get the Nokia E63 COMPort. I run my code above to get comport I saw 3 but only 1 COM port COM4 port used to be, you have no way to remove the COM port can not be used ? you see my attach file http://imagizer.imageshack.com/img673/9968/t1MSeT.jpg
|
|
|
|
|
(No forum really fits..)
I'm trying to create a C#-like grammar in GOLD[^] that can handle generics with the same syntax like C# but the '<' is giving me trouble because the LALR-parser runs into a Shift-Reduce-conflict with the '<' used in the production for comparing values.
As I have seen in the C#-grammer-sample* that comes with GOLD you can do some acrobatics with the order of productions and whatnot to force the LALR-parser onto the right track (used for array-declarations there) but I can't figure out a way to make it work here.
* reflecting C# 1.0 I assume; my grammar is derived from it; the "acrobatics" are documented in the section titled "Statement Expressions & Local Variable Declaration"
I don't want to use a different parser because there's an extremely nifty framework (bsn[^]) to base your interpreter on which I'm already using - rather I'd use a different token than '<' to open a generic type argument list.
Here's the grammar, the culprit is on line 40/41 (section titled "Shared by multiple sections"). I realize due to its length it can be seen as a bit of an imposition. Please just don't bother if it doesn't really interest you 
"Case Sensitive" = 'True'
"Character Mapping" = 'Unicode'
"Start Symbol" = <Compilation Unit>
! ----------------------------------------------------------------- Sets
{ID Head} = {Letter} + [_]
{ID Tail} = {AlphaNumeric} + [_]
{String Ch} = {Printable} - ["]
{Lit String Ch} = {All Valid} - ["]
{Char Ch} = {Printable} - ['']
{Hex Digit} = {Digit} + [abcdef] + [ABCDEF]
{Bin Digit} = [01]
{Directive Ch} = {All Valid} - {CR} - {LF}
! ----------------------------------------------------------------- Terminals
Identifier = {ID Head} {ID Tail}*
MemberName = '.' {ID Head} {ID Tail}*
DecLiteral = {Digit}+ ( [UuLl] | [Uu][Ll] | [Ll][Uu] )?
RealLiteral = {Digit}*'.'{Digit}+ ( [dfmDFM] )?
StringLiteral = '"'( {String Ch} | '\'{Printable} )* '"' | '@' ('"' {Lit String Ch}+ '"')+
CharLiteral = '' ( {Char Ch} | '\'{Printable} )''
! ----------------------------------------------------------------- Comments
Comment Line = '//'
Comment Start = '/*'
Comment End = '*/'
! ===========================================================================
! Shared by multiple sections
! ===========================================================================
<Valid ID> ::= Identifier <Generic Type List Opt>
| <Base Type>
<Qualified ID> ::= <Valid ID> <Member List Opt>
<Member List Opt> ::= <Member List Opt> MemberName <Generic Type List Opt>
| !Zero or more
<Generic Type List Opt> ::= '<' <Generic Type List> '>'
|
<Generic Type List> ::= <Generic Type List> ',' <Generic Type>
| <Generic Type>
<Generic Type> ::= <Qualified ID>
! ===========================================================================
! Literals
! ===========================================================================
<Literal> ::= DecLiteral
| RealLiteral
| CharLiteral
| StringLiteral
| true
| false
| null
! ===========================================================================
! Types
! ===========================================================================
! The following defines built-in datatypes only. This is necessary for local
! variable declarations.
<Base Type> ::= <Other Type>
| <Integral Type>
<Other Type> ::= float
| double
| decimal
| bool
| object
| string
| datetime
| var
! Integral types are valid in enumeration declarations.
<Integral Type> ::= sbyte
| byte
| short
| ushort
| int
| uint
| long
| ulong
| char
! ===========================================================================
! C.2.4 Expressions
! ===========================================================================
<Expression Opt> ::= <Expression>
| !Nothing
<Expression List> ::= <Expression> ',' <Expression List>
| <Expression>
<Expression> ::= <Conditional Exp> '=' <Expression>
| <Conditional Exp> '+=' <Expression>
| <Conditional Exp> '-=' <Expression>
| <Conditional Exp> '*=' <Expression>
| <Conditional Exp> '/=' <Expression>
| <Conditional Exp>
<Conditional Exp> ::= <Or Exp> '?' <Or Exp> ':' <Conditional Exp>
| <Or Exp>
<Or Exp> ::= <Or Exp> '||' <And Exp>
| <And Exp>
<And Exp> ::= <And Exp> '&&' <Equality Exp>
| <Equality Exp>
<Equality Exp> ::= <Equality Exp> '==' <Compare Exp>
| <Equality Exp> '!=' <Compare Exp>
| <Compare Exp>
<Compare Exp> ::= <Compare Exp> '<' <Add Exp>
| <Compare Exp> '>' <Add Exp>
| <Compare Exp> '<=' <Add Exp>
| <Compare Exp> '>=' <Add Exp>
! | <Compare Exp> is <Qualified ID> ! <<<<< Shift-Reduce-Conflict
! | <Compare Exp> as <Qualified ID> ! <<<<< Shift-Reduce-Conflict
| <Add Exp>
<Add Exp> ::= <Add Exp> '+' <Mult Exp>
| <Add Exp> '-' <Mult Exp>
| <Mult Exp>
<Mult Exp> ::= <Mult Exp> '*' <Unary Exp>
| <Mult Exp> '/' <Unary Exp>
| <Mult Exp> '%' <Unary Exp>
| <Unary Exp>
<Unary Exp> ::= '!' <Unary Exp>
| '-' <Unary Exp>
| '++' <Unary Exp>
| '--' <Unary Exp>
| '(' <Expression> ')' <Method Exp> ! Cast "expression" is required to avoid a conflict
| <Method Exp>
<Method Exp> ::= <Method Exp> <Method>
| <Primary Exp>
<Primary Exp> ::= new <Qualified ID> '(' <Arg List Opt> ')' ! Non array creation
| '(' <Expression> ')'
| <Primary>
<Primary> ::= <Valid ID> '(' <Arg List Opt> ')' ! Current object method
| <Literal>
! | <Valid ID> ! replaced by <Base Type> / Identifier
| <Base Type>
! | Identifier ! <<<<< Shift-Reduce-Conflict
! ===========================================================================
! Arguments
! ===========================================================================
<Arg List Opt> ::= <Arg List>
| !Nothing
<Arg List> ::= <Argument> ',' <Arg List>
| <Argument>
<Argument> ::= <Expression>
! ===========================================================================
! C.2.5 Statements
! ===========================================================================
<Stm List> ::= <Statement> <Stm List>
| <Statement>
! This repetative productions below resolve the hanging-else problem by
! restricting the "if-then" statement to remove ambiguity. Two levels of
! statements are declared with the second, "restricted", group only used in
! the "then" clause of a "if-then-else" statement.
!
! The "restricted" group is completely identical the the first with one
! exception: only the "if-then-else" variant of the if statement is allowed.
! In other words, no "if" statements without "else" clauses can appear inside
! the "then" part of an "if-then-else" statement. Using this solution, the
! "else" will bind to the last "If" statement, and still allows chaining.
<Statement> ::= <Local Var Decl> ';'
| if '(' <Expression> ')' <Statement>
| if '(' <Expression> ')' <Then Stm> else <Statement>
| for '(' <For Init Opt> ';' <For Condition Opt> ';' <For Iterator Opt> ')' <Statement>
| while '(' <Expression> ')' <Statement>
| <Normal Stm>
<Then Stm> ::= if '(' <Expression> ')' <Then Stm> else <Then Stm>
| for '(' <For Init Opt> ';' <For Condition Opt> ';' <For Iterator Opt> ')' <Then Stm>
| while '(' <Expression> ')' <Then Stm>
| <Normal Stm>
<Normal Stm> ::= try <Block> <Catch Clauses Opt> <Finally Clause Opt>
| break ';'
| continue ';'
| return <Expression Opt> ';'
| display <Expression> ';'
| <Statement Exp> ';'
| <Block>
<Block> ::= '{' <Stm List> '}'
| '{' '}'
<Variable Declarator> ::= Identifier
| Identifier '=' <Expression>
! ===========================================================================
! For Clauses
! ===========================================================================
<For Init Opt> ::= <Local Var Decl>
| <Statement Exp List>
| !Nothing
<For Iterator Opt> ::= <Statement Exp List>
| !Nothing
<For Condition Opt> ::= <Expression>
| !Nothing
<Statement Exp List> ::= <Statement Exp> ',' <Statement Exp List>
| <Statement Exp>
! ===========================================================================
! Catch Clauses
! ===========================================================================
<Catch Clauses Opt> ::= <Catch Clause> <Catch Clauses Opt>
| !Nothing
<Catch Clause> ::= catch '(' <Qualified ID> Identifier ')' <Block>
<Finally Clause Opt> ::= finally <Block>
| !Nothing
! ===========================================================================
! Statement Expressions & Local Variable Declaration
! ===========================================================================
! The complex productions below are able to avoid the shift-reduce error caused
! by declaring an array. The notation used by C# (and the rest of the C++
! family) prevents an array declaration to be distinguished from an array
! assignment statement until a number of characters are read.
!
! a.b.c[2] = "Test"
! a.b.c[] = new String[3]
!
! The system CANNOT make a decision between the two until it is reading the
! contents the [ ... ].
!
! As a result, the local variable declaration below contains the full notation
! for each of the C# methods at the same level as local variable declarations.
! Since the system does not have to reduce UNTIL it is within the [ ... ], no
! shift-reduce error will occur. Nasty, huh?
<Local Var Decl> ::= <Qualified ID> <Variable Declarator>
<Statement Exp> ::= <Qualified ID> '(' <Arg List Opt> ')'
| <Qualified ID> '(' <Arg List Opt> ')' <Methods Opt> <Assign Tail>
| <Qualified ID> '[' <Expression List> ']' <Methods Opt> <Assign Tail>
| <Qualified ID> <Assign Tail>
<Assign Tail> ::= '++'
| '--'
| '=' <Expression>
| '+=' <Expression>
| '-=' <Expression>
| '*=' <Expression>
| '/=' <Expression>
<Methods Opt> ::= <Method> <Methods Opt>
| !Null
<Method> ::= MemberName ! <Generic Type List Opt> ! <<<<< Shift-Reduce-Conflict
! | MemberName <Generic Type List Opt> '(' <Arg List Opt> ')' ! <<<<< Shift-Reduce-Conflict
| '[' <Expression List> ']'
! ===========================================================================
! C.2.6 Namespaces
! ===========================================================================
<Compilation Unit> ::= <Using List Opt> <Compilation Items Opt>
<Using List Opt> ::= <Using Directive> <Using List Opt>
| !Nothing
<Using Directive> ::= using <Qualified ID> ';'
<Compilation Items Opt> ::= <Compilation Item> <Compilation Items Opt>
| ! Zero or more
<Compilation Item> ::= <Method Dec>
| <Statement>
! | '{' <Stm List> '}'
! ===========================================================================
! C.2.7 Classes
! ===========================================================================
<Method Dec> ::= <Qualified ID> Identifier <Generic Type List Opt> '(' <Formal Param List Opt> ')' <Block>
| 'void' Identifier <Generic Type List Opt> '(' <Formal Param List Opt> ')' <Block>
<Formal Param List Opt> ::= <Formal Param List>
| !Nothing
<Formal Param List> ::= <Formal Param> ',' <Formal Param List>
| <Formal Param>
<Formal Param> ::= <Qualified ID> Identifier
edit: grammar updated
If the brain were so simple we could understand it, we would be so simple we couldn't. — Lyall Watson
modified 23-May-15 13:55pm.
|
|
|
|
|
|
No, unfortunately it doesn't help - I'm not writing the parser generator, I have to cope with what it can handle 
Kenneth Haugland wrote: I'm so curious. What you are going to use this for?
Please take a look at my response[^] to Manfred R. Bihy below
If the brain were so simple we could understand it, we would be so simple we couldn't. — Lyall Watson
|
|
|
|
|
Does this GOLD CC allow for multiple token lookahead or is it strictly LALR(1)?
Cheers!
"I had the right to remain silent, but I didn't have the ability!"
Ron White, Comedian
|
|
|
|
|
I've been dabbling for a bit in ANTLR[^] which is actually a Java project by a cool professor. There is also a C# port available, just look here: http://www.antlr.org/download.html[^].
If I remember correctly ANTLR is LL(K) which should help with your problem. I haven't really done any serious work with compilers the last eight years so guess I'm not of to much help there. 
Cheers!
"I had the right to remain silent, but I didn't have the ability!"
Ron White, Comedian
|
|
|
|
|
Quote: Does this GOLD CC allow for multiple token lookahead or is it strictly LALR(1)?
It's strictly LALR(1).
Without knowing too much about parsers I had a gut feeling this might be the issue here. But I'm hoping that it's somehow possible to write the grammar in a way that one lookahead will suffice without butchering the syntax
The reason why I don't want to use another parser generator is that there's a framework/execution engine for GOLD which simplifies and beautifies the code you have to write for your interpreter - take a look at this:
public class If : Statement
{
private readonly Expression _test;
private readonly Statement _falseStatement;
private readonly Statement _trueStatement;
[Rule(@"<Stm> ::= ~if ~'(' <Expr> ~')' <Stm>")]
public If(Expression _test, Statement trueStatement)
: this(_test, trueStatement, null)
{
}
[Rule(@"<Stm> ::= ~if ~'(' <Expr> ~')' <Then Stm> ~else <Stm>")]
[Rule(@"<Then Stm> ::= ~if ~'(' <Expr> ~')' <Then Stm> ~else <Then Stm>")]
public If(Expression test, Statement trueStatement, Statement falseStatement)
{
_test = test;
_trueStatement = trueStatement;
_falseStatement = falseStatement;
}
protected override void DoExecute(IExecutionContext ctx)
{
if (Convert.ToBoolean(_test.GetValue(ctx)))
_trueStatement.Execute(ctx);
else if (_falseStatement != null)
_falseStatement.Execute(ctx);
}
}
You basically have nothing to do than write classes "like that" for your productions, put a Rule-attribute on the constructor(s), feed a source code into a "SematicProcessor"-class of that framework and it'll instantiate all those classes for you representing the fed program and you can call DoExecute(..) on the top node
It's for "yet another embeddable scripting engine" I wrote mainly for self-education. It doesn't bring a whole lot of new features to the table but it has a (IMO) very interesting twist which is why I intend to write an article about it. It's 90% finished (ignoring generics) so I wouldn't want to switch to another parser generator just for being able to replicate the C# syntax for generics - but it would be nice to have because you could just "drop in" existing C# code.
cheers, Sascha
If the brain were so simple we could understand it, we would be so simple we couldn't. — Lyall Watson
|
|
|
|
|
Wow, that rule attribute is sweet! 
Does GOLD also build an abstract syntax tree (AST)?
AST is one of the neat things about ANTLR. You can go over the syntax tree in multiple passes if you wish to and can do all sorts of optimizations on it.
Coming back to your problem: I remember doing some YACC stuff at uni and IIRC you can tell it try the shift first and if that didn't work out it'll do the reduce later.
This is what I found on the GOLD.org site:
Gold.org: Versions 2.4 and later of the GOLD Parser Builder automatically fixes Shift-Reduce Conflicts by not "reducing" when it would cause a conflict. This is the same behavior of the YACC compiler-compiler. It is best to closely check these states to determine if the "shift" is the action wanted.
So what version are you using then?
Cheers!
"I had the right to remain silent, but I didn't have the ability!"
Ron White, Comedian
|
|
|
|
|
Wrong Site URL. It is http://goldparser.org/[^] not gold.org
What do you get when you cross a joke with a rhetorical question?
The metaphorical solid rear-end expulsions have impacted the metaphorical motorized bladed rotating air movement mechanism.
Do questions with multiple question marks annoy you???
|
|
|
|
|
Oh wow, glad you noticed that! Thanks for your, ehemm, contribution! 
"I had the right to remain silent, but I didn't have the ability!"
Ron White, Comedian
|
|
|
|
General 
News 
Suggestion 
Question 
Bug 
Answer 
Joke 
Praise 
Rant 
Admin 
Submit an article or tip
