Networking with MyCPU

• Overview
• Using network on a minimalist MyCPU computer
• Using network on a MyCPU with Ethernet card and Harddisk
• Networking with MyCPU Emulator
• Starting network automatically at MyCPU start up
• Description of MyCPU networking programs and tools
• Writing own networking programs in "C"

Overview

The MyCPU webserver consists of the components CPU, Interrupt Controller, Memory Unit with extension board, IDE interface with CF-Card and Ethernet Interface Board.

Using network on a minimalist MyCPU computer

• A working MyCPU processor
• Memory base board with latest software installed
• RS232 interface board
• Interrupt controller board
• Two Null-modem cables
• A PC with two serial ports (COM1 and COM2)
• Optional: An old VT100 terminal

1. Setup your MyCPU hardware, connect the boards via a flat cable backplane, and connect a power supply to the +5V and GND rails. It is not required to supply the +12V rail on the backplane.
2. Connect a VT100 compatible terminal with serial port 1 of MyCPU.
3. Alternatively connect com1 of the PC with port 1 of MyCPU. Run hyperterminal or similar on the PC.
4. Connect com2 of the PC with serial port 2 of MyCPU.
5. Download the latest MyCPU software package from the internet.
6. Unzip the package and run the program server/rfss.exe. Enter "rfss /p2" in a DOS-box to bind rfss to com2:
7. Switch on the powersupply. MyCPU should boot now. MyCPU will show a boot-menu that was loaded from the PC.
8. When the menu is displayed choose menu point [3]: boot MyCPU with network support
9. Configure the IP address for MyCPU. Because DHCP is not supported you must configure a static IP address. Enter "edit /etc/netconfig" on the MyCPU. Scroll down to the line "ipaddress = 192.168.1.33". Change the IP address to the one you have chosen for MyCPU. Leave the editor by pressing F8 and then "Y". Note: If you cannot leave the editor by pressing F8, then press F1 and then 'X'.
10. Kill the remotefs-service on MyCPU: enter the line "kill remotefs".
11. Quit the rfss tool on the PC by pressing "X"
12. Start the network on MyCPU by entering "net start all". You will get the message that FTP could not be started if you do not have the memory extension board installed. That's ok.
13. Start the SLIP connection on you Windows XP machine. Make sure that you have set the correct parameters for the serial connection. The parameters are: 115200 baud, 8 bits, 1 stopbit, hardware handshake. Important: Use an other IP address for the PC than for the MyCPU. If MyCPU is 192.168.1.33, then use for SLIP 192.168.1.2 (for example). And please disable the Windows firewall on the SLIP connection. Windows should be able to connect to MyCPU now.
14. Now you should be able to ping the MyCPU. Open a DOS-box on the PC and enter "ping 192.168.1.33" (the MyCPU's internet address).
15. Also telnet should work. In the DOS-box, enter "telnet 192.168.1.33". The login is "root" and the password is "mycpu". Press [enter] twice to see the prompt.
16. Now start a webbrowser and enter the URL "http://192.168.1.33". You should see a small website served by your MyCPU!
17. On MyCPU there are two useful tools you may try: "netstat" displays some network statistics and "ifconfig" shows the actual network configuration. And of course there is also a "ping" on MyCPU available :-)

Using network on a MyCPU with Ethernet card and Harddisk

• A working MyCPU processor
• Memory base board + extension board with latest software installed
• RS232 interface board
• Interrupt controller board
• IDE controller board with installed harddisk or CF-card
• Ethernet controller board
• A Null-modem cable and a crossed Ethernet cable
• A VT100 terminal or a PC running hyperterm
• Optional: MyCPU VGA graphic unit and keyboard interface extension card

1. Setup your MyCPU hardware, connect the boards via a flat cable backplane, and connect a power supply to the +5V and GND rails. It is not required to supply the +12V rail on the backplane.
2. Connect a VT100 compatible terminal with serial port 1 of MyCPU or use the Video display and keyboard.
3. Connect MyCPU's ethernet card with a crossed cable to your PC or with a non-crossed cable to a network switch.
4. Download and install the latest software package on MyCPU's harddisk. To do so, you will need a second serial connection to a PC running the rfss.exe program. You must start remotefs on the MyCPU by entering "remotefs com2: 14:". Change to drive 14: and enter "copy8" to install the update on you harddisk. Hint: A more easy way to install the update is to format drive 8: (enter "format 8:") and then reboot the system. (Before formatting the drive please ensure that the remote-fs connection works properly!).
5. Configure the IP address for MyCPU. Because DHCP is still not supported you must configure a static IP address. Enter "edit /etc/netconfig" on the MyCPU. Scroll down to the line "ipaddress = 192.168.1.33". Change the IP address to the one you have chosen for MyCPU. Change also the gateway address and the subnet mask. Now scroll up to the line "devicelib = SL25". Change "SL25" to "SL26". SL26 is the driver for the ethernet card. Leave the editor by pressing F8 and then "Y". Note: If you cannot leave the editor by pressing F8, then press F1 and then 'X'.
6. Start the network on MyCPU by entering "net start all". You may get the message that FTP could not be started if you do not have the memory extension board installed. That's ok.
7. Now you should be able to ping the MyCPU. Open a DOS-box on the PC and enter "ping 192.168.1.33" (the MyCPU's internet address).
8. Also telnet should work. In the DOS-box, enter "telnet 192.168.1.33". The login is "root" and the password is "mycpu". Press [enter] twice to see the prompt.
9. Now start a webbrowser and enter the URL "http://192.168.1.33". You should see a small website served by your MyCPU!
10. File transfers from and to MyCPU become very easy now: Simply use a FTP client progam to connect to MyCPU! Try it out, open a webbrowser and enter the URL "ftp://192.168.1.33". The login is "root" and the password is "mycpu". Hint: It is a very good idea to use programs like WinSCP, FlashFXP or ftp.exe (DOS box) to transfer files via FTP. The ftp clients that are built into the web browsers aren't so good.
11. On MyCPU there are three useful tools you may try: "netstat" displays some network statistics, "ifconfig" shows the actual network configuration and "arp" is used to manage the MAC-to-IP-address resolution. And of course there is also a "ping" on MyCPU available :-)
12. To stop the network on MyCPU, enter "net stop"
13. You may want to change the default username and password for telnet and ftp. The default words are set in the first lines of the script "net". Type "edit /bin/net" to edit the script.

Networking with MyCPU Emulator

• A PC running Windows XP. The PC must have an active ethernet network connection to anywhere.
• WinPcap packet capture driver (click to download, please use v4.0.2)
• MyCPU Emulator (click to download)

1. Download the emulator and the packet capture driver. Install the driver on your PC (administrator rights are required)
2. Check the network configuration of your PC. Your PC should have a static IP address assigned. And the PC must have one active ethernet connection (not wireless or dial-up!) to anywhere (an ethernet switch as remote station is sufficient, a second computer is not required).
3. Find an unused IP address in your network. You will need this IP for the MyCPU emulator.
4. Start the MyCPU emulator by double-clicking the file "cpuemu8.exe".
5. At the MyCPU command prompt enter "edit /etc/netconfig".
6. Scroll down to the line "ipaddress = 192.168.1.33". Change the IP address to the one you have chosen for MyCPU. Change also the gateway address and the subnet mask.
7. Leave the editor by pressing F8 and then 'Y'.
8. Start the network by entering "net start all".
9. The network will be set up automatically. If you made a mistake while entering the IP addresses, you are required to quit the emulator and restart them again. Repeat the last four steps.
10. The network should work now. Try to ping your PC from MyCPU (enter "ping aaa.bbb.ccc.ddd" at the prompt, where aaa.bbb.ccc.ddd is the IP address of your PC)
11. If your PC does not answer the ping you may have a firewall installed that prohibits pings. If so, try to ping the MyCPU emulation from within a DOS box on your PC.
12. If you still have problems with the network connection, try setting up the interface manually. Start the MyCPU emulator, press [ESC] three times, and then press 'N'. You should get a list with all network adapters installed in your PC. Choose the one that is connected with a cable to a switch or to an other computer. You should get the message that the network is initialized now. Press 'R' to run the emulation, and then type "net start all" to start the network on MyCPU.
13. The network services Telnet, http and ftp should work now. Open a webbrowser and enter MyCPU's IP address in the address line. The browser should load a small website from the emulator. Telnet and ftp should work also. You need a login name and password for these services: The login is "root", password is "mycpu".
14. MyCPU knows some networking commands on the command line: Try "netstat", "ifconfig" and "arp".
15. To stop the network on MyCPU, enter "net stop"

Starting network automatically at MyCPU start up

• To start the whole network system (http, Telnet and ftp), add the line "call net start all"

• To start only one or two special services, add one or two of these lines:
     "call net start telnet" (starts telnet)
     "call net start httpd" (starts the http webserver)
     "call net start ftpd" (starts the ftp server)

Description of MyCPU networking programs and tools

1. net
2. netstart
3. httpserv
4. telserv
5. ftpd
6. ifconfig
7. netstat
8. ping
9. arp

Command: net

Command: netstart

Service: httpserv

Service: telserv

Service: ftpd

Command: ifconfig

Command: netstat

Command: ping

Command: arp

Writing own networking programs in "C"

1. Introduction

2. How it works

3. Socket Functions

• socket()
• close()
• shutdown()
• accept()
• bind()
• connect()
• listen()
• recv()
• recvfrom()
• send()
• sendto()
• read()
• write()
• gethostbyname()
• getpeername()
• getsockname()
• getsockopt()
• setsockopt()
• select()
• select2()
• ioctlsocket()
• fcntl()
• inet_addr()
• inet_aton()
• inet_ntoa()
• htons(), ntohs(), htonl(), ntohl()

• getaddrinfo(), freeaddrinfo(), gai_strerror()
• gethostname()
• gethostbyaddr()
• getnameinfo()
• inet_ntop(), inet_pton()
• ioctl(): please see ioctlsocket()
• poll()

• RAW sockets are not supported
• Signals are not supported in conjunction with sockets
• MyCPU is single threaded, fork() is not supported
• Most socket options (used with ioctlsocket() and setsockopt()) are not implemented
• Use ioctlsocket() instead of ioctl() on sockets
• Standard header files are not supported, only <sockets.h> is available

4. Programming Examples

/*
 *   server.c -- a stream socket server demo for MyCPU
 *
 *   Compile with
 *       cl65 -t mycpu server.c socketslib.lib
 */

#include <stdlib.h>
#include <unistd.h>
#include <stdio.h>
#include <conio.h>
#include <string.h>
#include <time.h>
#include <sockets.h>

#define PORT     4000  /* the port users will be connecting to */
#define BACKLOG     3  /* how many pending connections queue will hold */

#define READSIZE  100
#define SENDSIZE  100
static char readbuf[READSIZE];  /* buffer for receive data */
static char sendbuf[SENDSIZE];  /* buffer for send data */

int main(void)
{
    fd_set master_set, rd_set;
    struct sockaddr_in servaddr, peeraddr;
    socklen_t slen;
    unsigned timeout;
    int sockfd;   /* server socket */
    int connfd;   /* socket of data connection */
    int ret, n;
    int quit=0;

    /* create new TCP socket */
    sockfd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
    if (sockfd < 0) {
        perror("socket()");
        exit(1);
    }

    /* bind socket to server port */
    memset(&servaddr, 0, sizeof(servaddr));
    servaddr.sin_family      = AF_INET;
    servaddr.sin_addr.s_addr = INADDR_ANY;
    servaddr.sin_port        = htons(PORT);
    ret = bind(sockfd, (struct sockaddr *)&servaddr, sizeof(servaddr));
    if (ret < 0) {
        perror("bind()");
        close(sockfd);
        exit(1);
    }

    /* set socket to listen mode */
    ret = listen(sockfd, BACKLOG);
    if (ret < 0) {
        perror("listen()");
        close(sockfd);
        exit(1);
    }

    /* prepare for select() */
    FD_ZERO(&master_set);
    FD_SET(sockfd, &master_set);
    connfd = -1;

    /* handle connections in an endless loop */
    while (!quit)
    {
        /* check for incomming connections and data by polling the sockets with select() */
        timeout = 5;  /* 5 x 50ms = 250ms. timeout can also be set to 0 */
        rd_set = master_set;
        n = select2(FD_SETSIZE+1, &rd_set, NULL, &timeout);
        if (n < 0) {
            perror("select()");
            close(sockfd);
            exit(1);
        }

        /* Timeout or nothing to do? -> Print message while we are idle. */
        if (n == 0) {
            printf("(clock %lu) Press any key to quit or connect to port %i\r", clock(), PORT);
            if (kbhit()) {
                cgetc();
                printf("\nQuit\n");
                quit = 1;
            }
        }

        /* Is a socket ready for read? */
        if (n > 0) {
            if (FD_ISSET(sockfd, &rd_set)) {
                /* It is the server socket. Somebody wants to connect to us. */
                /* Close other connection if established. */
                if (connfd >= 0) {
                    FD_CLR(connfd, &master_set);
                    close(connfd);
                }
                /* get new connection socket */
                slen = sizeof(peeraddr);
                connfd = accept(sockfd, (struct sockaddr *)&peeraddr, &slen);
                if (connfd >= 0) {
                    /* add new connection to master_set so select() will look at it */
                    FD_SET(connfd, &master_set);
                    /* print connection data */
                    printf("\n\nGot new connection from IP %s, port %u\n",
                           inet_ntoa(peeraddr.sin_addr), ntohs(peeraddr.sin_port));
                    /* send a welcome message to our peer */
                    sprintf(sendbuf, "Welcome! Server time is %lu ticks.", clock());
                    toascii(sendbuf, sendbuf); /* on MyCPU: convert character set */
                    write(connfd, sendbuf, strlen(sendbuf));
                }
            }
            else
            {
                /* Any other socket is ready for read. Check if it is the connection socket. */
                if ((connfd >= 0) && FD_ISSET(connfd, &rd_set)) {
                    /* there is incomming data on the connection */
                    ret = read(connfd, readbuf, READSIZE-1);
                    if (ret < 0) {
                        /* we lost the connection */
                        printf("\nLost connection to IP %s, port %u\n",
                               inet_ntoa(peeraddr.sin_addr), ntohs(peeraddr.sin_port));
                        FD_CLR(connfd, &master_set);
                        close(connfd);
                        connfd = -1;
                    } else {
                        /* print out the received data */
                        readbuf[ret] = 0;
                        topetscii(readbuf, readbuf); /* on MyCPU: convert character set */
                        printf("\nreceived %i bytes: \"%s\"\n", ret, readbuf);
                    }
                }
            }
        }
    }

    /* cleanup and exit */
    close(sockfd);
    if (connfd >= 0) {
        close(connfd);
    }

    return 0;
}

/*
 *   client.c -- a stream socket client demo for MyCPU
 *
 *   Compile with
 *       cl65 -t mycpu client.c socketslib.lib
 */

#include <stdlib.h>
#include <unistd.h>
#include <stdio.h>
#include <conio.h>
#include <string.h>
#include <time.h>
#include <sockets.h>

#define PORT     4000  /* the port users will be connecting to */
#define BACKLOG     3  /* how many pending connections queue will hold */

#define READSIZE  100
#define SENDSIZE  300
static char readbuf[READSIZE];  /* buffer for receive data */
static char sendbuf[SENDSIZE];  /* buffer for send data */

int main(int argc, char *argv[])
{
    fd_set master_set, rd_set;
    struct sockaddr_in addr;
    unsigned timeout;
    int sockfd;
    int ret, n;
    int i=0, quit=0;

    if (argc != 5) {
        printf("Usage: %s ServerIP word1 word2 word3\n", argv[0]);
        printf("Example: %s 192.168.1.33 Hello beautiful world\n", argv[0]);
        return 1;
    }

    /* create new TCP socket */
    sockfd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
    if (sockfd < 0) {
        perror("socket()");
        exit(1);
    }

    /* connect socket to server */
    memset(&addr, 0, sizeof(addr));
    addr.sin_family      = AF_INET;             /* AF_INET means "Internet Protocol */
    addr.sin_addr.s_addr = inet_addr(argv[1]);  /* convert IP address to binary number */
    addr.sin_port        = htons(PORT);         /* set server port number */
    printf("Connecting to %s ... ", inet_ntoa(addr.sin_addr));
    ret = connect(sockfd, (struct sockaddr*)&addr, sizeof(addr));
    if (ret < 0) {
        perror("connect() failed");
        close(sockfd);
        exit(1);
    }
    printf("ok.\n");

    /* prepare for select() */
    FD_ZERO(&master_set);
    FD_SET(sockfd, &master_set);

    /* handle the TCP/IP connection */
    while (!quit)
    {
        /* check for incomming data polling the socket with select() */
        timeout = 20;  /* 20 x 50ms = 1s */
        rd_set = master_set;
        n = select2(FD_SETSIZE+1, &rd_set, NULL, &timeout);
        if (n < 0) {
            perror("select()");
            close(sockfd);
            exit(1);
        }

        /* Timeout? -> Send next message to server */
        if (n == 0) {
            printf("sending \"%s\"\n", argv[i+2]);
            toascii(sendbuf, argv[i+2]); /* on MyCPU: convert character set */
            ret = write(sockfd, sendbuf, strlen(sendbuf));
            if (ret < 0) {
                perror("write() - connection lost!");
                close(sockfd);
                exit(1);
            }
            if (++i >= 3)
                quit = 1;
        }

        /* Is a socket ready for read? */
        if (n > 0) {
            if (FD_ISSET(sockfd, &rd_set)) {
                /* read data from our socket */
                ret = read(sockfd, readbuf, READSIZE-1);
                if (ret < 0) {
                    perror("read() - connection lost!");
                    close(sockfd);
                    exit(1);
                }
                if (ret > 0) {
                    readbuf[ret] = 0;
                    topetscii(readbuf, readbuf); /* on MyCPU: convert character set */
                    printf("received %i bytes: \"%s\"\n", ret, readbuf);
                }
            }
        }
    }

    /* cleanup and exit */
    close(sockfd);
    return 0;
}

5. External Links