Netzer: Version tracking

  • Main Page
  • Related Pages
  • Modules
  • Data Structures
  • Files

Version tracking

Version 1.4.222
Added spanish version. Thanks to Manel!

Version 1.4.220
Bug fix: I2C configuration was not correctly loaded if not in I2CMasterMode.

Version 1.4.219
Bug fix: GPIOs were not acessable in I2CMasterMode.

Version 1.4.215
Bug fixes:
  • Changes of IP address due DHCP elapsed lease times, late IP address arrival or fallback from DHCP to AutoIP or manual address now works better with socket closing and MDNS restarting.
  • Waiting for the idle polarity on SPI clock in SPI slave mode removed: Solution: The serial task does not start until the clock polarity and clock signal match. All other tasks (GPIO, TCP/IP) start normally, so the Netzer is accessable via web. Changing the SPI clock mode on the serial page takes effect after restart first (for SPI slave).
  • Guest-Login shows the ID and configure button
  • Remove space from IO strings (i.e. "IO 0" -> "IO0")
  • Translate configure button in German
  • Bug fixed in base version: Authentication dialog appears with no need.

Version 1.4.198

The firmware is now splitted into two parts, base and pro. The base version is maintained and published for free. The base version is a subset of the pro version. Pro licenses are bundled with Netzer hardware or can be purchased seperately in the MoBaCon webshop.

Bugfixes and new features in the base and pro version:

  • Password of the admin account was not changeable???
  • Added dutch as third supported Netzer language (thanks goes to Bart Eversdijk for translation)
  • GPIO service is now a standalone service which can be activated independently of the serial service
  • Completly reworked GPIO websites for simpler configuration
  • Added baudrate 38400 bps for serial UART mode
  • Improved serial transmit and receive routines (mostly rewritten in assembler)
  • Increased both, receive and send serial buffer to 256 bytes
  • Changed the SPI master protocol (more details: SPImaster)
  • Completly reworked the SPI slave protocol (more details: SPIslave)

New features in the pro version:

  • Added events for GPIO server: The GPIO server sends messages on rising and/or falling edges for digital inputs.
  • Added event counter functionality for IO0, IO1 and IO2. The features are:
    • Configurable for rising or falling edges
    • Decrementing or incrementing
    • 16 bit + 1 bit overflow flag value, accessable and resetable due website
    • Optional filter (1ms - 250ms) i.e. for debouncing of switches
  • Added ADC (10 bit) functionality for IO4 and IO5
  • Added 10 bit (hardware) PWM functionality for IO3 and SPI_INT This impulse mode has the following features:
    • Selectable frequency: 2.5 kHz, 10 kHz or 40 kHz (common for both channel)
    • Selectable logic, active low or high
    • Configurable duty value on startup
  • Added 16 bit impulse functionality for IO3 and SPI_INT: This impulse mode has the following features:
    • Three modi: Single impulse, single impulse on IO0 trigger and continuous mode
    • Configurable impulse unit (100ns, 200ns, 400ns and 800ns)
    • Selectable logic, low or high impulse
    • Configurable duty value on startup
  • Selectable radix (hexadecimal or decimal) for GPIO website and server communication
  • Selectable auto refresh rate for GPIO website
  • Javascript (deactivatable) on GPIO website
  • Authentication (using web user accounts) can be enabled for GPIO server
  • All the new channel mode values (ADC, impulse and pwm) can also be accessed from GPIO server
  • Added more variants how the device obtains the IP address:
    • DHCP without failover
    • DHCP with failover to AutoIP (default) - thats the original variant
    • DHCP with failover to ManualIP
    • AutoIP
    • ManualIP - Also from the orginal code
  • HTTP port can be changed
  • All IO pins can be changed in serial SPI master mode with a protocol extension (more details: SPImaster)

Version 1.3.134 - Inofficial release
Bug fixes:
  • Prevent authentification dialog on unknown files.

Version 1.3.132 from 11-04-25
Bug fixes:
  • Fixed wrong eeprom address for I2C when doing a reset to factory setting.
  • SPI modes were completly broken due a stupid copy and paste error in the ISR.

Version 1.3.129 from 11-04-13
Important bug fix: Fixed interpreting bug at GPIO server module when accessing via the 'x' placeholder.

Version 1.3.128 from 11-03-15
Added 4800 Baud as UART Baudrate.

Important bug fixes:

  • Sending all DHCP messages as UDP-broadcast fixes possible problems with some DHCP servers.

  • All serial modes ran with the wrong baudrate due the wrong MCU frequency. The MCU runs with 41.6667 MHz now as intended.

Version 1.3.122 from 11-02-22
  • Upgraded to latest MCC18 compiler 3.37.01

  • Show a message on web interface if no valid bootloader is installed.

  • Added the authentication module to the web interface. The web sites can only be accessed with a valid username and password. HTTP simple authentication is used for this. Netzer supports three different user: administrator, user and guest. Each user has different rights (standard username, standard password):
    1. The administrator has root rights (admin, admin).
    2. The user can only do a few commands and has GPIO access (user, user).
    3. The guest has readonly rights (guest, guest).

  • With the authentication module a great security leak is hopefully gone: Firmware updates can only be started from the administrator. The TFTP reboot module is only started if activated via the webinterface.

  • A early init routine is added where a project can do some initialization directly after main is called. For the NtzerIO project some IO port registers are configured (unused ports as outputs to prevent floating).

  • Reseting Netzer to factory settings can be started directly at the board (in case the password is lost...). Simply put a resistor (about 10K) between GND and PGD (one of the ICD2 pins) on startup. If the Netzer seems to "hang" remove the resistor. After removing the LEDs should blinking some time and afterwards the Netzer restarts.

  • Fixed a Gratuitous ARP bug in the bootup module. This bug leads to lot of gratuitous ARPs on startup in a short time (not in DHCP). It is changed to only three ARP packets with an interval of 500 ms.

  • Added a Netzer mode, called "Webinterface only" - no GPIO and serial server are started in this mode.

  • Fixed a bug in serial and GPIO server: After unplugging network cable both servers did not start anymore.
Version 1.2.103 from 11-01-08
  • I2C Master module implemented with friendly support of Hygrosens Instruments Ltd. Possible transactions: Write, Read, Write/Read.
  • Versioning of bootloader. IO module displays the bootloader version on the index website.
  • Fixed a IP address filter problem in UDP module
Version 1.1.83 from 10-11-02 (Elektor release for Netzer project website)
  • Cleaned up the source files and completed documentation for this version.
  • Fixed a bug in bootloader module: faulty upload of debug images completly blocked some devices.
  • Added the project identifier in the boot EEPROM. Migration between different Netzer project is possible now.
Version 1.1.5 from 10-09-14 (Official release for Elektor)
Added the SPI modules for master and slave operation to Netzer IO. Added some useful buttons on the web page like shut down and LED blinking.

Version 1.0.1 from 10-09-02 (First release candidate running on hardware)
Added the first parts of the Netzer IO project including the GPIO and UART module.

Version 1.0.X (Inofficial development)
Initial release of the Netzer project. Porting the core modules from eWicht to Netzer project.
Generated on Fri Mar 29 10:34:28 2013 for Netzer by doxygen 1.5.5


Netzer: The MoBaCon Software License (MBCSL)

  • Data Structures
  • Files

The MoBaCon Software License (MBCSL)

The MBCSL applies to the software's source and object code and comes with any rights that I have in it (other than trademarks).

You agree to the MBCSL by copying, distributing, or making a derivative work of the software.

You get the royalty free right to:

  • Use the software for non-commercial purposes;
  • Make derivative works of it for non-commercial (this is called a "Derived Work");
  • Copy and distribute it and any Derived Work for non-commercial purposes.

If you distribute the software or a Derived Work, you are required to give it back to the community by:

  • Attend and observe the included Microchip License Agreement (see Microchip for details);
  • Prominently noting the date of any changes you make;
  • Leaving other people's copyright notices, warranty disclaimers, and license terms in place;
  • Providing the source code, build scripts, installation scripts, and interface definitions in a form that is easy to get and best to modify;
  • Licensing it to everyone under MBCSL without adding further restrictions to the rights provided;
  • Conspicuously announcing that it is available under that license.

There are some things that you must shoulder:

  • You get NO WARRANTIES. None of any kind;
  • If the software damages you in any way, you may only recover direct damages up to the amount you paid for it (that is zero if you did not pay anything). You may not recover any other damages, including those called "consequential damages." (The state or country where you live may not allow you to limit your liability in this way, so this may not apply to you);

The MBCSL continues perpetually, except that your license rights end automatically if:

  • You do not abide by the "give back to the community" terms (your licensees get to keep their rights if they abide);
  • Anyone prevents you from distributing the software under the terms of the MBCSL.

MoBaCon can offer special licenses especially for commercial purpose with less limitations (BSD or MPL). Please contact me: schlender (at) mobacon (dot) de.


Netzer: List of bugs and feature requests

List of bugs and feature requests

Report found bugs to kontakt (at) mobacon (dot) de

Version 1.4.210

No known bugs at the moment.


Netzer: Folder structure and project files

Folder structure and project files

The files in the root directory are the common sources which are used by the projects.

Further files in the root directory:

  • The central makefile including targets for building the common sources, the doxygen documentation and deploying.
  • The Doxyfile for building the documentation
  • The workspace file for the MPLAB IDE

All the sources which are licensed by Microchip are located in the seperate Microchip folder. These are files for EEPROM access via UNIO and the TCPIP Stack modules, the MPFS sources and the bootloader.

The documentation input files like several additional text files and images are located in doc. The output of the documentation build process is also written to doc.

The final image and hex files are put into the Release folder.

Each project has a seperate folder. These files are typically included:

  • The project makefile for configuring the project build process. The file uses the central Makefile in the root directory for buidling the project.
  • The project related source and header files (including projectdefs.h for several project related defines)
  • The project file for the MPLAB IDE
  • The project related linker script
  • The project related website in the web folder
  • The intermediate output files of the build process are put into the bin folder


Netzer: How to build

How to build

What to install

Toolchain summary

  • mpasmwin.exe v5.42
  • mplink.exe v4.40
  • mcc18.exe v3.40
  • mplib.exe v4.40
  • MPLAB IDE V8.80

Compiler

The MCC18 Compiler (V3.37 or greater) can be used under a free Student License. The latest version can be downloaded from the Microchip website. This license enables the user to compile and link the project modules (The extended mode is not used).

The MCC18 is available for Windows only. For Linux and MAC you can give the PICC Compiler (http://www.htsoft.com/) a try (I have not tried this, please let me know if it works).

Also I have read about users which are using MCC18 with WINE.

Another NEW option is MPLAB X which is available for Windows, Linux and MAC. Currently only available as BETA. Write me an eMail if you tried it.

IDE

The MPLAB IDE (V8.63 or greater) is free but for Windows only. The latest version can be downloaded from the Microchip website. Workspace and project files for MPLAB are included in this project.

Alternativly you can use MinGW and the included makefiles to build the project. Also any IDE (i.e. Eclipse) where a make process can be started is possible.

MPFS and VisualStudio

For compiling the project web sites to a MPFS image the MPFS tool is needed. The MPFS Tool, intergrated in Microchips TCP/IP Stack, was modified for these project. The sources and an already compiled executable (in the MPFS folder) are included in this software package. If you'd like to compile the sources due own modifications you need Microsofts Visual Studio Express for C# (freely available at Microsoft). The MPLAB project files include the build of the web image as prebuild steps. The makefile includes a target for the MPFS image.

The MPFS image itself is an ANSI C file which is simply compiled within the build process.

How to build with MPLAB

Simply open the root workspace file *.mcw with the MPLAB IDE. Activate the project, your prefered mode, the appropriate Debugger or Programmer and select "Build All". When the build process has finished the generated image file is located in the Release folder. Continue with programming or debugging the device with the output *.cof and *.hex files.

Activating the debug mode

This mode is for real time hardware debugging on i.e. a Microchip ICD2. The build image is running without the special bootloader and can therefore be flashed directly to the device target.

Activating the release mode

This mode generates an image which can not run without the special bootloader. Typically the user will choose this mode because no programmer device like an Microchip ICD2 is needed. Simply build the application and use a tftp client for uploading the image (see DEPLOY).

How to build with MinGW

The included makefiles also can be used to build the device images. Only release images are generated by default.


Netzer: How to deploy

How to deploy

Upload with a TFTP client

The device comes with an integrated bootloader which enables firmware updates via TFTP.

Each bootloader uses the assigned MAC address 00-04-A3-00-00-00 and IP address 192.168.97.60. Via this MAC and IP the bootloader can be accessed directly. These default addresses are statically defined and can only be changed by recompiling the bootloader itself.

The only services that are available during bootloader operation are TFTP and ARP. ICMP (ping) and other services are not implemented.

TFTP operation on clean or faulty devices

On clean devices the bootloader is active by default. The active bootloader is indicated by a fast blinking link LED.

If an application is installed the bootloader stays active after power cycling for approx. two seconds.

To access the bootloader directly, the bootloader's IP address must be on the same subnet as your computer. For the default 192.168.97.60 IP address, you must temporarily change the settings on your PC.

The following instructions assume you are using Microsoft Windows XP and will vary for other operating systems.

  1. Open Network Connections.

  2. Right click on the network adapter that you are using to communicate with the bootloader and choose Properties.

  3. Select Internet Protocol (TCP/IP) and click Properties.

  4. Select Use the following IP address and then enter the IP address 192.168.97.61.

    Click OK and then Close on the previous dialog to close them and set the new address.

After completing the TFTP upload process, restore your PC's IP address settings to allow normal network activity and access to the application you bootloaded.

TFTP operation on running applications

If an already deployed application is compiled with the Reboot module of the Microchip TCPIP Stack, the build process can be started sending TFTP packets to the device.

Since Netzer Version 1.3 the Reboot module must be explicitly activated via the web interface (common settings, see image below). This can only be done due an user with administrative rights.

Once a TFTP packet received the device enters the bootloader automatically. IP address and MAC address of the application are adopted by the bootloader. Therefore no network settings must be changed in case the device application was accessable before.

TFTP Operation

Most operating systems come with a TFTP client built in. In Microsoft Windows, this utility is named tftp.exe. This utility is a very simple console application which can be used to upload your application .hex file over the network to the bootloader. To perform a Flash upgrade using the tftp.exe client, follow these procedures:

  1. Enter the bootloader mode like described above.
  2. At a console, execute the following command. Make appropriate path changes to the hex file.
    tftp 192.168.97.60 put "eWicht.hex"
  3. If successful, the TFTP client will indicate how long the transfer took.
  4. The bootloader does data read back verification shortly after writing and does not need a second step to read back the Flash contents. If a verification error occurs, the error will be immediately reported to the TFTP client.

With the ICD2

When a new bootloader must be programmed or you want to debug an application you have to connect with a programming device like the ICD2.

Before connecting the enclosure of the eWicht must be opened: The 5 wire (VCC, GND, PGD, PGC, MCLR) interface of the ICD2 must be connected to the pads (see the red circle in the image below).

Cutout of the Netzer top placement

Important Note: VCC must NOT be powered from the ICD2. Use an external 3.3 Volt power supply instead!

If you have problems connecting to Netzer C107 should be removed.


Netzer: The I2C master protocol

The I2C master protocol

Netzer supports I2C master emulation since version 1.2.

The most data transactions are done transparently by Netzer. But a few protocol specifiers are implemented for handling the special states of I2C.

The termination character

The character 0x00 in the TCP/IP communication has special meaning in terminating any pending I2C transmission. If Netzer sends a 0x00 either the bus is busy or a slave does not respond on address or data bytes. In the latter cases the bus is freed with a stop condition automatically. If Netzer receives 0x00 while a I2C transmission is pending, the transmission will be finished with a automatic generated stop condition.

If 0x00 should be sent via the I2C interface it must be escaped with a leading backspace. Therefore also the backslash itself must be escaped.

The start condition and the slave address byte

A start condition is automatically announced on the bus, if Netzer gets the first character via the TCP/IP serial socket. If an error occurs while announcing the start condition Netzer responds with a '0x00'. I2C protocol defines the very first byte after the start condition as slave address. Netzer sends a '0x00' via TCP/IP if no slave responds (ACK bit was '1'). Also a stop condition is initiated by Netzer. After the successful transmission of the slave address Netzer sends '0xFF' via TCP/IP.

General call address

The I2C general call address 0x00 addresses all slaves on the I2C bus. Sending 0x00 as the very first byte is allowed as an exception of the Netzer protocol. The escaping backslash MUST not be used.

The R/W bit

Netzer also checks the R/W bit (LSB) of the slave address character.
If the R/W bit is cleared a transmission from master to slave is initiated. Each byte received by Netzer via the TCP/IP socket is directly sent to the slave (consider escaping!). In response Netzer sends via TCP/IP either '0xFF' as positive acknowledge (ACK bit was '0') or '0x00' as negative acknowledge (ACK bit was '1'). In case of a negative acknowledge Netzer initiates a stop condition on the bus.
If the R/W bit is set a transmission from slave to master is initiated (clock is generated by I2C master). After the successful transmission of the slave address Netzer waits for further bytes on the TCP/IP socket. On receiving a byte via TCP/IP a byte is pulled from the slave and is sent via TCP/IP. In case the received byte is '0x00' the transmission is over and Netzer generates a stop condition on the bus. Any other value pulls the next byte from slave.

Repeated start

I2C supports repeated start. This symbol concatenates a stop and start condition while a I2C transmission is pending without freeing the bus inbetween. The special character 's' (0x73) in TCP/IP stream initiates the repeated start on the bus. Therefore the 's' must be escaped during normal stream transmission to Netzer. Exception to escaping 's' is the very first character (slave address) analog to the "General Call address" section. Receiving an 's' from Netzer has no special meaning but 's' :)

Examples

Take a look at the following picture for circuiting a I2C EEPROM IC as slave to Netzer.

Connecting a simple EEPROM to Netzer

Accessing the Netzer serial socket from Windows

HyperTerminal is a bit exhausting for transfering hexadecimal characters. Here is an alternate method doing this. Checkout the tools com2tcp and com0com (http://com0com.sourceforge.net/). After installing com0com as Null modem emulator you get new virtual COM ports named CNCA0 or CNCB0. Now you can start com2tcp like this:
com2tcp --ignore-dsr \\.\CNCA0 ne041a4c.local 64000
The command connects to Netzer named "ne041a4c.local" with the serial socket running on port 64000. If successfully connected the socket is bound to COM port CNCA0. Due the Null modem mechanism all the data is mirrored between the virtual COM ports generated by com0com. With your prefered terminal program, you are able to connect to i.e CNCB0. Characters written to CNCB0 are sent to CNCA0 and to Netzer. Received characters from Netzer are received on CNCA0 and later on CNCB0.

EEPROM slave address

The EEPROM has the slave address 0x50. Because the LSB is reserved for the R/W indicator the address is shifted left by one: 0xA0.

Writing to the EEPROM

See the following byte sequence for writing a 0x55 to memory address 0 of the EEPROM:
Write per TCP/IP to Netzer: 0xA0 0x5C 0x00 0x55 0x00
Answer from EEPROM received per TCP/IP from Netzer: 0xFF 0xFF 0xFF

  1. 0xA0 is the slave address with the R/W bit cleared, means write access.
  2. Netzer answers with 0xFF, indicating the available slave.
  3. 0x5C 0x00 transfers the memory address 0 - of course must be backslashed ('\' = 0x5C)
  4. Netzer answers with 0xFF, successful transfered memory address.
  5. 0x55 is the value which is written to EEPROM
  6. Netzer answers with 0xFF, successful transfered value.
  7. 0x00 stops the transmission - I2C bus is released.

Reading from EEPROM

Write per TCP/IP to Netzer: 0xA0 0x5C 0x00 0x73 0xA1 0x01 0x00
Answer from EEPROM received per TCP/IP from Netzer: 0xFF 0xFF 0xFF 0xFF 0x55 0x78

  1. 0xA0 is the slave address with the R/W bit cleared, means write access.
  2. Netzer answers with 0xFF, indicating the available slave.
  3. 0x5C 0x00 transfers the memory address 0 - of course must be backslashed ('\' = 0x5C)
  4. Netzer answers with 0xFF, successful transfered memory address.
  5. 0x73 initiates a repeated start on the bus.
  6. Netzer answers with 0xFF, successful repeated start.
  7. 0xA1 is the slave address with the R/W bit set, means read access.
  8. Netzer answers with 0xFF, indicating the available slave.
  9. Now the 0x01 says to Netzer: Pull me one byte from slave and acknowledge it.
  10. Netzer answers with the value read from memory address 0: 0x55.
  11. The 0 says to Netzer: Pull me one more byte from slave and stop.
  12. Netzer answers with the value read from memory address 1 (auto increment feature of the EEPROM): 0x78.
  13. Netzer automatically announces a stop condition after sending the byte.


Netzer: The SPI master protocol

The SPI master protocol

The most data transactions are done transparently by Netzer.

But a few protocol specifiers are implemented for handling.

The protocol is slightly different for the base and the pro version.

The protocol in base version.

In this version only one SPI slave is supported which is selected with the SPI_CS pin. On startup the SPI_CS pin is automatically configured as output and is driven high (slave is deselected).

If a TCP client is connected to the serial server, any sent character starts the SPI communication. The SPI_CS pin is automatically forced low.

All characters are sent transparently to the SPI slave. Due the three wire characteristic of SPI a written value also leads to a read one which is directly sent back to the connected TCP client.

To stop a pending SPI communication the client has to sent a backslash as escaping symbol and a null character right after. This is different from the protocol until Netzer firmware version 1.3! The SPI_CS pin is driven high when the serial server receives this characters. For sending a backslash to the SPI slave the serial TCP client has to sent two backslashes. Other escaped commands are ignored by the serial server.

The protocol in pro version.

There is no dedicated CS pin in this version. All pins (except the SPI pins MOSI, MISO and CLK) can be set or reset with protocol commands. The TCP client has to ensure that the appropriate CS pin is driven low before sending data to a SPI slave. Also he must manually stop the SPI communication with setting the CS pin at the end. Configure all used CS pins as set on startup via the io websites.

For accessing the pins the GPIO IDs are used. The IDs are escaped with the backslash character. For sending a backslash to the SPI slave the serial TCP client has to sent two backslashes. Small letters clear the appropriate pin, capitals set it.

For example sets \A the IO0 pin, \a resets it. Another example is IO5 where \F sets it, and \f resets it. Ensure that the pins are configured as digital outputs.


Netzer: The SPI slave protocol

The SPI slave protocol

For using the Netzer as Ethernet modem from i.e. another microcontroller the Netzer has the SPI slave mode implemented. TCP/IP connections can be established and released (as client or server) and data can be received and sent.

Important note: Since version 1.4 the protocol and interface has significantly changed compared with prior versions. For older versions please check out the Elektor website.

Physical connection

At least six free pins on the master side are needed. See the diagramm for a typical connection.
All pins are read only for the GPIO access (GPIO webpage and GPIO service).

Connection example

Waveforms

Netzer pin | Direction | Description
SPI_CLK | Input | The master generates edges for data transmission here. One tranfer unit is eight edges and therefore eight bits. All clock polarities are supported by Netzer (settable via web interface). Important Note: The selected idle state on this pin is checked by Netzer on startup to ensure synchronicity with SPI master. Netzer blocks as long as the pin level does not match the idle state!
SPI_MO | Output / Open | Netzer shifts out its data on SPI_CLK edges.
SPI_MI | Input | Master shifts out its data on SPI_CLK edges.
SPI_CS | Input | The master MUST select Netzer with a low chip select line. During the entire transmission the chip select must stay low. Note: Releasing the chip select does not automatically reset the register interface (see below). A released chip select disables the internal SPI_MO driver. A pullup or pulldown resistor is needed therefore on this pin to prevent floating.
SPI_INT | Output | Netzer pulls this pin low, if internal states has changed. The master MUST check this line inbetween complete transmissions of eight bit. If the line is low the master MUST stop any pending register access immediately with a rising edge on IO1. The interrupt pin is released after a SPI master write to the interrupts flags register.
IO5 | Output | IO5 is used as handshake pin for increasing data throughput. The pin is low during master transmissions. On finished master transmissions the pin is driven high as soon as the Netzer internal SPI module has detected pending data. During the processing of the received byte the line stays high. If processing is finished and possible data is provided by the slave for shifting out the line returns to low. The master is not allowed to start a new transmission during the high state of IO5.
IO1 | Input | IO1 is used for controlling the register access. A falling edge on IO1 starts a new register access. Netzer awaits the very next byte from master after the edge as register address. A rising edge on the pin stops the register access. For easier connection the SPI_CS pin and IO5 can connected together.

The protocol

Two commands, register read and register write, are supported. The first byte after a falling edge on IO1 is the address and control byte which is transmitted by the SPI master.

Bit 7 | Bit 6 - Bit 0
0 = Read access 1 = Write access | Register address
The address and control byte

The returned byte from Netzer is a dummy byte and MUST be ignored by the master. After this address and control byte 0-n bytes may be transmitted by master till the IO1 pin is reset to 1.

Write access is performed with 0-n bytes after the address and control byte. The transfered bytes are written to the addressed register. Normally all the bytes are acknowledged by Netzer with a non zero value in return. Consider that a received byte deals with the prior written byte - not with the current one. Writing more than one byte to a register address is important for the socket data registers (see below).

Read access is performed with 1-n dummy bytes after the address and control byte. The returned bytes from Netzer (excluding the first one as mentioned above) are the read bytes from the requested register address. Reading more than one byte from a register address is important for the socket data registers (see below).

The virtual register set

The communication with Netzer takes place via a virtual register set.

This overhead is processed in software. For the protocol a virtual register set is implemented. The whole SPI communication is based on this registers.
Register address | Register name | Access | Description
0x00 Interrupt flags RW Read out this register while interrupts are pending (SPI_INT=0). The flags in this register determine the interrupt source. When no interrupt is pending the content of this register is 0. Writing to this register (any value or none) resets the pending interrupt (SPI_INT=1). Here are the flags:
Name | Bit | Description
STATE CHANGED | 0 | State of Netzer has changed. Read out new Netzer state at address 0x01.
SOCKET STATE CHANGED | 1 | State of Netzer socket has changed. Read out new Netzer socket state at address 0x02.
Important note: Pending interrupts block any shutdown or restart process until the interrupt register is cleared.
0x01 Netzer state RW

Read access delivers the current state of Netzer:
State | Value | Description
NETZER_STARTING | 0x00 | Netzer is starting, bootup.
NETZER_NOLINK | 0x01 | Netzer is idle but has no network link.
NETZER_IP_ERROR | 0x02 | Netzer has network link but no valid IP address.
NETZER_READY | 0x03 | Netzer is ready and has a valid IP address.
NETZER_SHUTDOWN | 0x04 | Netzer is shutting down right now.
Each state change leads to the set STATE CHANGED flag (see Interrupt flags above).

Write access executes commands on Netzer. Here are the supported commands:
State | Value | Description
NOP | 0x00 | This command does simply nothing.
RESTART | 0x01 | This command restarts Netzer.
SHUTDOWN | 0x02 | This command shuts down Netzer.

0x02 Netzer socket state RW

Read access delivers the socket flags:
Name | Bit | Description
RX_BUFFER_FULL | 0 | The Netzer receive buffer is full. STOP transfering data to Netzer until this bit is gone!
TX_DATA_PENDING | 1 | New data has arrived from TCP/IP connection. Read out via data address (0x1F)!
CONNECTED | 2 | Netzer is connected via TCP/IP with a remote device.
IS_SERVER | 3 | Netzer is server now. If set, this bit can not be reset until shutdown.
MAILBOX_BUSY | 4 | Netzer processes the last socket command. Not finished yet.
All changes on the flags lead to an interrupt and a set SOCKET STATE CHANGED flag. Exception: A newly set MAILBOX_BUSY flag leads to no interrupt.

Write access executes commands on Netzer:
State | Value | Description
NOP | 0x00 | This command does simply nothing.
LISTEN | 0x01 | This command configures Netzer as server (opens listener). Once configured as server the Netzer can configured as client again after restart.
CONNECT | 0x02 | Start connecting to the configured server (address 0x18-0x1D). This command has no effect in server mode.
DISCONNECT | 0x03 | Disconnects socket from the remote connected device.

0x03-0x05 | Reserved
0x06 | Firmware-Version: Build (low) | R
0x07 | Firmware-Version: Build (high) | R
0x08 | Firmware-Version: Minor | R
0x09 | Firmware-Version: Major | R
0x0A-0x0F | MAC address | R | The Netzer MAC address as six byte array.
0x10-0x14 | IP address | R | The Netzer IP address as four byte array.
0x14-0x18 | Reserved
0x18-0x1B Remote IP address RW

Read access: In Server mode the read value is only valid if connected.

Write access: Only for client mode: Enter the IP address of the remote node to connect.

0x1C-0x1D Port RW

The data format is little endian!

Server mode: Writing the port where the server should listen on. Do this BEFORE configuring Netzer as server! 0 (default) takes the web interface configured port.

Client mode: Writing the port of the remote node to connect.

0x1E | Reserved
0x1F Socket data RW

If Netzer is connected via TCP/IP with remote node it uses two internal (ring) buffer. The receive buffer and the send buffer. They have a size of 256 bytes each.

Writing to the socket data address writes data to the receive buffer. Netzer automatically sends data from receive buffer via TCP/IP if connected. If the RX_BUFFER_FULL flag is set the SPI master has to stop transfering data and wait for a cleared RX_BUFFER_FULL.

Reading from socket data address sequentially reads from the send buffer. The transmit buffer is automatically filled with incoming TCP/IP packets. The SPI master should read out the send buffer only if the TX_DATA_PENDING flag is set!


Netzer: Todo List

Todo List

File DHCP.c
Generate a doxygen page for discussing the Netzer project and the DHCP and AutoIP behavior (High level).

Global _CheckForQueryResponse
Message compression.

File stringtable.c
Split string tables for seperate language firmware (to store flash memory). \

File TCP.c
Change from AppConfig structure to sIPConfig

Global DHCPTask
Save the probed auto IP-Address in EEPROM

Global IPConvertMaskToSubnet
Add the (DWORD) output values.

Global IPConvertMaskToSubnet
Move this function to the helpers.

Global IPConvertSubnetToMask
Move this function to the helpers.


Netzer: Module Index

Modules

Here is a list of all modules:
  • Application module
  • Application network and initialization module
  • Multicast DNS
    • Resolving records
  • String tables
  • Web interface
  • NetzerIO Project
  • TCP/IP Stack from Microchip Version 4.50 (Modified)
    • ARP
    • DHCP
    • HTTP
    • ICMP
    • IP
    • MAC
    • MPFS
    • Reboot
    • Stack Task
    • TCP
    • Tick
    • UDP
  • Module for accessing UNIO EEPROMs


Netzer: Application module

Application module

Detailed Description

This module manages the application stuff from bringing up the TCPIP Stack, doing all the user interactions for this and initializing and handle the child modules.

Files

file | adc.c
Implementation of ADC conversion.
file | adc.h
API for analog channel access.
file | appl.c
This file implements the Netzer application module.
file | timer.asm
This file handles the low priority interrupt and the tick counter.
file | appl.h
This file includes the Netzer application module API.
file | flash.c
Implementation of flash routines.
file | flash.h
API for accessing the internal flash memory.
file | helper.h
API for misc helper functions.
file | helper.h
API for misc helper functions.
file | netzerTypedefs.h
Defines common typedefs for use in Netzer projects.
file | time.h
API fo using the time module.
file | toa.h
API fo using the assembler conversion routines.

Defines

#define | BOOTUP_EEPROM_ADD (0x0000u)
EEPROM byte address for application network data.
#define | PROJECT_EEPROM_ADD (0x0030u)
EEPROM byte address for application data.
#define | SNTP_EEPROM_ADD (0x0070u)
EEPROM byte address for SNTP server URL.
#define | AUTHENT_EEPROM_ADD (0x0090u)
EEPROM byte address for authentication data.
#define | MAC_EEPROM_ADD (0x00FAu)
This EEPROM address stores the predefined 6 byte IEEE MAC address which is used by the TCP/IP stack.

Enumerations

enum ApplCommands_t {
APPL_CMD_IDLE = 0, APPL_CMD_RESTART, APPL_CMD_RESET_TO_FACTORY, APPL_CMD_SHUTDOWN,
APPL_CMD_BOOTLOADER, APPL_CMD_BLINK, APPL_CMD_COUNT
}
This typedef defines some common commands for the application. More...
enum NetzerState_t {
NETZER_STARTING = 0, NETZER_NOLINK, NETZER_IP_ERROR, NETZER_READY,
NETZER_SHUTDOWN
}
The device states as enumerator. More...

Functions

BOOL | ApplInit (void)
Call this function to initialize the application module.
void | ApplMain (void)
Call this function periodically to execute the application module.
void | ApplResetToFactory (void)
This function restores the EEPROM content to a well known state.
BOOL | ApplIsRunning (void)
The function is the indicator for the running application.
void | ApplStop (void)
This function finally stops the application, i.e.
void | ApplCommand (ApplCommands_t Command)
Call this function to execute several application commands.
void | ApplStateChanged (NetzerState_t NewState)
This function is called by different core modules to indicate Netzer state changes.
NetzerState_t | ApplGetCurrentState (void)
This function can be called to obtain the current state of Netzer.

Define Documentation

#define AUTHENT_EEPROM_ADD (0x0090u)

EEPROM byte address for authentication data.

The data consists of one user/password combination which is stored here. Each, user and password can have a length of 8 bytes.

#define BOOTUP_EEPROM_ADD (0x0000u)

EEPROM byte address for application network data.

See CommonConfig_t for a detailed documentation of the structure elements. On startup the data is loaded into RAM (sPCommonConfig).

#define PROJECT_EEPROM_ADD (0x0030u)

EEPROM byte address for application data.

Each Netzer project is free to use the EEPROM space from this address. The boot module checks for different project contents and migrates the EEPROM content if necessary.

#define SNTP_EEPROM_ADD (0x0070u)

EEPROM byte address for SNTP server URL.

Server name can be up to 32 bytes.

Enumeration Type Documentation

enum ApplCommands_t

This typedef defines some common commands for the application.

This commands can executed with the ApplCommand function.

Enumerator:
APPL_CMD_IDLE | This command is used as a NOP command.
APPL_CMD_RESTART | Restarts the device.
APPL_CMD_RESET_TO_FACTORY | Restartes the device and loads default values to EEPROM.
APPL_CMD_SHUTDOWN | Shuts down the device.
APPL_CMD_BOOTLOADER | Restarts the device and enters bootloader.
APPL_CMD_BLINK | Starts or stops the blinking of the network LED.
APPL_CMD_COUNT | Dummy for getting the count of all commands.

enum NetzerState_t

The device states as enumerator.

Enumerator:
NETZER_STARTING | Netzer is starting, bootup.
NETZER_NOLINK | Netzer is idle but has no network link.
NETZER_IP_ERROR | Netzer has network link but no valid IP address.
NETZER_READY | Netzer is ready and has a valid IP address.
NETZER_SHUTDOWN | Netzer currently is shutting down.

Function Documentation

void ApplCommand ( ApplCommands_t Command )

Call this function to execute several application commands.

Parameters:
Command The command which should be executed.

NetzerState_t ApplGetCurrentState ( void )

This function can be called to obtain the current state of Netzer.

Returns:
The current state as enumerated value.

BOOL ApplInit ( void )

Call this function to initialize the application module.

Return values:
TRUE | Initialization was successful.
FALSE | Initialization failed.

BOOL ApplIsRunning ( void )

The function is the indicator for the running application.

Return values:
TRUE | The application module is running.
FALSE | The application has reached the final state (shut down).

void ApplMain ( void )

Call this function periodically to execute the application module.

void ApplResetToFactory ( void )

This function restores the EEPROM content to a well known state.

void ApplStateChanged ( NetzerState_t NewState )

This function is called by different core modules to indicate Netzer state changes.

Note:
There is an implementation hook PROJECT_STATE_CHANGED for handle this in several projects.
Parameters:
NewState New Netzer state as enumerated value.

void ApplStop ( void )

This function finally stops the application, i.e.

in case of shut down.


Netzer: Application network and initialization module

Application network and initialization module

Detailed Description

The module brings up the Netzer and the TCP/IP stack as configured by the user.

The module therefore loads the persistent stored EEPROM data for the network stack. After configuring the network it starts the network stack and checks for occuring errors. If the start fails, the user and the application are informed. If no error occurs, the application can start with the usage of a configured network.

Files

file | bootup.c
Implementation of the boot process of the Netzer application.
file | bootup.h
Prototypes for calling the Netzer application boot up and network routines.

Data Structures

struct | _IP_CONFIG
This typedef defines the local structure for TCP/IP stack parameters. More...
struct | CommonConfig_t
This typedef defines the peristent structure for common settings and TCP/IP stack parameters. More...

Defines

#define | MAX_NETWORKNAME_LENGTH 8
The maximum allowed length for network names (currently used in the MDNS).

Enumerations

enum IPSelectionModes_t {
IPS_DHCP_ENABLED = 0, IPS_DHCP_AUTOIP, IPS_DHCP_MANUALIP, IPS_AUTO_IP,
IPS_MANUAL_IP, IPS_MODE_COUNT
}
This typedef defines the various modes how the Netzer gets its IP address. More...
enum | IPObtainedFrom_t { IPO_DHCP = 0, IPO_AUTO, IPO_MANUAL }
This enumerator states from which instance the current device IP was obtained from. More...
enum | NetzerProjects_t
Enumerates the different targets a Netzer can be used for. More...
enum IPField_t {
VAR_IP_ADDRESS = 0, VAR_GATEWAY_ADDRESS, VAR_SUBNET_MASK, VAR_MAN_IP_ADDRESS,
VAR_MAN_SUBNET_MASK, VAR_MAN_GATEWAY_ADDRESS, VAR_IP_ADDRESS_EEPROM, VAR_SUBNET_MASK_EEPROM,
VAR_GATEWAY_ADDRESS_EEPROM
}
Use this enumerator for the function BootupPrintIPAddress to get a well formated IP address. More...

Functions

void | BootupInit (void)
This function initializes the application network module.
BOOL | BootupMain (void)
This function must be called periodically by the application.
void | BootupResetToFactory (void)
Sometimes the reset of the persistent data in the EEPROM to a well known state is needed.
void | BootupEnterBootloader (void)
Calling this function prepares the bootloader entry.
void | BootupBlink (void)
This function blinks the network LED with a second period.
void | BootupGetNetworkName (BOOL Persistent, BYTE *pNameBuffer, BYTE SizeOfBuffer)
Delivers the network name of the device.
void | BootupPrintIPAddress (IPField_t Position, BYTE *pBuffer)
Use this function to generate a string from a IP address of this device.
void | BootupPrintFormatedIPAddress (BYTE *pIPAddress, BYTE *pBuffer)
Use this function to print a formated IP address to a given RAM buffer.
BOOL | BootupSetIPAddress (IPField_t Position, BYTE *pIPString)
Use this function to change the given IP address with an IP address string.
void | BootupSetNetworkName (BYTE *pName)
Use this function to change the network name of the device.
IPSelectionModes_t | BootupGetIPMode (BOOL LoadFromPersistent)
Delivers the current selected Netzer IP mode.
void | BootupSetHTTPPort (WORD NewPort)
Set a new port for the HTTP service for the next session (after reboot).
WORD | BootupGetHTTPPort (BOOL LoadFromPersistent)
Delivers the currently set or persistently written port value for the HTTP service.
void | BootupGetIPAddress (IPField_t Position, BYTE *pBuffer)
Use this function to obtain any of the device IP addresses.
void | BootupInvalidateIPSettings (void)
Reset the current IP settings to invalid.

Variables

static SM_BOOTUP | _sm
The local state machine.
static BYTE | _au8NetworkDataForBootloader [12]
Stores the network related data like MAC address and IP address for reboot.
static DWORD | _timer
The timer state for measuring times.
static WORD | _persistentHTTPPort
The HTTP port - staying consistent with EEPROM.
IPConfig_t sIPConfig
This field stores the local TCP/IP parameters.
CommonConfig_t sPCommonConfig
The persitent data field.

Enumeration Type Documentation

enum IPField_t

Use this enumerator for the function BootupPrintIPAddress to get a well formated IP address.

Enumerator:
VAR_IP_ADDRESS | Prints out the current device IP address.
VAR_GATEWAY_ADDRESS | Prints out the current device gateway address.
VAR_SUBNET_MASK | Prints out the current device subnet mask.
VAR_MAN_IP_ADDRESS | Prints out the manual set IP address.
VAR_MAN_SUBNET_MASK | Prints out the manual set subnet mask.
VAR_MAN_GATEWAY_ADDRESS | Prints out the manual set gateway IP address.
VAR_IP_ADDRESS_EEPROM | Prints out the device IP address from EEPROM.
VAR_SUBNET_MASK_EEPROM | Prints out the device IP address from EEPROM.
VAR_GATEWAY_ADDRESS_EEPROM | Prints out the device gateway address from EEPROM.

enum IPObtainedFrom_t

This enumerator states from which instance the current device IP was obtained from.

Enumerator:
IPO_DHCP The IP address is obtained via DHCP.

IPO_AUTO The IP address is obtained via auto IP (in range 169.254).

IPO_MANUAL The IP address is set manually.

enum IPSelectionModes_t

This typedef defines the various modes how the Netzer gets its IP address.

Enumerator:
IPS_DHCP_ENABLED The IP address is obtained via DHCP.

The device remains in boot up without a valid IP address as long as no DHCP server has responded.

IPS_DHCP_AUTOIP The IP address is obtained via DHCP.

If DHCP fails, the device selects an auto IP address from the 169.254 range.

IPS_DHCP_MANUALIP The IP address is obtained via DHCP.

If DHCP fails, the device uses the manual configured IP address.

IPS_AUTO_IP A so called auto IP address from the 169.254 range is selected on bootup.

IPS_MANUAL_IP The manual IP address is used from bootup.

IPS_MODE_COUNT Placeholder to determine the count of different supported IP set modes.

enum NetzerProjects_t

Enumerates the different targets a Netzer can be used for.

Function Documentation

void BootupBlink ( void )

This function blinks the network LED with a second period.

This can be used by the application to identifiy the device in the field.

void BootupEnterBootloader ( void )

Calling this function prepares the bootloader entry.

After restarting the device the bootloader remains active and uses the prepared MAC and IP address.

WORD BootupGetHTTPPort ( BOOL LoadFromPersistent )

Delivers the currently set or persistently written port value for the HTTP service.

Parameters:
LoadFromPersistent TRUE means, load the HTTP port from EEPROM. FALSE means, load the HTTP port from local RAM storage.
Note:
Currently the value is not loaded from EEPROM, a static placeholder is used to prevent EEPROM usage here.

void BootupGetIPAddress | ( | IPField_t | Position,
 |  | BYTE * | pBuffer
 | ) |  |

Use this function to obtain any of the device IP addresses.

Parameters:
Position | Specifies which IP address should be returned.
pBuffer | Buffer for the IPv4 address with at least 4 bytes space.

IPSelectionModes_t BootupGetIPMode ( BOOL LoadFromPersistent )

Delivers the current selected Netzer IP mode.

Parameters:
LoadFromPersistent TRUE means, load the IP mode from EEPROM. FALSE means, load the IP mode from local RAM storage.
Returns:
One of the IP modes, see IPSelectionModes_t for more details.

void BootupGetNetworkName | ( | BOOL | Persistent,
 |  | BYTE * | pNameBuffer,
 |  | BYTE | SizeOfBuffer
 | ) |  |

Delivers the network name of the device.

Parameters:
Persistent | If TRUE, the name is read from the EEPROM, if FALSE the name is read from the current state.
pNameBuffer | Pointer to a buffer the name is copied to.
SizeOfBuffer | Size of the given buffer.

void BootupInit ( void )

This function initializes the application network module.

The network data persitant stored in EEPROM is loaded and the TCP/IP Stack is configured with this settings. If the function detects an empty EEPROM it loads the factory settings to ensure proper operation of the Netzer device.

Returns:
None
Remarks:
None

void BootupInvalidateIPSettings ( void )

Reset the current IP settings to invalid.

Restarts the internal bootup state machine.

BOOL BootupMain ( void )

This function must be called periodically by the application.

First of all the function tries to configure and to start the network due directly accessing the TCP/IP stack and its parameters. Several reasons in the network or on the local device can lead to a non working network. The function is able to detect this and report it to the calling application.

Possible reasons for network failures:

  • The network cable is unplugged or disconnected somewhere.
  • An address conflict is detected on the network.

Precondition:
The application network module must be initialized by a call of BootupInit.
Return values:
TRUE | The network module is ready, the application can start using the network.
FALSE | The network is not ready due several reasons (see above).
Remarks:
None

void BootupPrintFormatedIPAddress | ( | BYTE * | pIPAddress,
 |  | BYTE * | pBuffer
 | ) |  |

Use this function to print a formated IP address to a given RAM buffer.

Parameters:
pIPAddress | Pointer to the 32 bit IP address.
pBuffer | Pointer to the output buffer (must have a size of at least 13 bytes).

void BootupPrintIPAddress | ( | IPField_t | Position,
 |  | BYTE * | pBuffer
 | ) |  |

Use this function to generate a string from a IP address of this device.

Parameters:
Position | Specifies which IP address should be formated.
pBuffer | Pointer to the output buffer (must have a size of at least 13 bytes).

void BootupResetToFactory ( void )

Sometimes the reset of the persistent data in the EEPROM to a well known state is needed.

The call of this function resets Netzer to the following parameters:

Manual settings: IP: 192.168.0.10 Subnet: 255.255.255.0 (/24) Gateway: 192.168.0.1 Language: English

The network address is accquired automatically (by DHCP or AutoIP), the first AutoIP address is generated and saved in EEPROM.

void BootupSetHTTPPort ( WORD NewPort )

Set a new port for the HTTP service for the next session (after reboot).

Parameters:
NewPort The port is written to EEPROM.

BOOL BootupSetIPAddress | ( | IPField_t | Position,
 |  | BYTE * | pIPString
 | ) |  |

Use this function to change the given IP address with an IP address string.

Parameters:
Position | Specifies which IP address should be set.
pIPString | Pointer to the input buffer with the stored IP string.
Return values:
TRUE | Set was succesful.
FALSE | Set has failed.

void BootupSetNetworkName ( BYTE * pName )

Use this function to change the network name of the device.

Parameters:
pName Pointer to the new name string.

Variable Documentation

IPConfig_t sIPConfig

This field stores the local TCP/IP parameters.

Some of them will be loaded from the persistent data fields. Other fields are updated dynamically if the TCP/IP stack configuration change.

CommonConfig_t sPCommonConfig

The persitent data field.

The field stores common settings of the Netzer and for the network. At the beginning the application must call BootupInit. This function loads the data which is stored in the data EEPROM into this SRAM field. The IP Menu or the function BootupResetToFactory can change this fields and store it back to the EEPROM.


Netzer: Multicast DNS

Multicast DNS

Detailed Description

As networked devices become smaller, more portable, and more ubiquitous, the ability to operate with less configured infrastructure is increasingly important.

In particular, the ability to look up DNS resource record data types (including, but not limited to, host names) in the absence of a conventional managed DNS server, is becoming essential.

Multicast DNS (mDNS) provides the ability to do DNS-like operations on the local link in the absence of any conventional unicast DNS server. In addition, mDNS designates a portion of the DNS namespace to be free for local use, without the need to pay any annual fee, and without the need to set up delegations or otherwise configure a conventional DNS server to answer for those names (Source: Abstract of the Multicast DNS internet draft from 2006).

DNS Service Discovery is a way of using standard DNS programming interfaces, servers, and packet formats to browse the network for services (Source: www.dns-sd.org).

References and recommended reading: RFC 1034, RFC 1035, Internet drafts for mDNS and DNS-SD.

Files

file | mdns.c
Multicast Domain Name System (MDNS) implementation file for the Netzer application.
file | mdns.h
MDNS Client Module Header file for the application.

Modules

Resolving records
The module include functions for resolving unique records like hostname or service records.

Defines

#define | MDNS_PORT 5353u
The MDNS UDP port.
#define | DNS_PORT 53u
The DNS UDP port.
#define | DNS_TYPE_A (0x0001u)
DNS type for hostnames.
#define | DNS_TYPE_PTR (0x000cu)
DNS type for pointer records.
#define | DNS_TYPE_MX (0x000fu)
DNS type for mailbox records.
#define | DNS_TYPE_SRV (0x0021u)
DNS type for service records.
#define | DNS_TYPE_TXT (0x0010u)
DNS type for text records.
#define | DNS_TYPE_ANY (0x00FFu)
DNS type for all records.

Enumerations

enum | _MDNS_STATE { MDNS_HAS_STOPPED = 0, MDNS_IS_STARTING_UP, MDNS_IS_RUNNING }
Possible states of the MDNS responder service. More...

Functions

BOOL | bInitMDNSResponder (WORD HTTPPort)
The function initializes the MDNS service.
void | StartMDNSResponder (void)
The service is started by a call of this function.
void | StopMDNSResponder (void)
The service is stopped by a call of this function.
void | MDNSResponder (void)
The function implements the state machine of the MDNS responder.
void | MDNSProcessFrame (NODE_INFO *remoteNode, IP_ADDR *localIP)
In the MDNS module the state machine and the receiption of frames are divorced.
MDNS_STATE | eGetMDNSState (void)
The function retrieves the state of the MDNS responder.

Enumeration Type Documentation

enum _MDNS_STATE

Possible states of the MDNS responder service.

The state of the service can be requested by the eGetMDNSState function.

Enumerator:
MDNS_HAS_STOPPED | The MDNS service has stopped.
MDNS_IS_STARTING_UP | The service is starting.
MDNS_IS_RUNNING | The service is running.

Function Documentation

BOOL bInitMDNSResponder ( WORD HTTPPort )

The function initializes the MDNS service.

The application must call this function at least once before starting and using the service. After the sucessful init the application can start the service with StartMDNSResponder. Every time the network interface changes, the application must call this function to ensure the correct functionality of the service.

Parameters:
HTTPPort The currently used port of the HTTP service.
Return values:
TRUE | The initialization was successful.
FALSE | The initialization was not successful and therefore the service can not be used.
Precondition:
First call this function after got the IP address and checked the validness.

MDNS_STATE eGetMDNSState ( void )

The function retrieves the state of the MDNS responder.

For a simplified API only a few states from the internal MDNS state machine are returned.

Returns:
The state of the MDNS responder.

void MDNSProcessFrame | ( | NODE_INFO * | remoteNode,
 |  | IP_ADDR * | localIP
 | ) |  |

In the MDNS module the state machine and the receiption of frames are divorced.

The receiption of frames is handled stateless and answers will be promptly generated. For quick processing the UDP module should check for the MDNS socket or event he MDNS port in received messages and call this function directly. With the given parameters the function filters for relevant frames.

Precondition:
The responder must be initialzed by a bInitMDNSResponder call and started by a StartMDNSResponder call.
Parameters:
remoteNode | Extracted information about the remote node (MAC and IP).
localIP | The IP address where the frame was send to (can be a unicast or multicast address).

void MDNSResponder ( void )

The function implements the state machine of the MDNS responder.

The application must call this function periodically. The state machine handles the starting and the resolve procedures.

Precondition:
The responder must be initialzed by a bInitMDNSResponder call and started by a StartMDNSResponder call.

void StartMDNSResponder ( void )

The service is started by a call of this function.

The application should check the state of the service with eGetMDNSState if the service was started successfully. The starting procedure can take some milliseconds or seconds. The procedure includes a so called probing, where all the unique DNS records (see MDNS draft for a detailed discussion about unique and shared records). will be announced to the network. The procedures fails, if the network knows some of this unique records (i.e. the hostname is already taken by another host).

Precondition:
The responder must be initialzed by a bInitMDNSResponder call.

void StopMDNSResponder ( void )

The service is stopped by a call of this function.

This function is called automatically in case the starting procedure fails. If the starting procedure was successful and the service is running before the call so-called "goodbye" announcements (see MDNS draft for details) for shared records will be send.

Precondition:
The responder must be initialzed by a bInitMDNSResponder call.


Netzer: Resolving records

Resolving records
[Multicast DNS]

Detailed Description

The module include functions for resolving unique records like hostname or service records.

For all the included functions the precondition takes affect that the MDNS responder was successfully initialized by bInitMDNSResponder and started by StartMDNSResponder.

Functions

void | MDNSResolveService (char *pName, ROM char *pServiceName)
The function resolves a service record via MDNS.
void | MDNSResolveName (char *pName)
The function resolves a hostname record via MDNS to an IP address.
void | MDNSStopResolving (void)
A pending resolvation process will be stopped.
BOOL | bMDNSServiceIsResolved (IP_ADDR *pIP, WORD_VAL *pu16Port)
After calling MDNSResolveService the application should check periodically the resolvation progress with a call of this function.
BOOL | bMDNSNameIsResolved (IP_ADDR *pIP)
After calling MDNSResolveName the application should check periodically the resolvation progress with a call of this function.

Function Documentation

BOOL bMDNSNameIsResolved ( IP_ADDR * pIP )

After calling MDNSResolveName the application should check periodically the resolvation progress with a call of this function.

Return values:
TRUE | The hostname was completely resolved. Check the pIP parameter.
FALSE | The resolvation progress is pending or not yet started.
Parameters:
[out] pIP In case the hostname is resolved this parameter stores the IP address of the requested host.
Precondition:
MDNSResolveName must be called.

BOOL bMDNSServiceIsResolved | ( | IP_ADDR * | pIP,
 |  | WORD_VAL * | pu16Port
 | ) |  |

After calling MDNSResolveService the application should check periodically the resolvation progress with a call of this function.

Return values:
TRUE | The service was completely resolved. Check the parameters pIP and pu16Port for the requested information.
FALSE | The resolvation progress is pending or not yet started.
Parameters:
[out] | pIP | In case the service is resolved this parameter stores the IP address of the host where the service is running.
[out] | pu16Port | In case the service is resolved this parameter stores the port number of the service.
Precondition:
MDNSResolveService must be called.

void MDNSResolveName ( char * pName )

The function resolves a hostname record via MDNS to an IP address.

The hostname is set to the .local domain automatically.

Parameters:
pName A pointer to a hostname label in RAM. The label must be DNS conform.

void MDNSResolveService | ( | char * | pName,
 |  | ROM char * | pServiceName
 | ) |  |

The function resolves a service record via MDNS.

The resolve is done in two steps. First the service record query is answered by a remote network device with a valid service record. The service record includes the port of the requested service for example. The query answer also includes the hostname where the service is running. The second step resolves the hostname into an IP address. For this issue the function MDNSResolveName is called internally.

Example: From the given parameters (pName = "DDW-Server", pServiceName = "_srcp") the search string is "DDW-Server._srcp._tcp.local.".

Parameters:
pName | A pointer to a name label in RAM. The label must be DNS conform. The name is the name of the service, NOT of a hostname!
pServiceName | A pointer to a service name label in ROM (i.e. _srcp). The label must be DNS conform.
Remarks:
Actually the function only supports the resolvation of TCP services.

void MDNSStopResolving ( void )

A pending resolvation process will be stopped.

This function will be called automatically when stopping the MDNS service with StopMDNSResponder.


Netzer: String tables

String tables

Detailed Description

Here are defined some language string tables.

The application code can access strings for multiple languages. Once set the language identifier, the module automatically returns the correct strings.

Files

file | stringtable.c
This file implements the string tables for multi language support.
file | stringtable.h
This file includes the Netzer string table defines and API.

Enumerations

enum LanguageIDs_t {
LANGID_NOTSPECIFIED = -1, LANGID_GERMAN = 0, LANGID_ENGLISH, LANGID_NETHERLANDS,
LANGID_SPANISH, LANGID_COUNT
}
The IDs of supported languages. More...
enum | StringTableIDs_t
String ID table for accessing the string table entries.
enum | StateTableIDs_t
Error ID table for accessing the error string table entries.

Functions

void | StrTbl_SetLanguage (LanguageIDs_t LangId)
The function sets the actual string table for this session (not permanently).
void | StrTbl_GetString (uint8_t *pString, uint16_t StringId)
The function copies the string with the given ID to the given RAM location.
ROM char * | StringGetPointer (uint16_t StringId)
The function delivers a ROM pointer to the given string ID.
ROM char * | StringGetLanguageStringPointer (uint8_t LanguageId, uint16_t StringId)
The function delivers a ROM pointer to the given string ID on a given string table.
ROM char * | StringGetStatePointer (StateTableIDs_t StateId)
The function delivers a ROM pointer to the given string ID from the state table.

Enumeration Type Documentation

enum LanguageIDs_t

The IDs of supported languages.

Enumerator:
LANGID_NOTSPECIFIED | Language ID for factory resets and initial startups.
LANGID_GERMAN | Language ID for the German string table.
LANGID_ENGLISH | Language ID for the English string table.
LANGID_NETHERLANDS | Language ID for the Netherlands string table.
LANGID_SPANISH | Language ID for the Spanish string table.
LANGID_COUNT | Placeholder to get supported languages.

Function Documentation

ROM char* StringGetLanguageStringPointer | ( | uint8_t | LanguageId,
 |  | uint16_t | StringId
 | ) |  |

The function delivers a ROM pointer to the given string ID on a given string table.

The language ID which was set before with StrTbl_SetLanguage is not affected due this function.

Precondition:
None.
Parameters:
LanguageId | One of the valid language IDs like LANGID_GERMAN or LANGID_ENGLISH for example.
StringId | String ID of the string to load.
Returns:
The pointer to the string in the flash memory.

ROM char* StringGetPointer ( uint16_t StringId )

The function delivers a ROM pointer to the given string ID.

Precondition:
StrTbl_SetLanguage should be called. Else the result is always a string from the German string table.
Parameters:
StringId String ID of the string to load.
Returns:
The pointer to the string in the flash memory.

ROM char* StringGetStatePointer ( StateTableIDs_t StateId )

The function delivers a ROM pointer to the given string ID from the state table.

Precondition:
StrTbl_SetLanguage should be called. Else the result is always a string from the German string table.
Parameters:
StateId String ID of the string to load.
Returns:
The pointer to the string in the flash memory.

void StrTbl_GetString | ( | uint8_t * | pString,
 |  | uint16_t | StringId
 | ) |  |

The function copies the string with the given ID to the given RAM location.

Precondition:
StrTbl_SetLanguage should be called. Else the result is always a string from the German string table.
Parameters:
pString | Pointer to a buffer in RAM. Ensure that in the buffer is enough space.
StringId | String ID of the string to load.

void StrTbl_SetLanguage ( LanguageIDs_t LangId )

The function sets the actual string table for this session (not permanently).

Precondition:
None.
Parameters:
LangId One of the valid language IDs like LANGID_GERMAN or LANGID_ENGLISH for example.


Netzer: Web interface

Web interface

Detailed Description

The routines process the cgi scripts of the HTTP server.

That means that prepared variables in the cgi files which are sent to a client are filled with data. The routines also process commands received via input buttons in forms on the websites.

Files

file | auth.c
The web authentication module implementation of Netzer.
file | auth.h
The web authentication module interface of Netzer.
file | web.c
The integrated web interface implementation of Netzer.
file | web.h
Web interface module defines and global function prototypes for Netzer.
file | HTTPPrint.h
Provides callback headers and resolution for the web interface.
file | MPFSImg.c
Defines an MPFS2 image to be stored in program memory.

Defines

#define | WEB_STACKSIZE (256u)
Working space for HTML processing.

Enumerations

enum | PageID_t
All html files have this unique index. More...

Functions

void | WebOptionROM (BOOL Selected, BYTE Value, ROM BYTE *pString)
Prints a formated HTML option field to the HTTP socket with content string from ROM.
void | WebRadioROM (ROM BYTE *pName, DWORD Value, BOOL Selected, BYTE AccessLevel)
Prints a formated HTML radio field to the HTTP socket with name string from ROM.
void | WebCheckboxROM (ROM BYTE *pName, DWORD Value, BOOL Selected, BYTE AccessLevel)
Prints a formated HTML checkbox to the HTTP socket with name string from ROM.
void | WebCheckbox (BYTE *pName, DWORD Value, BOOL Selected, BYTE AccessLevel)
Prints a formated HTML checkbox to the HTTP socket with name string from RAM.
void | WebReportChangedState (StateTableIDs_t StringID, PageID_t DestinationPageID)
Call this function during a HTTP POST session if the user should be forwarded to a message webpage (state.htm) showing a error or state change string.
BYTE | HTTPNeedsAuth (BYTE *cFile)
This function is called on the starting authentfication process, if any file is requested via HTTP.
BYTE | WebGetAuthLevelOfCurrentPage (void)
Each shown webpage has dedicated level of authorization which is stored in an internal structure with all the other webpage related data.
BYTE | WebGetCurrentPageID (void)
Returns the ID of the last loaded html page.

Variables

BYTE | webwork [WEB_STACKSIZE]
The working space for HTML processing.

Enumeration Type Documentation

enum PageID_t

All html files have this unique index.

The ID is used as parameter in various function and simplifies webpage processing. A Netzer based project can use own IDs starting from PAGEID_PROJECT.

Function Documentation

BYTE HTTPNeedsAuth ( BYTE * cFile )

This function is called on the starting authentfication process, if any file is requested via HTTP.

It is possible to grant access with or without authentication.

Parameters:
cFile Pointer to the string of the requested web file.
Return values:
0 | The file needs authentication.
Other | The file needs no authentication.

void WebCheckbox | ( | BYTE * | pName,
 |  | DWORD | Value,
 |  | BOOL | Selected,
 |  | BYTE | AccessLevel
 | ) |  |

Prints a formated HTML checkbox to the HTTP socket with name string from RAM.

Output template:

<input type="checkbox" name="" value="" />
Parameters:
pName | Pointer to a string in RAM where the name of the checkbox is located.
Value | Value of the checkbox.
Selected | TRUE Writes a selected checkbox, FALSE writes a not selected.
AccessLevel | The access level for this checkbox (users with a lower access level are able to change the button). -1 -> Always read only.

void WebCheckboxROM | ( | ROM BYTE * | pName,
 |  | DWORD | Value,
 |  | BOOL | Selected,
 |  | BYTE | AccessLevel
 | ) |  |

Prints a formated HTML checkbox to the HTTP socket with name string from ROM.

Output template:

<input type="checkbox" name="" value="" />
Parameters:
pName | Pointer to a string in ROM where the name of the checkbox is located.
Value | Value of the checkbox.
Selected | TRUE Writes a selected checkbox, FALSE writes a not selected.
AccessLevel | The access level for this checkbox (users with a lower access level are able to change the button). -1 -> Always read only.

BYTE WebGetAuthLevelOfCurrentPage ( void )

Each shown webpage has dedicated level of authorization which is stored in an internal structure with all the other webpage related data.

Return values:
The authentication level. The valid levels are starting with 0x80. 0x80 has administrative rights, 0x81 user rights and 0x82 are guest rights.

BYTE WebGetCurrentPageID ( void )

Returns the ID of the last loaded html page.

Returns:
The last loaded page ID.

void WebOptionROM | ( | BOOL | Selected,
 |  | BYTE | Value,
 |  | ROM BYTE * | pString
 | ) |  |

Prints a formated HTML option field to the HTTP socket with content string from ROM.

Output template:

<option value="">Content</option>

Parameters:
Selected | TRUE Writes a selected option field, FALSE writes a not selected one.
Value | Value of the option field.
pString | Pointer to the content string.

void WebRadioROM | ( | ROM BYTE * | pName,
 |  | DWORD | Value,
 |  | BOOL | Selected,
 |  | BYTE | AccessLevel
 | ) |  |

Prints a formated HTML radio field to the HTTP socket with name string from ROM.

Output template:

<input type="radio" name="" value="" />
Parameters:
pName | Pointer to a string in ROM where the name of the radio field is located.
Value | Value of the radio field.
Selected | TRUE Writes a selected radio button, FALSE writes a not selected.
AccessLevel | The access level for this radio button (users with a lower access level are able to change the button). -1 -> Always read only.

void WebReportChangedState | ( | StateTableIDs_t | StringID,
 |  | PageID_t | DestinationPageID
 | ) |  |

Call this function during a HTTP POST session if the user should be forwarded to a message webpage (state.htm) showing a error or state change string.

Parameters:
StringID | The ID for a string shown on the message webpage.
DestinationPageID | The ID of the webpage where the user is forwarded to after acknowledging the message webpage with pressing OK.


Netzer: NetzerIO Project

NetzerIO Project

Detailed Description

These modules handle serial communication with peripherals connected via UART or SPI.

Furthermore digital IOs are handled by the NetzerIO project.

Files

file | gpio.c
Implementation of gpio access.
file | gpio.h
API for GPIO (digital IO) access.
file | i2c.c
Implementation of the I2C communication stuff.
file | i2c.h
API for serial communication via I2C.
file | io.c
Implementation of the common io application stuff.
file | projectdefs.h
Some project related defines and typedefs for the NetzerIO project.
file | projectIRQ.inc
This file extends the low priority interrupt hook to call some IO routines (for example filter timer and serial stubs).
file | projectIRQ.asm
This file extends low and high priority interrupts in a very efficient and small footprint manner.
file | serial.c
Implementation of the serial communication stuff.
file | serial.h
API for serial communication via UART or SPI.
file | webio.c
Implementation of the web io stuff.

Defines

#define | GPIOWriteSPIChipSelect(Value) LATFbits.LATF7 = Value
In SPI mode the SPI_CS pin can be quickly written with this function.
#define | GPIOWriteSPIInt(Value) LATCbits.LATC2 = Value
In SPI slave mode the int pin can be quickly written with this function.
#define | GPIOWriteSPIBusy(Value) LATAbits.LATA3 = Value
In SPI slave mode the busy pin can be quickly written with this function.
#define | GPIOReadSPIRegister() PORTBbits.RB1
In SPI slave mode the register pin can be quickly read with this function.
#define | GPIOWriteSPINetzerDataValid(Value) LATAbits.LATA2 = Value
In SPI slave mode the data valid pin can be quickly written with this function.
#define | GPIOReadSPIMasterWrite() PORTDbits.RD1
In SPI slave mode the master data valid can be quickly read with this function.
#define | GPIOReadSPIClock() PORTCbits.RC3
In SPI mode the SPI_INT pin can be quickly read with this function.

Enumerations

enum PortType_t {
PT_DIG_INPUT = 0, PT_DIG_OUTPUT, PT_ANALOG_INPUT, PT_PWM,
PT_IMPULSE
}
A GPIO channel can be configured as one of this types. More...
enum | TimerPrescaler_t { TMR_PRESCALER1 = 0, TMR_PRESCALER2, TMR_PRESCALER4, TMR_PRESCALER8 }
Use this enumerator to configure prescaler values for impulse generation. More...
enum | PWMFrequencies_t { PF_2500_HZ = 0, PF_10000_HZ, PF_40000_HZ }
Use this enumerator to configure prescaler values for PWM generation. More...
enum | ImpulseMode_t { IPM_SINGLE = 0, IPM_TRIGGERED, IPM_CONTINUOUS }
Modes for impulse generation. More...
enum | GPIOServerConnection_t { GPIO_SERVER_NOT_RUNNING = 0, GPIO_SERVER_RUNNING, GPIO_SERVER_CONNECTED }
This enumerator is used to express the GPIO server state. More...
enum | EdgeCounterMode_t { EC_DISABLED = 0, EC_DECREMENTS, EC_INCREMENTS }
Modes of the edge trigger counter. More...
enum | EdgeTriggerMode_t { ET_DISABLED = 0, ET_FALLING, ET_RISING }
Modes of the edge trigger interrupt. More...
enum EdgeFilterMode_t {
EF_DISABLED = 0, EF_1_MS, EF_10_MS, EF_100_MS,
EF_250_MS
}
Filter mode for the edge trigger interrupt. More...
enum | EventMode_t { EM_DISABLED = 0, EM_ON_FALLING_EDGES, EM_ON_RISING_EDGES, EM_ON_ALL_EDGES }
Modes for the GPIO event service. More...
enum | GPIORadix_t { RADIX_IS_HEXADECIMAL = 0, RADIX_IS_DECIMAL }
Display radix for numbers on webpages and GPIO server. More...

Functions

void | GPIOInit (SerialMode_t Mode)
Initializes the GPIO module in the requested mode.
void | GPIOResetToFactory (void)
Resets the GPIO module EEPROM section to well known start parameters.
WORD | GPIOGetTCPPort (BOOL bPersistent)
Delivers the current configured TCP port of the GPIO server.
void | GPIOSetTCPPortPersistent (WORD Port)
Configures a new TCP port for the GPIO server.
BOOL | GPIOInitTask (void)
After initializing network and application stuff the application should call this function to prepare task members needed for proper GPIO task operation.
void | GPIOTask (void)
Call this function periodically from main application to execute GPIO module tasks.
void | GPIOStopTask (void)
On network errors or shut down events these function should be called by the main application to proper stop the GPIO tasks (i.e disconnecting a connected client).
BOOL | bGPIOCheckForStoppedTask (void)
Before shutting down the application should poll for valid GPIO task shutdown.
PortType_t | GPIOGetPortType (BYTE GPIOChannel)
Delivers the current port configuration of a GPIO pin.
BOOL | GPIOIsPortOverwritten (BYTE GPIOChannel)
Delivers if the port is currently overwritten by an alternative pin (i.e serial).
void | GPIOSetPortValue (BYTE Channel, BOOL Value)
This function sets the state for a single IO pin.
BOOL | GPIOGetPinValue (BYTE GPIOChannel)
This function reads the state from a single IO pin.
GPIOServerConnection_t | GPIOGetServerState (void)
This function delivers the current state of the GPIO server.
DWORD | GPIOGetConnectedIP (void)
Delivers the IP of a client who is connected to GPIO server.
void | GPIOResetEdgeCounter (BYTE Channel)
Thread safe reset the edge counter for the given channel.
BOOL | GPIOServerIsActivated (void)
Getter for activated GPIO server.
void | GPIOActivateServerPersistent (BOOL Activate)
Setter for GPIO server state.
ROM BYTE * | GPIOGetPortName (BYTE Channel)
Delivers the port alias name for the given channel.
EventMode_t | GPIOGetEventMode (BYTE Channel)
Delivers the GPIO server event mode of a GPIO channel.
void | GPIOSetEventMode (BYTE Channel, EventMode_t Mode)
Sets the GPIO server event mode of a GPIO channel.
void | GPIOSetPortType (BYTE Channel, PortType_t PortType)
Sets the port mode of a GPIO channel.
BOOL | GPIOGetStartupValue (BYTE Channel)
Delivers the startup value for a given channel.
void | GPIOSetStartupValue (BYTE Channel, BOOL Value)
Configures the startup value for binary output configured values.
void | GPIOFlushToEEPROM (void)
All prior changed values are persistently written to EEPROM.
void | GPIOConfigurePort (BYTE Channel)
Call this function for a given channel to reconfigure the port and all other peripherals associated with the new port function.
BOOL | GPIOIsTypeSupportedByPort (BYTE Channel, PortType_t PortType)
Determines programmatically if a given port supports a requested configuration.
BOOL | GPIOGetImpulseLogic (BYTE Channel)
Delivers the configured logic for an impulse channel.
TimerPrescaler_t | GPIOGetImpulsePrescaler (void)
Delivers the configured prescaler for all impulse channel.
WORD | GPIOGetStartImpulseWidth (BYTE Channel)
Delivers the configured startup value for an impulse channel.
WORD | GPIOGetCurrentImpulseWidth (BYTE Channel)
Delivers the current value for an impulse channel.
void | GPIOSetImpulseLogic (BYTE Channel, BOOL Logic)
Configures the logic for an impulse channel.
void | GPIOSetImpulsePrescaler (TimerPrescaler_t Prescaler)
Configures the prescaler for all impulse channel.
void | GPIOSetStartupImpulseWidth (BYTE Channel, WORD ImpulseWidth)
Configures the startup value for an impulse channel.
void | GPIOSetCurrentImpulseWidth (BYTE Channel, WORD ImpulseWidth)
Sets the value for an impulse or pwm channel.
EdgeTriggerMode_t | GPIOGetEdgeTriggerMode (BYTE Channel)
Delivers the current mode of the edge trigger for a given channel.
EdgeFilterMode_t | GPIOGetEdgeFilterMode (BYTE Channel)
Delivers the current filter mode of the edge trigger for a given channel.
EdgeCounterMode_t | GPIOGetEdgeCounterMode (BYTE Channel)
Delivers the current counter mode of the edge trigger for a given channel.
DWORD | GPIOGetEdgeCounter (BYTE Channel)
Delivers the current edge counter value.
void | GPIOSetEdgeTriggerMode (BYTE Channel, EdgeTriggerMode_t Mode)
Configures a new edge trigger mode for a given channel.
void | GPIOSetEdgeFilterMode (BYTE Channel, EdgeFilterMode_t Mode)
Configures a new edge filter mode for a given channel.
void | GPIOSetEdgeCounterMode (BYTE Channel, EdgeCounterMode_t Mode)
Configures a new edge counter mode for a given channel.
void | GPIOSetAllPinValues (WORD NewValue)
Use this function to write to all pins at once.
void | GPIOSetPWMLogic (BYTE Channel, BOOL Value)
Configures the logic for a pwm channel.
void | GPIOSetPWMFrequency (PWMFrequencies_t Value)
Configures the frequency for all pwm channel.
void | GPIOSetPWMStartDuty (BYTE Channel, WORD Value)
Configures the startup value of a pwm channel.
BOOL | GPIOGetPWMLogic (BYTE Channel)
Delivers the configured logic for a pwm channel.
PWMFrequencies_t | GPIOGetPWMFrequency (void)
Delivers the configured frequency for all pwm channel.
WORD | GPIOGetPWMStartDuty (BYTE Channel)
Delivers the configured startup value for a pwm channel.
ImpulseMode_t | GPIOGetImpulseMode (void)
Delivers the configured mode for all impulse channel.
void | GPIOSetImpulseMode (ImpulseMode_t Mode)
Sets a new mode for all impulse channel.
void | GPIOReconfigurePeripherals (void)
Call this function after reconfiguring a single or multiple ports with GPIOConfigurePort.
void | GPIOInitPeripherals (void)
Call this function before reconfiguring a single or multiple ports with GPIOConfigurePort.
GPIORadix_t | GPIOGetRadix (void)
Delivers the currently set radix for displaying values on the GPIO server and the web interface.
void | GPIOSetRadix (GPIORadix_t NewRadix)
Sets a new radix for displaying values on the GPIO server and the web interface.
BYTE | GPIOGetRefresh (void)
Delivers the currently set refresh rate for auto refreshing the GPIO web interface.
void | GPIOSetRefresh (BYTE Refresh)
Sets a new refresh rate for auto refreshing the GPIO web interface.
BOOL | GPIOIsScriptActive (void)
Delivers if javascript for the GPIO web interface is currently active.
void | GPIOActivateScript (BOOL Active)
Activates or deactivates javascript for the GPIO web interface.
BOOL | GPIOIsAuthActive (void)
Delivers if authentication for the GPIO server is currently active.
void | GPIOActivateAuth (BOOL Active)
Activates or deactivates authentication for the GPIO server.

Define Documentation

#define GPIOReadSPIClock ( ) PORTCbits.RC3

In SPI mode the SPI_INT pin can be quickly read with this function.

Return values:
TRUE | The pin is high.
FALSE | The pin is low.

#define GPIOWriteSPIBusy ( Value ) LATAbits.LATA3 = Value

In SPI slave mode the busy pin can be quickly written with this function.

Parameters:
Value TRUE means on, FALSE means off.

#define GPIOWriteSPIChipSelect ( Value ) LATFbits.LATF7 = Value

In SPI mode the SPI_CS pin can be quickly written with this function.

Parameters:
Value TRUE means on, FALSE means off.

#define GPIOWriteSPIInt ( Value ) LATCbits.LATC2 = Value

In SPI slave mode the int pin can be quickly written with this function.

Parameters:
Value TRUE means on, FALSE means off.

#define GPIOWriteSPINetzerDataValid ( Value ) LATAbits.LATA2 = Value

In SPI slave mode the data valid pin can be quickly written with this function.

Parameters:
Value TRUE means on, FALSE means off.

Enumeration Type Documentation

enum EdgeCounterMode_t

Modes of the edge trigger counter.

Enumerator:
EC_DISABLED | Edge counter is disabled.
EC_DECREMENTS | Counter decrements on edges.
EC_INCREMENTS | Counter increments on edges.

enum EdgeFilterMode_t

Filter mode for the edge trigger interrupt.

All edges after a detected edge are filtered out up to a given time after. It is possible to debounce switches for example.

Enumerator:
EF_DISABLED | No filter is enabled.
EF_1_MS | Filter all edges up to a millisecond after.
EF_10_MS | Filter all edges up to 10 milliseconds after.
EF_100_MS | Filter all edges up to 100 milliseconds after.
EF_250_MS | Filter all edges up to 250 milliseconds after.

enum EdgeTriggerMode_t

Modes of the edge trigger interrupt.

Enumerator:
ET_DISABLED | Edge trigger interrupt is disabled.
ET_FALLING | Edge trigger interrupt on falling edges.
ET_RISING | Edge trigger interrupt on rising edges.

enum EventMode_t

Modes for the GPIO event service.

On configured events a x=... message is sent to the client without request.

Enumerator:
EM_DISABLED | Event service is disabled.
EM_ON_FALLING_EDGES | Events are sent on falling edges.
EM_ON_RISING_EDGES | Events are sent on rising edges.
EM_ON_ALL_EDGES | Events are sent on both edges.

enum GPIORadix_t

Display radix for numbers on webpages and GPIO server.

Enumerator:
RADIX_IS_HEXADECIMAL | Radix is hexadecimal.
RADIX_IS_DECIMAL | Radix is decimal.

enum GPIOServerConnection_t

This enumerator is used to express the GPIO server state.

Enumerator:
GPIO_SERVER_NOT_RUNNING | Inactive server.
GPIO_SERVER_RUNNING | Running, waiting for client connect.
GPIO_SERVER_CONNECTED | Client connected, waiting for GPIO commands.

enum ImpulseMode_t

Modes for impulse generation.

Enumerator:
IPM_SINGLE | Single impulse generation on writing a new value.
IPM_TRIGGERED | Impulse generation on edge interrupt of IO0.
IPM_CONTINUOUS | Continuous impulse generation with 16 bit resolution.

enum PortType_t

A GPIO channel can be configured as one of this types.

Enumerator:
PT_DIG_INPUT | Configure pin as digital input.
PT_DIG_OUTPUT | Configure pin as digital output.
PT_ANALOG_INPUT | Pin is configured as analog input.
PT_PWM | Pin is configured as PWM output.
PT_IMPULSE | Pin is configured for impulse generation.

enum PWMFrequencies_t

Use this enumerator to configure prescaler values for PWM generation.

Enumerator:
PF_2500_HZ | 2500 Hertz.
PF_10000_HZ | 10000 Hertz.
PF_40000_HZ | 40000 Hertz.

enum TimerPrescaler_t

Use this enumerator to configure prescaler values for impulse generation.

Enumerator:
TMR_PRESCALER1 | Unit is 100 ns.
TMR_PRESCALER2 | Unit is 200 ns.
TMR_PRESCALER4 | Unit is 400 ns.
TMR_PRESCALER8 | Unit is 800 ns.

Function Documentation

BOOL bGPIOCheckForStoppedTask ( void )

Before shutting down the application should poll for valid GPIO task shutdown.

Return values:
TRUE | The task has successfully stopped.
FALSE | Stopping the GPIO task is pending.

void GPIOActivateAuth ( BOOL Active )

Activates or deactivates authentication for the GPIO server.

The new state is not automatically stored in EEPROM. Call the function GPIOFlushToEEPROM for persistent storage.

Parameters:
Active TRUE enables authentication, FALSE disables it.

void GPIOActivateScript ( BOOL Active )

Activates or deactivates javascript for the GPIO web interface.

The new javascript state is not automatically stored in EEPROM. Call the function GPIOFlushToEEPROM for persistent storage.

Parameters:
Active TRUE activates javascript. FALSE deactivates javascript.

void GPIOActivateServerPersistent ( BOOL Activate )

Setter for GPIO server state.

The server is deactivated or activated after restarting Netzer.

Parameters:
Activate If TRUE, server is activated after restart. If FALSE, server is deactivated after restart.

void GPIOConfigurePort ( BYTE Channel )

Call this function for a given channel to reconfigure the port and all other peripherals associated with the new port function.

Parameters:
Channel GPIO channel. All channels are supported.

void GPIOFlushToEEPROM ( void )

All prior changed values are persistently written to EEPROM.

DWORD GPIOGetConnectedIP ( void )

Delivers the IP of a client who is connected to GPIO server.

Returns:
The IP address as 32 bit value, 0 if no client is connected.

WORD GPIOGetCurrentImpulseWidth ( BYTE Channel )

Delivers the current value for an impulse channel.

Parameters:
Channel GPIO channel. GPIO_03_ID and GPIO_09_ID are supported.
Returns:
The impulse value.

DWORD GPIOGetEdgeCounter ( BYTE Channel )

Delivers the current edge counter value.

Parameters:
Channel GPIO channel. Only GPIO_00_ID, GPIO_01_ID and GPIO_02_ID are supported.
Returns:
The current edge counter value. The low word contains the value. If the high word is not 0 than the counter is overrun or underrun. It depends on the counters configuration.

EdgeCounterMode_t GPIOGetEdgeCounterMode ( BYTE Channel )

Delivers the current counter mode of the edge trigger for a given channel.

Parameters:
Channel GPIO channel. Only GPIO_00_ID, GPIO_01_ID and GPIO_02_ID are supported.
Returns:
The configured edge counter mode.

EdgeFilterMode_t GPIOGetEdgeFilterMode ( BYTE Channel )

Delivers the current filter mode of the edge trigger for a given channel.

Parameters:
Channel GPIO channel. Only GPIO_00_ID, GPIO_01_ID and GPIO_02_ID are supported.
Returns:
The configured filter mode.

EdgeTriggerMode_t GPIOGetEdgeTriggerMode ( BYTE Channel )

Delivers the current mode of the edge trigger for a given channel.

Parameters:
Channel GPIO channel. Only GPIO_00_ID, GPIO_01_ID and GPIO_02_ID are supported.
Returns:
The configured mode.

EventMode_t GPIOGetEventMode ( BYTE Channel )

Delivers the GPIO server event mode of a GPIO channel.

Parameters:
Channel GPIO channel. All channels are supported.
Returns:
The mode of the requested channel.

BOOL GPIOGetImpulseLogic ( BYTE Channel )

Delivers the configured logic for an impulse channel.

Parameters:
Channel GPIO channel. GPIO_03_ID and GPIO_09_ID are supported.
Return values:
TRUE | The impulse logic is '1'. Means that on full level the output is constantly '1'.
FALSE | The impulse logic is '0'. Means that on full level the output is constantly '0'.

ImpulseMode_t GPIOGetImpulseMode ( void )

Delivers the configured mode for all impulse channel.

Returns:
The configured impulse mode.

TimerPrescaler_t GPIOGetImpulsePrescaler ( void )

Delivers the configured prescaler for all impulse channel.

Returns:
The prescaler value.

BOOL GPIOGetPinValue ( BYTE GPIOChannel )

This function reads the state from a single IO pin.

This reading is indpendent from the configured direction of the pin.

Parameters:
GPIOChannel Use one of the GPIO_XX_ID defines to select the IO pin.

ROM BYTE* GPIOGetPortName ( BYTE Channel )

Delivers the port alias name for the given channel.

Parameters:
Channel Channel of the requested name.
Returns:
ROM pointer to the name.

PortType_t GPIOGetPortType ( BYTE GPIOChannel )

Delivers the current port configuration of a GPIO pin.

Parameters:
GPIOChannel Channel to request.
Returns:
Configured port type.

PWMFrequencies_t GPIOGetPWMFrequency ( void )

Delivers the configured frequency for all pwm channel.

Returns:
The configured frequency.

BOOL GPIOGetPWMLogic ( BYTE Channel )

Delivers the configured logic for a pwm channel.

Parameters:
Channel GPIO channel. GPIO_03_ID and GPIO_09_ID are supported.
Return values:
TRUE | The pwm logic is '1'. Means that on full level the output is constantly '1'.
FALSE | The pwm logic is '0'. Means that on full level the output is constantly '0'.

WORD GPIOGetPWMStartDuty ( BYTE Channel )

Delivers the configured startup value for a pwm channel.

Parameters:
Channel GPIO channel. GPIO_03_ID and GPIO_09_ID are supported.
Returns:
The configured startup value.

GPIORadix_t GPIOGetRadix ( void )

Delivers the currently set radix for displaying values on the GPIO server and the web interface.

Returns:
The configured radix.

BYTE GPIOGetRefresh ( void )

Delivers the currently set refresh rate for auto refreshing the GPIO web interface.

Returns:
The currently configured refresh rate in seconds. 0 means off.

GPIOServerConnection_t GPIOGetServerState ( void )

This function delivers the current state of the GPIO server.

Returns:
The current state.

WORD GPIOGetStartImpulseWidth ( BYTE Channel )

Delivers the configured startup value for an impulse channel.

Parameters:
Channel GPIO channel. GPIO_03_ID and GPIO_09_ID are supported.
Returns:
The impulse startup value.

BOOL GPIOGetStartupValue ( BYTE Channel )

Delivers the startup value for a given channel.

This startup value is only valid for ports configured as digital output.

Parameters:
Channel GPIO channel. All channels are supported.
Return values:
TRUE | Output is '1' on startup.
FALSE | Output is '0' on startup.

WORD GPIOGetTCPPort ( BOOL bPersistent )

Delivers the current configured TCP port of the GPIO server.

Parameters:
bPersistent If TRUE the return value is read from EEPROM. If FALSE the value is taken from the current state.
Returns:
The port of the listening GPIO server.

void GPIOInit ( SerialMode_t Mode )

Initializes the GPIO module in the requested mode.

Should be called once at startup (very early).

Parameters:
Mode Specifies the serial mode for NetzerIO. GPIO module must know this because it configures some port pins also for the serial modes.

void GPIOInitPeripherals ( void )

Call this function before reconfiguring a single or multiple ports with GPIOConfigurePort.

The function disables timer and interrupts and initializes all periperals to a startup state.

BOOL GPIOInitTask ( void )

After initializing network and application stuff the application should call this function to prepare task members needed for proper GPIO task operation.

Return values:
TRUE | Initialization was successful.
FALSE | Initialization failed, try again later.

BOOL GPIOIsAuthActive ( void )

Delivers if authentication for the GPIO server is currently active.

If active a login prompt is printed on the server first and username and password must be entered before usage of the server.

Return values:
TRUE | Authentication is enabled.
FALSE | Authentication is disabled.

BOOL GPIOIsPortOverwritten ( BYTE GPIOChannel )

Delivers if the port is currently overwritten by an alternative pin (i.e serial).

Parameters:
GPIOChannel Channel to request.
Return values:
TRUE | Channel is overwritten.
FALSE | Channel is used as configured.

BOOL GPIOIsScriptActive ( void )

Delivers if javascript for the GPIO web interface is currently active.

Return values:
TRUE | Javascript is enabled.
FALSE | Javascript is disabled.

BOOL GPIOIsTypeSupportedByPort | ( | BYTE | Channel,
 |  | PortType_t | PortType
 | ) |  |

Determines programmatically if a given port supports a requested configuration.

Parameters:
Channel | GPIO channel. All channels are supported.
PortType | Type which is requested for the given channel.
Return values:
TRUE | Channel supports port type.
FALSE | Channel does not support port type.

void GPIOReconfigurePeripherals ( void )

Call this function after reconfiguring a single or multiple ports with GPIOConfigurePort.

The function configures timer and enables interrupts as needed.

void GPIOResetEdgeCounter ( BYTE Channel )

Thread safe reset the edge counter for the given channel.

Parameters:
Channel Channel to reset. Only GPIO_00_ID, GPIO_01_ID and GPIO_02_ID support the edge counter.

BOOL GPIOServerIsActivated ( void )

Getter for activated GPIO server.

Return values:
TRUE | The server is active in the current session.
FALSE | The server is not active in the current session.

void GPIOSetAllPinValues ( WORD NewValue )

Use this function to write to all pins at once.

Only ports which are configured as digital outputs are affected.

Parameters:
NewValue All pin values in a port mask.

void GPIOSetCurrentImpulseWidth | ( | BYTE | Channel,
 |  | WORD | ImpulseWidth
 | ) |  |

Sets the value for an impulse or pwm channel.

This value is not stored persistently. Use GPIOSetStartupImpulseWidth instead. For impulse channels the value must be at least 100. For pwm channels the maximum value is 1023. The function automatically adjust this values if exceeded.

Parameters:
Channel | GPIO channel. GPIO_03_ID and GPIO_09_ID are supported.
ImpulseWidth | New value.

void GPIOSetEdgeCounterMode | ( | BYTE | Channel,
 |  | EdgeCounterMode_t | Mode
 | ) |  |

Configures a new edge counter mode for a given channel.

The new mode is not automatically stored in EEPROM. Call the function GPIOFlushToEEPROM for persistent storage.

Parameters:
Channel | GPIO channel. Only GPIO_00_ID, GPIO_01_ID and GPIO_02_ID are supported.
Mode | The new counter mode.

void GPIOSetEdgeFilterMode | ( | BYTE | Channel,
 |  | EdgeFilterMode_t | Mode
 | ) |  |

Configures a new edge filter mode for a given channel.

The new mode is not automatically stored in EEPROM. Call the function GPIOFlushToEEPROM for persistent storage.

Parameters:
Channel | GPIO channel. Only GPIO_00_ID, GPIO_01_ID and GPIO_02_ID are supported.
Mode | The new filter mode.

void GPIOSetEdgeTriggerMode | ( | BYTE | Channel,
 |  | EdgeTriggerMode_t | Mode
 | ) |  |

Configures a new edge trigger mode for a given channel.

The new mode is not automatically stored in EEPROM. Call the function GPIOFlushToEEPROM for persistent storage.

Parameters:
Channel | GPIO channel. Only GPIO_00_ID, GPIO_01_ID and GPIO_02_ID are supported.
Mode | The new mode.

void GPIOSetEventMode | ( | BYTE | Channel,
 |  | EventMode_t | Mode
 | ) |  |

Sets the GPIO server event mode of a GPIO channel.

The new mode is not automatically stored in EEPROM. Call the function GPIOFlushToEEPROM for persistent storage.

Parameters:
Channel | GPIO channel. All channels are supported.
Mode | The new mode of the requested channel.

void GPIOSetImpulseLogic | ( | BYTE | Channel,
 |  | BOOL | Logic
 | ) |  |

Configures the logic for an impulse channel.

The new logic is not automatically stored in EEPROM. Call the function GPIOFlushToEEPROM for persistent storage.

Parameters:
Channel | GPIO channel. GPIO_03_ID and GPIO_09_ID are supported.
Logic | TRUE means on full level the output is constantly '1'. FALSE means on full level the output is constantly '0'.

void GPIOSetImpulseMode ( ImpulseMode_t Mode )

Sets a new mode for all impulse channel.

The new mode is not automatically stored in EEPROM. Call the function GPIOFlushToEEPROM for persistent storage.

Parameters:
Mode The new impulse mode.

void GPIOSetImpulsePrescaler ( TimerPrescaler_t Prescaler )

Configures the prescaler for all impulse channel.

The new prescaler value is not automatically stored in EEPROM. Call the function GPIOFlushToEEPROM for persistent storage.

Parameters:
Prescaler New prescaler value.

void GPIOSetPortType | ( | BYTE | Channel,
 |  | PortType_t | PortType
 | ) |  |

Sets the port mode of a GPIO channel.

The new port mode is not automatically stored in EEPROM. Call the function GPIOFlushToEEPROM for persistent storage.

Parameters:
Channel | GPIO channel. All channels are supported.
PortType | The new type of the requested channel.

void GPIOSetPortValue | ( | BYTE | Channel,
 |  | BOOL | Value
 | ) |  |

This function sets the state for a single IO pin.

That is only valid if the pin is not overwritten by another function of i.e the serial server. Also the pin must be configured as digital output.

Parameters:
Channel | Use one of the GPIO_XX_ID defines to select the IO pin.
Value | TRUE means on, FALSE means off.

void GPIOSetPWMFrequency ( PWMFrequencies_t Value )

Configures the frequency for all pwm channel.

The new frequency is not automatically stored in EEPROM. Call the function GPIOFlushToEEPROM for persistent storage.

Parameters:
Value The new frequency.

void GPIOSetPWMLogic | ( | BYTE | Channel,
 |  | BOOL | Value
 | ) |  |

Configures the logic for a pwm channel.

The new logic is not automatically stored in EEPROM. Call the function GPIOFlushToEEPROM for persistent storage.

Parameters:
Channel | GPIO channel. GPIO_03_ID and GPIO_09_ID are supported.
Value | TRUE means on full level the output is constantly '1'. FALSE means on full level the output is constantly '0'.

void GPIOSetPWMStartDuty | ( | BYTE | Channel,
 |  | WORD | Value
 | ) |  |

Configures the startup value of a pwm channel.

The new value is not automatically stored in EEPROM. Call the function GPIOFlushToEEPROM for persistent storage.

Parameters:
Channel | GPIO channel. GPIO_03_ID and GPIO_09_ID are supported.
Value | The new startup value. Due the 10 bit width only values up to 1023 can be set. Higher values are automatically adjusted to 1023.

void GPIOSetRadix ( GPIORadix_t NewRadix )

Sets a new radix for displaying values on the GPIO server and the web interface.

The new radix is not automatically stored in EEPROM. Call the function GPIOFlushToEEPROM for persistent storage.

Parameters:
NewRadix The new radix.

void GPIOSetRefresh ( BYTE Refresh )

Sets a new refresh rate for auto refreshing the GPIO web interface.

The new rate is not automatically stored in EEPROM. Call the function GPIOFlushToEEPROM for persistent storage.

Parameters:
Refresh The new refresh rate in seconds. 0 disables refreshing.

void GPIOSetStartupImpulseWidth | ( | BYTE | Channel,
 |  | WORD | ImpulseWidth
 | ) |  |

Configures the startup value for an impulse channel.

The new startup value is not automatically stored in EEPROM. Call the function GPIOFlushToEEPROM for persistent storage. The value must be at least 100. Else the function adjusts it to 100.

Parameters:
Channel | GPIO channel. GPIO_03_ID and GPIO_09_ID are supported.
ImpulseWidth | Impulse value on startup.

void GPIOSetStartupValue | ( | BYTE | Channel,
 |  | BOOL | Value
 | ) |  |

Configures the startup value for binary output configured values.

The new startup value is not automatically stored in EEPROM. Call the function GPIOFlushToEEPROM for persistent storage.

Parameters:
Channel | GPIO channel. All channels are supported.
Value | TRUE means output is '1' on startup. FALSE means output is '0' on startup.

void GPIOSetTCPPortPersistent ( WORD Port )

Configures a new TCP port for the GPIO server.

This value is stored persistent in EEPROM.

Parameters:
Port The new port value.

void GPIOStopTask ( void )

On network errors or shut down events these function should be called by the main application to proper stop the GPIO tasks (i.e disconnecting a connected client).

void GPIOTask ( void )

Call this function periodically from main application to execute GPIO module tasks.


Netzer: TCP/IP Stack from Microchip Version 4.50 (Modified)

TCP/IP Stack from Microchip Version 4.50 (Modified)

Detailed Description

Choosen Microchips ethernet controller family among PIC18F97J60 enables the Netzer project to use the free open source TCP/IP stack of microchip.

Note: The first versions of Netzer based on some older stack versions since V4.0. I have merged periodicly with new stack versions to get the latest bug fixes from Microchip.

For more informations regarding the Microchip Stack see AN833.

Some parts of the stack are modified due the requirements of Netzer. This parts are marked directly in the code (look after the keyword MODIFIX) or in case of large modifications at the headers of the files.

Doxygen comments are also added to used functions to generate a more detailed documentation for a better understanding of Netzer.

Software License Agreement
Copyright (C) 2002-2008 Microchip Technology Inc. All rights reserved.

Microchip licenses to you the right to use, modify, copy, and distribute: (i) the Software when embedded on a Microchip microcontroller or digital signal controller product ("Device") which is integrated into Licensee's product; or (ii) ONLY the Software driver source files ENC28J60.c and ENC28J60.h ported to a non-Microchip device used in conjunction with a Microchip ethernet controller for the sole purpose of interfacing with the ethernet controller.

You should refer to the license agreement accompanying this Software for additional information regarding your rights and obligations.

THE SOFTWARE AND DOCUMENTATION ARE PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION, ANY WARRANTY OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT SHALL MICROCHIP BE LIABLE FOR ANY INCIDENTAL, SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES, LOST PROFITS OR LOST DATA, COST OF PROCUREMENT OF SUBSTITUTE GOODS, TECHNOLOGY OR SERVICES, ANY CLAIMS BY THIRD PARTIES (INCLUDING BUT NOT LIMITED TO ANY DEFENSE THEREOF), ANY CLAIMS FOR INDEMNITY OR CONTRIBUTION, OR OTHER SIMILAR COSTS, WHETHER ASSERTED ON THE BASIS OF CONTRACT, TORT (INCLUDING NEGLIGENCE), BREACH OF WARRANTY, OR OTHERWISE.

Click here for a printable version.

Modules

ARP
The Address Resolution Protocol, or ARP, is a foundation layer of TCP/IP.
DHCP
Dynamic Host Configuration Protocol (DHCP) is a protocol used by networked devices (clients) to obtain various parameters necessary for the clients to operate in an Internet Protocol (IP) network.
HTTP
Hypertext Transfer Protocol (HTTP) is a communications protocol for the transfer of information on the intranet and the World Wide Web.
ICMP
Implements a PING server as the only ICMP service.
IP
This group implements the IP or network layer.
MAC
The MAC or data link layer provides basic functions to access the underlaying physical layer.
MPFS
The MPFS2 file system module provides a light-weight read-only file system that can be stored in external EEPROM, external serial Flash, or internal Flash program memory.
Reboot
This UDP based module listens continously for UDP packets addressing the TFTP port.
Stack Task
The Stack Manager coordinates the other Microchip TCP/IP Stack modules.
TCP
TCP is a standard transport layer protocol described in RFC 793.
Tick
The Tick module provides accurate time-keeping capabilities based on the hardware clock.
UDP
UDP is a standard transport layer protocol described in RFC 768.


Netzer: ARP

ARP
[TCP/IP Stack from Microchip Version 4.50 (Modified)]

Detailed Description

The Address Resolution Protocol, or ARP, is a foundation layer of TCP/IP.

It translates IP addresses to physical MAC addresses, or locates a gateway through which a machine may be located. TCP applications will not need to access ARP directly. The TCPOpen function will handle both ARP and DNS operations transparently. UDP applications however will likely need to use ARP. Responses to incoming ARP requests are processed automatically. Resolution of ARP requests follows a simple state machine, as indicated in the following diagram.

Files

file | ARP.c
Address Resolution Protocol (ARP) Client and Server Module for Microchip TCP/IP Stack.
file | ARP.h
ARP Module Defs for Microchip TCP/IP Stack.

Functions

void | ARPResolve (IP_ADDR *IPAddr)
Transmits an ARP request to resolve an IP address.
BOOL | ARPIsResolved (IP_ADDR *IPAddr, MAC_ADDR *MACAddr)
Determines if an ARP request has been resolved yet.
void | ARPFlush (void)
Flushes the ARP cache.

Function Documentation

BOOL ARPIsResolved | ( | IP_ADDR * | IPAddr,
 |  | MAC_ADDR * | MACAddr
 | ) |  |

Determines if an ARP request has been resolved yet.

This function checks if an ARP request has been resolved yet, and if so, stores the resolved MAC address in the pointer provided.

Precondition:
ARP packet is ready in the MAC buffer.
Parameters:
IPAddr | - The IP address to be resolved
MACAddr | - A buffer to store the corresponding MAC address
Return values:
TRUE | The IP address has been resolved and MAC address indicates the response.
FALSE | The IP address is not resolved.
Remarks:
None

void ARPResolve ( IP_ADDR * IPAddr )

Transmits an ARP request to resolve an IP address.

This function transmits and ARP request to determine the hardware address of a given IP address.

Precondition:
ARP packet is ready in the MAC buffer.
Parameters:
IPAddr - The IP address to be resolved
Returns:
None
Remarks:
None

Generated on Fri Mar 29 10:34:28 2013 for Netzer by doxygen 1.5.5


Netzer: DHCP

DHCP
[TCP/IP Stack from Microchip Version 4.50 (Modified)]

Detailed Description

Dynamic Host Configuration Protocol (DHCP) is a protocol used by networked devices (clients) to obtain various parameters necessary for the clients to operate in an Internet Protocol (IP) network.

By using this protocol, system administration workload greatly decreases, and devices can be added to the network with minimal or no manual configurations (Source: Wikipedia).

Files

file | DHCP.c
Dynamic Host Configuration Protocol (DHCP) Client Module for Microchip TCP/IP Stack.
file | DHCP.h
DHCP Defs for Microchip TCP/IP Stack.

Defines

#define | DHCPIsBound() (DHCPFlags.bits.bIsBound)
Determines if the DHCP server is currently bound.

Functions

void | DHCPReset (void)
Resets the DHCP Client.
void | DHCPTask (void)
Performs periodic DHCP tasks.
void | DHCPDisable (void)
Disables the DHCP client.
void | DHCPEnable (void)
Enables the DHCP client.
BOOL | DHCPHasBoundStateChanged (void)
This function checks whether the internal address bound state of thze DHCP client has changed.
void | DHCPGetIPParameterFromServer (IPConfig_t *pIPConfig)
If DHCP client is bound this function fills the given IP structure with the current IP parameters obtained from DHCP server.
BOOL | DHCPIsEnabled (void)
This function returns the enable state of the DHCP client.
BOOL | DHCPHasFailed (void)
This function returns the failed state of the DHCP client.

Define Documentation

#define DHCPIsBound ( ) (DHCPFlags.bits.bIsBound)

Determines if the DHCP server is currently bound.

Return values:
TRUE | DHCP is bound to given configuration.
FALSE | DHCP has not yet been bound.
Remarks:
This function is a MACRO to DHCPFlags.bits.bIsBound.

Function Documentation

void DHCPDisable ( void )

Disables the DHCP client.

Disables the DHCP client by sending the state machine to "SM_DHCP_DISABLED". If the board was previously configured by DHCP, the configuration will continue to be used but the module will no longer preform any renewals.

Precondition:
None
Returns:
None
Remarks:
Since the board continues using its old configuration, it is possible that the lease may expire and the DHCP server provide the IP to another client. The application should replace the current IP address and other configuration with static information following a call to this function.

void DHCPEnable ( void )

Enables the DHCP client.

Enables the DHCP client if it is disabled. If it is already enabled, nothing is done.

Precondition:
None
Returns:
None

void DHCPGetIPParameterFromServer ( IPConfig_t * pIPConfig )

If DHCP client is bound this function fills the given IP structure with the current IP parameters obtained from DHCP server.

Those parameters which are not obtained by server stay zero. If the client is not bound then the structure is cleared only.

Parameters:
pIPConfig Pointer to IP structure field.

BOOL DHCPHasBoundStateChanged ( void )

This function checks whether the internal address bound state of thze DHCP client has changed.

The bound state change is a semaphore and clears automatically with this function call (if set).

Return values:
TRUE | State has changed (either got an IP address or lost the current IP due elapsed lease time. Check DHCPIsBound for more details.
FALSE | State has not changed since last call.

BOOL DHCPHasFailed ( void )

This function returns the failed state of the DHCP client.

Return values:
TRUE | Obtaining has failed for the first time - client tries later automatically.
FALSE | The client has successfully obtained IP data or obtianing is currently in progress.

BOOL DHCPIsEnabled ( void )

This function returns the enable state of the DHCP client.

Return values:
TRUE | The client is enabled.
FALSE | The client is disabled.

void DHCPReset ( void )

Resets the DHCP Client.

Resets the DHCP Client, giving up any current lease, knowledge of DHCP servers, etc.

Precondition:
None
Returns:
None

void DHCPTask ( void )

Performs periodic DHCP tasks.

This function performs any periodic tasks requied by the DHCP module, such as sending and receiving messages involved with obtaining and maintaining a lease.

Precondition:
None
Returns:
None
MODIFIX: Added AutoIP support.

Todo:
Save the probed auto IP-Address in EEPROM


Netzer: HTTP

HTTP
[TCP/IP Stack from Microchip Version 4.50 (Modified)]

Detailed Description

Hypertext Transfer Protocol (HTTP) is a communications protocol for the transfer of information on the intranet and the World Wide Web.

Its original purpose was to provide a way to publish and retrieve hypertext pages over the Internet (Source Wikipedia).

Files

file | HTTP2.c
HyperText Transfer Protocol (HTTP) Server Module for Microchip TCP/IP Stack.
file | HTTP2.h
HTTP definitions on Microchip TCP/IP Stack.


Netzer: ICMP

ICMP
[TCP/IP Stack from Microchip Version 4.50 (Modified)]

Detailed Description

Implements a PING server as the only ICMP service.

Other nodes in an ethernet network can ping the device for testing the connection.

Files

file | ICMP.c
Internet Control Message Protocol (ICMP) Server Module for Microchip TCP/IP Stack.
file | ICMP.h
ICMP Module Defs for Microchip TCP/IP Stack.


Netzer: IP

IP
[TCP/IP Stack from Microchip Version 4.50 (Modified)]

Detailed Description

This group implements the IP or network layer.

Almost all functions of the group are used by UDP and TCP functions.

Files

file | IP.c
Internet Protocol (IP) Version 4 Communications Layer Module for Microchip TCP/IP Stack.
file | IP.h
IP Defs for Microchip TCP/IP Stack.

Functions

DWORD | IPConvertSubnetToMask (BYTE Subnet)
This function converts the CIDR subnet expression to the long IP expression.
BYTE | IPConvertMaskToSubnet (BYTE *MaskArray)
This function converts the long IP subnet expression to the CIDR expression.

Function Documentation

BYTE IPConvertMaskToSubnet ( BYTE * MaskArray )

This function converts the long IP subnet expression to the CIDR expression.

Examples for subnet expression relations:
CIDR | Netmask
/8 | 255.0.0.0
/12 | 255.240.0.0
/16 | 255.255.0.0
/20 | 255.255.240.0
/24 | 255.255.255.0
/30 | 255.255.255.252
This function is added for MoBaCon projects.

Todo:
Add the (DWORD) output values.
Todo:
Move this function to the helpers.
Parameters:
MaskArray The subnet as long IP expression (i.e {255,0,0,0}).
Returns:
The subnet mask as CIDR expression.

DWORD IPConvertSubnetToMask ( BYTE Subnet )

This function converts the CIDR subnet expression to the long IP expression.

Examples for subnet expression relations:
CIDR | Netmask
/8 | 255.0.0.0
/12 | 255.240.0.0
/16 | 255.255.0.0
/20 | 255.255.240.0
/24 | 255.255.255.0
/30 | 255.255.255.252
This function is added for MoBaCon projects.

Todo:
Move this function to the helpers.
Parameters:
Subnet The subnet in CIDR notation.
Returns:
The subnet mask as long IP expression.


Netzer: MAC

MAC
[TCP/IP Stack from Microchip Version 4.50 (Modified)]

Detailed Description

The MAC or data link layer provides basic functions to access the underlaying physical layer.

This physical layer and parts of the MAC layer are part of the ethernet transceiver. Additional functions like hardware initialisization, packet transmission and receiption must be done in software. The functions of this group do this job.

Files

file | ETH97J60.c
Medium Access Control (MAC) Layer for Microchip PIC18F97J60 family.
file | ETH97J60.h
Ethernet registers/bits for PIC18F97J60.
file | MAC.h
MAC Module Defs for Microchip Stack.

Functions

BOOL | MACIsLinked (void)
Returns the link status of the PHY/MAC.

Function Documentation

BOOL MACIsLinked ( void )

Returns the link status of the PHY/MAC.

Precondition:
None
Return values:
TRUE | If the PHY reports that a link partner is present and the link has been up continuously since the last call to MACIsLinked().
FALSE | If the PHY reports no link partner, or the link went down momentarily since the last call to MACIsLinked()
Remarks:
None

Generated on Fri Mar 29 10:34:28 2013 for Netzer by doxygen 1.5.5


Netzer: MPFS

MPFS
[TCP/IP Stack from Microchip Version 4.50 (Modified)]

Detailed Description

The MPFS2 file system module provides a light-weight read-only file system that can be stored in external EEPROM, external serial Flash, or internal Flash program memory.

This file system serves as the basis for the HTTP2 web server module, but is also used by the SNMP module and is available to other applications that require basic read-only storage capabilities.

Files

file | MPFS2.c
Microchip File System (MPFS) File Access API.
file | MPFS2.h
MPFS Defines and prototypes for Microchip File System.


Netzer: Reboot

Reboot
[TCP/IP Stack from Microchip Version 4.50 (Modified)]

Detailed Description

This UDP based module listens continously for UDP packets addressing the TFTP port.

If receiving a packet it initiates a shut down procedure for activating the bootloader and starting a firmware update.

Files

file | Reboot.c
Module for Microchip TCP/IP Stack
  • Remotely resets the PIC
  • Reference: Internet Bootloader documentation.

file | Reboot.h
Reboot Server Module Header.


Netzer: Stack Task

Stack Task
[TCP/IP Stack from Microchip Version 4.50 (Modified)]

Detailed Description

The Stack Manager coordinates the other Microchip TCP/IP Stack modules.

StackTask is implemented as a cooperative task; when given processing time, it polls the MAC layer for valid data packets. When one is received, it decodes it and routes it to the appropriate module for further processing.

Files

file | StackTsk.c
TCP/IP Stack Manager Module for Microchip TCP/IP Stack.
file | StackTsk.h
Microchip TCP/IP Stack Definitions.

Typedefs

typedef struct _MAC_ADDR | MAC_ADDR
This structure stores a 6 byte MAC address.
typedef struct _NODE_INFO | NODE_INFO
This structure stores informations of an network node.

Functions

void | StackInit (void)
Initializes the Microchip TCP/IP Stack and its components.
void | StackTask (void)
TCP/IP Stack FSM is executed.
void | StackApplications (void)
Calls all loaded application modules.

Function Documentation

void StackApplications ( void )

Calls all loaded application modules.

Precondition:
StackInit() is already called.
Remarks:
This function must be called periodically to ensure timely responses.

void StackInit ( void )

Initializes the Microchip TCP/IP Stack and its components.

Precondition:
None
Remarks:
This function must be called before any of the stack or its component routines are used.

void StackTask ( void )

TCP/IP Stack FSM is executed.

Precondition:
StackInit() is already called.
Remarks:
This FSM checks for new incoming packets, and routes it to appropriate stack components. It also performs timed operations. This function must be called periodically to ensure timely responses.


Netzer: TCP

TCP
[TCP/IP Stack from Microchip Version 4.50 (Modified)]

Detailed Description

TCP is a standard transport layer protocol described in RFC 793.

It provides reliable stream-based connections over unreliable networks, and forms the foundation for HTTP, SMTP, and many other protocol standards.

Connections made over TCP guarantee data transfer at the expense of throughput. Connections are made through a three-way handshake process, ensuring a one-to- one connection. Remote nodes advertise how much data they are ready to receive, and all data transmitted must be acknowledged. If a remote node fails to acknowledge the receipt of data, it is automatically retransmitted. This ensures that network errors such as lost, corrupted, or out-of-order packets are automatically corrected.

To accomplish this, TCP must operate in a buffer. Once the transmit buffer is full, no more data can be sent until the remote node has acknowledged receipt. For the Microchip TCP/IP Stack, the application must return to the main stack loop in order for this to happen. Likewise, the remote node cannot transmit more data until the local device has acknowledged receipt and that space is available in the buffer. When a local application needs to read more data, it must return to the main stack loop and wait for a new packet to arrive.

The TCP flow diagram below provides an overview for the use of the TCP module:

Sockets are opened using TCPOpen. This function can either open a listening socket to wait for client connections, or can make a client connection to the remote node. The remote node can be specified by a host name string to be resolved in DNS, an IP address, or a NODE_INFO struct containing previously resolved IP and MAC address information.

Once connected, applications can read and write data. On each entry, the application must verify that the socket is still connected. For most applications a call to TCPIsConnected will be sufficient, but TCPWasReset may also be used for listening sockets that may turn over quickly.

To write data, call TCPIsPutReady to check how much space is available. Then, call any of the TCPPut family of functions to write data as space is available. Once complete, call TCPFlush to transmit data immediately. Alternately, return to the main stack loop. Data will be transmitted when either

  1. half of the transmit buffer becomes full or
  2. a delay time has passed (usually 40ms).

To read data, call TCPIsGetReady to determine how many bytes are ready to be retrieved. Then use the TCPGet family of functions to read data from the socket, and/or the TCPFindEx family of functions to locate data in the buffer. When no more data remains, return to the main stack loop to wait for more data to arrive.

If the application needs to close the connection, call TCPDisconnect, then return to the main stack loop and wait for the remote node to acknowledge the disconnection. Client sockets will return to the idle state, while listening sockets will wait for a new connection.

For more information read the associated RFC.

Files

file | TCP.c
Transmission Control Protocol (TCP) Communications Layer.
file | TCP.h
TCP Module Defs for Microchip TCP/IP Stack.

Functions

BOOL | TCPWasReset (TCP_SOCKET hTCP)
Self-clearing semaphore inidicating socket reset.
BOOL | TCPIsConnected (TCP_SOCKET hTCP)
Determines if a socket has an established connection.
void | TCPDisconnect (TCP_SOCKET hTCP)
Disconnects an open socket.
WORD | TCPIsPutReady (TCP_SOCKET hTCP)
Determines how much free space is available in the TCP TX buffer.
BOOL | TCPPut (TCP_SOCKET hTCP, BYTE byte)
Writes a single byte to a TCP socket.
WORD | TCPPutArray (TCP_SOCKET hTCP, BYTE *Data, WORD Len)
Writes an array from RAM to a TCP socket.
BYTE * | TCPPutString (TCP_SOCKET hTCP, BYTE *Data)
Writes a null-terminated string from RAM to a TCP socket.
WORD | TCPIsGetReady (TCP_SOCKET hTCP)
Determines how many bytes can be read from the TCP RX buffer.
BOOL | TCPGet (TCP_SOCKET hTCP, BYTE *byte)
Retrieves a single byte to a TCP socket.
WORD | TCPFindEx (TCP_SOCKET hTCP, BYTE cFind, WORD wStart, WORD wSearchLen, BOOL bTextCompare)
Searches for a byte in the TCP RX buffer.
void | TCPFlush (TCP_SOCKET hTCP)
Immediately transmits all pending TX data.
TCP_SOCKET | TCPOpen (DWORD dwRemoteHost, BYTE vRemoteHostType, WORD wPort, BYTE vSocketPurpose)
Opens a TCP socket for listening or as a client.

Function Documentation

void TCPDisconnect ( TCP_SOCKET hTCP )

Disconnects an open socket.

This function closes a connection to a remote node by sending a FIN. The function can be called a second time to force a socket closed by sending a RST packet. This is useful when the application knows that the remote node will not send an ACK (if it has crashed or lost its link), or when the application needs to reuse the socket immediately regardless of whether or not the remote node would like to transmit more data before closing.

Precondition:
TCP is initialized.
Parameters:
hTCP The socket to check.
Returns:
None
Remarks:
This function does nothing if the socket is not already connected. If the socket is using SSL, a CLOSE_NOTIFY record will be transmitted first to allow the SSL session to be resumed at a later time.

WORD TCPFindEx | ( | TCP_SOCKET | hTCP,
 |  | BYTE | cFind,
 |  | WORD | wStart,
 |  | WORD | wSearchLen,
 |  | BOOL | bTextCompare
 | ) |  |

Searches for a byte in the TCP RX buffer.

This function finds the first occurrance of a byte in the TCP RX buffer. It can be used by an application to abstract searches out of their own application code. For increased efficiency, the function is capable of limiting the scope of search to a specific range of bytes. It can also perform a case-insensitive search if required.

For example, if the buffer contains "I love PIC MCUs!" and the cFind byte is ' ', a value of 1 will be returned.

Precondition:
TCP is initialized.
Parameters:
hTCP | The socket to search within.
cFind | The byte to find in the buffer.
wStart | Zero-indexed starting position within the buffer.
wSearchLen | Length from wStart to search in the buffer.
bTextCompare | TRUE for case-insensitive text search, FALSE for binary search
Return values:
0xFFFF | Search array not found
Otherwise | Zero-indexed position of the first occurrance
Remarks:
Since this function usually must transfer data from external storage to internal RAM for comparison, its performance degrades significantly when the buffer is full and the array is not found. For better performance, try to search for characters that are expected to exist or limit the scope of the search as much as possible. The HTTP2 module, for example, uses this function to parse headers. However, it searches for newlines, then the separating colon, then reads the header name to RAM for final comparison. This has proven to be significantly faster than searching for full header name strings outright.

void TCPFlush ( TCP_SOCKET hTCP )

Immediately transmits all pending TX data.

This function immediately transmits all pending TX data with a PSH flag. If this function is not called, data will automatically be sent when either a) the TX buffer is half full or b) the TCP_AUTO_TRANSMIT_TIMEOUT_VAL (default: 40ms) has elapsed.

Precondition:
TCP is initialized and the socket is connected.
Parameters:
hTCP The socket whose data is to be transmitted.
Returns:
None
Remarks:
SSL application data is automatically flushed, so this function has no effect for SSL sockets.

BOOL TCPGet | ( | TCP_SOCKET | hTCP,
 |  | BYTE * | byte
 | ) |  |

Retrieves a single byte to a TCP socket.

Precondition:
TCP is initialized.
Parameters:
hTCP | The socket from which to read.
byte | Pointer to location in which the read byte should be stored.
Return values:
TRUE | A byte was read from the buffer.
FALSE | The buffer was empty, or the socket is not connected.

BOOL TCPIsConnected ( TCP_SOCKET hTCP )

Determines if a socket has an established connection.

This function determines if a socket has an established connection to a remote node. Call this function after calling TCPOpen to determine when the connection is set up and ready for use. This function was historically used to check for disconnections, but TCPWasReset is now a more appropriate solution.

Precondition:
TCP is initialized.
Parameters:
hTCP - The socket to check.
Return values:
TRUE | The socket has an established connection to a remote node.
FALSE | The socket is not currently connected.
Remarks:
A socket is said to be connected only if it is in the TCP_ESTABLISHED state. Sockets in the process of opening or closing will return FALSE.

WORD TCPIsGetReady ( TCP_SOCKET hTCP )

Determines how many bytes can be read from the TCP RX buffer.

Call this function to determine how many bytes can be read from the TCP RX buffer. If this function returns zero, the application must return to the main stack loop before continuing in order to wait for more data to arrive.

Precondition:
TCP is initialized.
Parameters:
hTCP The socket to check.
Returns:
The number of bytes available to be read from the TCP RX buffer.

WORD TCPIsPutReady ( TCP_SOCKET hTCP )

Determines how much free space is available in the TCP TX buffer.

Call this function to determine how many bytes can be written to the TCP TX buffer. If this function returns zero, the application must return to the main stack loop before continuing in order to transmit more data.

Precondition:
TCP is initialized.
Parameters:
hTCP The socket to check.
Returns:
The number of bytes available to be written in the TCP TX buffer.

TCP_SOCKET TCPOpen | ( | DWORD | dwRemoteHost,
 |  | BYTE | vRemoteHostType,
 |  | WORD | wPort,
 |  | BYTE | vSocketPurpose
 | ) |  |

Opens a TCP socket for listening or as a client.

Provides a unified method for opening TCP sockets. This function can open both client and server sockets. For client sockets, it can accept host name string to query in DNS, and IP address as a string, an IP address in binary form, or a previously resolved NODE_INFO structure. When a host name or IP address only is provided, the TCP module will internally perform the necessary DNS and/or ARP resolution steps before reporting that the TCP socket is connected (via a call to TCPISConnected returning TRUE). Server sockets ignore this destination parameter and listen only on the indicated port.

The vSocketPurpose field allows sockets to be opened with varying buffer size parameters and memory storage mediums. This field corresponds to pre-defined sockets types in TCPIPConfig.h or the TCPIPConfig utility.

Sockets are statically allocated on boot, but can be claimed with this function and freed using TCPDisconnect (for client sockets). Server sockets are opened permanently for the duration of the application. Calls to TCPDisconnect will only release the socket to the listening state.

Precondition:
TCP is initialized.
Parameters:
dwRemoteHost | For client sockets only. Provide a pointer to a null\-terminated string of the remote host name (ex\: "www.microchip.com" or "192.168.1.123"), a literal destination IP address (ex\: 0x7B01A8C0 or an IP_ADDR data type), or a pointer to a NODE_INFO structure with the remote IP address and remote node or gateway MAC address specified. If a string is provided, note that it must be statically allocated in memory and cannot be modified or deallocated until TCPIsConnected returns TRUE. This parameter is ignored for server sockets.
vRemoteHostType | TCP_OPEN_SERVER, TCP_OPEN_RAM_HOST, TCP_OPEN_ROM_HOST, TCP_OPEN_IP_ADDRESS, or TCP_OPEN_NODE_INFO.
wPort | For client sockets, the remote TCP port to which a connection should be made. For server sockets, the local TCP port on which to listen for connections.
vSocketPurpose | Any of the TCP_PURPOSE_* constants defined in TCPIPConfig.h or the TCPIPConfig utility.
Return values:
INVALID_SOCKET | No sockets of the specified type were available to be opened.
Otherwise | A TCP_SOCKET handle. Save this handle and use it when calling all other TCP APIs.
Remarks:
This function replaces the old TCPConnect and TCPListen functions.
If TCP_OPEN_RAM_HOST or TCP_OPEN_ROM_HOST are used for the destination type, the DNS client module must also be enabled.

Example:
    // Open a server socket
    skt = TCPOpen(NULL, TCP_OPEN_SERVER, HTTP_PORT, TCP_PURPOSE_HTTP_SERVER);

    // Open a client socket to www.microchip.com
    // The double cast here prevents compiler warnings
    skt = TCPOpen((DWORD)(PTR_BASE)"www.microchip.com",
                    TCP_OPEN_ROM_HOST, 80, TCP_PURPOSE_DEFAULT);

    // Reopen a client socket without repeating DNS or ARP
    SOCKET_INFO cache = TCPGetSocketInfo(skt);  // Call with the old socket
    skt = TCPOpen((DWORD)(PTR_BASE)&cache.remote, TCP_OPEN_NODE_INFO,
                    cache.remotePort.Val, TCP_PURPOSE_DEFAULT);

BOOL TCPPut | ( | TCP_SOCKET | hTCP,
 |  | BYTE | byte
 | ) |  |

Writes a single byte to a TCP socket.

Precondition:
TCP is initialized.
Parameters:
hTCP | The socket to which data is to be written.
byte | The byte to write.
Return values:
TRUE | The byte was written to the transmit buffer.
FALSE | The transmit buffer was full, or the socket is not connected.

WORD TCPPutArray | ( | TCP_SOCKET | hTCP,
 |  | BYTE * | Data,
 |  | WORD | Len
 | ) |  |

Writes an array from RAM to a TCP socket.

Precondition:
TCP is initialized.
Parameters:
hTCP | The socket to which data is to be written.
Data | Pointer to the array to be written.
Len | Number of bytes to be written.
Returns:
The number of bytes written to the socket. If less than len, the buffer became full or the socket is not conected.

BYTE* TCPPutString | ( | TCP_SOCKET | hTCP,
 |  | BYTE * | Data
 | ) |  |

Writes a null-terminated string from RAM to a TCP socket.

The null-terminator is not copied to the socket.

Precondition:
TCP is initialized.
Parameters:
hTCP | The socket to which data is to be written.
Data | Pointer to the string to be written.
Returns:
Pointer to the byte following the last byte written to the socket. If this pointer does not dereference to a NUL byte, the buffer became full or the socket is not connected.
Remarks:
The return value of this function differs from that of TCPPutArray. To write long strings in a single state, initialize the *data pointer to the first byte, then call this function repeatedly (breaking to the main stack loop after each call) until the return value dereferences to a NUL byte. Save the return value as the new starting *data pointer otherwise.

BOOL TCPWasReset ( TCP_SOCKET hTCP )

Self-clearing semaphore inidicating socket reset.

This function is a self-clearing semaphore indicating whether or not a socket has been disconnected since the previous call. This function works for all possible disconnections: a call to TCPDisconnect, a FIN from the remote node, or an acknowledgement timeout caused by the loss of a network link. It also returns TRUE after the first call to TCPInit. Applications should use this function to reset their state machines.

This function was added due to the possibility of an error when relying on TCPIsConnected returing FALSE to check for a condition requiring a state machine reset. If a socket is closed (due to a FIN ACK) and then immediately reopened (due to a the arrival of a new SYN) in the same cycle of the stack, calls to TCPIsConnected by the application will never return FALSE even though the socket has been disconnected. This can cause errors for protocols such as HTTP in which a client will immediately open a new connection upon closing of a prior one. Relying on this function instead allows applications to trap those conditions and properly reset their internal state for the new connection.

Precondition:
TCP is initialized.
Parameters:
hTCP The socket to check.
Return values:
TRUE | The socket has been disconnected since the previous call.
FALSE | The socket has not been disconnected since the previous call.


Netzer: Tick

Tick
[TCP/IP Stack from Microchip Version 4.50 (Modified)]

Detailed Description

The Tick module provides accurate time-keeping capabilities based on the hardware clock.

By default, it uses Timer 0 on 8-bit parts and Timer 1 on 16- and 32-bit families. The module is interrupt driven, which makes the timing stable and accurate. As such, it is also suitable for a real-time clock.

The Tick module exists to assist with the implementation of non-blocking delays and timeouts. Rather than using a loop to count to a specific number, use the Tick module and compare a previous time with the current time. In this fashion applications can return its unused cycles to the stack during long delays, which increases the overall efficiency of the system.

Files

file | Tick.c
Tick Manager for Timekeeping.
file | Tick.h
Tick Manager for PIC18.


Netzer: UDP

UDP
[TCP/IP Stack from Microchip Version 4.50 (Modified)]

Detailed Description

UDP is a standard transport layer protocol described in RFC 768.

It provides fast but unreliable data-gram based transfers over networks, and forms the foundation SNTP, SNMP, DNS, and many other protocol standards.

Files

file | UDP.c
User Datagram Protocol (UDP) Communications Layer Server Module for Microchip TCP/IP Stack.
file | UDP.h
UDP Module Defs for Microchip TCP/IP Stack.


Netzer: Module for accessing UNIO EEPROMs

Module for accessing UNIO EEPROMs

Detailed Description

This group implements the UNIO protocol to access storage devices.

  • Reference: AN1191

Files

file | eeprom.c
Implementation file of the eeprom access (ANSI C part).
file | UNIO.c
Implementation of the UNIO protocol.
file | UNIO.h
API for accessing the UNIO protocol.


Netzer: Data Structures

  • Data Fields

Data Structures

Here are the data structures with brief descriptions:
_FLAGS | T Y P E D E F S
_IP_CONFIG | This typedef defines the local structure for TCP/IP stack parameters
CommonConfig_t | This typedef defines the peristent structure for common settings and TCP/IP stack parameters
IoData_t | This typedef defines the peristent structure for common application settings


Netzer: _FLAGS Union Reference

  • Data Fields

_FLAGS Union Reference

#include <UNIO.h>

Detailed Description

T Y P E D E F S.


Netzer: _IP_CONFIG Struct Reference

  • Data Fields

_IP_CONFIG Struct Reference
[Application network and initialization module]

#include <bootup.h>

Detailed Description

This typedef defines the local structure for TCP/IP stack parameters.

Data Fields

IP_ADDR | MyIPAddr
The 4 byte IP address.
IP_ADDR | MyMask
The 4 byte subnet mask.
IP_ADDR | MyGateway
The 4 byte default subnet gateway.
IP_ADDR | PrimaryDNSServer
The 4 byte primary DNS address.
IP_ADDR | SecondaryDNSServer
The 4 byte secondary DNS address.
IPObtainedFrom_t IPObtainedFrom
The IP was obtained from.
unsigned char | bIPunique: 1
Indicates if IP is unique.


Netzer: CommonConfig_t Struct Reference

  • Data Fields

CommonConfig_t Struct Reference
[Application network and initialization module]

#include <bootup.h>

Detailed Description

This typedef defines the peristent structure for common settings and TCP/IP stack parameters.

It is stored at the EEPROM address BOOTUP_EEPROM_ADD. Upon start the EEPROM data is load to sPCommonConfig.

Data Fields

DWORD | VersionTag
The application can detect a firmware update due comparing the versions of the EEPROM data and the installed application and can do some migration stuff.
BYTE | LanguageID
This field stores an ID which language is selected for webpage.
IP_ADDR | ManIPAddr
The last manual configured IP address.
BYTE | ManMask
The last manual configured subnet mask.
IP_ADDR | ManGateway
The last manual configured default gateway.
IP_ADDR | PrimaryDNS
The last manual configured primary DNS address.
IP_ADDR | SecondaryDNS
The last manual configured secondary DNS address.
IP_ADDR | LastAutoIP
The last used Auto IP address.
IPSelectionModes_t IPSelection
How to obtain the IP address.
BYTE | NetworkName [MAX_NETWORKNAME_LENGTH+1]
The name of the device in the network.
NetzerProjects_t Project
This field indicates how the EEPROM data must be interpreted.

Field Documentation

DWORD CommonConfig_t::VersionTag

The application can detect a firmware update due comparing the versions of the EEPROM data and the installed application and can do some migration stuff.

BYTE CommonConfig_t::LanguageID

This field stores an ID which language is selected for webpage.

NetzerProjects_t CommonConfig_t::Project

This field indicates how the EEPROM data must be interpreted.

The application should keep the flash and EEPROM target consistent.


Netzer: IoData_t Struct Reference

  • Data Fields

IoData_t Struct Reference

Detailed Description

This typedef defines the peristent structure for common application settings.


Netzer: Data Fields

  • Data Fields
  • All
  • Variables
Here is a list of all documented struct and union fields with links to the struct/union documentation for each field:

  • bIPunique : _IP_CONFIG
  • IPObtainedFrom : _IP_CONFIG
  • IPSelection : CommonConfig_t
  • LanguageID : CommonConfig_t
  • LastAutoIP : CommonConfig_t
  • ManGateway : CommonConfig_t
  • ManIPAddr : CommonConfig_t
  • ManMask : CommonConfig_t
  • MyGateway : _IP_CONFIG
  • MyIPAddr : _IP_CONFIG
  • MyMask : _IP_CONFIG
  • NetworkName : CommonConfig_t
  • PrimaryDNS : CommonConfig_t
  • PrimaryDNSServer : _IP_CONFIG
  • Project : CommonConfig_t
  • SecondaryDNS : CommonConfig_t
  • SecondaryDNSServer : _IP_CONFIG
  • VersionTag : CommonConfig_t


Netzer: File Index

  • File List
  • Globals

File List

Here is a list of all documented files with brief descriptions:
adc.c | Implementation of ADC conversion
adc.h | API for analog channel access
appl.c | This file implements the Netzer application module
appl.h | This file includes the Netzer application module API
ARP.c | Address Resolution Protocol (ARP) Client and Server Module for Microchip TCP/IP Stack
ARP.h | ARP Module Defs for Microchip TCP/IP Stack
auth.c | The web authentication module implementation of Netzer
auth.h | The web authentication module interface of Netzer
bootup.c | Implementation of the boot process of the Netzer application
bootup.h | Prototypes for calling the Netzer application boot up and network routines
Compiler.h | Compiler and hardware specific definitions
DHCP.c | Dynamic Host Configuration Protocol (DHCP) Client Module for Microchip TCP/IP Stack
DHCP.h | DHCP Defs for Microchip TCP/IP Stack
eeprom.c | Implementation file of the eeprom access (ANSI C part)
ETH97J60.c | Medium Access Control (MAC) Layer for Microchip PIC18F97J60 family
ETH97J60.h | Ethernet registers/bits for PIC18F97J60
flash.c | Implementation of flash routines
flash.h | API for accessing the internal flash memory
GenericTypeDefs.h | Generic Type Definitions
gpio.c | Implementation of gpio access
gpio.h | API for GPIO (digital IO) access
helper.h | API for misc helper functions
Helpers.c | Helper Functions for Microchip TCP/IP Stack
Helpers.h | Helper Function Defs for Microchip TCP/IP Stack
HTTP2.c | HyperText Transfer Protocol (HTTP) Server Module for Microchip TCP/IP Stack
HTTP2.h | HTTP definitions on Microchip TCP/IP Stack
HTTPPrint.h | Provides callback headers and resolution for the web interface
i2c.c | Implementation of the I2C communication stuff
i2c.h | API for serial communication via I2C
ICMP.c | Internet Control Message Protocol (ICMP) Server Module for Microchip TCP/IP Stack
ICMP.h | ICMP Module Defs for Microchip TCP/IP Stack
io.c | Implementation of the common io application stuff
IP.c | Internet Protocol (IP) Version 4 Communications Layer Module for Microchip TCP/IP Stack
IP.h | IP Defs for Microchip TCP/IP Stack
MAC.h | MAC Module Defs for Microchip Stack
main.c | This file includes the main entry function
main.h | This file includes some defines for main.c and also the fuse settings for the PIC
mdns.c | Multicast Domain Name System (MDNS) implementation file for the Netzer application
mdns.h | MDNS Client Module Header file for the application
MPFS2.c | Microchip File System (MPFS) File Access API
MPFS2.h | MPFS Defines and prototypes for Microchip File System
MPFSImg.c | Defines an MPFS2 image to be stored in program memory
netzerTypedefs.h | Defines common typedefs for use in Netzer projects
projectdefs.h | Some project related defines and typedefs for the NetzerIO project
projectIRQ.asm | This file extends low and high priority interrupts in a very efficient and small footprint manner
projectIRQ.inc | This file extends the low priority interrupt hook to call some IO routines (for example filter timer and serial stubs)
Reboot.c Module for Microchip TCP/IP Stack
  • Remotely resets the PIC
  • Reference: Internet Bootloader documentation
Reboot.h | Reboot Server Module Header
serial.c | Implementation of the serial communication stuff
serial.h | API for serial communication via UART or SPI
StackTsk.c | TCP/IP Stack Manager Module for Microchip TCP/IP Stack
StackTsk.h | Microchip TCP/IP Stack Definitions
stringtable.c | This file implements the string tables for multi language support
stringtable.h | This file includes the Netzer string table defines and API
TCP.c | Transmission Control Protocol (TCP) Communications Layer
TCP.h | TCP Module Defs for Microchip TCP/IP Stack
TCPIP.h | Microchip TCP/IP Stack Include File
TCPIPConfig.h | Microchip TCP/IP Stack Application Configuration Header
Tick.c | Tick Manager for Timekeeping
Tick.h | Tick Manager for PIC18
time.h | API fo using the time module
timer.asm | This file handles the low priority interrupt and the tick counter
toa.h | API fo using the assembler conversion routines
UDP.c | User Datagram Protocol (UDP) Communications Layer Server Module for Microchip TCP/IP Stack
UDP.h | UDP Module Defs for Microchip TCP/IP Stack
UNIO.c | Implementation of the UNIO protocol
UNIO.h | API for accessing the UNIO protocol
web.c | The integrated web interface implementation of Netzer
web.h | Web interface module defines and global function prototypes for Netzer
webio.c | Implementation of the web io stuff


Netzer: adc.c File Reference

adc.c File Reference

Detailed Description

Implementation of ADC conversion.

Software License
See the MBCSL for details.
Author:
Sven Schlender (kontakt at mobacon dot de)
Date:
2011-04-22

Functions

WORD | ADCGetValue (BYTE Channel)
Returns the current ADC value of the requested channel.
void | ADCInitialize (void)
Initializes and calibrates the ADC module.

Function Documentation

WORD ADCGetValue ( BYTE Channel )

Returns the current ADC value of the requested channel.

The function checks wheter the channel supports ADC measurent and blocks until the value is read.

Parameters:
Channel On of the GPIO channels (GPIO_XX_ID). Note, that not every channel supports ADC (currently only GPIO_04_ID and GPIO_05_ID).
Returns:
The ADC value as 10-bit representation.

Generated on Fri Mar 29 10:34:27 2013 for Netzer by doxygen 1.5.5


Netzer: adc.h File Reference

adc.h File Reference

Detailed Description

API for analog channel access.

Software License
See the MBCSL for details.
Author:
Sven Schlender (kontakt at mobacon dot de)
Date:
2011-07-22

Functions

void | ADCInitialize (void)
Initializes and calibrates the ADC module.
WORD | ADCGetValue (BYTE Channel)
Returns the current ADC value of the requested channel.

Function Documentation

WORD ADCGetValue ( BYTE Channel )

Returns the current ADC value of the requested channel.

The function checks wheter the channel supports ADC measurent and blocks until the value is read.

Parameters:
Channel On of the GPIO channels (GPIO_XX_ID). Note, that not every channel supports ADC (currently only GPIO_04_ID and GPIO_05_ID).
Returns:
The ADC value as 10-bit representation.

Generated on Fri Mar 29 10:34:27 2013 for Netzer by doxygen 1.5.5


Netzer: appl.c File Reference

appl.c File Reference

Detailed Description

This file implements the Netzer application module.

Software License
See the MBCSL for details.
Author:
Sven Schlender (kontakt at mobacon dot de)
Date:
2009-10-30

Functions

BOOL | ApplInit (void)
Call this function to initialize the application module.
void | ApplStop (void)
This function finally stops the application, i.e.
void | ApplMain (void)
Call this function periodically to execute the application module.
BOOL | ApplIsRunning (void)
The function is the indicator for the running application.
void | ApplResetToFactory (void)
This function restores the EEPROM content to a well known state.
void | ApplCommand (ApplCommands_t Command)
Call this function to execute several application commands.
void | ApplStateChanged (NetzerState_t NewState)
This function is called by different core modules to indicate Netzer state changes.
NetzerState_t | ApplGetCurrentState (void)
This function can be called to obtain the current state of Netzer.

Generated on Fri Mar 29 10:34:27 2013 for Netzer by doxygen 1.5.5


Netzer: appl.h File Reference

appl.h File Reference

Detailed Description

This file includes the Netzer application module API.

Software License
See the MBCSL for details.
Author:
Sven Schlender (kontakt at mobacon dot de)
Date:
2009-04-30

Functions

BOOL | ApplInit (void)
Call this function to initialize the application module.
void | ApplMain (void)
Call this function periodically to execute the application module.
void | ApplResetToFactory (void)
This function restores the EEPROM content to a well known state.
BOOL | ApplIsRunning (void)
The function is the indicator for the running application.
void | ApplStop (void)
This function finally stops the application, i.e.
void | ApplCommand (ApplCommands_t Command)
Call this function to execute several application commands.
void | ApplStateChanged (NetzerState_t NewState)
This function is called by different core modules to indicate Netzer state changes.
NetzerState_t | ApplGetCurrentState (void)
This function can be called to obtain the current state of Netzer.

Generated on Fri Mar 29 10:34:27 2013 for Netzer by doxygen 1.5.5


Netzer: ARP.c File Reference

ARP.c File Reference

Detailed Description

Address Resolution Protocol (ARP) Client and Server Module for Microchip TCP/IP Stack.

  • Provides IP address to Ethernet MAC address translation
  • Reference: RFC 826

  • Dependencies: string.h StackTsk.h Helpers.h ARP.h MAC.h
  • Processor: PIC18, PIC24F, PIC24H, dsPIC30F, dsPIC33F, PIC32
  • Compiler: Microchip C32 v1.00 or higher Microchip C30 v3.01 or higher Microchip C18 v3.13 or higher HI-TECH PICC-18 STD 9.50PL3 or higher
  • Company: Microchip Technology, Inc.

See the Microchip License Agreement for more details.

Modifications to the original file
  • Search for "MODIFIX" in the code!
  • Removed preprocessor macro STACK_CLIENT_MODE as always defined.
  • Added function ARPFlush for flushing the ARP cache.

Functions

void | ARPResolve (IP_ADDR *IPAddr)
Transmits an ARP request to resolve an IP address.
BOOL | ARPIsResolved (IP_ADDR *IPAddr, MAC_ADDR *MACAddr)
Determines if an ARP request has been resolved yet.
void | ARPFlush (void)
Flushes the ARP cache.

Generated on Fri Mar 29 10:34:27 2013 for Netzer by doxygen 1.5.5


Netzer: ARP.h File Reference

ARP.h File Reference

Detailed Description

ARP Module Defs for Microchip TCP/IP Stack.

  • Dependencies: Stacktsk.h MAC.h
  • Processor: PIC18, PIC24F, PIC24H, dsPIC30F, dsPIC33F, PIC32MX
  • Compiler: Microchip C32 v1.00 or higher Microchip C30 v3.01 or higher Microchip C18 v3.13 or higher HI-TECH PICC-18 STD 9.50PL3 or higher
  • Company: Microchip Technology, Inc.

See the Microchip License Agreement for more details.

Modifications to the original file
  • Removed preprocessor macro STACK_CLIENT_MODE as always defined.
  • Added doxygen comments to the function prototypes.

Functions

void | ARPResolve (IP_ADDR *IPAddr)
Transmits an ARP request to resolve an IP address.
BOOL | ARPIsResolved (IP_ADDR *IPAddr, MAC_ADDR *MACAddr)
Determines if an ARP request has been resolved yet.
void | ARPFlush (void)
Flushes the ARP cache.

Generated on Fri Mar 29 10:34:27 2013 for Netzer by doxygen 1.5.5


Netzer: auth.c File Reference

auth.c File Reference

Detailed Description

The web authentication module implementation of Netzer.

Software License
See the MBCSL for details.
Author:
Sven Schlender (kontakt at mobacon dot de)
Date:
2011-02-03

Functions

void | AuthReload (void)
Call this function for initial or repeated loading of all user/password combinations from persistent storage (EEPROM) to quick accessable RAM.
void | AuthStoreInEEPROM (CHAR UserID)
Store the authentication data for the given user from RAM to persistent storage (EEPROM).
void | AuthReset (CHAR UserID)
The given user is reseted to a well known factory state.
void | AuthProcessPostData (BYTE *pControl, BYTE *pValue, DWORD Value)
The function handles the call from the user set webpage form and processes new user data.
BYTE | HTTPCheckAuth (BYTE *cUser, BYTE *cPass)
The function is called after authentication is entered.
void | AuthSetUserForDialog (BYTE UserID)
Call this function during the session of a HTTP POST of the user set webpage.
void | AuthExecuteApplCommand (BYTE RawCommandFromWeb)
Commands to application (like restart, shut down, reset to factory settings) are filtered through this function.
void | AuthInit (void)
Call this function to initialize the socket based authentication here.
void | AuthStartAuthentification (TCP_SOCKET Socket)
If a socket needs authentication than call this function directly once after the connection.
AuthReturnCodes_t | AuthHandleAuthentification (TCP_SOCKET Socket)
Call this function periodically from the socket handler until one of the final states is reached (answer is not AUTH_PENDING).

Function Documentation

void AuthExecuteApplCommand ( BYTE RawCommandFromWeb )

Commands to application (like restart, shut down, reset to factory settings) are filtered through this function.

Only a authenticated user with enough permissions can execute dedicated application commands.

Parameters:
RawCommandFromWeb The command as numeric value directly from a GET call (see webpage index.htm for expressions).

AuthReturnCodes_t AuthHandleAuthentification ( TCP_SOCKET Socket )

Call this function periodically from the socket handler until one of the final states is reached (answer is not AUTH_PENDING).

The function uses the given socket as handle for managing several authentication sessions in parallel. Also it uses the socket to print login informations and receive username and password.

Parameters:
Socket Give the TCP socket handler to associate the socket with the authentication data state.
Returns:
If the answer is AUTH_PENDING than later call this function again. Else check the code for further processing - a further call is not necessary.

void AuthInit ( void )

Call this function to initialize the socket based authentication here.

Do the calling once on startup.

void AuthProcessPostData | ( | BYTE * | pControl,
 |  | BYTE * | pValue,
 |  | DWORD | Value
 | ) |  |

The function handles the call from the user set webpage form and processes new user data.

Parameters:
pControl | A pointer to the name of the form control.
pValue | A pointer to the value of the control as a string.
Value | The preprocessed numeric version of the value.

void AuthReset ( CHAR UserID )

The given user is reseted to a well known factory state.

Parameters:
UserID The zero based user id for which username and password are restored. -1 restores all known users at once.

void AuthSetUserForDialog ( BYTE UserID )

Call this function during the session of a HTTP POST of the user set webpage.

The process function than operates with the given SetID.

Parameters:
UserID The zero based user id on which the form processing is be done.

void AuthStartAuthentification ( TCP_SOCKET Socket )

If a socket needs authentication than call this function directly once after the connection.

The function initializes the state machine and other socket based data to start the authentication process.

Parameters:
Socket Give the TCP socket handler to bind the socket to authentication data state. The caller can use the socket handle for later state machine handling of the authentication (AuthHandleAuthentification).

void AuthStoreInEEPROM ( CHAR UserID )

Store the authentication data for the given user from RAM to persistent storage (EEPROM).

Parameters:
UserID The zero based user id for which username and password are stored. -1 stores all known users at once.

BYTE HTTPCheckAuth | ( | BYTE * | cUser,
 |  | BYTE * | cPass
 | ) |  |

The function is called after authentication is entered.

It must check whether the user/password combination is valid.

Parameters:
cUser | Pointer to the string of the requesting user.
cPass | Pointer to the string of the password of requesting user.
Return values:
0 | User/password combination is invalid.
Other | User/password combination is valid.

Generated on Fri Mar 29 10:34:27 2013 for Netzer by doxygen 1.5.5


Netzer: auth.h File Reference

auth.h File Reference

Detailed Description

The web authentication module interface of Netzer.

Software License
See the MBCSL for details.
Author:
Sven Schlender (kontakt at mobacon dot de)
Date:
2011-02-03

enum | AuthReturnCodes_t { AUTH_PENDING = 0, AUTH_FAILED, AUTH_OK, AUTH_READONLY }
 | This state enumerator is used for authentication handling on a generic socket (see AuthHandleAuthentification for more details). More...
void | AuthReload (void)
 | Call this function for initial or repeated loading of all user/password combinations from persistent storage (EEPROM) to quick accessable RAM.
void | AuthStoreInEEPROM (CHAR UserID)
 | Store the authentication data for the given user from RAM to persistent storage (EEPROM).
void | AuthReset (CHAR UserID)
 | The given user is reseted to a well known factory state.
void | AuthProcessPostData (BYTE *pControl, BYTE *pValue, DWORD Value)
 | The function handles the call from the user set webpage form and processes new user data.
void | AuthExecuteApplCommand (BYTE RawCommandFromWeb)
 | Commands to application (like restart, shut down, reset to factory settings) are filtered through this function.
BYTE | HTTPCheckAuth (BYTE *cUser, BYTE *cPass)
 | The function is called after authentication is entered.
void | AuthSetUserForDialog (BYTE UserID)
 | Call this function during the session of a HTTP POST of the user set webpage.
void | AuthInit (void)
 | Call this function to initialize the socket based authentication here.
void | AuthStartAuthentification (TCP_SOCKET Socket)
 | If a socket needs authentication than call this function directly once after the connection.
AuthReturnCodes_t | AuthHandleAuthentification (TCP_SOCKET Socket)
 | Call this function periodically from the socket handler until one of the final states is reached (answer is not AUTH_PENDING).

Enumeration Type Documentation

enum AuthReturnCodes_t

This state enumerator is used for authentication handling on a generic socket (see AuthHandleAuthentification for more details).

Enumerator:
AUTH_PENDING | State handling is pending, call again later.
AUTH_FAILED | Authentication has failed due unknown user name or pass.
AUTH_OK | Authentication was successful.
AUTH_READONLY | Authentication was successful. Guest has logged in.

Function Documentation

void AuthExecuteApplCommand ( BYTE RawCommandFromWeb )

Commands to application (like restart, shut down, reset to factory settings) are filtered through this function.

Only a authenticated user with enough permissions can execute dedicated application commands.

Parameters:
RawCommandFromWeb The command as numeric value directly from a GET call (see webpage index.htm for expressions).

AuthReturnCodes_t AuthHandleAuthentification ( TCP_SOCKET Socket )

Call this function periodically from the socket handler until one of the final states is reached (answer is not AUTH_PENDING).

The function uses the given socket as handle for managing several authentication sessions in parallel. Also it uses the socket to print login informations and receive username and password.

Parameters:
Socket Give the TCP socket handler to associate the socket with the authentication data state.
Returns:
If the answer is AUTH_PENDING than later call this function again. Else check the code for further processing - a further call is not necessary.

void AuthInit ( void )

Call this function to initialize the socket based authentication here.

Do the calling once on startup.

void AuthProcessPostData | ( | BYTE * | pControl,
 |  | BYTE * | pValue,
 |  | DWORD | Value
 | ) |  |

The function handles the call from the user set webpage form and processes new user data.

Parameters:
pControl | A pointer to the name of the form control.
pValue | A pointer to the value of the control as a string.
Value | The preprocessed numeric version of the value.

void AuthReset ( CHAR UserID )

The given user is reseted to a well known factory state.

Parameters:
UserID The zero based user id for which username and password are restored. -1 restores all known users at once.

void AuthSetUserForDialog ( BYTE UserID )

Call this function during the session of a HTTP POST of the user set webpage.

The process function than operates with the given SetID.

Parameters:
UserID The zero based user id on which the form processing is be done.

void AuthStartAuthentification ( TCP_SOCKET Socket )

If a socket needs authentication than call this function directly once after the connection.

The function initializes the state machine and other socket based data to start the authentication process.

Parameters:
Socket Give the TCP socket handler to bind the socket to authentication data state. The caller can use the socket handle for later state machine handling of the authentication (AuthHandleAuthentification).

void AuthStoreInEEPROM ( CHAR UserID )

Store the authentication data for the given user from RAM to persistent storage (EEPROM).

Parameters:
UserID The zero based user id for which username and password are stored. -1 stores all known users at once.

BYTE HTTPCheckAuth | ( | BYTE * | cUser,
 |  | BYTE * | cPass
 | ) |  |

The function is called after authentication is entered.

It must check whether the user/password combination is valid.

Parameters:
cUser | Pointer to the string of the requesting user.
cPass | Pointer to the string of the password of requesting user.
Return values:
0 | User/password combination is invalid.
Other | User/password combination is valid.

Generated on Fri Mar 29 10:34:27 2013 for Netzer by doxygen 1.5.5


Netzer: bootup.c File Reference

bootup.c File Reference

Detailed Description

Implementation of the boot process of the Netzer application.

Software License
See the MBCSL for details.
Author:
Sven Schlender (kontakt at mobacon dot de)
Date:
2009-10-30

Functions

void | BootupInit (void)
This function initializes the application network module.
BOOL | BootupMain (void)
This function must be called periodically by the application.
void | BootupGetNetworkName (BOOL Persistent, BYTE *pNameBuffer, BYTE SizeOfBuffer)
Delivers the network name of the device.
void | BootupEnterBootloader (void)
Calling this function prepares the bootloader entry.
void | BootupBlink (void)
This function blinks the network LED with a second period.
void | BootupResetToFactory (void)
Sometimes the reset of the persistent data in the EEPROM to a well known state is needed.
IPSelectionModes_t | BootupGetIPMode (BOOL bLoadFromPersistent)
Delivers the current selected Netzer IP mode.
void | BootupGetIPAddress (IPField_t Position, BYTE *pBuffer)
Use this function to obtain any of the device IP addresses.
void | BootupPrintIPAddress (IPField_t Position, BYTE *pBuffer)
Use this function to generate a string from a IP address of this device.
void | BootupPrintFormatedIPAddress (BYTE *pIPAddress, BYTE *pBuffer)
Use this function to print a formated IP address to a given RAM buffer.
BOOL | BootupSetIPAddress (IPField_t Position, BYTE *pIPString)
Use this function to change the given IP address with an IP address string.
void | BootupSetNetworkName (BYTE *pName)
Use this function to change the network name of the device.
void | BootupSetHTTPPort (WORD NewPort)
Set a new port for the HTTP service for the next session (after reboot).
WORD | BootupGetHTTPPort (BOOL LoadFromPersistent)
Delivers the currently set or persistently written port value for the HTTP service.

Variables

static SM_BOOTUP | _sm
The local state machine.
static BYTE | _au8NetworkDataForBootloader [12]
Stores the network related data like MAC address and IP address for reboot.
static DWORD | _timer
The timer state for measuring times.
static WORD | _persistentHTTPPort
The HTTP port - staying consistent with EEPROM.

Generated on Fri Mar 29 10:34:27 2013 for Netzer by doxygen 1.5.5


Netzer: bootup.h File Reference

bootup.h File Reference

Detailed Description

Prototypes for calling the Netzer application boot up and network routines.

Software License
See the MBCSL for details.
Author:
Sven Schlender (kontakt at mobacon dot de)
Date:
2008-09-26

Data Structures

struct | _IP_CONFIG
This typedef defines the local structure for TCP/IP stack parameters. More...
struct | CommonConfig_t
This typedef defines the peristent structure for common settings and TCP/IP stack parameters. More...

Defines

#define | MAX_NETWORKNAME_LENGTH 8
The maximum allowed length for network names (currently used in the MDNS).

Enumerations

enum IPSelectionModes_t {
IPS_DHCP_ENABLED = 0, IPS_DHCP_AUTOIP, IPS_DHCP_MANUALIP, IPS_AUTO_IP,
IPS_MANUAL_IP, IPS_MODE_COUNT
}
This typedef defines the various modes how the Netzer gets its IP address. More...
enum | IPObtainedFrom_t { IPO_DHCP = 0, IPO_AUTO, IPO_MANUAL }
This enumerator states from which instance the current device IP was obtained from. More...
enum | NetzerProjects_t
Enumerates the different targets a Netzer can be used for. More...
enum IPField_t {
VAR_IP_ADDRESS = 0, VAR_GATEWAY_ADDRESS, VAR_SUBNET_MASK, VAR_MAN_IP_ADDRESS,
VAR_MAN_SUBNET_MASK, VAR_MAN_GATEWAY_ADDRESS, VAR_IP_ADDRESS_EEPROM, VAR_SUBNET_MASK_EEPROM,
VAR_GATEWAY_ADDRESS_EEPROM
}
Use this enumerator for the function BootupPrintIPAddress to get a well formated IP address. More...

Functions

void | BootupInit (void)
This function initializes the application network module.
BOOL | BootupMain (void)
This function must be called periodically by the application.
void | BootupResetToFactory (void)
Sometimes the reset of the persistent data in the EEPROM to a well known state is needed.
void | BootupEnterBootloader (void)
Calling this function prepares the bootloader entry.
void | BootupBlink (void)
This function blinks the network LED with a second period.
void | BootupGetNetworkName (BOOL Persistent, BYTE *pNameBuffer, BYTE SizeOfBuffer)
Delivers the network name of the device.
void | BootupPrintIPAddress (IPField_t Position, BYTE *pBuffer)
Use this function to generate a string from a IP address of this device.
void | BootupPrintFormatedIPAddress (BYTE *pIPAddress, BYTE *pBuffer)
Use this function to print a formated IP address to a given RAM buffer.
BOOL | BootupSetIPAddress (IPField_t Position, BYTE *pIPString)
Use this function to change the given IP address with an IP address string.
void | BootupSetNetworkName (BYTE *pName)
Use this function to change the network name of the device.
IPSelectionModes_t | BootupGetIPMode (BOOL LoadFromPersistent)
Delivers the current selected Netzer IP mode.
void | BootupSetHTTPPort (WORD NewPort)
Set a new port for the HTTP service for the next session (after reboot).
WORD | BootupGetHTTPPort (BOOL LoadFromPersistent)
Delivers the currently set or persistently written port value for the HTTP service.
void | BootupGetIPAddress (IPField_t Position, BYTE *pBuffer)
Use this function to obtain any of the device IP addresses.
void | BootupInvalidateIPSettings (void)
Reset the current IP settings to invalid.

Variables

IPConfig_t sIPConfig
This field stores the local TCP/IP parameters.
CommonConfig_t sPCommonConfig
The persitent data field.

Generated on Fri Mar 29 10:34:27 2013 for Netzer by doxygen 1.5.5


Netzer: Compiler.h File Reference

Compiler.h File Reference

Detailed Description

Compiler and hardware specific definitions.

  • Dependencies: None
  • Processor: PIC18, PIC24F, PIC24H, dsPIC30F, dsPIC33F, PIC32
  • Compiler: Microchip C32 v1.00 or higher Microchip C30 v3.01 or higher Microchip C18 v3.13 or higher HI-TECH PICC-18 STD 9.50PL3 or higher
  • Company: Microchip Technology, Inc.

See the Microchip License Agreement for more details.

Modifications to the original file
None.

Generated on Fri Mar 29 10:34:27 2013 for Netzer by doxygen 1.5.5


Netzer: DHCP.c File Reference

DHCP.c File Reference

Detailed Description

Dynamic Host Configuration Protocol (DHCP) Client Module for Microchip TCP/IP Stack.

  • Provides automatic IP address, subnet mask, gateway address, DNS server address, and other configuration parameters on DHCP enabled networks.
  • Reference: RFC 2131, 2132

  • Dependencies: UDP
  • Processor: PIC18, PIC24F, PIC24H, dsPIC30F, dsPIC33F, PIC32
  • Compiler: Microchip C32 v1.00 or higher Microchip C30 v3.01 or higher Microchip C18 v3.13 or higher HI-TECH PICC-18 STD 9.50PL3 or higher
  • Company: Microchip Technology, Inc.

See the Microchip License Agreement for more details.

Modifications to the original file
  • Search for "MODIFIX" in the code !
  • Removed preprocessor macro STACK_USE_DHCP_CLIENT as always defined.
  • Implemented the AutoIP feature. If the DHCP client does not find any DHCP server and for that reason gets no IP address, a IP address in the 169.254.X.X address pool is choosen. The following functions are affected:
    1. Extended the function DHCPReset()
    2. Extended the function DHCPTask()
  • Removed hostname things
Todo:
Generate a doxygen page for discussing the Netzer project and the DHCP and AutoIP behavior (High level).

Functions

void | DHCPReset (void)
Resets the DHCP Client.
void | DHCPDisable (void)
Disables the DHCP client.
void | DHCPEnable (void)
Enables the DHCP client.
BOOL | DHCPIsEnabled (void)
This function returns the enable state of the DHCP client.
BOOL | DHCPHasFailed (void)
This function returns the failed state of the DHCP client.
void | DHCPTask (void)
Performs periodic DHCP tasks.
BOOL | DHCPHasBoundStateChanged (void)
This function checks whether the internal address bound state of thze DHCP client has changed.
void | DHCPGetIPParameterFromServer (IPConfig_t *pIPConfig)
If DHCP client is bound this function fills the given IP structure with the current IP parameters obtained from DHCP server.

Generated on Fri Mar 29 10:34:27 2013 for Netzer by doxygen 1.5.5


Netzer: DHCP.h File Reference

DHCP.h File Reference

Detailed Description

DHCP Defs for Microchip TCP/IP Stack.

  • Dependencies: TCPIPStack.h UDP.h
  • Processor: PIC18, PIC24F, PIC24H, dsPIC30F, dsPIC33F, PIC32
  • Compiler: Microchip C32 v1.00 or higher Microchip C30 v3.01 or higher Microchip C18 v3.13 or higher HI-TECH PICC-18 STD 9.50PL3 or higher
  • Company: Microchip Technology, Inc.

See the Microchip License Agreement for more details.

Modifications to the original file
  • Changed the prototype for DHCPReset.
  • Added doxygen comments to the function prototypes.
  • Removed the prototype for the function DHCPServerTask

Defines

#define | DHCPIsBound() (DHCPFlags.bits.bIsBound)
Determines if the DHCP server is currently bound.

Functions

void | DHCPReset (void)
Resets the DHCP Client.
void | DHCPTask (void)
Performs periodic DHCP tasks.
void | DHCPDisable (void)
Disables the DHCP client.
void | DHCPEnable (void)
Enables the DHCP client.
BOOL | DHCPHasBoundStateChanged (void)
This function checks whether the internal address bound state of thze DHCP client has changed.
void | DHCPGetIPParameterFromServer (IPConfig_t *pIPConfig)
If DHCP client is bound this function fills the given IP structure with the current IP parameters obtained from DHCP server.
BOOL | DHCPIsEnabled (void)
This function returns the enable state of the DHCP client.
BOOL | DHCPHasFailed (void)
This function returns the failed state of the DHCP client.

Generated on Fri Mar 29 10:34:27 2013 for Netzer by doxygen 1.5.5


Netzer: eeprom.c File Reference

eeprom.c File Reference

Detailed Description

Implementation file of the eeprom access (ANSI C part).

Generated on Fri Mar 29 10:34:27 2013 for Netzer by doxygen 1.5.5


Netzer: ETH97J60.c File Reference

ETH97J60.c File Reference

Detailed Description

Medium Access Control (MAC) Layer for Microchip PIC18F97J60 family.

Module for Microchip TCP/IP Stack:

  • Provides access to PIC18F97J60 family Ethernet controller
  • Reference: PIC18F97J60 Family data sheet, IEEE 802.3 Standard

  • Dependencies: ETH97J60.h MAC.h string.h StackTsk.h Helpers.h Delay.h
  • Processor: PIC18F97J60 family
  • Compiler: Microchip C32 v1.00 or higher Microchip C30 v3.01 or higher Microchip C18 v3.13 or higher HI-TECH PICC-18 STD 9.50PL3 or higher
  • Company: Microchip Technology, Inc.

See the Microchip License Agreement for more details.

Modifications to the original file
Search for "MODIFIX" in the code!

Defines

#define | HALF_DUPLEX
D E F I N I T I O N S.

Functions

BOOL | MACIsLinked (void)
Returns the link status of the PHY/MAC.

Generated on Fri Mar 29 10:34:27 2013 for Netzer by doxygen 1.5.5


Netzer: ETH97J60.h File Reference

ETH97J60.h File Reference

Detailed Description

Ethernet registers/bits for PIC18F97J60.

  • Dependencies: None
  • Processor: PIC18F97J60 family
  • Compiler: Microchip C18 v3.13 or higher HI-TECH PICC-18 STD 9.50PL3 or higher
  • Company: Microchip Technology, Inc.

See the Microchip License Agreement for more details.

Modifications to the original file
None

Generated on Fri Mar 29 10:34:27 2013 for Netzer by doxygen 1.5.5


Netzer: flash.c File Reference

flash.c File Reference

Detailed Description

Implementation of flash routines.

Software License
See the MBCSL for details.
Author:
Sven Schlender (kontakt at mobacon dot de)
Date:
2011-10-12

Generated on Fri Mar 29 10:34:27 2013 for Netzer by doxygen 1.5.5


Netzer: flash.h File Reference

flash.h File Reference

Detailed Description

API for accessing the internal flash memory.

Software License
See the MBCSL for details.
Author:
Sven Schlender (kontakt at mobacon dot de)
Date:
2011-07-22

#define | FLASH_WRITE_SIZE (64ul)
 | Device specific minimum flash block size which can be written.
#define | FLASH_ERASE_SIZE (1024ul)
 | Device specific minimum flash block size which can be erased.
#define | INTERNAL_FLASH_SIZE (1024ul*128ul)
 | The internal flash size for the pic18f97j60.
#define | TOTAL_MEMORY_SIZE (INTERNAL_FLASH_SIZE - BOOTLOADER_SIZE)
 | The memory size takes in account the existing bootloader.
#define | BOOTLOADER_SIZE (8ul*1024ul)
 | Size of the bootloader code.
void | RawEraseFlashBlock (auto uint32_t Address)
 | Erases the specified page (size of FLASH_ERASE_SIZE).
BOOL | RawWriteFlashBlock (auto uint32_t Address, auto uint8_t *BlockData, auto uint8_t *StatusData)
 | Writes one FLASH_WRITE_SIZE block of data to the Flash memory.

Function Documentation

void RawEraseFlashBlock ( auto uint32_t Address )

Erases the specified page (size of FLASH_ERASE_SIZE).

This function is bootloader safe. If an attempt to erase the addresses containing the bootloader is made, the function will not perform the erase.

Parameters:
Address Begining byte address to start erasing at. Note that this address must be page aligned (ie: evenly divisible by FLASH_ERASE_SIZE).

BOOL RawWriteFlashBlock | ( | auto uint32_t | Address,
 |  | auto uint8_t * | BlockData,
 |  | auto uint8_t * | StatusData
 | ) |  |

Writes one FLASH_WRITE_SIZE block of data to the Flash memory.

The memory must be erased prior to writing.

Parameters:
Address | Location to write to. This address MUST be an integer multiple of the FLASH_WRITE_SIZE constant.
BlockData | Pointer to an array of bytes to write. The array is assumed to be exactly FLASH_WRITE_SIZE in length (or longer). If longer, only the first FLASH_WRITE_SIZE bytes will be written. You must call WriteFlashBlock() again with an updated Address to write more bytes.
StatusData | Pointer to a byte array of size FLASH_WRITE_SIZE/8 which will be written with the results of the write. Each bit in the array represents one data byte successfully or unsuccessfully written. If the bit is set, the write was successful. Pointer can be NULL if individual byte status data is not needed.
Return values:
TRUE | If the write was successful or no write was needed because the data was already matching.
FALSE | If the write failed either because some other data was already in the memory (need to perform Erase first), or if, following the write, the data did not verify correctly (may have run out of Flash Erase-Write cycles).

Generated on Fri Mar 29 10:34:27 2013 for Netzer by doxygen 1.5.5


Netzer: GenericTypeDefs.h File Reference

GenericTypeDefs.h File Reference

Detailed Description

Generic Type Definitions.

  • Dependencies: None
  • Processor: PIC18, PIC24F, PIC24H, dsPIC30F, dsPIC33F, PIC32
  • Compiler: Microchip C18, C30, C32 HI-TECH PICC-18
  • Company: Microchip Technology, Inc.

See the Microchip License Agreement for more details.

Modifications to the original file
None.

Typedefs

typedef struct _MAC_ADDR | MAC_ADDR
This structure stores a 6 byte MAC address.
typedef struct _NODE_INFO | NODE_INFO
This structure stores informations of an network node.

Generated on Fri Mar 29 10:34:27 2013 for Netzer by doxygen 1.5.5


Netzer: gpio.c File Reference

gpio.c File Reference

Detailed Description

Implementation of gpio access.

Software License
See the MBCSL for details.
Author:
Sven Schlender (kontakt at mobacon dot de)
Date:
2010-08-25

Functions

void | GPIOInit (SerialMode_t Mode)
Initializes the GPIO module in the requested mode.
void | GPIOResetToFactory (void)
Resets the GPIO module EEPROM section to well known start parameters.
WORD | GPIOGetTCPPort (BOOL bPersistent)
Delivers the current configured TCP port of the GPIO server.
void | GPIOSetTCPPortPersistent (WORD Port)
Configures a new TCP port for the GPIO server.
BOOL | GPIOInitTask (void)
After initializing network and application stuff the application should call this function to prepare task members needed for proper GPIO task operation.
void | GPIOStopTask (void)
On network errors or shut down events these function should be called by the main application to proper stop the GPIO tasks (i.e disconnecting a connected client).
BOOL | bGPIOCheckForStoppedTask (void)
Before shutting down the application should poll for valid GPIO task shutdown.
void | GPIOTask (void)
Call this function periodically from main application to execute GPIO module tasks.
PortType_t | GPIOGetPortType (BYTE GPIOChannel)
Delivers the current port configuration of a GPIO pin.
BOOL | GPIOIsPortOverwritten (BYTE GPIOChannel)
Delivers if the port is currently overwritten by an alternative pin (i.e serial).
void | GPIOSetPortValue (BYTE GPIOChannel, BOOL Value)
This function sets the state for a single IO pin.
BOOL | GPIOGetPinValue (BYTE GPIOChannel)
This function reads the state from a single IO pin.
GPIOServerConnection_t | GPIOGetServerState (void)
This function delivers the current state of the GPIO server.
DWORD | GPIOGetConnectedIP (void)
Delivers the IP of a client who is connected to GPIO server.
void | GPIOSetAllPinValues (WORD NewValue)
Use this function to write to all pins at once.
BOOL | GPIOServerIsActivated (void)
Getter for activated GPIO server.
void | GPIOActivateServerPersistent (BOOL Activate)
Setter for GPIO server state.
ROM BYTE * | GPIOGetPortName (BYTE Channel)
Delivers the port alias name for the given channel.
void | GPIOSetPortType (BYTE Channel, PortType_t PortType)
Sets the port mode of a GPIO channel.
BOOL | GPIOGetStartupValue (BYTE Channel)
Delivers the startup value for a given channel.
void | GPIOSetStartupValue (BYTE Channel, BOOL Value)
Configures the startup value for binary output configured values.
void | GPIOFlushToEEPROM (void)
All prior changed values are persistently written to EEPROM.
void | GPIOConfigurePort (BYTE Channel)
Call this function for a given channel to reconfigure the port and all other peripherals associated with the new port function.

Generated on Fri Mar 29 10:34:27 2013 for Netzer by doxygen 1.5.5


Netzer: gpio.h File Reference

gpio.h File Reference

Detailed Description

API for GPIO (digital IO) access.

Software License
See the MBCSL for details.
Author:
Sven Schlender (kontakt at mobacon dot de)
Date:
2010-10-29

Defines

#define | GPIOWriteSPIChipSelect(Value) LATFbits.LATF7 = Value
In SPI mode the SPI_CS pin can be quickly written with this function.
#define | GPIOWriteSPIInt(Value) LATCbits.LATC2 = Value
In SPI slave mode the int pin can be quickly written with this function.
#define | GPIOWriteSPIBusy(Value) LATAbits.LATA3 = Value
In SPI slave mode the busy pin can be quickly written with this function.
#define | GPIOReadSPIRegister() PORTBbits.RB1
In SPI slave mode the register pin can be quickly read with this function.
#define | GPIOWriteSPINetzerDataValid(Value) LATAbits.LATA2 = Value
In SPI slave mode the data valid pin can be quickly written with this function.
#define | GPIOReadSPIMasterWrite() PORTDbits.RD1
In SPI slave mode the master data valid can be quickly read with this function.
#define | GPIOReadSPIClock() PORTCbits.RC3
In SPI mode the SPI_INT pin can be quickly read with this function.

Enumerations

enum PortType_t {
PT_DIG_INPUT = 0, PT_DIG_OUTPUT, PT_ANALOG_INPUT, PT_PWM,
PT_IMPULSE
}
A GPIO channel can be configured as one of this types. More...
enum | TimerPrescaler_t { TMR_PRESCALER1 = 0, TMR_PRESCALER2, TMR_PRESCALER4, TMR_PRESCALER8 }
Use this enumerator to configure prescaler values for impulse generation. More...
enum | PWMFrequencies_t { PF_2500_HZ = 0, PF_10000_HZ, PF_40000_HZ }
Use this enumerator to configure prescaler values for PWM generation. More...
enum | ImpulseMode_t { IPM_SINGLE = 0, IPM_TRIGGERED, IPM_CONTINUOUS }
Modes for impulse generation. More...
enum | GPIOServerConnection_t { GPIO_SERVER_NOT_RUNNING = 0, GPIO_SERVER_RUNNING, GPIO_SERVER_CONNECTED }
This enumerator is used to express the GPIO server state. More...
enum | EdgeCounterMode_t { EC_DISABLED = 0, EC_DECREMENTS, EC_INCREMENTS }
Modes of the edge trigger counter. More...
enum | EdgeTriggerMode_t { ET_DISABLED = 0, ET_FALLING, ET_RISING }
Modes of the edge trigger interrupt. More...
enum EdgeFilterMode_t {
EF_DISABLED = 0, EF_1_MS, EF_10_MS, EF_100_MS,
EF_250_MS
}
Filter mode for the edge trigger interrupt. More...
enum | EventMode_t { EM_DISABLED = 0, EM_ON_FALLING_EDGES, EM_ON_RISING_EDGES, EM_ON_ALL_EDGES }
Modes for the GPIO event service. More...
enum | GPIORadix_t { RADIX_IS_HEXADECIMAL = 0, RADIX_IS_DECIMAL }
Display radix for numbers on webpages and GPIO server. More...

Functions

void | GPIOInit (SerialMode_t Mode)
Initializes the GPIO module in the requested mode.
void | GPIOResetToFactory (void)
Resets the GPIO module EEPROM section to well known start parameters.
WORD | GPIOGetTCPPort (BOOL bPersistent)
Delivers the current configured TCP port of the GPIO server.
void | GPIOSetTCPPortPersistent (WORD Port)
Configures a new TCP port for the GPIO server.
BOOL | GPIOInitTask (void)
After initializing network and application stuff the application should call this function to prepare task members needed for proper GPIO task operation.
void | GPIOTask (void)
Call this function periodically from main application to execute GPIO module tasks.
void | GPIOStopTask (void)
On network errors or shut down events these function should be called by the main application to proper stop the GPIO tasks (i.e disconnecting a connected client).
BOOL | bGPIOCheckForStoppedTask (void)
Before shutting down the application should poll for valid GPIO task shutdown.
PortType_t | GPIOGetPortType (BYTE GPIOChannel)
Delivers the current port configuration of a GPIO pin.
BOOL | GPIOIsPortOverwritten (BYTE GPIOChannel)
Delivers if the port is currently overwritten by an alternative pin (i.e serial).
void | GPIOSetPortValue (BYTE Channel, BOOL Value)
This function sets the state for a single IO pin.
BOOL | GPIOGetPinValue (BYTE GPIOChannel)
This function reads the state from a single IO pin.
GPIOServerConnection_t | GPIOGetServerState (void)
This function delivers the current state of the GPIO server.
DWORD | GPIOGetConnectedIP (void)
Delivers the IP of a client who is connected to GPIO server.
void | GPIOResetEdgeCounter (BYTE Channel)
Thread safe reset the edge counter for the given channel.
BOOL | GPIOServerIsActivated (void)
Getter for activated GPIO server.
void | GPIOActivateServerPersistent (BOOL Activate)
Setter for GPIO server state.
ROM BYTE * | GPIOGetPortName (BYTE Channel)
Delivers the port alias name for the given channel.
EventMode_t | GPIOGetEventMode (BYTE Channel)
Delivers the GPIO server event mode of a GPIO channel.
void | GPIOSetEventMode (BYTE Channel, EventMode_t Mode)
Sets the GPIO server event mode of a GPIO channel.
void | GPIOSetPortType (BYTE Channel, PortType_t PortType)
Sets the port mode of a GPIO channel.
BOOL | GPIOGetStartupValue (BYTE Channel)
Delivers the startup value for a given channel.
void | GPIOSetStartupValue (BYTE Channel, BOOL Value)
Configures the startup value for binary output configured values.
void | GPIOFlushToEEPROM (void)
All prior changed values are persistently written to EEPROM.
void | GPIOConfigurePort (BYTE Channel)
Call this function for a given channel to reconfigure the port and all other peripherals associated with the new port function.
BOOL | GPIOIsTypeSupportedByPort (BYTE Channel, PortType_t PortType)
Determines programmatically if a given port supports a requested configuration.
BOOL | GPIOGetImpulseLogic (BYTE Channel)
Delivers the configured logic for an impulse channel.
TimerPrescaler_t | GPIOGetImpulsePrescaler (void)
Delivers the configured prescaler for all impulse channel.
WORD | GPIOGetStartImpulseWidth (BYTE Channel)
Delivers the configured startup value for an impulse channel.
WORD | GPIOGetCurrentImpulseWidth (BYTE Channel)
Delivers the current value for an impulse channel.
void | GPIOSetImpulseLogic (BYTE Channel, BOOL Logic)
Configures the logic for an impulse channel.
void | GPIOSetImpulsePrescaler (TimerPrescaler_t Prescaler)
Configures the prescaler for all impulse channel.
void | GPIOSetStartupImpulseWidth (BYTE Channel, WORD ImpulseWidth)
Configures the startup value for an impulse channel.
void | GPIOSetCurrentImpulseWidth (BYTE Channel, WORD ImpulseWidth)
Sets the value for an impulse or pwm channel.
EdgeTriggerMode_t | GPIOGetEdgeTriggerMode (BYTE Channel)
Delivers the current mode of the edge trigger for a given channel.
EdgeFilterMode_t | GPIOGetEdgeFilterMode (BYTE Channel)
Delivers the current filter mode of the edge trigger for a given channel.
EdgeCounterMode_t | GPIOGetEdgeCounterMode (BYTE Channel)
Delivers the current counter mode of the edge trigger for a given channel.
DWORD | GPIOGetEdgeCounter (BYTE Channel)
Delivers the current edge counter value.
void | GPIOSetEdgeTriggerMode (BYTE Channel, EdgeTriggerMode_t Mode)
Configures a new edge trigger mode for a given channel.
void | GPIOSetEdgeFilterMode (BYTE Channel, EdgeFilterMode_t Mode)
Configures a new edge filter mode for a given channel.
void | GPIOSetEdgeCounterMode (BYTE Channel, EdgeCounterMode_t Mode)
Configures a new edge counter mode for a given channel.
void | GPIOSetAllPinValues (WORD NewValue)
Use this function to write to all pins at once.
void | GPIOSetPWMLogic (BYTE Channel, BOOL Value)
Configures the logic for a pwm channel.
void | GPIOSetPWMFrequency (PWMFrequencies_t Value)
Configures the frequency for all pwm channel.
void | GPIOSetPWMStartDuty (BYTE Channel, WORD Value)
Configures the startup value of a pwm channel.
BOOL | GPIOGetPWMLogic (BYTE Channel)
Delivers the configured logic for a pwm channel.
PWMFrequencies_t | GPIOGetPWMFrequency (void)
Delivers the configured frequency for all pwm channel.
WORD | GPIOGetPWMStartDuty (BYTE Channel)
Delivers the configured startup value for a pwm channel.
ImpulseMode_t | GPIOGetImpulseMode (void)
Delivers the configured mode for all impulse channel.
void | GPIOSetImpulseMode (ImpulseMode_t Mode)
Sets a new mode for all impulse channel.
void | GPIOReconfigurePeripherals (void)
Call this function after reconfiguring a single or multiple ports with GPIOConfigurePort.
void | GPIOInitPeripherals (void)
Call this function before reconfiguring a single or multiple ports with GPIOConfigurePort.
GPIORadix_t | GPIOGetRadix (void)
Delivers the currently set radix for displaying values on the GPIO server and the web interface.
void | GPIOSetRadix (GPIORadix_t NewRadix)
Sets a new radix for displaying values on the GPIO server and the web interface.
BYTE | GPIOGetRefresh (void)
Delivers the currently set refresh rate for auto refreshing the GPIO web interface.
void | GPIOSetRefresh (BYTE Refresh)
Sets a new refresh rate for auto refreshing the GPIO web interface.
BOOL | GPIOIsScriptActive (void)
Delivers if javascript for the GPIO web interface is currently active.
void | GPIOActivateScript (BOOL Active)
Activates or deactivates javascript for the GPIO web interface.
BOOL | GPIOIsAuthActive (void)
Delivers if authentication for the GPIO server is currently active.
void | GPIOActivateAuth (BOOL Active)
Activates or deactivates authentication for the GPIO server.

Generated on Fri Mar 29 10:34:27 2013 for Netzer by doxygen 1.5.5


Netzer: helper.h File Reference

helper.h File Reference

Detailed Description

API for misc helper functions.

Software License
See the MBCSL for details.
Author:
Sven Schlender (kontakt at mobacon dot de)
Date:
2011-07-26

Functions

BYTE | HelperConvertNibbleFromHex (BYTE AsciiChar)
Convert the given ASCII hex character to the binary expression.
WORD | HelperConvertWordFromHex (BYTE *pAsciiString)
Convert the given ASCII hex string to the binary WORD expression.

Function Documentation

BYTE HelperConvertNibbleFromHex ( BYTE AsciiChar )

Convert the given ASCII hex character to the binary expression.

Parameters:
AsciiChar A ASCII character in the range 0-9 or a-f resp. A-F.
Returns:
The converted binary representation.

WORD HelperConvertWordFromHex ( BYTE * pAsciiString )

Convert the given ASCII hex string to the binary WORD expression.

Parameters:
pAsciiString A ASCII string with characters in the range 0-9 or a-f resp. A-F. The string can have a length up to 4.
Returns:
The converted binary representation.

Generated on Fri Mar 29 10:34:27 2013 for Netzer by doxygen 1.5.5


Netzer: Helpers.c File Reference

Helpers.c File Reference

Detailed Description

Helper Functions for Microchip TCP/IP Stack.

  • Dependencies: None
  • Processor: PIC18, PIC24F, PIC24H, dsPIC30F, dsPIC33F, PIC32
  • Compiler: Microchip C32 v1.00 or higher Microchip C30 v3.01 or higher Microchip C18 v3.13 or higher HI-TECH PICC-18 STD 9.50PL3 or higher
  • Company: Microchip Technology, Inc.

See the Microchip License Agreement for more details.

Modifications to the original file
  • None.

Generated on Fri Mar 29 10:34:27 2013 for Netzer by doxygen 1.5.5


Netzer: Helpers.h File Reference

Helpers.h File Reference

Detailed Description

Helper Function Defs for Microchip TCP/IP Stack.

  • Dependencies: stacktsk.h
  • Processor: PIC18, PIC24F, PIC24H, dsPIC30F, dsPIC33F, PIC32
  • Compiler: Microchip C32 v1.00 or higher Microchip C30 v3.01 or higher Microchip C18 v3.13 or higher HI-TECH PICC-18 STD 9.50PL3 or higher
  • Company: Microchip Technology, Inc.

See the Microchip License Agreement for more details.

Modifications to the original file
None

Generated on Fri Mar 29 10:34:27 2013 for Netzer by doxygen 1.5.5


Netzer: HTTP2.c File Reference

HTTP2.c File Reference

Detailed Description

HyperText Transfer Protocol (HTTP) Server Module for Microchip TCP/IP Stack.

  • Serves dynamic pages to web browsers such as Microsoft Internet Explorer, Mozilla Firefox, etc.
  • Reference: RFC 2068

  • Dependencies: TCP, MPFS, HTTPGetVar() callback, HTTPExecCmd() callback
  • Processor: PIC18, PIC24F, PIC24H, dsPIC30F, dsPIC33F, PIC32
  • Compiler: Microchip C32 v1.00 or higher Microchip C30 v3.01 or higher Microchip C18 v3.13 or higher HI-TECH PICC-18 STD 9.50PL3 or higher
  • Company: Microchip Technology, Inc.

See the Microchip License Agreement for more details.

Modifications to the original file
Added the function HTTPCheckForIdle. Added the port parameter for HTTPInit.

Generated on Fri Mar 29 10:34:27 2013 for Netzer by doxygen 1.5.5


Netzer: HTTP2.h File Reference

HTTP2.h File Reference

Detailed Description

HTTP definitions on Microchip TCP/IP Stack.

  • Dependencies: None
  • Processor: PIC18, PIC24F, PIC24H, dsPIC30F, dsPIC33F, PIC32
  • Compiler: Microchip C32 v1.00 or higher Microchip C30 v3.01 or higher Microchip C18 v3.13 or higher HI-TECH PICC-18 STD 9.50PL3 or higher
  • Company: Microchip Technology, Inc.

See the Microchip License Agreement for more details.

Modifications to the original file
  • Added doxygen comments to the function prototypes.
  • Added prototype for HTTPCheckForIdle function.

Generated on Fri Mar 29 10:34:27 2013 for Netzer by doxygen 1.5.5


Netzer: HTTPPrint.h File Reference

HTTPPrint.h File Reference

Detailed Description

Provides callback headers and resolution for the web interface.

Author:
MPFS Utility
Date:
2009-05-01

Generated on Fri Mar 29 10:34:27 2013 for Netzer by doxygen 1.5.5


Netzer: i2c.c File Reference

i2c.c File Reference

Detailed Description

Implementation of the I2C communication stuff.

Software License
See the MBCSL for details.
Author:
Sven Schlender (kontakt at mobacon dot de)
Date:
2010-10-29

Functions

void | I2CLoadConfig (void)
Loads the I2C configuration from EEPROM.
void | I2CInit (void)
Initializes the I2C module with the requested frequency.
I2CClockFrequencies_t | I2CGetFrequency (void)
Delivers the currently used frequency of I2C master mode.
void | I2CSetFrequency (I2CClockFrequencies_t NewFrequency)
Sets the clock frequency in I2C master mode.
void | I2CResetToFactory (void)
This function restores the EEPROM content of the I2C module to a well known state (Default frequency is 100 kHz).
void | I2CStopTask (void)
On network errors or shut down events these function should be called to proper stop the I2C related tasks.
BOOL | I2CCheckForStoppedTask (void)
Before shutting down the application should poll for valid I2C task shutdown.
void | I2CTask (BOOL NewDataReceived)
Call this function periodically from main application to execute the I2C module task.
void | I2CISR (void)
The interrupt routine of the i2c module.

Function Documentation

BOOL I2CCheckForStoppedTask ( void )

Before shutting down the application should poll for valid I2C task shutdown.

Return values:
TRUE | The task has successfully stopped.
FALSE | Stopping the I2C task is pending.

I2CClockFrequencies_t I2CGetFrequency ( void )

Delivers the currently used frequency of I2C master mode.

The frequency can be read indepently from the current active NetzerIO mode.

Returns:
The frequency as enumerated value.

void I2CInit ( void )

Initializes the I2C module with the requested frequency.

Should be called once at startup (very early).

void I2CISR ( void )

The interrupt routine of the i2c module.

Must be called if the module is active and a high priority interrupt has occured.

Important: Only call this function from interrupt context!

void I2CLoadConfig ( void )

Loads the I2C configuration from EEPROM.

Must be called once at startup (very early).

void I2CResetToFactory ( void )

This function restores the EEPROM content of the I2C module to a well known state (Default frequency is 100 kHz).

void I2CSetFrequency ( I2CClockFrequencies_t Frequency )

Sets the clock frequency in I2C master mode.

If in I2C master mode the change takes effect directly. The new mode is stored persistent in EEPROM.

Parameters:
Frequency The frequency as enumerated value.

void I2CStopTask ( void )

On network errors or shut down events these function should be called to proper stop the I2C related tasks.

void I2CTask ( BOOL DataInFIFO )

Call this function periodically from main application to execute the I2C module task.

Parameters:
DataInFIFO TRUE if data is located in the TCP/IP receive FIFO buffer. FALSE if the TCP/IP receive FIFO buffer is empty.

Generated on Fri Mar 29 10:34:27 2013 for Netzer by doxygen 1.5.5


Netzer: i2c.h File Reference

i2c.h File Reference

Detailed Description

API for serial communication via I2C.

Software License
See the MBCSL for details.
Author:
Sven Schlender (kontakt at mobacon dot de)
Date:
2010-12-16

enum | I2CClockFrequencies_t { I2CFREQ_400K = 0, I2CFREQ_100K, I2CFREQ_COUNT }
 | The supported clock frequencies in I2C master mode. More...
void | I2CLoadConfig (void)
 | Loads the I2C configuration from EEPROM.
void | I2CInit (void)
 | Initializes the I2C module with the requested frequency.
void | I2CStopTask (void)
 | On network errors or shut down events these function should be called to proper stop the I2C related tasks.
BOOL | I2CCheckForStoppedTask (void)
 | Before shutting down the application should poll for valid I2C task shutdown.
void | I2CTask (BOOL DataInFIFO)
 | Call this function periodically from main application to execute the I2C module task.
I2CClockFrequencies_t | I2CGetFrequency (void)
 | Delivers the currently used frequency of I2C master mode.
void | I2CSetFrequency (I2CClockFrequencies_t Frequency)
 | Sets the clock frequency in I2C master mode.
void | I2CResetToFactory (void)
 | This function restores the EEPROM content of the I2C module to a well known state (Default frequency is 100 kHz).
void | I2CISR (void)
 | The interrupt routine of the i2c module.

Enumeration Type Documentation

enum I2CClockFrequencies_t

The supported clock frequencies in I2C master mode.

Enumerator:
I2CFREQ_400K | 400 KHz.
I2CFREQ_100K | 100 KHz.
I2CFREQ_COUNT | Dummy for getting the count of all supported frequencies.

Function Documentation

BOOL I2CCheckForStoppedTask ( void )

Before shutting down the application should poll for valid I2C task shutdown.

Return values:
TRUE | The task has successfully stopped.
FALSE | Stopping the I2C task is pending.

I2CClockFrequencies_t I2CGetFrequency ( void )

Delivers the currently used frequency of I2C master mode.

The frequency can be read indepently from the current active NetzerIO mode.

Returns:
The frequency as enumerated value.

void I2CInit ( void )

Initializes the I2C module with the requested frequency.

Should be called once at startup (very early).

void I2CISR ( void )

The interrupt routine of the i2c module.

Must be called if the module is active and a high priority interrupt has occured.

Important: Only call this function from interrupt context!

void I2CLoadConfig ( void )

Loads the I2C configuration from EEPROM.

Must be called once at startup (very early).

void I2CResetToFactory ( void )

This function restores the EEPROM content of the I2C module to a well known state (Default frequency is 100 kHz).

void I2CSetFrequency ( I2CClockFrequencies_t Frequency )

Sets the clock frequency in I2C master mode.

If in I2C master mode the change takes effect directly. The new mode is stored persistent in EEPROM.

Parameters:
Frequency The frequency as enumerated value.

void I2CStopTask ( void )

On network errors or shut down events these function should be called to proper stop the I2C related tasks.

void I2CTask ( BOOL DataInFIFO )

Call this function periodically from main application to execute the I2C module task.

Parameters:
DataInFIFO TRUE if data is located in the TCP/IP receive FIFO buffer. FALSE if the TCP/IP receive FIFO buffer is empty.

Generated on Fri Mar 29 10:34:27 2013 for Netzer by doxygen 1.5.5


Netzer: ICMP.c File Reference

ICMP.c File Reference

Detailed Description

Internet Control Message Protocol (ICMP) Server Module for Microchip TCP/IP Stack.

  • Provides "ping" diagnostics
  • Reference: RFC 792

  • Dependencies: IP, ARP
  • Processor: PIC18, PIC24F, PIC24H, dsPIC30F, dsPIC33F, PIC32
  • Compiler: Microchip C32 v1.00 or higher Microchip C30 v3.01 or higher Microchip C18 v3.13 or higher HI-TECH PICC-18 STD 9.50PL3 or higher
  • Company: Microchip Technology, Inc.

See the Microchip License Agreement for more details.

Modifications to the original file
  • Removed preprocessor macro STACK_USE_ICMP_SERVER as always defined.
  • Removed all code sections requested with STACK_USE_ICMP_CLIENT because the Netzer project does not use ping requests.

Generated on Fri Mar 29 10:34:27 2013 for Netzer by doxygen 1.5.5


Netzer: ICMP.h File Reference

ICMP.h File Reference

Detailed Description

ICMP Module Defs for Microchip TCP/IP Stack.

  • Dependencies: StackTsk.h IP.h MAC.h
  • Processor: PIC18, PIC24F, PIC24H, dsPIC30F, dsPIC33F, PIC32
  • Compiler: Microchip C32 v1.00 or higher Microchip C30 v3.01 or higher Microchip C18 v3.13 or higher HI-TECH PICC-18 STD 9.50PL3 or higher
  • Company: Microchip Technology, Inc.

See the Microchip License Agreement for more details.

Modifications to the original file
  • Removed STACK_USE_ICMP_CLIENT function prototypes.

Generated on Fri Mar 29 10:34:27 2013 for Netzer by doxygen 1.5.5


Netzer: io.c File Reference

io.c File Reference

Detailed Description

Implementation of the common io application stuff.

Software License
See the MBCSL for details.
Author:
Sven Schlender (kontakt at mobacon dot de)
Date:
2010-11-01

Data Structures

struct | IoData_t
This typedef defines the peristent structure for common application settings. More...

Functions

void | IoEarlyInit (void)
Call this function prior calling of all other modules.
BOOL | IoInit (void)
Call this function to init the IO project and its sub modules.
void | IoSetNewSerialMode (SerialMode_t Mode)
Configures the new mode, which is written to EEPROM.
SerialMode_t | IoGetSerialMode (BOOL bPersistent)
Delivers the current configured IO mode.
void | IoResetToFactory (void)
Reset the persitent settings of the IO project to well known states.
BOOL | IoInitTasks (void)
Initializes the IO project tasks.
void | IoTasks (void)
Executes the IO project tasks.
void | IoStopTasks (void)
Stops the IO project tasks.
BOOL | IoCheckForStoppedTasks (void)
Checks for stopped IO project tasks.
void | IoShutdown (void)
Is called once after the main cycle is breaked due shutdown or restart requests.

Function Documentation

BOOL IoCheckForStoppedTasks ( void )

Checks for stopped IO project tasks.

Should be called after IoStopTasks.

Return values:
TRUE | Tasks are stopped.
FALSE | Tasks are running yet.

void IoEarlyInit ( void )

Call this function prior calling of all other modules.

SerialMode_t IoGetSerialMode ( BOOL bPersistent )

Delivers the current configured IO mode.

Parameters:
bPersistent If TRUE the mode is read from EEPROM, if FALSE the mode is read from local state.
Returns:
The IO mode as enumerated value.

BOOL IoInit ( void )

Call this function to init the IO project and its sub modules.

Return values:
TRUE | Initialization was successful.
FALSE | Initialization failed.

BOOL IoInitTasks ( void )

Initializes the IO project tasks.

Return values:
TRUE | Initialization of all tasks was successful.
FALSE | At least one task initialization has failed, try again later.

void IoResetToFactory ( void )

Reset the persitent settings of the IO project to well known states.

void IoSetNewSerialMode ( SerialMode_t Mode )

Configures the new mode, which is written to EEPROM.

Note:
This new value do not change the current mode - it takes affect after restart first.
Parameters:
Mode The IO mode as enumerated value.

void IoShutdown ( void )

Is called once after the main cycle is breaked due shutdown or restart requests.

void IoStopTasks ( void )

Stops the IO project tasks.

void IoTasks ( void )

Executes the IO project tasks.

Generated on Fri Mar 29 10:34:27 2013 for Netzer by doxygen 1.5.5


Netzer: IP.c File Reference

IP.c File Reference

Detailed Description

Internet Protocol (IP) Version 4 Communications Layer Module for Microchip TCP/IP Stack.

  • Provides a transport for TCP, UDP, and ICMP messages
  • Reference: RFC 791

Dependencies: Ethernet (ETH97J60.c) Processor: PIC18, PIC24F, PIC24H, dsPIC30F, dsPIC33F, PIC32 Compiler: Microchip C32 v1.00 or higher Microchip C30 v3.01 or higher Microchip C18 v3.13 or higher HI-TECH PICC-18 STD 9.50PL3 or higher Company: Microchip Technology, Inc.

See the Microchip License Agreement for more details.

Modifications to the original file
  • Search for "MODIFIX" in the code !
  • Added the function IPConvertSubnetToMask
  • Added the function IPConvertMaskToSubnet

Functions

DWORD | IPConvertSubnetToMask (BYTE Subnet)
This function converts the CIDR subnet expression to the long IP expression.
BYTE | IPConvertMaskToSubnet (BYTE *MaskArray)
This function converts the long IP subnet expression to the CIDR expression.

Generated on Fri Mar 29 10:34:27 2013 for Netzer by doxygen 1.5.5


Netzer: IP.h File Reference

IP.h File Reference

Detailed Description

IP Defs for Microchip TCP/IP Stack.

  • Dependencies: StackTsk.h MAC.h
  • Processor: PIC18, PIC24F, PIC24H, dsPIC30F, dsPIC33F, PIC32MX
  • Compiler: Microchip C32 v1.00 or higher Microchip C30 v3.01 or higher Microchip C18 v3.13 or higher HI-TECH PICC-18 STD 9.50PL3 or higher
  • Company: Microchip Technology, Inc.

See the Microchip License Agreement for more details.

Modifications to the original file
  • Search for "MODIFIX" in the code!
  • Added doxygen comments to the function prototype of u32IPConvertSubnetToMask.

Functions

DWORD | IPConvertSubnetToMask (BYTE Subnet)
This function converts the CIDR subnet expression to the long IP expression.
BYTE | IPConvertMaskToSubnet (BYTE *MaskArray)
This function converts the long IP subnet expression to the CIDR expression.

Generated on Fri Mar 29 10:34:27 2013 for Netzer by doxygen 1.5.5


Netzer: MAC.h File Reference

MAC.h File Reference

Detailed Description

MAC Module Defs for Microchip Stack.

  • Dependencies: StackTsk.h
  • Processor: PIC18, PIC24F, PIC24H, dsPIC30F, dsPIC33F, PIC32
  • Compiler: Microchip C32 v1.00 or higher Microchip C30 v3.01 or higher Microchip C18 v3.13 or higher HI-TECH PICC-18 STD 9.50PL3 or higher
  • Company: Microchip Technology, Inc.

See the Microchip License Agreement for more details.

Modifications to the original file
  • Added doxygen comments to the function prototypes used by MoBaCon projects.
  • Added MAC address which is located in flash.

Functions

BOOL MACIsLinked (void)
Returns the link status of the PHY/MAC.

Generated on Fri Mar 29 10:34:27 2013 for Netzer by doxygen 1.5.5


Netzer: main.c File Reference

main.c File Reference

Detailed Description

This file includes the main entry function.

In main all necessary initialization stuff is done. After the init calling the main loop is executed which calls all module routines periodically. In case of an user requested shut down the main routine is leaved and Netzer is shut down.

Software License
See the MBCSL for details.
Author:
Sven Schlender (kontakt at mobacon dot de)
Date:
2010-08-25

Generated on Fri Mar 29 10:34:27 2013 for Netzer by doxygen 1.5.5


Netzer: main.h File Reference

main.h File Reference

Detailed Description

This file includes some defines for main.c and also the fuse settings for the PIC.

Software License
See the MBCSL for details.
Author:
Sven Schlender (kontakt at mobacon dot de)
Date:
2009-04-30

Generated on Fri Mar 29 10:34:27 2013 for Netzer by doxygen 1.5.5


Netzer: mdns.c File Reference

mdns.c File Reference

Detailed Description

Multicast Domain Name System (MDNS) implementation file for the Netzer application.

Software License
See the MBCSL for details.
Author:
Sven Schlender (kontakt at mobacon dot de)
Date:
2008-09-26

Functions

static void | _CheckForQueryResponse (WORD_VAL u16Type, WORD_VAL *pu16Length, BYTE u8Startlabel)
BOOL | bInitMDNSResponder (WORD HTTPPort)
Note: Important: First call this function after got the IP address and checked the validness.
void | StartMDNSResponder (void)
The service is started by a call of this function.
void | StopMDNSResponder (void)
The service is stopped by a call of this function.
MDNS_STATE | eGetMDNSState (void)
The function retrieves the state of the MDNS responder.
void | MDNSResponder ()
The function implements the state machine of the MDNS responder.
void | MDNSProcessFrame (NODE_INFO *remoteNode, IP_ADDR *localIP)
In the MDNS module the state machine and the receiption of frames are divorced.
BOOL | bMDNSNameIsResolved (IP_ADDR *pIP)
After calling MDNSResolveName the application should check periodically the resolvation progress with a call of this function.
BOOL | bMDNSServiceIsResolved (IP_ADDR *pIP, WORD_VAL *pu16Port)
After calling MDNSResolveService the application should check periodically the resolvation progress with a call of this function.
void | MDNSStopResolving (void)
A pending resolvation process will be stopped.
void | MDNSResolveName (char *pName)
The function resolves a hostname record via MDNS to an IP address.
void | MDNSResolveService (char *pName, ROM char *pServiceName)
The function resolves a service record via MDNS.

Function Documentation

static void _CheckForQueryResponse | ( | WORD_VAL | u16Type,
 |  | WORD_VAL * | pu16Length,
 |  | BYTE | u8Startlabel |
 | ) |  |  | [static]

Todo:
Message compression.

Generated on Fri Mar 29 10:34:27 2013 for Netzer by doxygen 1.5.5


Netzer: mdns.h File Reference

mdns.h File Reference

Detailed Description

MDNS Client Module Header file for the application.

Software License
See the MBCSL for details.
Author:
Sven Schlender (kontakt at mobacon dot de)
Date:
2008-09-26

Defines

#define | MDNS_PORT 5353u
The MDNS UDP port.
#define | DNS_PORT 53u
The DNS UDP port.
#define | DNS_TYPE_A (0x0001u)
DNS type for hostnames.
#define | DNS_TYPE_PTR (0x000cu)
DNS type for pointer records.
#define | DNS_TYPE_MX (0x000fu)
DNS type for mailbox records.
#define | DNS_TYPE_SRV (0x0021u)
DNS type for service records.
#define | DNS_TYPE_TXT (0x0010u)
DNS type for text records.
#define | DNS_TYPE_ANY (0x00FFu)
DNS type for all records.

Enumerations

enum | _MDNS_STATE { MDNS_HAS_STOPPED = 0, MDNS_IS_STARTING_UP, MDNS_IS_RUNNING }
Possible states of the MDNS responder service. More...

Functions

BOOL | bInitMDNSResponder (WORD HTTPPort)
The function initializes the MDNS service.
void | StartMDNSResponder (void)
The service is started by a call of this function.
void | StopMDNSResponder (void)
The service is stopped by a call of this function.
void | MDNSResponder (void)
The function implements the state machine of the MDNS responder.
void | MDNSProcessFrame (NODE_INFO *remoteNode, IP_ADDR *localIP)
In the MDNS module the state machine and the receiption of frames are divorced.
MDNS_STATE | eGetMDNSState (void)
The function retrieves the state of the MDNS responder.
void | MDNSResolveService (char *pName, ROM char *pServiceName)
The function resolves a service record via MDNS.
void | MDNSResolveName (char *pName)
The function resolves a hostname record via MDNS to an IP address.
void | MDNSStopResolving (void)
A pending resolvation process will be stopped.
BOOL | bMDNSServiceIsResolved (IP_ADDR *pIP, WORD_VAL *pu16Port)
After calling MDNSResolveService the application should check periodically the resolvation progress with a call of this function.
BOOL | bMDNSNameIsResolved (IP_ADDR *pIP)
After calling MDNSResolveName the application should check periodically the resolvation progress with a call of this function.

Generated on Fri Mar 29 10:34:27 2013 for Netzer by doxygen 1.5.5


Netzer: MPFS2.c File Reference

MPFS2.c File Reference

Detailed Description

Microchip File System (MPFS) File Access API.

Module for Microchip TCP/IP Stack.

  • Provides single API for accessing web pages and other files from internal program memory or an external serial EEPROM memory
  • Reference: AN833

  • Dependencies: SPIEEPROM
  • Processor: PIC18, PIC24F, PIC24H, dsPIC30F, dsPIC33F, PIC32
  • Compiler: Microchip C32 v1.00 or higher Microchip C30 v3.01 or higher Microchip C18 v3.13 or higher HI-TECH PICC-18 STD 9.50PL3 or higher
  • Company: Microchip Technology, Inc.

Modifications to the original file
  • Huffman decoding for indexed files added. Search MODIFIX keyword for details.

Generated on Fri Mar 29 10:34:27 2013 for Netzer by doxygen 1.5.5


Netzer: MPFS2.h File Reference

MPFS2.h File Reference

Detailed Description

MPFS Defines and prototypes for Microchip File System.

  • Dependencies: StackTsk.H
  • Processor: PIC18, PIC24F, PIC24H, dsPIC30F, dsPIC33F, PIC32
  • Compiler: Microchip C32 v1.00 or higher Microchip C30 v3.01 or higher Microchip C18 v3.13 or higher HI-TECH PICC-18 STD 9.50PL3 or higher
  • Company: Microchip Technology, Inc.

See the Microchip License Agreement for more details.

Modifications to the original file
  • None.

Generated on Fri Mar 29 10:34:27 2013 for Netzer by doxygen 1.5.5


Netzer: MPFSImg.c File Reference

MPFSImg.c File Reference

Detailed Description

Defines an MPFS2 image to be stored in program memory.

The websites of the device are stored here.

Author:
MPFS Utility
Date:
2009-05-01

Generated on Fri Mar 29 10:34:27 2013 for Netzer by doxygen 1.5.5


Netzer: netzerTypedefs.h File Reference

netzerTypedefs.h File Reference

Detailed Description

Defines common typedefs for use in Netzer projects.

Software License
See the MBCSL for details.
Author:
Sven Schlender (kontakt at mobacon dot de)
Date:
2011-05-08

Defines

#define | GPIO_INPUT TRUE
Expression for GPIO configured as input.
#define | GPIO_OUTPUT FALSE
Expression for GPIO configured as output.
#define | GPIO_COUNT (13u)
Count of supported GPIOs at the moment.
#define | GPIO_00_ID 0x00
ID for accessing the pin IO0.
#define | GPIO_01_ID 0x01
ID for accessing the pin IO1.
#define | GPIO_02_ID 0x02
ID for accessing the pin IO2.
#define | GPIO_03_ID 0x03
ID for accessing the pin IO3.
#define | GPIO_04_ID 0x04
ID for accessing the pin IO4.
#define | GPIO_05_ID 0x05
ID for accessing the pin IO5.
#define | GPIO_06_ID 0x06
ID for accessing the pin TX.
#define | GPIO_07_ID 0x07
ID for accessing the pin RX.
#define | GPIO_08_ID 0x08
ID for accessing the pin SPI_CS.
#define | GPIO_09_ID 0x09
ID for accessing the pin SPI_INT.
#define | GPIO_0A_ID 0x0A
ID for accessing the pin SPI_CLK.
#define | GPIO_0B_ID 0x0B
ID for accessing the pin SPI_MISO.
#define | GPIO_0C_ID 0x0C
ID for accessing the pin SPI_MOSI.

Enumerations

enum ApplCommands_t {
APPL_CMD_IDLE = 0, APPL_CMD_RESTART, APPL_CMD_RESET_TO_FACTORY, APPL_CMD_SHUTDOWN,
APPL_CMD_BOOTLOADER, APPL_CMD_BLINK, APPL_CMD_COUNT
}
This typedef defines some common commands for the application. More...
enum NetzerState_t {
NETZER_STARTING = 0, NETZER_NOLINK, NETZER_IP_ERROR, NETZER_READY,
NETZER_SHUTDOWN
}
The device states as enumerator. More...
enum | PageID_t
All html files have this unique index. More...

Generated on Fri Mar 29 10:34:27 2013 for Netzer by doxygen 1.5.5


Netzer: projectdefs.h File Reference

projectdefs.h File Reference

Detailed Description

Some project related defines and typedefs for the NetzerIO project.

Software License
See the MBCSL for details.
Author:
Sven Schlender (kontakt at mobacon dot de)
Date:
2010-10-29

#define | PROJECT_ID IO_PROJECT
 | The project identifier.
#define | LICENSE_NAME ""
 | The project name.
#define | PROJECT_EARLYINIT IoEarlyInit
 | This macro is used as hook in the Main function before other modules are called.
#define | PROJECT_INIT IoInit
 | This macro is used as hook in the ApplInit function.
#define | PROJECT_RESET_TO_FACTORY IoResetToFactory
 | This macro is used as hook in the ApplResetToFactory function.
#define | PROJECT_STATE_CHANGED(NewState)
 | This macro is used as hook in the ApplStateChanged function.
#define | PROJECT_INIT_TASK IoInitTasks
 | This macro is used as hook in the ApplMain function.
#define | PROJECT_TASK IoTasks
 | This macro is used as hook in the ApplMain function.
#define | PROJECT_CYCLE SerialRegisterHandling
 | This macro is used as hook in the Main cycle.
#define | PROJECT_STOP_TASK IoStopTasks
 | This macro is used as hook in the ApplMain function.
#define | PROJECT_POWERDOWN IoShutdown
 | This macro is used as hook after leaving the Main cycle.
#define | PROJECT_CHECK_FOR_STOPPED_TASK IoCheckForStoppedTasks
 | This macro is used as hook in the ApplMain function.
#define | PROJECT_PROCESS_POST WebIoProcessPost
 | This macro is used as hook in the HTTPExecutePost (see web.c) function.
#define | GPIO_EEPROM_ADD (PROJECT_EEPROM_ADD+0x0008u)
 | EEPROM address for storing GPIO related stuff.
#define | SERIAL_EEPROM_ADD (PROJECT_EEPROM_ADD+0x0030u)
 | EEPROM address for storing serial related stuff.
#define | I2C_EEPROM_ADD (PROJECT_EEPROM_ADD+0x0038u)
 | EEPROM address for storing I2C related stuff.
#define | PROJECT_WEB_SUBFOLDER ""
 | This macro defines a possible subfolder for the web hierarchy.
#define | PROJECT_WEBSITES
 | Defines the sites for this project.
#define | PROJECT_HTTP_GET_EXECUTION WebIoHTTPExecuteGet
 | This define sets the get execution hook for project related pages to the given function.
enum | SerialMode_t { PROJECT_MODE_SERIAL_DISABLED = 0, PROJECT_MODE_UART, PROJECT_MODE_SPI_MASTER, PROJECT_MODE_SPI_SLAVE, PROJECT_MODE_I2C_MASTER, PROJECT_MODE_COUNT }
 | This typedef can be used to enumerate the different modes of NetzerIO. More...
void | IoEarlyInit (void)
 | Call this function prior calling of all other modules.
BOOL | IoInit (void)
 | Call this function to init the IO project and its sub modules.
SerialMode_t | IoGetSerialMode (BOOL bPersistent)
 | Delivers the current configured IO mode.
void | IoSetNewSerialMode (SerialMode_t Mode)
 | Configures the new mode, which is written to EEPROM.
void | IoResetToFactory (void)
 | Reset the persitent settings of the IO project to well known states.
BOOL | IoInitTasks (void)
 | Initializes the IO project tasks.
void | IoTasks (void)
 | Executes the IO project tasks.
void | IoStopTasks (void)
 | Stops the IO project tasks.
void | IoShutdown (void)
 | Is called once after the main cycle is breaked due shutdown or restart requests.
BOOL | IoCheckForStoppedTasks (void)
 | Checks for stopped IO project tasks.
void | WebIoProcessPost (BYTE PageIndex, BYTE *pControl, BYTE *pValueString, DWORD Value)
 | This function processes HTTP post requests.
void | WebIoHTTPExecuteGet (BYTE Index)
 | This function is called if a HTTP GET request is received for one of the project pages.

Define Documentation

#define GPIO_EEPROM_ADD (PROJECT_EEPROM_ADD+0x0008u)

EEPROM address for storing GPIO related stuff.

#define I2C_EEPROM_ADD (PROJECT_EEPROM_ADD+0x0038u)

EEPROM address for storing I2C related stuff.

#define LICENSE_NAME ""

The project name.

This name is displayed on index.htm of the Netzer website.

#define PROJECT_CHECK_FOR_STOPPED_TASK IoCheckForStoppedTasks

This macro is used as hook in the ApplMain function.

#define PROJECT_CYCLE SerialRegisterHandling

This macro is used as hook in the Main cycle.

#define PROJECT_EARLYINIT IoEarlyInit

This macro is used as hook in the Main function before other modules are called.

#define PROJECT_HTTP_GET_EXECUTION WebIoHTTPExecuteGet

This define sets the get execution hook for project related pages to the given function.

#define PROJECT_ID IO_PROJECT

The project identifier.

See NetzerProjects_t for a complete project list.

#define PROJECT_INIT IoInit

This macro is used as hook in the ApplInit function.

#define PROJECT_INIT_TASK IoInitTasks

This macro is used as hook in the ApplMain function.

Returns boolean True to indicate that initialization was successful.

#define PROJECT_POWERDOWN IoShutdown

This macro is used as hook after leaving the Main cycle.

#define PROJECT_PROCESS_POST WebIoProcessPost

This macro is used as hook in the HTTPExecutePost (see web.c) function.

#define PROJECT_RESET_TO_FACTORY IoResetToFactory

This macro is used as hook in the ApplResetToFactory function.

#define PROJECT_STATE_CHANGED ( NewState )

This macro is used as hook in the ApplStateChanged function.

#define PROJECT_STOP_TASK IoStopTasks

This macro is used as hook in the ApplMain function.

#define PROJECT_TASK IoTasks

This macro is used as hook in the ApplMain function.

#define PROJECT_WEB_SUBFOLDER ""

This macro defines a possible subfolder for the web hierarchy.

#define PROJECT_WEBSITES

Value:

{STRTBLID_GPIO, "gpio.htm",NAV_HEAD, 0x82},       \
                            {0, "gpiocfg.htm", PAGEID_GPIO, 0x80},            \
                            {STRTBLID_SERIAL, "serial.htm", NAV_HEAD, 0x80}
Defines the sites for this project.

#define SERIAL_EEPROM_ADD (PROJECT_EEPROM_ADD+0x0030u)

EEPROM address for storing serial related stuff.

Enumeration Type Documentation

enum SerialMode_t

This typedef can be used to enumerate the different modes of NetzerIO.

Enumerator:
PROJECT_MODE_SERIAL_DISABLED | No serial communication.
PROJECT_MODE_UART | The UART mode.
PROJECT_MODE_SPI_MASTER | The SPI master mode.
PROJECT_MODE_SPI_SLAVE | The SPI slave mode.
PROJECT_MODE_I2C_MASTER | The I2C master mode.
PROJECT_MODE_COUNT | Dummy for getting the count of all modes.

Function Documentation

BOOL IoCheckForStoppedTasks ( void )

Checks for stopped IO project tasks.

Should be called after IoStopTasks.

Return values:
TRUE | Tasks are stopped.
FALSE | Tasks are running yet.

void IoEarlyInit ( void )

Call this function prior calling of all other modules.

SerialMode_t IoGetSerialMode ( BOOL bPersistent )

Delivers the current configured IO mode.

Parameters:
bPersistent If TRUE the mode is read from EEPROM, if FALSE the mode is read from local state.
Returns:
The IO mode as enumerated value.

BOOL IoInit ( void )

Call this function to init the IO project and its sub modules.

Return values:
TRUE | Initialization was successful.
FALSE | Initialization failed.

BOOL IoInitTasks ( void )

Initializes the IO project tasks.

Return values:
TRUE | Initialization of all tasks was successful.
FALSE | At least one task initialization has failed, try again later.

void IoResetToFactory ( void )

Reset the persitent settings of the IO project to well known states.

void IoSetNewSerialMode ( SerialMode_t Mode )

Configures the new mode, which is written to EEPROM.

Note:
This new value do not change the current mode - it takes affect after restart first.
Parameters:
Mode The IO mode as enumerated value.

void IoShutdown ( void )

Is called once after the main cycle is breaked due shutdown or restart requests.

void IoStopTasks ( void )

Stops the IO project tasks.

void IoTasks ( void )

Executes the IO project tasks.

void WebIoHTTPExecuteGet ( BYTE Index )

This function is called if a HTTP GET request is received for one of the project pages.

For the IO project this function processes the given index on GPIO configuration sites.

Parameters:
Index is the value of a possible given Id parameter in the HTTP GET request.

void WebIoProcessPost | ( | BYTE | PageIndex,
 |  | BYTE * | pControl,
 |  | BYTE * | pValueString,
 |  | DWORD | Value
 | ) |  |

This function processes HTTP post requests.

Parameters:
PageIndex | Index of the post request file.
pControl | Pointer to the name of the post control.
pValueString | Pointer to the value string of the post control.
Value | The preprocessed value string as numeric variable.

Generated on Fri Mar 29 10:34:27 2013 for Netzer by doxygen 1.5.5


Netzer: projectIRQ.asm File Reference

projectIRQ.asm File Reference

Detailed Description

This file extends low and high priority interrupts in a very efficient and small footprint manner.

Also all the initialization of the indirect jump registers irqLowOffset (for low priority irqs) and irqHiOffset (for high priority irqs) is done here.

Generated on Fri Mar 29 10:34:27 2013 for Netzer by doxygen 1.5.5


Netzer: projectIRQ.inc File Reference

projectIRQ.inc File Reference

Detailed Description

This file extends the low priority interrupt hook to call some IO routines (for example filter timer and serial stubs).

The routine calling is done with some indirect jump magic. The variable irqLowOffset stores the lower part of the PC to jump to. The application has to adjust the higher parts of the PC (PCLATH and PCLATU) before using it. On startup both registers should be cleared and irqLowOffset should point to a simple retfie instruction. Currently this done in the projectIRQ.asm.

Before enabling any low priority interrupts the application must ensure the correct PC value. Else a deadlock can occur.

Generated on Fri Mar 29 10:34:27 2013 for Netzer by doxygen 1.5.5


Netzer: Reboot.c File Reference

Reboot.c File Reference

Detailed Description

Module for Microchip TCP/IP Stack
  • Remotely resets the PIC
  • Reference: Internet Bootloader documentation.

Dependencies: UDP Processor: PIC18, PIC24F, PIC24H, dsPIC30F, dsPIC33F, PIC32 Compiler: Microchip C32 v1.00 or higher Microchip C30 v3.01 or higher Microchip C18 v3.13 or higher HI-TECH PICC-18 STD 9.50PL3 or higher Company: Microchip Technology, Inc.

See the Microchip License Agreement for more details.

Modifications to the original file
  • Added the call to ApplCommand for initiating the shut down procedure.


Netzer: Reboot.h File Reference

Reboot.h File Reference

Detailed Description

Reboot Server Module Header.

Dependencies: None Processor: PIC18, PIC24F, PIC24H, dsPIC30F, dsPIC33F, PIC32 Compiler: Microchip C32 v1.00 or higher Microchip C30 v3.01 or higher Microchip C18 v3.13 or higher HI-TECH PICC-18 STD 9.50PL3 or higher Company: Microchip Technology, Inc.

See the Microchip License Agreement for more details.

Modifications to the original file
Added functions to activate and deactivate the module and checking if it is active.


Netzer: serial.c File Reference

serial.c File Reference

Detailed Description

Implementation of the serial communication stuff.

Software License
See the MBCSL for details.
Author:
Sven Schlender (kontakt at mobacon dot de)
Date:
2010-10-29

Functions

void | SerialInit (SerialMode_t Mode)
Initializes the serial module in the requested mode.
WORD | SerialGetTCPPort (BOOL bPersistent)
Delivers the current configured TCP port of the serial server.
void | SerialSetTCPPort (WORD Port)
Configures a new TCP port for the serial server.
BOOL | bSerialGetSPIMasterSample (void)
Delivers the sampling mode of the input signal in SPI master mode.
SPIClockFrequencies_t | SerialGetSPIFrequency (void)
Delivers the currently used frequency of SPI master mode.
SPIModes_t | SerialGetSPIMode (void)
Delivers the currently used clock mode in SPI master mode.
void | SerialSetSPIFrequency (SPIClockFrequencies_t Frequency)
Sets the clock frequency in SPI master mode.
void | SerialSetSPIMasterSample (BOOL Sample)
Sets the sampling mode of the input signal in SPI master mode.
void | SerialSetSPIMode (SPIModes_t Mode)
Sets the SPI clock mode in SPI master mode.
UARTBaudrates_t | SerialGetUARTBaudrate (void)
Delivers the currently used baudrate in the UART mode.
void | SerialSetUARTBaudrate (UARTBaudrates_t Baudrate)
Sets the UART baudrate in UART mode.
void | SerialResetToFactory (void)
Resets the serial module EEPROM section to well known start parameters.
BOOL | SerialInitTask (void)
After initializing network and application stuff the application should call this function to prepare task members needed for proper serial task operation.
void | SerialStopTask (void)
On network errors or shut down events these function should be called by the main application to proper stop the serial tasks (i.e disconnecting a connected client).
BOOL | bSerialCheckForStoppedTask (void)
Before shutting down the application should poll for valid serial task shutdown.
void | SerialTask (void)
Call this function periodically from main application to execute serial module tasks.
void | SerialShutdown (void)
Call this function to process shutdown actions for serial server and serial connections.
void | SerialRegisterHandling (void)
Call this function to serve the virtual register set accessed by the SPI master.
SerialServerConnection_t | SerialGetServerState (void)
This function delivers the current state of the serial server.
DWORD | SerialGetConnectedIP (void)
Delivers the IP of a client who is connected to serial server.
DWORD | SerialGetRXCounter (void)
Delivers the count of bytes the serial server has sent to a client.
DWORD | SerialGetTXCounter (void)
Delivers the count of bytes the serial server has received from a client.

Function Documentation

BOOL bSerialCheckForStoppedTask ( void )

Before shutting down the application should poll for valid serial task shutdown.

Return values:
TRUE | The task has successfully stopped.
FALSE | Stopping the serial task is pending.

BOOL bSerialGetSPIMasterSample ( void )

Delivers the sampling mode of the input signal in SPI master mode.

The mode can be read indepently from the current active NetzerIO mode.

Return values:
FALSE | Input data sampled at middle of data output time.
TRUE | Input data sampled at end of data output time.

DWORD SerialGetConnectedIP ( void )

Delivers the IP of a client who is connected to serial server.

Returns:
The IP address as 32 bit value, 0 if no client is connected.

DWORD SerialGetRXCounter ( void )

Delivers the count of bytes the serial server has sent to a client.

The counter is set to zero while a new session starts.

Returns:
The counter value.

SerialServerConnection_t SerialGetServerState ( void )

This function delivers the current state of the serial server.

Returns:
The current state.

SPIClockFrequencies_t SerialGetSPIFrequency ( void )

Delivers the currently used frequency of SPI master mode.

The frequency can be read indepently from the current active NetzerIO mode.

Returns:
The frequency as enumerated value.

SPIModes_t SerialGetSPIMode ( void )

Delivers the currently used clock mode in SPI master mode.

The mode can be read indepently from the current active NetzerIO mode.

Returns:
The SPI clock mode as enumerated value.

WORD SerialGetTCPPort ( BOOL bPersistent )

Delivers the current configured TCP port of the serial server.

Parameters:
bPersistent If TRUE the return value is read from EEPROM. If FALSE the value is taken from the current state.
Returns:
The port of the listening serial server.

DWORD SerialGetTXCounter ( void )

Delivers the count of bytes the serial server has received from a client.

The counter is set to zero while a new session starts.

Returns:
The counter value.

UARTBaudrates_t SerialGetUARTBaudrate ( void )

Delivers the currently used baudrate in the UART mode.

The baudrate can be read indepently from the current active NetzerIO mode.

Returns:
The baudrate as enumerated value.

void SerialInit ( SerialMode_t Mode )

Initializes the serial module in the requested mode.

Should be called once at startup (very early).

Parameters:
Mode Specifies the mode for NetzerIO. GPIO module must know this because it configures some port pins also for the serial modes.

BOOL SerialInitTask ( void )

After initializing network and application stuff the application should call this function to prepare task members needed for proper serial task operation.

Return values:
TRUE | Initialization was successful.
FALSE | Initialization failed, try again later.

void SerialSetSPIFrequency ( SPIClockFrequencies_t Frequency )

Sets the clock frequency in SPI master mode.

If in SPI master mode the change takes effect directly. The new mode is stored persistent in EEPROM.

Parameters:
Frequency The frequency as enumerated value.

void SerialSetSPIMasterSample ( BOOL bSample )

Sets the sampling mode of the input signal in SPI master mode.

If in SPI master mode the change takes effect directly. The new mode is stored persistent in EEPROM.

Parameters:
bSample If FALSE, the input data is sampled at middle of data output time. If TRUE, the input data is sampled at end of data output time.

void SerialSetSPIMode ( SPIModes_t Mode )

Sets the SPI clock mode in SPI master mode.

If in SPI master mode the change takes effect directly. The new mode is stored persistent in EEPROM.

Parameters:
Mode The SPI clock mode as enumerated value.

void SerialSetTCPPort ( WORD Port )

Configures a new TCP port for the serial server.

This value is stored persistent in EEPROM.

Parameters:
Port The new port value.

void SerialSetUARTBaudrate ( UARTBaudrates_t eBaudrate )

Sets the UART baudrate in UART mode.

If in UART mode the change takes effect directly. The new mode is stored persistent in EEPROM.

Parameters:
eBaudrate The baudrate as enumerated value.

void SerialStopTask ( void )

On network errors or shut down events these function should be called by the main application to proper stop the serial tasks (i.e disconnecting a connected client).

void SerialTask ( void )

Call this function periodically from main application to execute serial module tasks.


Netzer: serial.h File Reference

serial.h File Reference

Detailed Description

API for serial communication via UART or SPI.

Software License
See the MBCSL for details.
Author:
Sven Schlender (kontakt at mobacon dot de)
Date:
2010-10-29

enum | UARTBaudrates_t { BAUDRATE_0_3 = 0, BAUDRATE_1_2, BAUDRATE_2_4, BAUDRATE_9_6, BAUDRATE_19_2, BAUDRATE_57_6, BAUDRATE_115_2, BAUDRATE_4_8, BAUDRATE_38_4, BAUDRATE_COUNT }
 | The supported baudrates of the UART module. More...
enum | SPIModes_t { SPIMODE_0 = 0, SPIMODE_1, SPIMODE_2, SPIMODE_3, SPIMODE_COUNT }
 | The typical SPI master clock modes. More...
enum | SPIClockFrequencies_t { SPIFREQ_10M4 = 0, SPIFREQ_2M6, SPIFREQ_650K, SPIFREQ_COUNT, SPIFREQ_SLAVE }
 | The supported clock frequencies in SPI master mode. More...
enum | SerialServerConnection_t { SERIAL_SERVER_NOT_RUNNING = 0, SERIAL_SERVER_IS_LISTENING, SERIAL_SERVER_CONNECTED }
 | The serial server states. More...
void | SerialInit (SerialMode_t Mode)
 | Initializes the serial module in the requested mode.
WORD | SerialGetTCPPort (BOOL bPersistent)
 | Delivers the current configured TCP port of the serial server.
UARTBaudrates_t | SerialGetUARTBaudrate (void)
 | Delivers the currently used baudrate in the UART mode.
SPIClockFrequencies_t | SerialGetSPIFrequency (void)
 | Delivers the currently used frequency of SPI master mode.
SPIModes_t | SerialGetSPIMode (void)
 | Delivers the currently used clock mode in SPI master mode.
BOOL | bSerialGetSPIMasterSample (void)
 | Delivers the sampling mode of the input signal in SPI master mode.
void | SerialSetUARTBaudrate (UARTBaudrates_t eBaudrate)
 | Sets the UART baudrate in UART mode.
void | SerialSetSPIMasterSample (BOOL bSample)
 | Sets the sampling mode of the input signal in SPI master mode.
void | SerialSetSPIFrequency (SPIClockFrequencies_t Frequency)
 | Sets the clock frequency in SPI master mode.
void | SerialSetSPIMode (SPIModes_t Mode)
 | Sets the SPI clock mode in SPI master mode.
void | SerialSetTCPPort (WORD Port)
 | Configures a new TCP port for the serial server.
void | SerialResetToFactory (void)
 | Resets the serial module EEPROM section to well known start parameters.
BOOL | SerialInitTask (void)
 | After initializing network and application stuff the application should call this function to prepare task members needed for proper serial task operation.
void | SerialStopTask (void)
 | On network errors or shut down events these function should be called by the main application to proper stop the serial tasks (i.e disconnecting a connected client).
BOOL | bSerialCheckForStoppedTask (void)
 | Before shutting down the application should poll for valid serial task shutdown.
void | SerialTask (void)
 | Call this function periodically from main application to execute serial module tasks.
SerialServerConnection_t | SerialGetServerState (void)
 | This function delivers the current state of the serial server.
DWORD | SerialGetConnectedIP (void)
 | Delivers the IP of a client who is connected to serial server.
DWORD | SerialGetTXCounter (void)
 | Delivers the count of bytes the serial server has received from a client.
DWORD | SerialGetRXCounter (void)
 | Delivers the count of bytes the serial server has sent to a client.
void | SerialSendTCPData (void)
 | The given character is put into the TCP/IP transmit FIFO buffer.
void | SerialRegisterHandling (void)
 | Call this function to serve the virtual register set accessed by the SPI master.
void | SerialShutdown (void)
 | Call this function to process shutdown actions for serial server and serial connections.

Enumeration Type Documentation

enum SerialServerConnection_t

The serial server states.

Enumerator:
SERIAL_SERVER_NOT_RUNNING | Inactive server.
SERIAL_SERVER_IS_LISTENING | Running, waiting for client connect.
SERIAL_SERVER_CONNECTED | Client connected, waiting for data.

enum SPIClockFrequencies_t

The supported clock frequencies in SPI master mode.

Enumerator:
SPIFREQ_10M4 | 10.4 MBit/s (wow!).
SPIFREQ_2M6 | 2.6 MBit/s.
SPIFREQ_650K | 650 KBit/s.
SPIFREQ_COUNT | Dummy for getting the count of all supported frequencies.
SPIFREQ_SLAVE | Inofficial mode, only internal use.

enum SPIModes_t

The typical SPI master clock modes.

Enumerator:
SPIMODE_0 | Transmit occurs on transition from low to high, idle state is low.
SPIMODE_1 | Transmit occurs on transition from high to low, idle state is low.
SPIMODE_2 | Transmit occurs on transition from high to low, idle state is high.
SPIMODE_3 | Transmit occurs on transition from low to high, idle state is high.
SPIMODE_COUNT | Dummy for getting the count of all supported modes.

enum UARTBaudrates_t

The supported baudrates of the UART module.

Enumerator:
BAUDRATE_0_3 | 300 Baud.
BAUDRATE_1_2 | 1200 Baud.
BAUDRATE_2_4 | 2400 Baud.
BAUDRATE_9_6 | 9600 Baud.
BAUDRATE_19_2 | 19200 Baud.
BAUDRATE_57_6 | 57600 Baud.
BAUDRATE_115_2 | 115200 Baud.
BAUDRATE_4_8 | 4800 Baud.
BAUDRATE_38_4 | 38400 Baud.
BAUDRATE_COUNT | Dummy for getting the count of all supported baudrates.

Function Documentation

BOOL bSerialCheckForStoppedTask ( void )

Before shutting down the application should poll for valid serial task shutdown.

Return values:
TRUE | The task has successfully stopped.
FALSE | Stopping the serial task is pending.

BOOL bSerialGetSPIMasterSample ( void )

Delivers the sampling mode of the input signal in SPI master mode.

The mode can be read indepently from the current active NetzerIO mode.

Return values:
FALSE | Input data sampled at middle of data output time.
TRUE | Input data sampled at end of data output time.

DWORD SerialGetConnectedIP ( void )

Delivers the IP of a client who is connected to serial server.

Returns:
The IP address as 32 bit value, 0 if no client is connected.

DWORD SerialGetRXCounter ( void )

Delivers the count of bytes the serial server has sent to a client.

The counter is set to zero while a new session starts.

Returns:
The counter value.

SerialServerConnection_t SerialGetServerState ( void )

This function delivers the current state of the serial server.

Returns:
The current state.

SPIClockFrequencies_t SerialGetSPIFrequency ( void )

Delivers the currently used frequency of SPI master mode.

The frequency can be read indepently from the current active NetzerIO mode.

Returns:
The frequency as enumerated value.

SPIModes_t SerialGetSPIMode ( void )

Delivers the currently used clock mode in SPI master mode.

The mode can be read indepently from the current active NetzerIO mode.

Returns:
The SPI clock mode as enumerated value.

WORD SerialGetTCPPort ( BOOL bPersistent )

Delivers the current configured TCP port of the serial server.

Parameters:
bPersistent If TRUE the return value is read from EEPROM. If FALSE the value is taken from the current state.
Returns:
The port of the listening serial server.

DWORD SerialGetTXCounter ( void )

Delivers the count of bytes the serial server has received from a client.

The counter is set to zero while a new session starts.

Returns:
The counter value.

UARTBaudrates_t SerialGetUARTBaudrate ( void )

Delivers the currently used baudrate in the UART mode.

The baudrate can be read indepently from the current active NetzerIO mode.

Returns:
The baudrate as enumerated value.

void SerialInit ( SerialMode_t Mode )

Initializes the serial module in the requested mode.

Should be called once at startup (very early).

Parameters:
Mode Specifies the mode for NetzerIO. GPIO module must know this because it configures some port pins also for the serial modes.

BOOL SerialInitTask ( void )

After initializing network and application stuff the application should call this function to prepare task members needed for proper serial task operation.

Return values:
TRUE | Initialization was successful.
FALSE | Initialization failed, try again later.

void SerialSendTCPData ( void )

The given character is put into the TCP/IP transmit FIFO buffer.

The function is not thread safe and must only be called from interrupt context routines!

Communication takes place via the global variable SerialIsrCharacter.

void SerialSetSPIFrequency ( SPIClockFrequencies_t Frequency )

Sets the clock frequency in SPI master mode.

If in SPI master mode the change takes effect directly. The new mode is stored persistent in EEPROM.

Parameters:
Frequency The frequency as enumerated value.

void SerialSetSPIMasterSample ( BOOL bSample )

Sets the sampling mode of the input signal in SPI master mode.

If in SPI master mode the change takes effect directly. The new mode is stored persistent in EEPROM.

Parameters:
bSample If FALSE, the input data is sampled at middle of data output time. If TRUE, the input data is sampled at end of data output time.

void SerialSetSPIMode ( SPIModes_t Mode )

Sets the SPI clock mode in SPI master mode.

If in SPI master mode the change takes effect directly. The new mode is stored persistent in EEPROM.

Parameters:
Mode The SPI clock mode as enumerated value.

void SerialSetTCPPort ( WORD Port )

Configures a new TCP port for the serial server.

This value is stored persistent in EEPROM.

Parameters:
Port The new port value.

void SerialSetUARTBaudrate ( UARTBaudrates_t eBaudrate )

Sets the UART baudrate in UART mode.

If in UART mode the change takes effect directly. The new mode is stored persistent in EEPROM.

Parameters:
eBaudrate The baudrate as enumerated value.

void SerialStopTask ( void )

On network errors or shut down events these function should be called by the main application to proper stop the serial tasks (i.e disconnecting a connected client).

void SerialTask ( void )

Call this function periodically from main application to execute serial module tasks.


Netzer: StackTsk.c File Reference

StackTsk.c File Reference

Detailed Description

TCP/IP Stack Manager Module for Microchip TCP/IP Stack.

  • Handles internal RX packet pre-processing prior to dispatching to upper application layers.
  • Reference: AN833

  • Dependencies: ARP, IP, Ethernet (ETH97J60.c)
  • Processor: PIC18, PIC24F, PIC24H, dsPIC30F, dsPIC33F, PIC32
  • Compiler: Microchip C32 v1.00 or higher Microchip C30 v3.01 or higher Microchip C18 v3.13 or higher HI-TECH PICC-18 STD 9.50PL3 or higher
  • Company: Microchip Technology, Inc.

See the Microchip License Agreement for more details.

Modifications to the original file
  • Search for "MODIFIX" in the code!
  • Removed several preprocessor macro requests and unneede parts.

Functions

void | StackInit (void)
Initializes the Microchip TCP/IP Stack and its components.
void | StackTask (void)
TCP/IP Stack FSM is executed.
void | StackApplications (void)
Calls all loaded application modules.


Netzer: StackTsk.h File Reference

StackTsk.h File Reference

Detailed Description

Microchip TCP/IP Stack Definitions.

  • Dependencies: Compiler.h
  • Processor: PIC18, PIC24F, PIC24H, dsPIC30F, dsPIC33F, PIC32
  • Compiler: Microchip C32 v1.00 or higher Microchip C30 v3.01 or higher Microchip C18 v3.13 or higher HI-TECH PICC-18 STD 9.50PL3 or higher
  • Company: Microchip Technology, Inc.

See the Microchip License Agreement for more details.

Modifications to the original file
  • Search for "MODIFIX" in the code!
  • Added doxygen comments to the function prototypes.

Functions

void | StackInit (void)
Initializes the Microchip TCP/IP Stack and its components.
void | StackTask (void)
TCP/IP Stack FSM is executed.
void | StackApplications (void)
Calls all loaded application modules.


Netzer: stringtable.c File Reference

stringtable.c File Reference

Detailed Description

This file implements the string tables for multi language support.

Software License
See the MBCSL for details.
Author:
Sven Schlender (kontakt at mobacon dot de) Bart Eversdijk (BEK) Manel Márquez
Date:
2010-10-29
Todo:
Split string tables for seperate language firmware (to store flash memory). \

Functions

void | StrTbl_SetLanguage (LanguageIDs_t LanguageId)
The function sets the actual string table for this session (not permanently).
void | StrTbl_GetString (uint8_t *pString, uint16_t StringId)
The function copies the string with the given ID to the given RAM location.
ROM char * | StringGetPointer (uint16_t StringId)
The function delivers a ROM pointer to the given string ID.
ROM char * | StringGetLanguageStringPointer (uint8_t LanguageId, uint16_t StringId)
The function delivers a ROM pointer to the given string ID on a given string table.
ROM char * | StringGetStatePointer (StateTableIDs_t StateId)
The function delivers a ROM pointer to the given string ID from the state table.


Netzer: stringtable.h File Reference

stringtable.h File Reference

Detailed Description

This file includes the Netzer string table defines and API.

Software License
See the MBCSL for details.
Author:
Sven Schlender (kontakt at mobacon dot de)
Date:
2009-11-06

Enumerations

enum LanguageIDs_t {
LANGID_NOTSPECIFIED = -1, LANGID_GERMAN = 0, LANGID_ENGLISH, LANGID_NETHERLANDS,
LANGID_SPANISH, LANGID_COUNT
}
The IDs of supported languages. More...
enum | StringTableIDs_t
String ID table for accessing the string table entries.
enum | StateTableIDs_t
Error ID table for accessing the error string table entries.

Functions

void | StrTbl_SetLanguage (LanguageIDs_t LangId)
The function sets the actual string table for this session (not permanently).
void | StrTbl_GetString (uint8_t *pString, uint16_t StringId)
The function copies the string with the given ID to the given RAM location.
ROM char * | StringGetPointer (uint16_t StringId)
The function delivers a ROM pointer to the given string ID.
ROM char * | StringGetLanguageStringPointer (uint8_t LanguageId, uint16_t StringId)
The function delivers a ROM pointer to the given string ID on a given string table.
ROM char * | StringGetStatePointer (StateTableIDs_t StateId)
The function delivers a ROM pointer to the given string ID from the state table.


Netzer: TCP.c File Reference

TCP.c File Reference

Detailed Description

Transmission Control Protocol (TCP) Communications Layer.

Module for Microchip TCP/IP Stack

  • Provides reliable, handshaked transport of application stream oriented data with flow control
  • Reference: RFC 793

  • Dependencies: IP, Tick, Ethernet (ETH97J60.c), ARP (optional), DNS (optional)
  • Processor: PIC18, PIC24F, PIC24H, dsPIC30F, dsPIC33F, PIC32
  • Compiler: Microchip C32 v1.00 or higher Microchip C30 v3.01 or higher Microchip C18 v3.13 or higher HI-TECH PICC-18 STD 9.50PL3 or higher
  • Company: Microchip Technology, Inc.

See the Microchip License Agreement for more details.

Todo:
Change from AppConfig structure to sIPConfig

Modifications to the original file
  • Search for "MODIFIX" in the code!
  • Removed preprocessor macro STACK_USE_TCP as always defined.

Functions

TCP_SOCKET | TCPOpen (DWORD dwRemoteHost, BYTE vRemoteHostType, WORD wPort, BYTE vSocketPurpose)
Opens a TCP socket for listening or as a client.
BOOL | TCPWasReset (TCP_SOCKET hTCP)
Self-clearing semaphore inidicating socket reset.
BOOL | TCPIsConnected (TCP_SOCKET hTCP)
Determines if a socket has an established connection.
void | TCPDisconnect (TCP_SOCKET hTCP)
Disconnects an open socket.
void | TCPFlush (TCP_SOCKET hTCP)
Immediately transmits all pending TX data.
WORD | TCPIsPutReady (TCP_SOCKET hTCP)
Determines how much free space is available in the TCP TX buffer.
BOOL | TCPPut (TCP_SOCKET hTCP, BYTE byte)
Writes a single byte to a TCP socket.
WORD | TCPPutArray (TCP_SOCKET hTCP, BYTE *data, WORD len)
Writes an array from RAM to a TCP socket.
BYTE * | TCPPutString (TCP_SOCKET hTCP, BYTE *data)
Writes a null-terminated string from RAM to a TCP socket.
WORD | TCPIsGetReady (TCP_SOCKET hTCP)
Determines how many bytes can be read from the TCP RX buffer.
BOOL | TCPGet (TCP_SOCKET hTCP, BYTE *byte)
Retrieves a single byte to a TCP socket.
WORD | TCPFindEx (TCP_SOCKET hTCP, BYTE cFind, WORD wStart, WORD wSearchLen, BOOL bTextCompare)
Searches for a byte in the TCP RX buffer.


Netzer: TCP.h File Reference

TCP.h File Reference

Detailed Description

TCP Module Defs for Microchip TCP/IP Stack.

  • Dependencies: StackTsk.h
  • Processor: PIC18, PIC24F, PIC24H, dsPIC30F, dsPIC33F, PIC32
  • Compiler: Microchip C32 v1.00 or higher Microchip C30 v3.01 or higher Microchip C18 v3.13 or higher HI-TECH PICC-18 STD 9.50PL3 or higher
  • Company: Microchip Technology, Inc.

See the Microchip License Agreement for more details.

Modifications to the original file
None.

Functions

BOOL | TCPWasReset (TCP_SOCKET hTCP)
Self-clearing semaphore inidicating socket reset.
BOOL | TCPIsConnected (TCP_SOCKET hTCP)
Determines if a socket has an established connection.
void | TCPDisconnect (TCP_SOCKET hTCP)
Disconnects an open socket.
WORD | TCPIsPutReady (TCP_SOCKET hTCP)
Determines how much free space is available in the TCP TX buffer.
BOOL | TCPPut (TCP_SOCKET hTCP, BYTE byte)
Writes a single byte to a TCP socket.
WORD | TCPPutArray (TCP_SOCKET hTCP, BYTE *Data, WORD Len)
Writes an array from RAM to a TCP socket.
BYTE * | TCPPutString (TCP_SOCKET hTCP, BYTE *Data)
Writes a null-terminated string from RAM to a TCP socket.
WORD | TCPIsGetReady (TCP_SOCKET hTCP)
Determines how many bytes can be read from the TCP RX buffer.
BOOL | TCPGet (TCP_SOCKET hTCP, BYTE *byte)
Retrieves a single byte to a TCP socket.
WORD | TCPFindEx (TCP_SOCKET hTCP, BYTE cFind, WORD wStart, WORD wSearchLen, BOOL bTextCompare)
Searches for a byte in the TCP RX buffer.
void | TCPFlush (TCP_SOCKET hTCP)
Immediately transmits all pending TX data.
TCP_SOCKET | TCPOpen (DWORD dwRemoteHost, BYTE vRemoteHostType, WORD wPort, BYTE vSocketPurpose)
Opens a TCP socket for listening or as a client.


Netzer: TCPIP.h File Reference

TCPIP.h File Reference

Detailed Description

Microchip TCP/IP Stack Include File.

  • Dependencies: None
  • Processor: PIC18, PIC24F, PIC24H, dsPIC30F, dsPIC33F, PIC32
  • Compiler: Microchip C18, C30, C32 HI-TECH PICC-18
  • Company: Microchip Technology, Inc.

See the Microchip License Agreement for more details.

Modifications to the original file
None.


Netzer: TCPIPConfig.h File Reference

TCPIPConfig.h File Reference

Detailed Description

Microchip TCP/IP Stack Application Configuration Header.

  • Dependencies: Microchip TCP/IP Stack
  • Processor: PIC18, PIC24F, PIC24H, dsPIC30F, dsPIC33F, PIC32
  • Compiler: Microchip C32 v1.00 or higher Microchip C30 v3.01 or higher Microchip C18 v3.13 or higher HI-TECH PICC-18 STD 9.50PL3 or higher
  • Company: Microchip Technology, Inc.

See the Microchip License Agreement for more details.

Modifications to the original file
  • Configured for Netzer
/********************************************************************* Software License Agreement

Copyright (C) 2002-2008 Microchip Technology Inc. All rights reserved.

Microchip licenses to you the right to use, modify, copy, and distribute: (i) the Software when embedded on a Microchip microcontroller or digital signal controller product ("Device") which is integrated into Licensee's product; or (ii) ONLY the Software driver source files ENC28J60.c and ENC28J60.h ported to a non-Microchip device used in conjunction with a Microchip ethernet controller for the sole purpose of interfacing with the ethernet controller.

You should refer to the license agreement accompanying this Software for additional information regarding your rights and obligations.

THE SOFTWARE AND DOCUMENTATION ARE PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION, ANY WARRANTY OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT SHALL MICROCHIP BE LIABLE FOR ANY INCIDENTAL, SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES, LOST PROFITS OR LOST DATA, COST OF PROCUREMENT OF SUBSTITUTE GOODS, TECHNOLOGY OR SERVICES, ANY CLAIMS BY THIRD PARTIES (INCLUDING BUT NOT LIMITED TO ANY DEFENSE THEREOF), ANY CLAIMS FOR INDEMNITY OR CONTRIBUTION, OR OTHER SIMILAR COSTS, WHETHER ASSERTED ON THE BASIS OF CONTRACT, TORT (INCLUDING NEGLIGENCE), BREACH OF WARRANTY, OR OTHERWISE.

Author Date Comment ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Howard Schlunder 10/04/2006 Original


Netzer: Tick.c File Reference

Tick.c File Reference

Detailed Description

Tick Manager for Timekeeping.

  • Dependencies: Timer 0 (PIC18) or Timer 1 (PIC24F, PIC24H, dsPIC30F, dsPIC33F, PIC32)
  • Processor: PIC18, PIC24F, PIC24H, dsPIC30F, dsPIC33F, PIC32
  • Compiler: Microchip C32 v1.00 or higher Microchip C30 v3.01 or higher Microchip C18 v3.13 or higher HI-TECH PICC-18 STD 9.50PL3 or higher
  • Company: Microchip Technology, Inc.

See the Microchip License Agreement for more details.

Modifications to the original file
  • Look for MODIFIX in the code


Netzer: Tick.h File Reference

Tick.h File Reference

Detailed Description

Tick Manager for PIC18.

  • Dependencies: None
  • Processor: PIC18, PIC24F, PIC24H, dsPIC30F, dsPIC33F, PIC32
  • Compiler: Microchip C32 v1.00 or higher Microchip C30 v3.01 or higher Microchip C18 v3.13 or higher HI-TECH PICC-18 STD 9.50PL3 or higher
  • Company: Microchip Technology, Inc.

See the Microchip License Agreement for more details.

Modifications to the original file
  • Prototype for function TickGetDiv64K removed
  • Prototype for function TickUpdate removed


Netzer: time.h File Reference

time.h File Reference

Detailed Description

API fo using the time module.

Software License
See the MBCSL for details.
Author:
Sven Schlender (kontakt at mobacon dot de)
Date:
2011-07-22

void | TimeInit (void)
 | Initializes the time module.


Netzer: timer.asm File Reference

timer.asm File Reference

Detailed Description

This file handles the low priority interrupt and the tick counter.

This file implements the isr low priority hook. The hook is already filled with some content for tick timer handling. Prerequisite is that TMR0 is used as tick timer (see Tick for more details). The code is written to work in extended and standard PIC18 mode.

Netzer projects also can use this hook for handling custom interrupts. For this the assembler define PROJECT_SPECIFIC_IRQ must be defined while assembling timer.asm. The assembler will look for a file called "projectIRQ.inc" than. It depends on the content of PROJECT_SPECIFIC_IRQ (i.e. a call instruction or a macro) what is done. See projectIRQ.inc of the IO project for more details.

Author:
Sven Schlender (kontakt at mobacon dot de)
Date:
2011-07-20
Note:
If this file is assembled for extended mode than the symbol __EXTENDED18__ must be defined !!!


Netzer: toa.h File Reference

toa.h File Reference

Detailed Description

API fo using the assembler conversion routines.

Software License
See the MBCSL for details.
Author:
Sven Schlender (kontakt at mobacon dot de)
Date:
2011-08-15

Functions

BYTE * | utoa (auto WORD Value, auto BYTE *pBuffer)
Transfer a unsigned 16 bit value into corresponding string without trailing zeros.
BYTE * | ubtoa (auto BYTE Value, auto BYTE *pBuffer)
Convert the given value into a ASCII expression without trailing zeros.
BYTE | Htoc_low (auto BYTE Value)
Convert the low nibble of a given character to its ASCII hexadecimal representation.
BYTE | Htoc_high (auto BYTE Value)
Convert the high nibble of a given character to its ASCII hexadecimal representation.
BYTE | htoc_high (auto BYTE Value)
Convert the high nibble of a given character to its ASCII hexadecimal representation.
BYTE | htoc_low (auto BYTE Value)
Convert the low nibble of a given character to its ASCII hexadecimal representation.
BYTE * | htoa (auto WORD Value, auto BYTE *pBuffer)
Convert the given 16 bit value into a hexadecimal ASCII expression without trailing zeros.

Function Documentation

BYTE* htoa | ( | auto WORD | Value,
 |  | auto BYTE * | pBuffer
 | ) |  |

Convert the given 16 bit value into a hexadecimal ASCII expression without trailing zeros.

Parameters:
Value | The value to convert.
pBuffer | Buffer space for conversion (must be at least 5 bytes).
Returns:
A pointer to the end of the conversion string (for quick concatenations).

BYTE htoc_high ( auto BYTE Value )

Convert the high nibble of a given character to its ASCII hexadecimal representation.

Parameters:
Value The value to convert.
Returns:
ASCII character (0-9 and a-f) of the high nibble.

BYTE Htoc_high ( auto BYTE Value )

Convert the high nibble of a given character to its ASCII hexadecimal representation.

Parameters:
Value The value to convert.
Returns:
ASCII character (0-9 and A-F) of the high nibble.

BYTE htoc_low ( auto BYTE Value )

Convert the low nibble of a given character to its ASCII hexadecimal representation.

Parameters:
Value The value to convert.
Returns:
ASCII character (0-9 and a-f) of the low nibble.

BYTE Htoc_low ( auto BYTE Value )

Convert the low nibble of a given character to its ASCII hexadecimal representation.

Parameters:
Value The value to convert.
Returns:
ASCII character (0-9 and A-F) of the low nibble.

BYTE* ubtoa | ( | auto BYTE | Value,
 |  | auto BYTE * | pBuffer
 | ) |  |

Convert the given value into a ASCII expression without trailing zeros.

Parameters:
Value | The value to convert.
pBuffer | A buffer to copy the converted values. The buffer must be big enough (3 characters + null termination).
Returns:
A pointer to the end of the conversion string (for quick concatenations).

BYTE* utoa | ( | auto WORD | Value,
 |  | auto BYTE * | pBuffer
 | ) |  |

Transfer a unsigned 16 bit value into corresponding string without trailing zeros.

Parameters:
Value | Value to convert.
pBuffer | Buffer space for conversion (must be at least 6 bytes).
Returns:
A pointer to the end of the conversion string (for quick concatenations).


Netzer: UDP.c File Reference

UDP.c File Reference

Detailed Description

User Datagram Protocol (UDP) Communications Layer Server Module for Microchip TCP/IP Stack.

  • Provides unreliable, minimum latency transport of application datagram (packet) oriented data
  • Reference: RFC 768

  • Dependencies: IP, Ethernet (ETH97J60.c)
  • Processor: PIC18, PIC24F, PIC24H, dsPIC30F, dsPIC33F, PIC32MX
  • Compiler: Microchip C32 v1.00 or higher Microchip C30 v3.01 or higher Microchip C18 v3.13 or higher HI-TECH PICC-18 STD 9.50PL3 or higher
  • Company: Microchip Technology, Inc.

See the Microchip License Agreement for more details.

Modifications to the original file
  • Removed preprocessor macro STACK_USE_UDP as always defined.
  • Added a hook for processing MDNS frames in UDPProcess()
  • Added a function for determining the amount of bytes already put.
  • Added a IP filter in UDPProcess


Netzer: UDP.h File Reference

UDP.h File Reference

Detailed Description

UDP Module Defs for Microchip TCP/IP Stack.

  • Dependencies: StackTsk.h MAC.h
  • Processor: PIC18, PIC24F, PIC24H, dsPIC30F, dsPIC33F, PIC32MX
  • Compiler: Microchip C32 v1.00 or higher Microchip C30 v3.01 or higher Microchip C18 v3.13 or higher HI-TECH PICC-18 STD 9.50PL3 or higher
  • Company: Microchip Technology, Inc.

See the Microchip License Agreement for more details.

Modifications to the original file
Add function prototypes for get functions Added multicastPort flag properties for UDP sockets.


Netzer: UNIO.c File Reference

UNIO.c File Reference

Detailed Description

Implementation of the UNIO protocol.

Dependencies: p18f67j60.h delays.h UNIO PIC18.h Processor: PIC18F67J60 Compiler: MPLAB C18 3.20 or higher Assembler: MPASMWIN 5.20 or higher Linker: MPLINK 4.20 or higher Date: March 29, 2010 File Version: 1.1

Author: Chris Parris Company: Microchip Technology Inc.

Modifications to the original file
  • Adopted for PIC18F67J60
  • Added array access functions

Functions

void | _StartHeader (void)
P R I V A T E P R O T O T Y P E S.
void | EEPROMInit (void)
Initializes the EEPROM module and the connected EEPROM module.

Variables

near sBYTE | dataOut
G L O B A L V A R I A B L E S.


Netzer: UNIO.h File Reference

UNIO.h File Reference

Detailed Description

API for accessing the UNIO protocol.

Processor: PIC18F67J60 Compiler: MPLAB C18 3.20 or higher Assembler: MPASMWIN 5.20 or higher Linker: MPLINK 4.20 or higher Date: April 30, 2008 File Version: 1.0

Author: Chris Parris Company: Microchip Technology Inc.

Modifications to the original file
  • Adopted for PIC18F67J60
  • Added array access functions

Data Structures

union | _FLAGS
T Y P E D E F S. More...

Defines

#define | STARTHDR 0x55
C O N S T A N T D E F I N I T I O N S.
#define | BUSFREQ 75000
B U S F R E Q U E N C Y C A L C U L A T I O N.
#define | WREN 0b10010110
C O M M A N D D E F I N I T I O N S.
#define | SCIO PORTEbits.RE1
I / O P I N D E F I N I T I O N S.

Functions

void | ByteWrite (sWORD)
P R O T O T Y P E S.


Netzer: web.c File Reference

web.c File Reference

Detailed Description

The integrated web interface implementation of Netzer.

Software License
See the MBCSL for details.
Author:
Sven Schlender (kontakt at mobacon dot de)
Date:
2009-07-31

Functions

void | WebOptionROM (BOOL Selected, BYTE Value, ROM BYTE *pString)
Prints a formated HTML option field to the HTTP socket with content string from ROM.
void | WebRadioROM (ROM BYTE *pName, DWORD Value, BOOL Selected, BYTE AccessLevel)
Prints a formated HTML radio field to the HTTP socket with name string from ROM.
void | WebCheckboxROM (ROM BYTE *pName, DWORD Value, BOOL Selected, BYTE AccessLevel)
Prints a formated HTML checkbox to the HTTP socket with name string from ROM.
void | WebCheckbox (BYTE *pName, DWORD Value, BOOL Selected, BYTE AccessLevel)
Prints a formated HTML checkbox to the HTTP socket with name string from RAM.
BYTE | HTTPNeedsAuth (BYTE *cFile)
This function is called on the starting authentfication process, if any file is requested via HTTP.
void | WebReportChangedState (StateTableIDs_t StringID, PageID_t DestinationPageID)
Call this function during a HTTP POST session if the user should be forwarded to a message webpage (state.htm) showing a error or state change string.
BYTE | WebGetAuthLevelOfCurrentPage (void)
Each shown webpage has dedicated level of authorization which is stored in an internal structure with all the other webpage related data.
BYTE | WebGetCurrentPageID (void)
Returns the ID of the last loaded html page.
void | AuthExecuteApplCommand (BYTE RawCommandFromWeb)
Commands to application (like restart, shut down, reset to factory settings) are filtered through this function.

Function Documentation

void AuthExecuteApplCommand ( BYTE RawCommandFromWeb )

Commands to application (like restart, shut down, reset to factory settings) are filtered through this function.

Only a authenticated user with enough permissions can execute dedicated application commands.

Parameters:
RawCommandFromWeb The command as numeric value directly from a GET call (see webpage index.htm for expressions).


Netzer: web.h File Reference

web.h File Reference

Detailed Description

Web interface module defines and global function prototypes for Netzer.

Software License
See the MBCSL for details.
Author:
Sven Schlender (kontakt at mobacon dot de)
Date:
2009-01-23

Defines

#define | WEB_STACKSIZE (256u)
Working space for HTML processing.

Functions

void | WebOptionROM (BOOL Selected, BYTE Value, ROM BYTE *pString)
Prints a formated HTML option field to the HTTP socket with content string from ROM.
void | WebRadioROM (ROM BYTE *pName, DWORD Value, BOOL Selected, BYTE AccessLevel)
Prints a formated HTML radio field to the HTTP socket with name string from ROM.
void | WebCheckboxROM (ROM BYTE *pName, DWORD Value, BOOL Selected, BYTE AccessLevel)
Prints a formated HTML checkbox to the HTTP socket with name string from ROM.
void | WebCheckbox (BYTE *pName, DWORD Value, BOOL Selected, BYTE AccessLevel)
Prints a formated HTML checkbox to the HTTP socket with name string from RAM.
void | WebReportChangedState (StateTableIDs_t StringID, PageID_t DestinationPageID)
Call this function during a HTTP POST session if the user should be forwarded to a message webpage (state.htm) showing a error or state change string.
BYTE | HTTPNeedsAuth (BYTE *cFile)
This function is called on the starting authentfication process, if any file is requested via HTTP.
BYTE | WebGetAuthLevelOfCurrentPage (void)
Each shown webpage has dedicated level of authorization which is stored in an internal structure with all the other webpage related data.
BYTE | WebGetCurrentPageID (void)
Returns the ID of the last loaded html page.

Variables

BYTE | webwork [WEB_STACKSIZE]
The working space for HTML processing.


Netzer: webio.c File Reference

webio.c File Reference

Detailed Description

Implementation of the web io stuff.

Software License
See the MBCSL for details.
Author:
Sven Schlender (kontakt at mobacon dot de)
Date:
2010-11-01

Functions

void | WebIoProcessPost (BYTE PageIndex, BYTE *pControl, BYTE *pValueString, DWORD Value)
This function processes HTTP post requests.
void | WebIoHTTPExecuteGet (BYTE Index)
This function is called if a HTTP GET request is received for one of the project pages.
BYTE | HTTPCheckAuth (BYTE *cUser, BYTE *cPass)
The function is called after authentication is entered.

Function Documentation

BYTE HTTPCheckAuth | ( | BYTE * | cUser,
 |  | BYTE * | cPass
 | ) |  |

The function is called after authentication is entered.

It must check whether the user/password combination is valid.

Parameters:
cUser | Pointer to the string of the requesting user.
cPass | Pointer to the string of the password of requesting user.
Return values:
0 | User/password combination is invalid.
Other | User/password combination is valid.

void WebIoHTTPExecuteGet ( BYTE Index )

This function is called if a HTTP GET request is received for one of the project pages.

For the IO project this function processes the given index on GPIO configuration sites.

Parameters:
Index is the value of a possible given Id parameter in the HTTP GET request.

void WebIoProcessPost | ( | BYTE | PageIndex,
 |  | BYTE * | pControl,
 |  | BYTE * | pValueString,
 |  | DWORD | Value
 | ) |  |

This function processes HTTP post requests.

Parameters:
PageIndex | Index of the post request file.
pControl | Pointer to the name of the post control.
pValueString | Pointer to the value string of the post control.
Value | The preprocessed value string as numeric variable.


Netzer: Data Fields

  • File List
  • Globals
  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Defines
  • _
  • a
  • b
  • d
  • e
  • f
  • g
  • h
  • i
  • l
  • m
  • n
  • p
  • r
  • s
  • t
  • u
  • v
  • w

Here is a list of all documented functions, variables, defines, enums, and typedefs with links to the documentation:

- _ -

  • _au8NetworkDataForBootloader : bootup.c
  • _CheckForQueryResponse() : mdns.c
  • _MDNS_STATE : mdns.h
  • _persistentHTTPPort : bootup.c
  • _sm : bootup.c
  • _StartHeader() : UNIO.c
  • _timer : bootup.c


Netzer: Data Fields - Variables

  • Data Fields
  • All
  • Variables

  • bIPunique : _IP_CONFIG
  • IPObtainedFrom : _IP_CONFIG
  • IPSelection : CommonConfig_t
  • LanguageID : CommonConfig_t
  • LastAutoIP : CommonConfig_t
  • ManGateway : CommonConfig_t
  • ManIPAddr : CommonConfig_t
  • ManMask : CommonConfig_t
  • MyGateway : _IP_CONFIG
  • MyIPAddr : _IP_CONFIG
  • MyMask : _IP_CONFIG
  • NetworkName : CommonConfig_t
  • PrimaryDNS : CommonConfig_t
  • PrimaryDNSServer : _IP_CONFIG
  • Project : CommonConfig_t
  • SecondaryDNS : CommonConfig_t
  • SecondaryDNSServer : _IP_CONFIG
  • VersionTag : CommonConfig_t


Netzer: Data Fields

  • File List
  • Globals
  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Defines
  • _
  • a
  • b
  • d
  • e
  • f
  • g
  • h
  • i
  • l
  • m
  • n
  • p
  • r
  • s
  • t
  • u
  • v
  • w

Here is a list of all documented functions, variables, defines, enums, and typedefs with links to the documentation:

- l -

  • LANGID_COUNT : stringtable.h
  • LANGID_ENGLISH : stringtable.h
  • LANGID_GERMAN : stringtable.h
  • LANGID_NETHERLANDS : stringtable.h
  • LANGID_NOTSPECIFIED : stringtable.h
  • LANGID_SPANISH : stringtable.h
  • LanguageIDs_t : stringtable.h
  • LICENSE_NAME : projectdefs.h


Netzer: Data Fields

  • File List
  • Globals
  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Defines
  • _
  • a
  • b
  • d
  • e
  • f
  • g
  • h
  • i
  • l
  • m
  • n
  • p
  • r
  • s
  • t
  • u
  • v
  • w

Here is a list of all documented functions, variables, defines, enums, and typedefs with links to the documentation:

- m -

  • MAC_ADDR : GenericTypeDefs.h
  • MACIsLinked() : ETH97J60.c , MAC.h
  • MAX_NETWORKNAME_LENGTH : bootup.h
  • MDNS_HAS_STOPPED : mdns.h
  • MDNS_IS_RUNNING : mdns.h
  • MDNS_IS_STARTING_UP : mdns.h
  • MDNS_PORT : mdns.h
  • MDNSProcessFrame() : mdns.c , mdns.h
  • MDNSResolveName() : mdns.c , mdns.h
  • MDNSResolveService() : mdns.h , mdns.c
  • MDNSResponder() : mdns.c , mdns.h
  • MDNSStopResolving() : mdns.c , mdns.h


Netzer: Data Fields

  • File List
  • Globals
  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Defines
  • _
  • a
  • b
  • d
  • e
  • f
  • g
  • h
  • i
  • l
  • m
  • n
  • p
  • r
  • s
  • t
  • u
  • v
  • w

Here is a list of all documented functions, variables, defines, enums, and typedefs with links to the documentation:

- n -

  • NETZER_IP_ERROR : netzerTypedefs.h
  • NETZER_NOLINK : netzerTypedefs.h
  • NETZER_READY : netzerTypedefs.h
  • NETZER_SHUTDOWN : netzerTypedefs.h
  • NETZER_STARTING : netzerTypedefs.h
  • NetzerProjects_t : bootup.h
  • NetzerState_t : netzerTypedefs.h
  • NODE_INFO : GenericTypeDefs.h


Netzer: Data Fields

  • File List
  • Globals
  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Defines
  • _
  • a
  • b
  • d
  • e
  • f
  • g
  • h
  • i
  • l
  • m
  • n
  • p
  • r
  • s
  • t
  • u
  • v
  • w

Here is a list of all documented functions, variables, defines, enums, and typedefs with links to the documentation:

- a -

  • ADCGetValue() : adc.c , adc.h
  • ADCInitialize() : adc.h , adc.c
  • APPL_CMD_BLINK : netzerTypedefs.h
  • APPL_CMD_BOOTLOADER : netzerTypedefs.h
  • APPL_CMD_COUNT : netzerTypedefs.h
  • APPL_CMD_IDLE : netzerTypedefs.h
  • APPL_CMD_RESET_TO_FACTORY : netzerTypedefs.h
  • APPL_CMD_RESTART : netzerTypedefs.h
  • APPL_CMD_SHUTDOWN : netzerTypedefs.h
  • ApplCommand() : appl.c , appl.h
  • ApplCommands_t : netzerTypedefs.h
  • ApplGetCurrentState() : appl.h , appl.c
  • ApplInit() : appl.c , appl.h
  • ApplIsRunning() : appl.c , appl.h
  • ApplMain() : appl.c , appl.h
  • ApplResetToFactory() : appl.c , appl.h
  • ApplStateChanged() : appl.c , appl.h
  • ApplStop() : appl.c , appl.h
  • ARPFlush() : ARP.c , ARP.h
  • ARPIsResolved() : ARP.h , ARP.c
  • ARPResolve() : ARP.c , ARP.h
  • AUTH_FAILED : auth.h
  • AUTH_OK : auth.h
  • AUTH_PENDING : auth.h
  • AUTH_READONLY : auth.h
  • AuthExecuteApplCommand() : web.c , auth.h , auth.c
  • AuthHandleAuthentification() : auth.c , auth.h
  • AuthInit() : auth.h , auth.c
  • AuthProcessPostData() : auth.c , auth.h
  • AuthReload() : auth.h , auth.c
  • AuthReset() : auth.h , auth.c
  • AuthReturnCodes_t : auth.h
  • AuthSetUserForDialog() : auth.h , auth.c
  • AuthStartAuthentification() : auth.c , auth.h
  • AuthStoreInEEPROM() : auth.c , auth.h


Netzer: Data Fields

  • File List
  • Globals
  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Defines
  • _
  • a
  • b
  • d
  • e
  • f
  • g
  • h
  • i
  • l
  • m
  • n
  • p
  • r
  • s
  • t
  • u
  • v
  • w

Here is a list of all documented functions, variables, defines, enums, and typedefs with links to the documentation:

- b -

  • BAUDRATE_0_3 : serial.h
  • BAUDRATE_115_2 : serial.h
  • BAUDRATE_19_2 : serial.h
  • BAUDRATE_1_2 : serial.h
  • BAUDRATE_2_4 : serial.h
  • BAUDRATE_38_4 : serial.h
  • BAUDRATE_4_8 : serial.h
  • BAUDRATE_57_6 : serial.h
  • BAUDRATE_9_6 : serial.h
  • BAUDRATE_COUNT : serial.h
  • bGPIOCheckForStoppedTask() : gpio.c , gpio.h
  • bInitMDNSResponder() : mdns.c , mdns.h
  • bMDNSNameIsResolved() : mdns.h , mdns.c
  • bMDNSServiceIsResolved() : mdns.c , mdns.h
  • BOOTLOADER_SIZE : flash.h
  • BootupBlink() : bootup.c , bootup.h
  • BootupEnterBootloader() : bootup.c , bootup.h
  • BootupGetHTTPPort() : bootup.c , bootup.h
  • BootupGetIPAddress() : bootup.c , bootup.h
  • BootupGetIPMode() : bootup.c , bootup.h
  • BootupGetNetworkName() : bootup.h , bootup.c
  • BootupInit() : bootup.c , bootup.h
  • BootupInvalidateIPSettings() : bootup.h
  • BootupMain() : bootup.h , bootup.c
  • BootupPrintFormatedIPAddress() : bootup.c , bootup.h
  • BootupPrintIPAddress() : bootup.c , bootup.h
  • BootupResetToFactory() : bootup.c , bootup.h
  • BootupSetHTTPPort() : bootup.h , bootup.c
  • BootupSetIPAddress() : bootup.c , bootup.h
  • BootupSetNetworkName() : bootup.c , bootup.h
  • bSerialCheckForStoppedTask() : serial.c , serial.h
  • bSerialGetSPIMasterSample() : serial.c , serial.h
  • BUSFREQ : UNIO.h
  • ByteWrite() : UNIO.h


Netzer: Data Fields

  • File List
  • Globals
  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Defines
  • _
  • a
  • b
  • d
  • e
  • f
  • g
  • h
  • i
  • l
  • m
  • n
  • p
  • r
  • s
  • t
  • u
  • v
  • w

Here is a list of all documented functions, variables, defines, enums, and typedefs with links to the documentation:

- d -

  • dataOut : UNIO.c
  • DHCPDisable() : DHCP.c , DHCP.h
  • DHCPEnable() : DHCP.c , DHCP.h
  • DHCPGetIPParameterFromServer() : DHCP.c , DHCP.h
  • DHCPHasBoundStateChanged() : DHCP.c , DHCP.h
  • DHCPHasFailed() : DHCP.c , DHCP.h
  • DHCPIsBound : DHCP.h
  • DHCPIsEnabled() : DHCP.c , DHCP.h
  • DHCPReset() : DHCP.h , DHCP.c
  • DHCPTask() : DHCP.c , DHCP.h
  • DNS_PORT : mdns.h
  • DNS_TYPE_A : mdns.h
  • DNS_TYPE_ANY : mdns.h
  • DNS_TYPE_MX : mdns.h
  • DNS_TYPE_PTR : mdns.h
  • DNS_TYPE_SRV : mdns.h
  • DNS_TYPE_TXT : mdns.h


Netzer: Data Fields

  • File List
  • Globals
  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Defines
  • _
  • a
  • b
  • d
  • e
  • f
  • g
  • h
  • i
  • l
  • m
  • n
  • p
  • r
  • s
  • t
  • u
  • v
  • w

Here is a list of all documented functions, variables, defines, enums, and typedefs with links to the documentation:

- e -

  • EC_DECREMENTS : gpio.h
  • EC_DISABLED : gpio.h
  • EC_INCREMENTS : gpio.h
  • EdgeCounterMode_t : gpio.h
  • EdgeFilterMode_t : gpio.h
  • EdgeTriggerMode_t : gpio.h
  • EEPROMInit() : UNIO.c
  • EF_100_MS : gpio.h
  • EF_10_MS : gpio.h
  • EF_1_MS : gpio.h
  • EF_250_MS : gpio.h
  • EF_DISABLED : gpio.h
  • eGetMDNSState() : mdns.c , mdns.h
  • EM_DISABLED : gpio.h
  • EM_ON_ALL_EDGES : gpio.h
  • EM_ON_FALLING_EDGES : gpio.h
  • EM_ON_RISING_EDGES : gpio.h
  • ET_DISABLED : gpio.h
  • ET_FALLING : gpio.h
  • ET_RISING : gpio.h
  • EventMode_t : gpio.h


Netzer: Data Fields

  • File List
  • Globals
  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Defines
  • _
  • a
  • b
  • d
  • e
  • f
  • g
  • h
  • i
  • l
  • m
  • n
  • p
  • r
  • s
  • t
  • u
  • v
  • w

Here is a list of all documented functions, variables, defines, enums, and typedefs with links to the documentation:

- f -

  • FLASH_ERASE_SIZE : flash.h
  • FLASH_WRITE_SIZE : flash.h


Netzer: Data Fields

  • File List
  • Globals
  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Defines
  • _
  • a
  • b
  • d
  • e
  • f
  • g
  • h
  • i
  • l
  • m
  • n
  • p
  • r
  • s
  • t
  • u
  • v
  • w

Here is a list of all documented functions, variables, defines, enums, and typedefs with links to the documentation:

- g -

  • GPIO_00_ID : netzerTypedefs.h
  • GPIO_01_ID : netzerTypedefs.h
  • GPIO_02_ID : netzerTypedefs.h
  • GPIO_03_ID : netzerTypedefs.h
  • GPIO_04_ID : netzerTypedefs.h
  • GPIO_05_ID : netzerTypedefs.h
  • GPIO_06_ID : netzerTypedefs.h
  • GPIO_07_ID : netzerTypedefs.h
  • GPIO_08_ID : netzerTypedefs.h
  • GPIO_09_ID : netzerTypedefs.h
  • GPIO_0A_ID : netzerTypedefs.h
  • GPIO_0B_ID : netzerTypedefs.h
  • GPIO_0C_ID : netzerTypedefs.h
  • GPIO_COUNT : netzerTypedefs.h
  • GPIO_EEPROM_ADD : projectdefs.h
  • GPIO_INPUT : netzerTypedefs.h
  • GPIO_OUTPUT : netzerTypedefs.h
  • GPIO_SERVER_CONNECTED : gpio.h
  • GPIO_SERVER_NOT_RUNNING : gpio.h
  • GPIO_SERVER_RUNNING : gpio.h
  • GPIOActivateAuth() : gpio.h
  • GPIOActivateScript() : gpio.h
  • GPIOActivateServerPersistent() : gpio.c , gpio.h
  • GPIOConfigurePort() : gpio.c , gpio.h
  • GPIOFlushToEEPROM() : gpio.c , gpio.h
  • GPIOGetConnectedIP() : gpio.c , gpio.h
  • GPIOGetCurrentImpulseWidth() : gpio.h
  • GPIOGetEdgeCounter() : gpio.h
  • GPIOGetEdgeCounterMode() : gpio.h
  • GPIOGetEdgeFilterMode() : gpio.h
  • GPIOGetEdgeTriggerMode() : gpio.h
  • GPIOGetEventMode() : gpio.h
  • GPIOGetImpulseLogic() : gpio.h
  • GPIOGetImpulseMode() : gpio.h
  • GPIOGetImpulsePrescaler() : gpio.h
  • GPIOGetPinValue() : gpio.c , gpio.h
  • GPIOGetPortName() : gpio.c , gpio.h
  • GPIOGetPortType() : gpio.c , gpio.h
  • GPIOGetPWMFrequency() : gpio.h
  • GPIOGetPWMLogic() : gpio.h
  • GPIOGetPWMStartDuty() : gpio.h
  • GPIOGetRadix() : gpio.h
  • GPIOGetRefresh() : gpio.h
  • GPIOGetServerState() : gpio.c , gpio.h
  • GPIOGetStartImpulseWidth() : gpio.h
  • GPIOGetStartupValue() : gpio.c , gpio.h
  • GPIOGetTCPPort() : gpio.c , gpio.h
  • GPIOInit() : gpio.h , gpio.c
  • GPIOInitPeripherals() : gpio.h
  • GPIOInitTask() : gpio.c , gpio.h
  • GPIOIsAuthActive() : gpio.h
  • GPIOIsPortOverwritten() : gpio.c , gpio.h
  • GPIOIsScriptActive() : gpio.h
  • GPIOIsTypeSupportedByPort() : gpio.h
  • GPIORadix_t : gpio.h
  • GPIOReadSPIClock : gpio.h
  • GPIOReadSPIMasterWrite : gpio.h
  • GPIOReadSPIRegister : gpio.h
  • GPIOReconfigurePeripherals() : gpio.h
  • GPIOResetEdgeCounter() : gpio.h
  • GPIOResetToFactory() : gpio.h , gpio.c
  • GPIOServerConnection_t : gpio.h
  • GPIOServerIsActivated() : gpio.c , gpio.h
  • GPIOSetAllPinValues() : gpio.c , gpio.h
  • GPIOSetCurrentImpulseWidth() : gpio.h
  • GPIOSetEdgeCounterMode() : gpio.h
  • GPIOSetEdgeFilterMode() : gpio.h
  • GPIOSetEdgeTriggerMode() : gpio.h
  • GPIOSetEventMode() : gpio.h
  • GPIOSetImpulseLogic() : gpio.h
  • GPIOSetImpulseMode() : gpio.h
  • GPIOSetImpulsePrescaler() : gpio.h
  • GPIOSetPortType() : gpio.h , gpio.c
  • GPIOSetPortValue() : gpio.h , gpio.c
  • GPIOSetPWMFrequency() : gpio.h
  • GPIOSetPWMLogic() : gpio.h
  • GPIOSetPWMStartDuty() : gpio.h
  • GPIOSetRadix() : gpio.h
  • GPIOSetRefresh() : gpio.h
  • GPIOSetStartupImpulseWidth() : gpio.h
  • GPIOSetStartupValue() : gpio.h , gpio.c
  • GPIOSetTCPPortPersistent() : gpio.c , gpio.h
  • GPIOStopTask() : gpio.h , gpio.c
  • GPIOTask() : gpio.c , gpio.h
  • GPIOWriteSPIBusy : gpio.h
  • GPIOWriteSPIChipSelect : gpio.h
  • GPIOWriteSPIInt : gpio.h
  • GPIOWriteSPINetzerDataValid : gpio.h


Netzer: Data Fields

  • File List
  • Globals
  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Defines
  • _
  • a
  • b
  • d
  • e
  • f
  • g
  • h
  • i
  • l
  • m
  • n
  • p
  • r
  • s
  • t
  • u
  • v
  • w

Here is a list of all documented functions, variables, defines, enums, and typedefs with links to the documentation:

- h -

  • HALF_DUPLEX : ETH97J60.c
  • HelperConvertNibbleFromHex() : helper.h
  • HelperConvertWordFromHex() : helper.h
  • htoa() : toa.h
  • Htoc_high() : toa.h
  • htoc_high() : toa.h
  • htoc_low() : toa.h
  • Htoc_low() : toa.h
  • HTTPCheckAuth() : auth.h , webio.c , auth.c
  • HTTPNeedsAuth() : web.h , web.c


Netzer: Data Fields

  • File List
  • Globals
  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Defines
  • _
  • a
  • b
  • d
  • e
  • f
  • g
  • h
  • i
  • l
  • m
  • n
  • p
  • r
  • s
  • t
  • u
  • v
  • w

Here is a list of all documented functions, variables, defines, enums, and typedefs with links to the documentation:

- i -

  • I2C_EEPROM_ADD : projectdefs.h
  • I2CCheckForStoppedTask() : i2c.c , i2c.h
  • I2CClockFrequencies_t : i2c.h
  • I2CFREQ_100K : i2c.h
  • I2CFREQ_400K : i2c.h
  • I2CFREQ_COUNT : i2c.h
  • I2CGetFrequency() : i2c.c , i2c.h
  • I2CInit() : i2c.c , i2c.h
  • I2CISR() : i2c.c , i2c.h
  • I2CLoadConfig() : i2c.c , i2c.h
  • I2CResetToFactory() : i2c.c , i2c.h
  • I2CSetFrequency() : i2c.c , i2c.h
  • I2CStopTask() : i2c.c , i2c.h
  • I2CTask() : i2c.c , i2c.h
  • ImpulseMode_t : gpio.h
  • INTERNAL_FLASH_SIZE : flash.h
  • IoCheckForStoppedTasks() : io.c , projectdefs.h
  • IoEarlyInit() : io.c , projectdefs.h
  • IoGetSerialMode() : io.c , projectdefs.h
  • IoInit() : io.c , projectdefs.h
  • IoInitTasks() : io.c , projectdefs.h
  • IoResetToFactory() : io.c , projectdefs.h
  • IoSetNewSerialMode() : io.c , projectdefs.h
  • IoShutdown() : io.c , projectdefs.h
  • IoStopTasks() : io.c , projectdefs.h
  • IoTasks() : projectdefs.h , io.c
  • IPConvertMaskToSubnet() : IP.h , IP.c
  • IPConvertSubnetToMask() : IP.c , IP.h
  • IPField_t : bootup.h
  • IPM_CONTINUOUS : gpio.h
  • IPM_SINGLE : gpio.h
  • IPM_TRIGGERED : gpio.h
  • IPO_AUTO : bootup.h
  • IPO_DHCP : bootup.h
  • IPO_MANUAL : bootup.h
  • IPObtainedFrom_t : bootup.h
  • IPS_AUTO_IP : bootup.h
  • IPS_DHCP_AUTOIP : bootup.h
  • IPS_DHCP_ENABLED : bootup.h
  • IPS_DHCP_MANUALIP : bootup.h
  • IPS_MANUAL_IP : bootup.h
  • IPS_MODE_COUNT : bootup.h
  • IPSelectionModes_t : bootup.h


Netzer: Data Fields

  • File List
  • Globals
  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Defines
  • _
  • a
  • b
  • d
  • e
  • f
  • g
  • h
  • i
  • l
  • m
  • n
  • p
  • r
  • s
  • t
  • u
  • v
  • w

Here is a list of all documented functions, variables, defines, enums, and typedefs with links to the documentation:

- p -

  • PageID_t : netzerTypedefs.h
  • PF_10000_HZ : gpio.h
  • PF_2500_HZ : gpio.h
  • PF_40000_HZ : gpio.h
  • PortType_t : gpio.h
  • PROJECT_CHECK_FOR_STOPPED_TASK : projectdefs.h
  • PROJECT_CYCLE : projectdefs.h
  • PROJECT_EARLYINIT : projectdefs.h
  • PROJECT_HTTP_GET_EXECUTION : projectdefs.h
  • PROJECT_ID : projectdefs.h
  • PROJECT_INIT : projectdefs.h
  • PROJECT_INIT_TASK : projectdefs.h
  • PROJECT_MODE_COUNT : projectdefs.h
  • PROJECT_MODE_I2C_MASTER : projectdefs.h
  • PROJECT_MODE_SERIAL_DISABLED : projectdefs.h
  • PROJECT_MODE_SPI_MASTER : projectdefs.h
  • PROJECT_MODE_SPI_SLAVE : projectdefs.h
  • PROJECT_MODE_UART : projectdefs.h
  • PROJECT_POWERDOWN : projectdefs.h
  • PROJECT_PROCESS_POST : projectdefs.h
  • PROJECT_RESET_TO_FACTORY : projectdefs.h
  • PROJECT_STATE_CHANGED : projectdefs.h
  • PROJECT_STOP_TASK : projectdefs.h
  • PROJECT_TASK : projectdefs.h
  • PROJECT_WEB_SUBFOLDER : projectdefs.h
  • PROJECT_WEBSITES : projectdefs.h
  • PT_ANALOG_INPUT : gpio.h
  • PT_DIG_INPUT : gpio.h
  • PT_DIG_OUTPUT : gpio.h
  • PT_IMPULSE : gpio.h
  • PT_PWM : gpio.h
  • PWMFrequencies_t : gpio.h


Netzer: Data Fields

  • File List
  • Globals
  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Defines
  • _
  • a
  • b
  • d
  • e
  • f
  • g
  • h
  • i
  • l
  • m
  • n
  • p
  • r
  • s
  • t
  • u
  • v
  • w

Here is a list of all documented functions, variables, defines, enums, and typedefs with links to the documentation:

- r -

  • RADIX_IS_DECIMAL : gpio.h
  • RADIX_IS_HEXADECIMAL : gpio.h
  • RawEraseFlashBlock() : flash.h
  • RawWriteFlashBlock() : flash.h


Netzer: Data Fields

  • File List
  • Globals
  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Defines
  • _
  • a
  • b
  • d
  • e
  • f
  • g
  • h
  • i
  • l
  • m
  • n
  • p
  • r
  • s
  • t
  • u
  • v
  • w

Here is a list of all documented functions, variables, defines, enums, and typedefs with links to the documentation:

- s -

  • SCIO : UNIO.h
  • SERIAL_EEPROM_ADD : projectdefs.h
  • SERIAL_SERVER_CONNECTED : serial.h
  • SERIAL_SERVER_IS_LISTENING : serial.h
  • SERIAL_SERVER_NOT_RUNNING : serial.h
  • SerialGetConnectedIP() : serial.c , serial.h
  • SerialGetRXCounter() : serial.c , serial.h
  • SerialGetServerState() : serial.c , serial.h
  • SerialGetSPIFrequency() : serial.c , serial.h
  • SerialGetSPIMode() : serial.c , serial.h
  • SerialGetTCPPort() : serial.c , serial.h
  • SerialGetTXCounter() : serial.c , serial.h
  • SerialGetUARTBaudrate() : serial.c , serial.h
  • SerialInit() : serial.c , serial.h
  • SerialInitTask() : serial.c , serial.h
  • SerialMode_t : projectdefs.h
  • SerialRegisterHandling() : serial.c , serial.h
  • SerialResetToFactory() : serial.c , serial.h
  • SerialSendTCPData() : serial.h
  • SerialServerConnection_t : serial.h
  • SerialSetSPIFrequency() : serial.c , serial.h
  • SerialSetSPIMasterSample() : serial.c , serial.h
  • SerialSetSPIMode() : serial.c , serial.h
  • SerialSetTCPPort() : serial.c , serial.h
  • SerialSetUARTBaudrate() : serial.c , serial.h
  • SerialShutdown() : serial.c , serial.h
  • SerialStopTask() : serial.c , serial.h
  • SerialTask() : serial.c , serial.h
  • sIPConfig : bootup.h
  • sPCommonConfig : bootup.h
  • SPIClockFrequencies_t : serial.h
  • SPIFREQ_10M4 : serial.h
  • SPIFREQ_2M6 : serial.h
  • SPIFREQ_650K : serial.h
  • SPIFREQ_COUNT : serial.h
  • SPIFREQ_SLAVE : serial.h
  • SPIMODE_0 : serial.h
  • SPIMODE_1 : serial.h
  • SPIMODE_2 : serial.h
  • SPIMODE_3 : serial.h
  • SPIMODE_COUNT : serial.h
  • SPIModes_t : serial.h
  • StackApplications() : StackTsk.h , StackTsk.c
  • StackInit() : StackTsk.c , StackTsk.h
  • StackTask() : StackTsk.c , StackTsk.h
  • STARTHDR : UNIO.h
  • StartMDNSResponder() : mdns.c , mdns.h
  • StateTableIDs_t : stringtable.h
  • StopMDNSResponder() : mdns.h , mdns.c
  • StringGetLanguageStringPointer() : stringtable.h , stringtable.c
  • StringGetPointer() : stringtable.h , stringtable.c
  • StringGetStatePointer() : stringtable.c , stringtable.h
  • StringTableIDs_t : stringtable.h
  • StrTbl_GetString() : stringtable.c , stringtable.h
  • StrTbl_SetLanguage() : stringtable.h , stringtable.c


Netzer: Data Fields

  • File List
  • Globals
  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Defines
  • _
  • a
  • b
  • d
  • e
  • f
  • g
  • h
  • i
  • l
  • m
  • n
  • p
  • r
  • s
  • t
  • u
  • v
  • w

Here is a list of all documented functions, variables, defines, enums, and typedefs with links to the documentation:

- t -

  • TCPDisconnect() : TCP.c , TCP.h
  • TCPFindEx() : TCP.h , TCP.c
  • TCPFlush() : TCP.c , TCP.h
  • TCPGet() : TCP.h , TCP.c
  • TCPIsConnected() : TCP.c , TCP.h
  • TCPIsGetReady() : TCP.c , TCP.h
  • TCPIsPutReady() : TCP.c , TCP.h
  • TCPOpen() : TCP.h , TCP.c
  • TCPPut() : TCP.c , TCP.h
  • TCPPutArray() : TCP.h , TCP.c
  • TCPPutString() : TCP.c , TCP.h
  • TCPWasReset() : TCP.c , TCP.h
  • TimeInit() : time.h
  • TimerPrescaler_t : gpio.h
  • TMR_PRESCALER1 : gpio.h
  • TMR_PRESCALER2 : gpio.h
  • TMR_PRESCALER4 : gpio.h
  • TMR_PRESCALER8 : gpio.h
  • TOTAL_MEMORY_SIZE : flash.h


Netzer: Data Fields

  • File List
  • Globals
  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Defines
  • _
  • a
  • b
  • d
  • e
  • f
  • g
  • h
  • i
  • l
  • m
  • n
  • p
  • r
  • s
  • t
  • u
  • v
  • w

Here is a list of all documented functions, variables, defines, enums, and typedefs with links to the documentation:

- u -

  • UARTBaudrates_t : serial.h
  • ubtoa() : toa.h
  • utoa() : toa.h


Netzer: Data Fields

  • File List
  • Globals
  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Defines
  • _
  • a
  • b
  • d
  • e
  • f
  • g
  • h
  • i
  • l
  • m
  • n
  • p
  • r
  • s
  • t
  • u
  • v
  • w

Here is a list of all documented functions, variables, defines, enums, and typedefs with links to the documentation:

- v -

  • VAR_GATEWAY_ADDRESS : bootup.h
  • VAR_GATEWAY_ADDRESS_EEPROM : bootup.h
  • VAR_IP_ADDRESS : bootup.h
  • VAR_IP_ADDRESS_EEPROM : bootup.h
  • VAR_MAN_GATEWAY_ADDRESS : bootup.h
  • VAR_MAN_IP_ADDRESS : bootup.h
  • VAR_MAN_SUBNET_MASK : bootup.h
  • VAR_SUBNET_MASK : bootup.h
  • VAR_SUBNET_MASK_EEPROM : bootup.h


Netzer: Data Fields

  • File List
  • Globals
  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Defines
  • _
  • a
  • b
  • d
  • e
  • f
  • g
  • h
  • i
  • l
  • m
  • n
  • p
  • r
  • s
  • t
  • u
  • v
  • w

Here is a list of all documented functions, variables, defines, enums, and typedefs with links to the documentation:

- w -

  • WEB_STACKSIZE : web.h
  • WebCheckbox() : web.c , web.h
  • WebCheckboxROM() : web.c , web.h
  • WebGetAuthLevelOfCurrentPage() : web.c , web.h
  • WebGetCurrentPageID() : web.c , web.h
  • WebIoHTTPExecuteGet() : projectdefs.h , webio.c
  • WebIoProcessPost() : projectdefs.h , webio.c
  • WebOptionROM() : web.h , web.c
  • WebRadioROM() : web.c , web.h
  • WebReportChangedState() : web.c , web.h
  • webwork : web.h
  • WREN : UNIO.h


Netzer: Data Fields

  • File List
  • Globals
  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Defines
  • b
  • d
  • f
  • g
  • h
  • i
  • l
  • m
  • p
  • s
  • t
  • w

- b -

  • BOOTLOADER_SIZE : flash.h
  • BUSFREQ : UNIO.h

- d -

  • DHCPIsBound : DHCP.h
  • DNS_PORT : mdns.h
  • DNS_TYPE_A : mdns.h
  • DNS_TYPE_ANY : mdns.h
  • DNS_TYPE_MX : mdns.h
  • DNS_TYPE_PTR : mdns.h
  • DNS_TYPE_SRV : mdns.h
  • DNS_TYPE_TXT : mdns.h

- f -

  • FLASH_ERASE_SIZE : flash.h
  • FLASH_WRITE_SIZE : flash.h

- g -

  • GPIO_00_ID : netzerTypedefs.h
  • GPIO_01_ID : netzerTypedefs.h
  • GPIO_02_ID : netzerTypedefs.h
  • GPIO_03_ID : netzerTypedefs.h
  • GPIO_04_ID : netzerTypedefs.h
  • GPIO_05_ID : netzerTypedefs.h
  • GPIO_06_ID : netzerTypedefs.h
  • GPIO_07_ID : netzerTypedefs.h
  • GPIO_08_ID : netzerTypedefs.h
  • GPIO_09_ID : netzerTypedefs.h
  • GPIO_0A_ID : netzerTypedefs.h
  • GPIO_0B_ID : netzerTypedefs.h
  • GPIO_0C_ID : netzerTypedefs.h
  • GPIO_COUNT : netzerTypedefs.h
  • GPIO_EEPROM_ADD : projectdefs.h
  • GPIO_INPUT : netzerTypedefs.h
  • GPIO_OUTPUT : netzerTypedefs.h
  • GPIOReadSPIClock : gpio.h
  • GPIOReadSPIMasterWrite : gpio.h
  • GPIOReadSPIRegister : gpio.h
  • GPIOWriteSPIBusy : gpio.h
  • GPIOWriteSPIChipSelect : gpio.h
  • GPIOWriteSPIInt : gpio.h
  • GPIOWriteSPINetzerDataValid : gpio.h

- h -

  • HALF_DUPLEX : ETH97J60.c

- i -

  • I2C_EEPROM_ADD : projectdefs.h
  • INTERNAL_FLASH_SIZE : flash.h

- l -

  • LICENSE_NAME : projectdefs.h

- m -

  • MAX_NETWORKNAME_LENGTH : bootup.h
  • MDNS_PORT : mdns.h

- p -

  • PROJECT_CHECK_FOR_STOPPED_TASK : projectdefs.h
  • PROJECT_CYCLE : projectdefs.h
  • PROJECT_EARLYINIT : projectdefs.h
  • PROJECT_HTTP_GET_EXECUTION : projectdefs.h
  • PROJECT_ID : projectdefs.h
  • PROJECT_INIT : projectdefs.h
  • PROJECT_INIT_TASK : projectdefs.h
  • PROJECT_POWERDOWN : projectdefs.h
  • PROJECT_PROCESS_POST : projectdefs.h
  • PROJECT_RESET_TO_FACTORY : projectdefs.h
  • PROJECT_STATE_CHANGED : projectdefs.h
  • PROJECT_STOP_TASK : projectdefs.h
  • PROJECT_TASK : projectdefs.h
  • PROJECT_WEB_SUBFOLDER : projectdefs.h
  • PROJECT_WEBSITES : projectdefs.h

- s -

  • SCIO : UNIO.h
  • SERIAL_EEPROM_ADD : projectdefs.h
  • STARTHDR : UNIO.h

- t -

  • TOTAL_MEMORY_SIZE : flash.h

- w -

  • WEB_STACKSIZE : web.h
  • WREN : UNIO.h


Netzer: Data Fields

  • File List
  • Globals
  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Defines

  • _MDNS_STATE : mdns.h
  • ApplCommands_t : netzerTypedefs.h
  • AuthReturnCodes_t : auth.h
  • EdgeCounterMode_t : gpio.h
  • EdgeFilterMode_t : gpio.h
  • EdgeTriggerMode_t : gpio.h
  • EventMode_t : gpio.h
  • GPIORadix_t : gpio.h
  • GPIOServerConnection_t : gpio.h
  • I2CClockFrequencies_t : i2c.h
  • ImpulseMode_t : gpio.h
  • IPField_t : bootup.h
  • IPObtainedFrom_t : bootup.h
  • IPSelectionModes_t : bootup.h
  • LanguageIDs_t : stringtable.h
  • NetzerProjects_t : bootup.h
  • NetzerState_t : netzerTypedefs.h
  • PageID_t : netzerTypedefs.h
  • PortType_t : gpio.h
  • PWMFrequencies_t : gpio.h
  • SerialMode_t : projectdefs.h
  • SerialServerConnection_t : serial.h
  • SPIClockFrequencies_t : serial.h
  • SPIModes_t : serial.h
  • StateTableIDs_t : stringtable.h
  • StringTableIDs_t : stringtable.h
  • TimerPrescaler_t : gpio.h
  • UARTBaudrates_t : serial.h


Netzer: Data Fields

  • File List
  • Globals
  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Defines
  • a
  • b
  • e
  • g
  • i
  • l
  • m
  • n
  • p
  • r
  • s
  • t
  • v

- a -

  • APPL_CMD_BLINK : netzerTypedefs.h
  • APPL_CMD_BOOTLOADER : netzerTypedefs.h
  • APPL_CMD_COUNT : netzerTypedefs.h
  • APPL_CMD_IDLE : netzerTypedefs.h
  • APPL_CMD_RESET_TO_FACTORY : netzerTypedefs.h
  • APPL_CMD_RESTART : netzerTypedefs.h
  • APPL_CMD_SHUTDOWN : netzerTypedefs.h
  • AUTH_FAILED : auth.h
  • AUTH_OK : auth.h
  • AUTH_PENDING : auth.h
  • AUTH_READONLY : auth.h

- b -

  • BAUDRATE_0_3 : serial.h
  • BAUDRATE_115_2 : serial.h
  • BAUDRATE_19_2 : serial.h
  • BAUDRATE_1_2 : serial.h
  • BAUDRATE_2_4 : serial.h
  • BAUDRATE_38_4 : serial.h
  • BAUDRATE_4_8 : serial.h
  • BAUDRATE_57_6 : serial.h
  • BAUDRATE_9_6 : serial.h
  • BAUDRATE_COUNT : serial.h

- e -

  • EC_DECREMENTS : gpio.h
  • EC_DISABLED : gpio.h
  • EC_INCREMENTS : gpio.h
  • EF_100_MS : gpio.h
  • EF_10_MS : gpio.h
  • EF_1_MS : gpio.h
  • EF_250_MS : gpio.h
  • EF_DISABLED : gpio.h
  • EM_DISABLED : gpio.h
  • EM_ON_ALL_EDGES : gpio.h
  • EM_ON_FALLING_EDGES : gpio.h
  • EM_ON_RISING_EDGES : gpio.h
  • ET_DISABLED : gpio.h
  • ET_FALLING : gpio.h
  • ET_RISING : gpio.h

- g -

  • GPIO_SERVER_CONNECTED : gpio.h
  • GPIO_SERVER_NOT_RUNNING : gpio.h
  • GPIO_SERVER_RUNNING : gpio.h

- i -

  • I2CFREQ_100K : i2c.h
  • I2CFREQ_400K : i2c.h
  • I2CFREQ_COUNT : i2c.h
  • IPM_CONTINUOUS : gpio.h
  • IPM_SINGLE : gpio.h
  • IPM_TRIGGERED : gpio.h
  • IPO_AUTO : bootup.h
  • IPO_DHCP : bootup.h
  • IPO_MANUAL : bootup.h
  • IPS_AUTO_IP : bootup.h
  • IPS_DHCP_AUTOIP : bootup.h
  • IPS_DHCP_ENABLED : bootup.h
  • IPS_DHCP_MANUALIP : bootup.h
  • IPS_MANUAL_IP : bootup.h
  • IPS_MODE_COUNT : bootup.h

- l -

  • LANGID_COUNT : stringtable.h
  • LANGID_ENGLISH : stringtable.h
  • LANGID_GERMAN : stringtable.h
  • LANGID_NETHERLANDS : stringtable.h
  • LANGID_NOTSPECIFIED : stringtable.h
  • LANGID_SPANISH : stringtable.h

- m -

  • MDNS_HAS_STOPPED : mdns.h
  • MDNS_IS_RUNNING : mdns.h
  • MDNS_IS_STARTING_UP : mdns.h

- n -

  • NETZER_IP_ERROR : netzerTypedefs.h
  • NETZER_NOLINK : netzerTypedefs.h
  • NETZER_READY : netzerTypedefs.h
  • NETZER_SHUTDOWN : netzerTypedefs.h
  • NETZER_STARTING : netzerTypedefs.h

- p -

  • PF_10000_HZ : gpio.h
  • PF_2500_HZ : gpio.h
  • PF_40000_HZ : gpio.h
  • PROJECT_MODE_COUNT : projectdefs.h
  • PROJECT_MODE_I2C_MASTER : projectdefs.h
  • PROJECT_MODE_SERIAL_DISABLED : projectdefs.h
  • PROJECT_MODE_SPI_MASTER : projectdefs.h
  • PROJECT_MODE_SPI_SLAVE : projectdefs.h
  • PROJECT_MODE_UART : projectdefs.h
  • PT_ANALOG_INPUT : gpio.h
  • PT_DIG_INPUT : gpio.h
  • PT_DIG_OUTPUT : gpio.h
  • PT_IMPULSE : gpio.h
  • PT_PWM : gpio.h

- r -

  • RADIX_IS_DECIMAL : gpio.h
  • RADIX_IS_HEXADECIMAL : gpio.h

- s -

  • SERIAL_SERVER_CONNECTED : serial.h
  • SERIAL_SERVER_IS_LISTENING : serial.h
  • SERIAL_SERVER_NOT_RUNNING : serial.h
  • SPIFREQ_10M4 : serial.h
  • SPIFREQ_2M6 : serial.h
  • SPIFREQ_650K : serial.h
  • SPIFREQ_COUNT : serial.h
  • SPIFREQ_SLAVE : serial.h
  • SPIMODE_0 : serial.h
  • SPIMODE_1 : serial.h
  • SPIMODE_2 : serial.h
  • SPIMODE_3 : serial.h
  • SPIMODE_COUNT : serial.h

- t -

  • TMR_PRESCALER1 : gpio.h
  • TMR_PRESCALER2 : gpio.h
  • TMR_PRESCALER4 : gpio.h
  • TMR_PRESCALER8 : gpio.h

- v -

  • VAR_GATEWAY_ADDRESS : bootup.h
  • VAR_GATEWAY_ADDRESS_EEPROM : bootup.h
  • VAR_IP_ADDRESS : bootup.h
  • VAR_IP_ADDRESS_EEPROM : bootup.h
  • VAR_MAN_GATEWAY_ADDRESS : bootup.h
  • VAR_MAN_IP_ADDRESS : bootup.h
  • VAR_MAN_SUBNET_MASK : bootup.h
  • VAR_SUBNET_MASK : bootup.h
  • VAR_SUBNET_MASK_EEPROM : bootup.h


Netzer: Data Fields

  • File List
  • Globals
  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Defines
  • _
  • a
  • b
  • d
  • e
  • g
  • h
  • i
  • m
  • r
  • s
  • t
  • u
  • w

- _ -

  • _CheckForQueryResponse() : mdns.c
  • _StartHeader() : UNIO.c


Netzer: Data Fields

  • File List
  • Globals
  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Defines
  • _
  • a
  • b
  • d
  • e
  • g
  • h
  • i
  • m
  • r
  • s
  • t
  • u
  • w

- m -

  • MACIsLinked() : ETH97J60.c , MAC.h
  • MDNSProcessFrame() : mdns.h , mdns.c
  • MDNSResolveName() : mdns.c , mdns.h
  • MDNSResolveService() : mdns.h , mdns.c
  • MDNSResponder() : mdns.h , mdns.c
  • MDNSStopResolving() : mdns.c , mdns.h


Netzer: Data Fields

  • File List
  • Globals
  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Defines
  • _
  • a
  • b
  • d
  • e
  • g
  • h
  • i
  • m
  • r
  • s
  • t
  • u
  • w

- a -

  • ADCGetValue() : adc.c , adc.h
  • ADCInitialize() : adc.h , adc.c
  • ApplCommand() : appl.c , appl.h
  • ApplGetCurrentState() : appl.h , appl.c
  • ApplInit() : appl.c , appl.h
  • ApplIsRunning() : appl.c , appl.h
  • ApplMain() : appl.c , appl.h
  • ApplResetToFactory() : appl.h , appl.c
  • ApplStateChanged() : appl.c , appl.h
  • ApplStop() : appl.c , appl.h
  • ARPFlush() : ARP.c , ARP.h
  • ARPIsResolved() : ARP.c , ARP.h
  • ARPResolve() : ARP.c , ARP.h
  • AuthExecuteApplCommand() : auth.c , auth.h , web.c
  • AuthHandleAuthentification() : auth.h , auth.c
  • AuthInit() : auth.c , auth.h
  • AuthProcessPostData() : auth.c , auth.h
  • AuthReload() : auth.c , auth.h
  • AuthReset() : auth.c , auth.h
  • AuthSetUserForDialog() : auth.h , auth.c
  • AuthStartAuthentification() : auth.h , auth.c
  • AuthStoreInEEPROM() : auth.h , auth.c


Netzer: Data Fields

  • File List
  • Globals
  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Defines
  • _
  • a
  • b
  • d
  • e
  • g
  • h
  • i
  • m
  • r
  • s
  • t
  • u
  • w

- b -

  • bGPIOCheckForStoppedTask() : gpio.c , gpio.h
  • bInitMDNSResponder() : mdns.h , mdns.c
  • bMDNSNameIsResolved() : mdns.c , mdns.h
  • bMDNSServiceIsResolved() : mdns.h , mdns.c
  • BootupBlink() : bootup.c , bootup.h
  • BootupEnterBootloader() : bootup.c , bootup.h
  • BootupGetHTTPPort() : bootup.c , bootup.h
  • BootupGetIPAddress() : bootup.h , bootup.c
  • BootupGetIPMode() : bootup.c , bootup.h
  • BootupGetNetworkName() : bootup.c , bootup.h
  • BootupInit() : bootup.c , bootup.h
  • BootupInvalidateIPSettings() : bootup.h
  • BootupMain() : bootup.c , bootup.h
  • BootupPrintFormatedIPAddress() : bootup.h , bootup.c
  • BootupPrintIPAddress() : bootup.c , bootup.h
  • BootupResetToFactory() : bootup.c , bootup.h
  • BootupSetHTTPPort() : bootup.h , bootup.c
  • BootupSetIPAddress() : bootup.h , bootup.c
  • BootupSetNetworkName() : bootup.c , bootup.h
  • bSerialCheckForStoppedTask() : serial.c , serial.h
  • bSerialGetSPIMasterSample() : serial.h , serial.c
  • ByteWrite() : UNIO.h


Netzer: Data Fields

  • File List
  • Globals
  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Defines
  • _
  • a
  • b
  • d
  • e
  • g
  • h
  • i
  • m
  • r
  • s
  • t
  • u
  • w

- d -

  • DHCPDisable() : DHCP.c , DHCP.h
  • DHCPEnable() : DHCP.h , DHCP.c
  • DHCPGetIPParameterFromServer() : DHCP.c , DHCP.h
  • DHCPHasBoundStateChanged() : DHCP.h , DHCP.c
  • DHCPHasFailed() : DHCP.c , DHCP.h
  • DHCPIsEnabled() : DHCP.c , DHCP.h
  • DHCPReset() : DHCP.c , DHCP.h
  • DHCPTask() : DHCP.c , DHCP.h


Netzer: Data Fields

  • File List
  • Globals
  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Defines
  • _
  • a
  • b
  • d
  • e
  • g
  • h
  • i
  • m
  • r
  • s
  • t
  • u
  • w

- e -

  • EEPROMInit() : UNIO.c
  • eGetMDNSState() : mdns.h , mdns.c


Netzer: Data Fields

  • File List
  • Globals
  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Defines
  • _
  • a
  • b
  • d
  • e
  • g
  • h
  • i
  • m
  • r
  • s
  • t
  • u
  • w

- g -

  • GPIOActivateAuth() : gpio.h
  • GPIOActivateScript() : gpio.h
  • GPIOActivateServerPersistent() : gpio.h , gpio.c
  • GPIOConfigurePort() : gpio.c , gpio.h
  • GPIOFlushToEEPROM() : gpio.h , gpio.c
  • GPIOGetConnectedIP() : gpio.c , gpio.h
  • GPIOGetCurrentImpulseWidth() : gpio.h
  • GPIOGetEdgeCounter() : gpio.h
  • GPIOGetEdgeCounterMode() : gpio.h
  • GPIOGetEdgeFilterMode() : gpio.h
  • GPIOGetEdgeTriggerMode() : gpio.h
  • GPIOGetEventMode() : gpio.h
  • GPIOGetImpulseLogic() : gpio.h
  • GPIOGetImpulseMode() : gpio.h
  • GPIOGetImpulsePrescaler() : gpio.h
  • GPIOGetPinValue() : gpio.c , gpio.h
  • GPIOGetPortName() : gpio.c , gpio.h
  • GPIOGetPortType() : gpio.c , gpio.h
  • GPIOGetPWMFrequency() : gpio.h
  • GPIOGetPWMLogic() : gpio.h
  • GPIOGetPWMStartDuty() : gpio.h
  • GPIOGetRadix() : gpio.h
  • GPIOGetRefresh() : gpio.h
  • GPIOGetServerState() : gpio.h , gpio.c
  • GPIOGetStartImpulseWidth() : gpio.h
  • GPIOGetStartupValue() : gpio.c , gpio.h
  • GPIOGetTCPPort() : gpio.c , gpio.h
  • GPIOInit() : gpio.c , gpio.h
  • GPIOInitPeripherals() : gpio.h
  • GPIOInitTask() : gpio.c , gpio.h
  • GPIOIsAuthActive() : gpio.h
  • GPIOIsPortOverwritten() : gpio.c , gpio.h
  • GPIOIsScriptActive() : gpio.h
  • GPIOIsTypeSupportedByPort() : gpio.h
  • GPIOReconfigurePeripherals() : gpio.h
  • GPIOResetEdgeCounter() : gpio.h
  • GPIOResetToFactory() : gpio.h , gpio.c
  • GPIOServerIsActivated() : gpio.c , gpio.h
  • GPIOSetAllPinValues() : gpio.c , gpio.h
  • GPIOSetCurrentImpulseWidth() : gpio.h
  • GPIOSetEdgeCounterMode() : gpio.h
  • GPIOSetEdgeFilterMode() : gpio.h
  • GPIOSetEdgeTriggerMode() : gpio.h
  • GPIOSetEventMode() : gpio.h
  • GPIOSetImpulseLogic() : gpio.h
  • GPIOSetImpulseMode() : gpio.h
  • GPIOSetImpulsePrescaler() : gpio.h
  • GPIOSetPortType() : gpio.h , gpio.c
  • GPIOSetPortValue() : gpio.h , gpio.c
  • GPIOSetPWMFrequency() : gpio.h
  • GPIOSetPWMLogic() : gpio.h
  • GPIOSetPWMStartDuty() : gpio.h
  • GPIOSetRadix() : gpio.h
  • GPIOSetRefresh() : gpio.h
  • GPIOSetStartupImpulseWidth() : gpio.h
  • GPIOSetStartupValue() : gpio.c , gpio.h
  • GPIOSetTCPPortPersistent() : gpio.c , gpio.h
  • GPIOStopTask() : gpio.h , gpio.c
  • GPIOTask() : gpio.c , gpio.h


Netzer: Data Fields

  • File List
  • Globals
  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Defines
  • _
  • a
  • b
  • d
  • e
  • g
  • h
  • i
  • m
  • r
  • s
  • t
  • u
  • w

- h -

  • HelperConvertNibbleFromHex() : helper.h
  • HelperConvertWordFromHex() : helper.h
  • htoa() : toa.h
  • Htoc_high() : toa.h
  • htoc_high() : toa.h
  • Htoc_low() : toa.h
  • htoc_low() : toa.h
  • HTTPCheckAuth() : auth.h , webio.c , auth.c
  • HTTPNeedsAuth() : web.h , web.c


Netzer: Data Fields

  • File List
  • Globals
  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Defines
  • _
  • a
  • b
  • d
  • e
  • g
  • h
  • i
  • m
  • r
  • s
  • t
  • u
  • w

- i -

  • I2CCheckForStoppedTask() : i2c.c , i2c.h
  • I2CGetFrequency() : i2c.h , i2c.c
  • I2CInit() : i2c.c , i2c.h
  • I2CISR() : i2c.h , i2c.c
  • I2CLoadConfig() : i2c.c , i2c.h
  • I2CResetToFactory() : i2c.c , i2c.h
  • I2CSetFrequency() : i2c.c , i2c.h
  • I2CStopTask() : i2c.h , i2c.c
  • I2CTask() : i2c.c , i2c.h
  • IoCheckForStoppedTasks() : io.c , projectdefs.h
  • IoEarlyInit() : io.c , projectdefs.h
  • IoGetSerialMode() : io.c , projectdefs.h
  • IoInit() : io.c , projectdefs.h
  • IoInitTasks() : io.c , projectdefs.h
  • IoResetToFactory() : io.c , projectdefs.h
  • IoSetNewSerialMode() : projectdefs.h , io.c
  • IoShutdown() : io.c , projectdefs.h
  • IoStopTasks() : io.c , projectdefs.h
  • IoTasks() : io.c , projectdefs.h
  • IPConvertMaskToSubnet() : IP.c , IP.h
  • IPConvertSubnetToMask() : IP.c , IP.h


Netzer: Data Fields

  • File List
  • Globals
  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Defines
  • _
  • a
  • b
  • d
  • e
  • g
  • h
  • i
  • m
  • r
  • s
  • t
  • u
  • w

- r -

  • RawEraseFlashBlock() : flash.h
  • RawWriteFlashBlock() : flash.h


Netzer: Data Fields

  • File List
  • Globals
  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Defines
  • _
  • a
  • b
  • d
  • e
  • g
  • h
  • i
  • m
  • r
  • s
  • t
  • u
  • w

- s -

  • SerialGetConnectedIP() : serial.c , serial.h
  • SerialGetRXCounter() : serial.h , serial.c
  • SerialGetServerState() : serial.c , serial.h
  • SerialGetSPIFrequency() : serial.h , serial.c
  • SerialGetSPIMode() : serial.c , serial.h
  • SerialGetTCPPort() : serial.c , serial.h
  • SerialGetTXCounter() : serial.c , serial.h
  • SerialGetUARTBaudrate() : serial.h , serial.c
  • SerialInit() : serial.c , serial.h
  • SerialInitTask() : serial.c , serial.h
  • SerialRegisterHandling() : serial.c , serial.h
  • SerialResetToFactory() : serial.c , serial.h
  • SerialSendTCPData() : serial.h
  • SerialSetSPIFrequency() : serial.c , serial.h
  • SerialSetSPIMasterSample() : serial.c , serial.h
  • SerialSetSPIMode() : serial.c , serial.h
  • SerialSetTCPPort() : serial.c , serial.h
  • SerialSetUARTBaudrate() : serial.c , serial.h
  • SerialShutdown() : serial.c , serial.h
  • SerialStopTask() : serial.c , serial.h
  • SerialTask() : serial.c , serial.h
  • StackApplications() : StackTsk.c , StackTsk.h
  • StackInit() : StackTsk.h , StackTsk.c
  • StackTask() : StackTsk.h , StackTsk.c
  • StartMDNSResponder() : mdns.c , mdns.h
  • StopMDNSResponder() : mdns.h , mdns.c
  • StringGetLanguageStringPointer() : stringtable.c , stringtable.h
  • StringGetPointer() : stringtable.c , stringtable.h
  • StringGetStatePointer() : stringtable.h , stringtable.c
  • StrTbl_GetString() : stringtable.c , stringtable.h
  • StrTbl_SetLanguage() : stringtable.h , stringtable.c


Netzer: Data Fields

  • File List
  • Globals
  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Defines
  • _
  • a
  • b
  • d
  • e
  • g
  • h
  • i
  • m
  • r
  • s
  • t
  • u
  • w

- t -

  • TCPDisconnect() : TCP.c , TCP.h
  • TCPFindEx() : TCP.h , TCP.c
  • TCPFlush() : TCP.c , TCP.h
  • TCPGet() : TCP.h , TCP.c
  • TCPIsConnected() : TCP.c , TCP.h
  • TCPIsGetReady() : TCP.c , TCP.h
  • TCPIsPutReady() : TCP.c , TCP.h
  • TCPOpen() : TCP.h , TCP.c
  • TCPPut() : TCP.c , TCP.h
  • TCPPutArray() : TCP.h , TCP.c
  • TCPPutString() : TCP.h , TCP.c
  • TCPWasReset() : TCP.h , TCP.c
  • TimeInit() : time.h


Netzer: Data Fields

  • File List
  • Globals
  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Defines
  • _
  • a
  • b
  • d
  • e
  • g
  • h
  • i
  • m
  • r
  • s
  • t
  • u
  • w

- u -

  • ubtoa() : toa.h
  • utoa() : toa.h


Netzer: Data Fields

  • File List
  • Globals
  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Defines
  • _
  • a
  • b
  • d
  • e
  • g
  • h
  • i
  • m
  • r
  • s
  • t
  • u
  • w

- w -

  • WebCheckbox() : web.c , web.h
  • WebCheckboxROM() : web.h , web.c
  • WebGetAuthLevelOfCurrentPage() : web.c , web.h
  • WebGetCurrentPageID() : web.h , web.c
  • WebIoHTTPExecuteGet() : projectdefs.h , webio.c
  • WebIoProcessPost() : projectdefs.h , webio.c
  • WebOptionROM() : web.c , web.h
  • WebRadioROM() : web.h , web.c
  • WebReportChangedState() : web.h , web.c


Netzer: Data Fields

  • File List
  • Globals
  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Defines

  • MAC_ADDR : GenericTypeDefs.h
  • NODE_INFO : GenericTypeDefs.h


Netzer: Data Fields

  • File List
  • Globals
  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Defines

  • _au8NetworkDataForBootloader : bootup.c
  • _persistentHTTPPort : bootup.c
  • _sm : bootup.c
  • _timer : bootup.c
  • dataOut : UNIO.c
  • sIPConfig : bootup.h
  • sPCommonConfig : bootup.h
  • webwork : web.h


Netzer: Main Page

Netzer Documentation

1.4

Generated on Fri Mar 29 10:34:27 2013 for Netzer by doxygen 1.5.5


Netzer: Page Index

Related Pages

Here is a list of all related documentation pages:
  • Version tracking
  • The MoBaCon Software License (MBCSL)
  • List of bugs and feature requests
  • Folder structure and project files
  • How to build
  • How to deploy
  • The I2C master protocol
  • The SPI master protocol
  • The SPI slave protocol
  • Todo List
Generated on Fri Mar 29 10:34:27 2013 for Netzer by doxygen 1.5.5