Henry
Wadsworth Longfellow was the most popular poet in American history.
His work commanded a readership that is almost unimaginable today
even for best-selling novels. In terms of their reach and influence,
Longfellow's poems resembled studio-era Hollywood films: they
were popular works of art enjoyed by huge, diverse audiences that
crossed all social classes and age groups. Writing in a period
before the electronic media usurped the serious literary artist's
role as society's story-teller, Longfellow did as much as any
author or politician of his time to shape the way nineteenth-century
Americans saw themselves, their nation, and their past. At a crucial
time in American historyjust as the Revolutionary War receded
from living memory and the disastrous Civil War inexorably approachedLongfellow
created the national myths for which his new and still unstoried
country hungered. His poems gave his contemporaries the words,
images, myths, and heroes by which they explained America to one
another and themselves. There is no better example of Longfellow's
genius at creating meaningful and enduring national myth than
"Paul Revere's Ride."
The
opening lines of "Paul Revere's Ride" are still so famous
that even people who have not read the entire poem often know
them by heart. They have become, in fact, so familiar that most
readers might easily take them for granted and miss the striking
and paradoxical rhetorical figures they contain. The poem's narrator,
for example, begins by saying, "Listen, my children, and you shall
hear." He addresses the tale specifically to children, and yet
the work is not in any narrow sense a children's poem. "Paul Revere's
Ride" was published in The Atlantic Monthly, hardly a juvenile
journal, and was eventually collected in Longfellow's masterful
book of interwoven narrative poems, Tales of a Wayside Inn
(1863), where it is spoken by the Landlord to an audience
of adult men. Why then does the poem begin by addressing only
one part of its intended audience?
By
invoking children in the opening line of his patriotic poem, Longfellow
implicitly defines his narrative as a story the older generation
considers important enough to pass down to posterity. What will
follow, therefore, is not merely an interesting story but a legacyone
of the traditional tales that defines both the audience and the
speaker's identity. Perhaps for this reason, Longfellow placed
"Paul Revere's Ride" as the first story told in Tales of a
Wayside Inn. The characters in the book meet and tell their
tales at a tavern in Sudbury, Massachusetts, not far from Boston.
Revere's historical exploits would have been a proud part of their
shared local lore.
Longfellow's
inclusion of the date in the third line serves a similar rhetorical
function. (Once again the familiarity of the opening lines makes
us forget how odd it is to present a complete dateday, month,
and yearin a poem. Longfellow never did so elsewhere in
his poetry.) The implicit message of the line is clear: Paul Revere's
achievements were of such singular importance that we must learn
the date by heart and teach it to posterity. Everyone in Longfellow's
original audience would have understood the significance of the
date. April 18, 1775 was the day before the American Revolution
began. The next morning at Lexington and Concord, the American
colonists would fire their "shot heard round the world" and initiate
their successful armed resistance against the British Empire.
The narrator also explains the necessity of passing this piece
of heritage on by reminding the listeners that "hardly a man is
now alive / who remembers that famous day and year." The original
witnesses are now mostly dead. It has become the audience's responsibility
to preserve the memory of Revere's heroic deeds.
Longfellow
was an immensely versatile poet who excelled at virtually every
form and genre from the epic to the sonnet. No form, however,
better displayed his distinctive gifts than the short narrative
poem. Nineteenth century readers greatly esteemed the form, which
combines the narrative pleasures of fiction with the verbal music
of verse. Modern critics, however, have generally downgraded narrative
poetry in favor of lyric verse. Longfellow's reputation has been
especially hard hit by the change in critical consensus, and once
popular poems like "Paul Revere's Ride" have consequently disappeared
from academic anthologies. The special qualities of these poems
seem antithetical to the lyric traditions of modern poetry, which
prize verbal compression, intellectual complexity, elliptical
style, and self-referential movement. Longfellow's greatest gifts
were best suited to more public poetryforceful clarity,
evocative simplicity, emotional directness, and a genius for memorable
(indeed often unforgettable) phrasing.
William
Butler Yeats once commented that Longfellow's popularity came
because "he tells his story or idea so that one needs nothing
but his verses to understand it." That observation particularly
applies to "Paul Revere's Ride," which takes a complicated historical
incident embedded in the politics of Revolutionary America and
retells it with narrative clarity, emotional power, and masterful
pacing. From the poem's first publication, historians have complained
that Longfellow distorted the actual incident and put far too
much emphasis on Revere's individual role. But Longfellow was
not interested in scholarly precision; he wanted to create a stirring
patriotic myth. In the process he took Paul Revere, a regional
folk hero hardly known outside Massachusetts, and turned him into
a national icon. To accomplish this feat, Longfellow mythologized
both the incident and the man. The new Revere became the symbolic
figure who awakens America to fight for freedom. The actual incident,
a literal call to arms for the Revolution, required less mythologization.
After all, revolutions are already the stuff of myth. Longfellow
had only to streamline the historical narrative so that the poem
could focus on a central heroic figure. The resulting storydespite
the scholarly complaintsis actually not too far from fact.
(Longfellow took considerably fewer liberties than Shakespeare
did with British history.) The final poem does not merely recount
an historical incident; it dramatizes unconquerable Yankee individuality
against the old order of European despotism.
Longfellow
was a master of narrative pacing. His description of Revere's
friend climbing the Old North Church tower displays the poet's
ability to make each narrative moment matter. By slowing down
the plot at this crucial moment, Longfellow not only builds suspense;
he also adds evocative physical details that heightens the moods.
(Decades later Hollywood would discover the same procedures.)
Reaching the belfry, the friend startles "the pigeons from their
perch." Fluttering around in they make "masses and moving shapes
of shade." The man now pauses to look down at the graves that
surrounded an eighteenth century churchan image that perhaps,
prefigures the deadly battle to be fought the next day. This lyric
moment of reflection provides a false sense of calm before the
explosive action that will follow. The man now remembers the task
at hand. There is a crucial deed to do.
The
scene now shifts suddenlywith a decisive cinematic cutto
the opposite shore where the solitary Revere waits for the signal.
(What other nineteenth-century American poet would have handled
this transition so boldly?) The historical Revere was one of many
riders, but Longfellow understood the powerful appeal of the single
heroic individual who fights oppression and makes a decisive impact
another narrative lesson not lost on Hollywood. Longfellow's
Revere is not a revolutionary organizer; he is a man of action.
As soon as he sees the first lantern, he springs into the saddle,
though he is smart enough to wait for the second light before
he rides off.
The
rest of the poem is pure actionmostly one long tableau of
Revere's ride from village to town to village. Once again the
effect, to a modern reader, is quintissentially cinematic. Longfellow's
galloping triple meters create a thrilling sense of speed, and
the rhetorical device of stating the time of night when Revere
enters each village adds a cumulative feeling of the rider's urgency.
Few poets could sustain a single, linear action for nearly forty
lines as Longfellow manages so compellingly in the poem's extended
climax. The last two stanzas also demonstrate Longfellow's narrative
authority. As the poet makes the sudden but clear transition from
Revere's arrival in the town of Concord to the following day's
conflict, Longfellow masterfully summarizes the Battle of Concord
in only eight lines. Once again, however, he rhetorically conscripts
the listener to collaborate in completing the story. "You know
the rest," says the narrator, "In the books you have read." Ingeniously,
Longfellow acknowledges the importance of the next day's battle
without accepting the artistic necessity to describe it in detail.
The
final stanza returns to the image of Revere riding through the
night. Now presented outside of the strictly linear chronology
that has hitherto characterized the poem, the galloping Revere
acquires an overtly symbolic quality. He is no longer the historical
figure awakening the Middlesex villages and farms. He has become
a timeless emblem of American courage and independence. Significantly,
the verb tenses in the final stanza shift from the past (rode)
in the opening five lines to the future tense (shall echo,
will waken) in the closing lines. The relevance of Longfellow's
patriotic symbol would not have been lost on the poet's original
audiencethe mostly New England Yankee readers of the Boston-based
Atlantic Monthly. Although Longfellow ostensibly mythologizes
the Revolutionary War, his poem addresses a more immediate crisisthe
impending break-up of the Union. Published a few months before
the Confederate attack on Fort Sumter initiated America's bloodiest
war, "Paul Revere's Ride" was Longfellow's reminder to New Englanders
of the courage their ancestors demonstrated in forming the Union.
Another "hour of darkness and peril and need," the poem's closing
lines implicitly warn, now draws near. The author's intentions
were overtly politicalto build public resolve to fight slavery
and protect the Unionbut he embodied his message in a poem
compellingly told in purely narrative terms. Longfellow's "Paul
Revere's Ride" was so successful that modern readers no longer
remember it as a poem but as a national legend. Underneath the
myth, however, a fine poem waits to be rediscovered.


Electron Angular LinvoDB3 Boilerplate
We are using node ,
Chromium ,
and Electron .
Here is a list of text from your LinvoDB3 database which is persistent, managed with AngularJS of course ;)
-
{{ note.text }}
Try to restart the application, this list will still be there ;)


|
Functional-lang
0.0
An example functional programming language
|
A syntax parser/Syntax analysis. More...
Go to the source code of this file.
Classes | |
| class | Environment |
| Environment for accessing variables. More... | |
| class | StackFrameObj< T > |
| Class for adding Expr's to stack frame of Environment. More... | |
| class | Expr |
| Main expression handle (should only be used as parent class). More... | |
| class | BiOpExpr |
| Binary operator expression. More... | |
| class | UnOpExpr |
| class | NumExpr |
| Floating point number expression. More... | |
| class | IntExpr |
| Integer number expression. More... | |
| class | IdExpr |
| Identifier expression. More... | |
| class | LambdaExpr |
| Lambda function expression. More... | |
| class | AtomExpr |
| Atom expression. More... | |
| class | IfExpr |
| If-then-else expression. More... | |
| class | AnyExpr |
| any expression More... | |
| class | LetExpr |
| Let expression. More... | |
| class | FunctionExpr |
| Represents a named function. More... | |
Enumerations | |
| enum | ExprType : int { expr_biop, expr_unop, expr_num, expr_int, expr_id, expr_lambda, expr_atom, expr_if, expr_any, expr_let, expr_fn } |
| Types of expressions. More... | |
Functions | |
| std::vector< Expr * >::iterator | find (std::vector< Expr * > &vec, Expr *expr) noexcept |
| const Expr * | assignExpressions (GCMain &gc, Environment &env, const Expr *thisExpr, const Expr *lhs, const Expr *rhs) noexcept |
| Expr * | reportSyntaxError (Lexer &lexer, const std::string &msg, const TokenPos &pos) |
| Expr * | eval (GCMain &gc, Environment &env, Expr *expr) noexcept |
| Executes eval function for given expr as long as different expr is returned. More... | |
| void | breadthEval (GCMain &gc, Environment &env, StackFrameObj< Expr > &lhs, StackFrameObj< Expr > &rhs) noexcept |
| Executes eval function for given expressions as long as differenct expr returned. Breadth first execution. More... | |
A syntax parser/Syntax analysis.
| enum ExprType : int |
Types of expressions.
|
noexcept |
Executes eval function for given expressions as long as differenct expr returned. Breadth first execution.
| gc | |
| env | |
| lhs | |
| rhs |
|
noexcept |
Executes eval function for given expr as long as different expr is returned.
| gc | |
| env | Environment to use |
| expr | Expression to evaluate |


An example of a custom JMX client,
Client
is included in
jmx_examples.zip
. This JMX client interacts with the same MBean, MXBean and JMX agent as were seen in the previous lessons. Due to the size of the Client
class, it will be examined in chunks, in the following sections.
To be able to create connections to JMX agents that are running remotely from the JMX client, you need to use the classes from the
javax.management.remote
.
package com.example; [...] import javax.management.remote.JMXConnector; import javax.management.remote.JMXConnectorFactory; import javax.management.remote.JMXServiceURL; public class Client { [...]
The Client
class will be creating
JMXConnector
instances, for which it will need a
JMXConnectorFactory
and a
JMXServiceURL
.
The JMX client needs a notification handler, to listen for and to process any notifications that might be sent by the MBeans that are registered in the JMX agent's MBean server. The JMX client's notification handler is an instance of the
NotificationListener
interface, as shown below.
[...] public static class ClientListener implements NotificationListener { public void handleNotification(Notification notification, Object handback) { echo("\nReceived notification:"); echo("\tClassName: " + notification.getClass().getName()); echo("\tSource: " + notification.getSource()); echo("\tType: " + notification.getType()); echo("\tMessage: " + notification.getMessage()); if (notification instanceof AttributeChangeNotification) { AttributeChangeNotification acn = (AttributeChangeNotification) notification; echo("\tAttributeName: " + acn.getAttributeName()); echo("\tAttributeType: " + acn.getAttributeType()); echo("\tNewValue: " + acn.getNewValue()); echo("\tOldValue: " + acn.getOldValue()); } } } [...]
This notification listener determines the origin of any notifications it receives, and retrieves the information stored in the notification. It then performs different actions with the notification information according to the type of notification received. In this case, when the listener receives notifications of the type
AttributeChangeNotification
it will obtain the name and type of the MBean attribute that has changed, as well as its old and new values, by calling the AttributeChangeNotification
methods getAttributeName
, getAttributeType
, getNewValue
and getOldValue
.
A new ClientListener
instance is created by later in the code.
ClientListener listener = new ClientListener();
The Client
class creates an RMI connector client that is configured to connect to an RMI connector server that you will launch when you start the JMX agent, Main
. This will allow the JMX client to interact with the JMX agent as if they were running on the same machine.
[...] public static void main(String[] args) throws Exception { echo("\nCreate an RMI connector client and " + "connect it to the RMI connector server"); JMXServiceURL url = new JMXServiceURL("service:jmx:rmi:///jndi/rmi://:9999/jmxrmi"); JMXConnector jmxc = JMXConnectorFactory.connect(url, null); [...]
As you can see, the Client
defines a
JMXServiceURL
named url
, that represents the location at which the connector client expects to find the connector server. This URL allows the connector client to retrieve the RMI connector server stub jmxrmi
from the RMI registry running on port 9999 of the local host, and to connect to the RMI connector server.
With the RMI registry thus identified, the connector client can be created. The connector client, jmxc
, is an instance of the interface
JMXConnector
, created by the connect()
method of
JMXConnectorFactory
. The connect()
method is passed the parameters url
and a null environment map when it is called.
With the RMI connection in place, the JMX client must connect to the remote MBean server, so that it can interact with the various MBeans registered in it by the remote JMX agent.
[...] MBeanServerConnection mbsc = jmxc.getMBeanServerConnection(); [...]
An instance of
MBeanServerConnection
, named mbsc, is then created by calling the getMBeanServerConnection()
method of the JMXConnector
instance jmxc
.
The connector client is now connected to the MBean server created by the JMX agent, and can register MBeans and perform operations on them with the connection remaining completely transparent to both ends.
To start with, the client defines some simple operations to discover information about the MBeans found in the agent's MBean server.
[...] echo("\nDomains:"); String domains[] = mbsc.getDomains(); Arrays.sort(domains); for (String domain : domains) { echo("\tDomain = " + domain); } [...] echo("\nMBeanServer default domain = " + mbsc.getDefaultDomain()); echo("\nMBean count = " + mbsc.getMBeanCount()); echo("\nQuery MBeanServer MBeans:"); Setnames = new TreeSet (mbsc.queryNames(null, null)); for (ObjectName name : names) { echo("\tObjectName = " + name); } [...]
The client calls various methods of MBeanServerConnection
in order to obtain the domains in which the different MBeans are operating, the number of MBeans registered in the MBean server, and the object names for each of the MBeans it discovers.
The client accesses the Hello
MBean in the MBean server through the MBean server connection by creating an MBean proxy. This MBean proxy is local to the client, and emulates the remote MBean.
[...] ObjectName mbeanName = new ObjectName("com.example:type=Hello"); HelloMBean mbeanProxy = JMX.newMBeanProxy(mbsc, mbeanName, HelloMBean.class, true); echo("\nAdd notification listener..."); mbsc.addNotificationListener(mbeanName, listener, null, null); echo("\nCacheSize = " + mbeanProxy.getCacheSize()); mbeanProxy.setCacheSize(150); echo("\nWaiting for notification..."); sleep(2000); echo("\nCacheSize = " + mbeanProxy.getCacheSize()); echo("\nInvoke sayHello() in Hello MBean..."); mbeanProxy.sayHello(); echo("\nInvoke add(2, 3) in Hello MBean..."); echo("\nadd(2, 3) = " + mbeanProxy.add(2, 3)); waitForEnterPressed(); [...]
MBean proxies allow you to access an MBean through a Java interface, allowing you to make calls on the proxy rather than having to write lengthy code to access a remote MBean. An MBean proxy for Hello
is created here by calling the method newMBeanProxy()
in the
javax.management.JMX
class, passing it the MBean's MBeanServerConnection
, object name, the class name of the MBean interface and true
, to signify that the proxy must behave as a
NotificationBroadcaster
. The JMX client can now perform the operations defined by Hello
as if they were the operations of a locally registered MBean. The JMX client also adds a notification listener and changes the MBean's CacheSize
attribute, to make it send a notification.
You can create proxies for MXBeans in exactly the same way as you create MBean proxies.
[...] ObjectName mxbeanName = new ObjectName("com.example:type=QueueSampler"); QueueSamplerMXBean mxbeanProxy = JMX.newMXBeanProxy(mbsc, mxbeanName, QueueSamplerMXBean.class); QueueSample queue1 = mxbeanProxy.getQueueSample(); echo("\nQueueSample.Date = " + queue1.getDate()); echo("QueueSample.Head = " + queue1.getHead()); echo("QueueSample.Size = " + queue1.getSize()); echo("\nInvoke clearQueue() in QueueSampler MXBean..."); mxbeanProxy.clearQueue(); QueueSample queue2 = mxbeanProxy.getQueueSample(); echo("\nQueueSample.Date = " + queue2.getDate()); echo("QueueSample.Head = " + queue2.getHead()); echo("QueueSample.Size = " + queue2.getSize()); [...]
As shown above, to create a proxy for an MXBean, all you have to do is call
JMX.newMXBeanProxy
instead of newMBeanProxy
. The MXBean proxy mxbeanProxy
allows the client to invoke the QueueSample
MXBean's operations as if they were the operations of a locally registered MXBean.
Once the JMX client has obtained all the information it needs and performed all the required operations on the MBeans in the remote JMX agent's MBean server, the connection must be closed down.
jmxc.close();
The connection is closed with a call to the
JMXConnector.close
method.
This example requires version 6 of the Java SE platform. To monitor the Main
JMX agent remotely using a the custom JMX client
Client
, follow these steps:
jmx_examples.zip
into your work_dir
directory.
unzip jmx_examples.zip
work_dir
directory.
javac com/example/*.java
Main
application, specifying the properties that expose Main
for remote management:
java -Dcom.sun.management.jmxremote.port=9999 -Dcom.sun.management.jmxremote.authenticate=false -Dcom.sun.management.jmxremote.ssl=false com.example.Main
A confirmation that Main
is waiting for something to happen is generated.
Client
application in a different terminal window:
java com.example.Client
A confirmation that an MBeanServerConnection
has been obtained is displayed.
The domains in which all the MBeans that are registered in the MBean server started by Main
are displayed.
The number of MBeans that are registered in the MBean server is displayed, as well as the object names of all these MBeans. The MBeans displayed include all the standard platform MXBeans running in the Java VM, as well as the Hello
MBean and the QueueSampler
MXBean that were registered in the MBean server by Main
.
The Hello
MBean's operations are invoked by Client
, with the following results:
Client
to listen for notifications from Main
.CacheSize
attribute is changed from 200 to 150.Main
, confirmation of the CacheSize
attribute change is displayed.Client
, a notification from Main
is displayed, informing Client
of the CacheSize
attribute change.Hello
MBean's sayHello
operation is invoked.Main
, the message "Hello world" is displayed.Hello
MBean's add
operation is invoked, with the values 2 and 3 as parameters. The result is displayed by Client
.
The QueueSampler
MXBean's operations are invoked by Client
, with the following results:
QueueSample
values date
, head
, and size
are displayed.clearQueue
operation is invoked.
The Client
closes the connection to the MBean server and a confirmation is displayed.


ResTORbio's respiratory illness drug fails late-stage study
REUTERS: ResTORbio Inc's said on Friday its lead drug missed the main goal in a late-stage testing in patients aged above 65 with respiratory illness.
The company said it will stop developing the drug, RTB101, for treating the respiratory illness, but continue to test the drug in other conditions, including Parkinson's disease.
(Reporting by Dania Nadeem in Bengaluru; Editing by Shinjini Ganguli)


|
insert
Syntax:
#include <vector> iterator insert( iterator loc, const TYPE& val ); void insert( iterator loc, size_type num, const TYPE& val ); void insert( iterator loc, input_iterator start, input_iterator end ); The insert() function either:
Note that inserting elements into a vector can be relatively time-intensive, since the underlying data structure for a vector is an array. In order to insert data into an array, you might need to displace a lot of the elements of that array, and this can take linear time. If you are planning on doing a lot of insertions into your vector and you care about speed, you might be better off using a container that has a linked list as its underlying data structure (such as a List or a Deque). For example, the following code uses the insert() function to splice four copies of the character 'C' into a vector of characters: // Create a vector, load it with the first 10 characters of the alphabet vector<char> alphaVector; for( int i=0; i < 10; i++ ) { alphaVector.push_back( i + 65 ); } // Insert four C's into the vector vector<char>::iterator theIterator = alphaVector.begin(); alphaVector.insert( theIterator, 4, 'C' ); // Display the vector for( theIterator = alphaVector.begin(); theIterator != alphaVector.end(); theIterator++ ) { cout << *theIterator; } This code would display: CCCCABCDEFGHIJ Here is another example of the insert() function. In this code, insert() is used to append the contents of one vector onto the end of another: vector<int> v1; v1.push_back( 0 ); v1.push_back( 1 ); v1.push_back( 2 ); v1.push_back( 3 ); vector<int> v2; v2.push_back( 5 ); v2.push_back( 6 ); v2.push_back( 7 ); v2.push_back( 8 ); cout << "Before, v2 is: "; for( int i = 0; i < v2.size(); i++ ) { cout << v2[i] << " "; } cout << endl; v2.insert( v2.end(), v1.begin(), v1.end() ); cout << "After, v2 is: "; for( int i = 0; i < v2.size(); i++ ) { cout << v2[i] << " "; } cout << endl; When run, this code displays: Before, v2 is: 5 6 7 8 After, v2 is: 5 6 7 8 0 1 2 3 |


Prepare for
takeoff.
Sendinblue is the smartest and most intuitive platform for growing businesses. Thrive digitally as we guide your business with the right marketing & sales tools.
Sendinblue is the smartest and most intuitive platform for growing businesses. Thrive digitally as we guide your business with the right marketing & sales tools.


| Item | Description | Quantity | Price | Subtotal |
|
Baseball cap
Color: Vintage Blue
Variation: Stripes
Product ID: #4421
|
2 | $19.99 | $39.98 | |
|
T-Shirt
Color: Yellow
Variation: V-Neck
Product ID: #23374
|
1 | $9.99 | $9.99 | |
|
Pullover
Color: Black
Variation: Winter Edition
Product ID: #2213
|
3 | $29.99 | $89.97 |
| Item | Description | Quantity | Price | Subtotal |
|
Baseball cap
Color: Vintage Blue
Variation: Stripes
Product ID: #4421
|
2 | $19.99 | $39.98 | |
|
T-Shirt
Color: Yellow
Variation: V-Neck
Product ID: #23374
|
1 | $9.99 | $9.99 | |
|
Pullover
Color: Black
Variation: Winter Edition
Product ID: #2213
|
3 | $29.99 | $89.97 |


5 September 2014 - News Story
The Isle of Man is set to be a centre for British star gazing after receiving an award from a UK research body.
5 September 2014 - News Story
Powerful and striking images have been submitted in the Biosphere Vannin photography competition.
5 September 2014 - News Story
Tree felling, school laptops, town centre parking, coastal erosion and bank closures are among the topics raised during House of Keys question time this week.


Hi,
Just purchased the following in order to log electrical consumption data and running into problems getting the system working.
- EmonTx V3 (433Mhz) - 1x CT and AC adapter
- EmonBase via Raspberry Pi & RFM12Pi @ 433Mhz
I have followed the steps here to set it up using the ready to go SD card & gateway - http://emoncms.org/site/docs/raspberrypigateway
Problem(s):
- Don't seem to be logging anything to emoncms.org
- Green LED on RFM12Pi does not come on/flash (apart from when powered on).
EmonTx
CT and/or AC adaptor plugged and powered via a USB DC power source.
I note that the red LED (near the USB connector) only ever flashes approximately every 5s. Isn't this meant to be solid initially and then flash?
Is there a way to check the configuration of the EmonTx or to rule out if it is/isn't OK?
RFM12Pi
Is there any way to test this without a working EmonTx? Want to make sure this is setup OK and is talking to emoncms.org.
I've installed the minicom driver and the default settings are as follows:
>minicom -b 9600 -o -D /dev/ttyAMA0
Available commands:
123 x - Toggle configuration change protection, 1=Unlocked
<nn> i - set node ID (standard node ids are 1..26)
<n> b - set MHz band (4 = 433, 8 = 868, 9 = 915)
<nnn> g - set network group (RFM12 only allows 212, 0 = any)
<n> c - set collect mode (advanced, normally 0)
...,<nn> a - send data packet to node <nn>, with ack
...,<nn> s - send data packet to node <nn>, no ack
<n> l - turn activity LED on DIG8 on or off
Current configuration:
79 i15 g210 @ 433 MHz Lock: 1
How do I change the node ID to 10 and get it to stay at that? I assume this is the standard for the the EmonTx?
Re: Raspberry Pi + Open Energy Monitor Setup Problems
The good news is that your RFM12Pi is configured correctly. The current configuration you are reading there is the settings of the RFM12Pi. The standard ID for that is 15 which is what you can see.
I'm guessing that if you stay looking at minicom you don't see any other lines of data appearing?
If so the problem you have is on the EmonTX.
So there are a couple of initial things to check.
1) Which plug are you plugging the CT into? Are you doubly sure you have it all the way in? (they can be very stiff!)
2) You don't say if you went for the fully built or the PCB version. If you went of the PCB version and soldered on the RFM12 unit, the first step is to check your soldering.
Re: Raspberry Pi + Open Energy Monitor Setup Problems
I see the following, sorry should have been a bit more patient..
I've tried CT1, CT2 and CT4 (only have 1 sensor). Have got it plugged fully in.
Got the fully built version.
Let me know if you need anymore information.
Re: Raspberry Pi + Open Energy Monitor Setup Problems
Have you got a USB to UART cable? Using this cable you should be able to read the serial output of the emonTx V3 (default 9600 baud). This output will help us debug further
The CT needs to be plugged in before powering on the emonTx, or hit the reset switch after plugging in a cable, it does a search at startup.
Re: Raspberry Pi + Open Energy Monitor Setup Problems
I have posted instructions of how to debug the emonTx V3 by reading it's serial output at the bottom of this page: http://openenergymonitor.org/emon/modules/emonTxV3
Re: Raspberry Pi + Open Energy Monitor Setup Problems
Hi,
I haven't got a USB to UART cable.
Yes, have plugged the CT in prior to powering it up. Have also hit the reset button after power up.
The frequency of the LED flashes (5 sec) seems strange and I haven't seen anyone else experience this.
Re: Raspberry Pi + Open Energy Monitor Setup Problems
Hi,
Thanks for sending the USB-UART cable. Much apprecaited.
What is the best way to diagnose this?
I have:
1. Setup the Arduino enviroment
2. installed the USB-UART driver
3 Opened up Arduino IDE and it shows COM3 under Tools-> Serial Port when I plug the USB cable in
4. Tools -> Serial Monitor is empty (baud 9600 is selected)
5. Have tried hitting reset on the emontx with no luck. Powered via USB cable with jump off.
Is it possible that there is no sketch loaded on to the emontx?
Please let me know what should be done next.
Re: Raspberry Pi + Open Energy Monitor Setup Problems
This is strange. You should not need to power the emonTx via USB it should self power via the UART cable, double check is been inserted the correct orientation. Do you still see the red led flash on the emonTx? What flashing pattern do you see? Does it only flash at startup?
Re: Raspberry Pi + Open Energy Monitor Setup Problems
Hi,
Yes, don't need to power it separately (I just did thinking it maybe required) and it does power itself off the UART cable. The little board on the USB-UART cable has a Blue light permanent lit.
The Red light on the emontx flashes every 5 seconds. Same as before. No flashing sequence and no change in flashing sequence.
I have no devices connected to it when connected via the UART cable btw.
What's next? Would appreciate a series of steps and options to try as opposed to trying to troubleshoot this one micro step at a time.
Should I try reloading the default sketch on to it? Is it likely that there is no sketch loaded onto it?
Please give me a few things to try so that I can go away and try them.
Re: Raspberry Pi + Open Energy Monitor Setup Problems
Debugging steps are detailed at the bottom of this page: http://openenergymonitor.org/emon/modules/emonTxV3
If your not seeing a serial output it could mean that some some reason there is no firmware on the emonTx.
Try pasting the following into the Arduino IDE and selecting upload, you should see the LED flash every second and print 'hello world' to the serial window
If this works the next step is to upload the emonTx firmware from Github
https://github.com/openenergymonitor/emonTxFirmware/tree/master/emonTxV3/RFM12B/emonTxV3_RFM12B_DiscreteSampling
http://wiki.openenergymonitor.org/index.php?title=EmonTx_V3#Uploading_Arduino_Firmware
Re: Raspberry Pi + Open Energy Monitor Setup Problems
Hi,
Loaded up that test program and it worked fine. Seems like the firmware was not uploaded.
Have uploaded the firmware and all is well now. Thanks.
Re: Raspberry Pi + Open Energy Monitor Setup Problems
Very sorry about that, not sure what went wrong. glad you got it sorted. Ah, the wonders of open software


Ploaisdjfklsd sdfjslkdf sdf sdfjlksdj fsdfk slakdfj asfd
skldfj sdfjsldkf jsldfkj sdfjsl fdskldfjs df