Maybe one way is to serve up some HTTP responses to a client's PC containing HTML/JavaScript. In essence making their browsers load scripts that can send POST requests using JavaScript's "xmlhttprequest" web interface API (and the setInterval() method as a continuous loop). If requests could be generated in a loop and had the destination path set to your Arduino's IP address, you could append post header parameter data at the end of the path ( something like 'http://my.arduinos.ip.address/?data_only=True' ). And as long as the server running on the Arduino was RESTful then you could send a request from the JavaScript in the browser and the Arduino could look at the post header data. There it could check to see if some parameter name was ever sent and render dynamic content as the response. Or just send some data back. The Arduino could also read the value(s) coming from the header data and do something with it to render a response as well. At the end of the day your browser would receive back some kind of response data that could then be used to modify the document object model (DOM) of the page loaded in the browser and basically insert or modify the existing data that was previously loaded on the page. Then the request/response cycle loops and the process begins all over again. Ultimately resulting in data that is periodically changing on the webpage (without having to refresh the entire page and is using less bandwidth/processor overhead, more fluid looking, etc..).
As an example lets say a web browser issued a POST requests to the Arduino's IP (or more specifically: JavaScript just called "XMLHttpRequest().send()" ) with the parameter "?data_only=True" present in the header.
The Arduino web server could check if the parameter "data_only" was present in the request, then it takes sensor measurements and bundles all of the values up into a response string.
Depending on your preference you could respond with a raw data format (proprietary to the application), or you could us a data-interchange format like JSON or XML.
I prefer JSON.
http://www.w3schools.com/json/
After the response from your Arduino has been sent back to your PC, the JavaScript from the HTML file you loaded earlier (that's now running in your browser) will receive it and can then read the data.
This data can be used in may ways. But in your case i believer all you want to see is some of the browser's DOM objects (like a Div section) display the values, so:
JSON is pretty simple:
looks like this:
{ "name":"sensor1", "type":"flux power", "value":1.21, "unit":"jigawatts" }
but you can also embed JSON within JSON, so to speak...
So lets say this is some JSON that your Arduino returns to your browser:
{
"sensor_array":
[
{ "name":"altitude" , "type":"altimeter" , "value":304, "unit":"km" },
{ "name":"speed" , "type":"xnav/inu", "value":28000, "unit":"km/h" },
{ "name":"coord" , "type":"gps", "value":"82.7° N 114.4° W" }
]
}
And the Javascript in the HTML file could have something similar to this:
<html>
<body>
<div id="MyDiv"> --The data between these tags will be replaced by JavaScript-- </div>
<script>
// Javascript function JSON.parse to parse JSON data
var jsonObj = JSON.parse(http_request.responseText);
// jsonObj variable now contains the data structure and can
// be accessed as jsonObj.sensor_array.
// now lets put that data in a Div
document.getElementById("MyDiv").innerHTML = jsonObj.sensor_array;
</script>
</body>
</html>
basically that's AJAX..
aka. asynchronous javascript and xml.
http://www.w3schools.com/ajax/default.ASP
Though I have never done any of that on an Arduino per se, so please don't ask me for specifics, This was only my best guess on one way someone might go about displaying real-time ("updating") data on a webpage (in this case without refreshing the page).
Now this part may or may not be of help to you but I have built sensor networks for automation and manufacturing industries in the past using Atmel stuff and some Arduinos.
The way I do it is by using a web framework and a centralized server / database.
If you know any scripting languages (like Python 2.x or PHP) then mod WSGI and Apache might be a good way a beginner could start a Web Application Framework. This allows the Arduino's only having to communicate raw sensor data to the server and not have to serve up client requests for full blown HTML (and possibly AJAX) request/response cycles, which is not only faster on the Arduino's behalf, But development of the web framework is at a centralized point, also centralized database access and it uses the Linux LAMP configuration which is very well known, secure and widely supported.
Good luck friend(s)!!