Eclipse Development

[bear24rw]

sounds awsome
i would probably defiently use it if it works perfectly

now, we just need to all hope that ifi doesnt radically change the RC lol

[Astronouth7303]

One thing I forgot to mention. My enhanced MCC18 wrappers are in subversion. I just have to figure out how to package them.

Originally Posted by bear24rw

i would probably defiently use it if it works perfectly

You haven't been developing software for long, have you?

Even if it doesn't, it'd still work a lot better than MPLAB and IFI Loader. (I can't do much about MCC18.)

[Stuart]

this post has intrigued me, but 2 questions. what is eclipse and why should I use it?(I can guess its a IDE/compiler of some sort but to me all compilers kinda look the same. what makes this "better" is the real question Im asking)

[chris31]

Originally Posted by Stuart

this post has intrigued me, but 2 questions. what is eclipse and why should I use it?(I can guess its a IDE/compiler of some sort but to me all compilers kinda look the same. what makes this "better" is the real question Im asking)

Linux.

The goal is to have a complete code development system all installable from 1 CD. MPLab has no Linux version so you can instead use a modified version of Eclipse.

Now that I think of it. Including instructions on how to set up a Subversion server in the final release might be helpful to some teams.

[prograid]

Originally Posted by Stuart

this post has intrigued me, but 2 questions. what is eclipse and why should I use it?(I can guess its a IDE/compiler of some sort but to me all compilers kinda look the same. what makes this "better" is the real question Im asking)

Well, as you guessed Eclipse is an IDE, sort off. It was conceived by some people at IBM as an extensible platform, written in Java, upon which other applications could be written. When initially released, it contained a set of Java Development Tools, as an example of this type of application. Later a set of C/C++ Development Tools was released. As you know, the robotics code is written in C.
The reasons, you can't just use Eclipse CDT right away are as follows:

1. Tricked you, you can, but...
2. You need to know how to write a makefile.
3. You won't get the syntax highlighting appropriate to MCC18 (the version of C used by the robot).
4. You won't get your errors from the compiler parsed.
5. Eclipse CDT can't parse the binary files (e.g., FRC_Library.lib) created by the C18 toolchain and show you the functions available inside.

Problems 2 & 4 are already fixed thanks to a plug-in I initially wrote. 2 has been fixed for a while. 4 was partially working for a while, then broke, and should be working now.
The other 2 are not working yet, but are not a very big deal. By innappropriate syntax highlighting, the only thing I can think of, is that certain keywords, such as "rom" & "ram" that are specific to the C18 version of C, aren't highlighted. Most people don't use 5 anyway (I never have).

Now why should you use Eclipse:

• My favorite, auto-completion. Hit Ctrl-Space while typing a long function or variable name, and Eclipse will show you a list of possible completions.
• Integrated Subversion/CVS support (was not available in MPLAB until very recently, and is still no where as nice)
• A tabbed editor, rather than the horrible MDI interface MPLAB uses.

And it's usable, as chris31 said on Windows and Linux. However, don't be scared off by this fact. If anything, it's more usable on Windows than Linux because there is no hassle with WINE (a sort of windows emulator to get the compiler working)

If you want more info see www.eclipse.org

Hope I answered your question,

Ben

[Nitinol]

Eclipse is unnecessarily resource hungry, a common drawback to software written in Java. Although Eclipse itself is available for multiple platforms, getting mcc18 to work on Linux is problematic as it relies on Wine, though that is a problem that can be overcome.
http://forum.microchip.com/tm.aspx?m...2&key=&#212261
There is an issue running mcc18 on 64 bit processors.

Assuming that these problems are overcome, most of the Linux community already relies heavily on Makefiles because a good majority of Open Source Linux Software is distributed as Source which requires compilation after downloading. Eclipse is indeed resource hungry, and unnecessarily large as a general purpose IDE. You're taking a general purpose IDE and using it for a specific purpose. Most of the Linux community already uses a combination of Makefiles and Emacs for nearly all of their programming needs.
Perhaps I should look into creating a pre-customized Emacs for the purpose of working with mcc18.
I've created an unfinished but functional Portable IDE-like program written in Perl, as a Test of Concept. If there's a large enough Linux community within the Chief Delphi Programming community, I can adapt this program to run under Linux, so long as they have mcc18 set up.
http://www.chiefdelphi.com/forums/sh...threadid=50708

I'm sorry I do not mean to bash anyone's project, I hope it did not seem that way.
It's still a great idea, and I would more than love to contribute to its development.
Eclipse is also a very versatile IDE, and does have several advantages over using using a few customizations in combination with makefiles.
Or some poorly written perhaps unreliable custom IDE.
(I suppose I should be allowed to bash my own project)

My apologies again.

[Astronouth7303]

Originally Posted by Nitinol

Eclipse is unnecessarily resource hungry, a common drawback to software written in Java.

I've found that Eclipse, while it does take a while to load, runs well on any system from 2000 or newer. (Milage May Vary.) Just make sure you have a decent amount of RAM. (I doubt 128MB will cut it.)

Originally Posted by Nitinol

Although Eclipse itself is available for multiple platforms, getting mcc18 to work on Linux is problematic as it relies on Wine, though that is a problem that can be overcome.

On distributions with a package manager, it's generally as easy as installing wine, grabbing the wrapper scripts, and sticking them in /bin.

There are multiple makefiles around. I use one that updates itself (uses make's variables instead of hard-coded file names). There is a script that will generate one for you. You can also use Eclipse's Managed Make to do it. (Make sure you have the mcc18 toolchain plugin installed.)

Originally Posted by Nitinol

There is an issue running mcc18 on 64 bit processors.

From the sound of it, there are only issues when you use a 64-bit operating system on top of a 64-bit processor. The 64-bit version of Windows XP is not widely used, IIRC. There are 64-bit Linux distros, but they are still somewhat unstable.

[shawger]

Originally Posted by Nitinol

Most of the Linux community already uses a combination of Makefiles and Emacs for nearly all of their programming needs.

Emacs?!?!?!?!? Vim ftw

But I agree with your point, Makefiles + text editors are definately the most flexible and robust way to go. While Eclipse is certainly better than MPlab, it has its own set of limitations which should not be overlooked.

Originally Posted by Astronouth7303

From the sound of it, there are only issues when you use a 64-bit operating system on top of a 64-bit processor. The 64-bit version of Windows XP is not widely used, IIRC. There are 64-bit Linux distros, but they are still somewhat unstable.

Yes, 64-bit Windows is virtually worthless because nobody makes decent drivers for it. Maybe that's changed with Vista.

But with Linux, 64-bit is a perfectly valid option. I'm running 64-bit Gentoo over here, and it is 100% functional and stable. Maybe some distros like Ubuntu or Fedora aren't quite as flexible when it comes to 64-bit, but 64-bit Linux should not be discounted.

[JBotAlan]

Well, I hit "no interest", then thought about it.

I would like a replacement for MPLAB, so yes, I could help beta test. I won't realistically help code on this, even though I would like to offer that.

This is a really cool project and I hope it doesn't "fizzle out".

JBot

[gnirts]

Is this project primarily going to be for development on Linux, or is this to make a drop-in replacement for MPLAB? I would be interested in using Eclipse as an IDE for code completion and possible more robust syntax highlighting, but have never really had any problems with IFI Loader or MCC18. Can I just use the IDE portion?

When is the first release coming?

Thanks,
Robinson

P.S. Did CD remove spell check from the reply form? Why do I recall being able to spell check? Or am I blind?

[chris31]

Originally Posted by gnirts

Is this project primarily going to be for development on Linux, or is this to make a drop-in replacement for MPLAB?

Because Eclipse runs on windows and linux I see no reason why there cant be a release of that also.

@Astro: You think you could get a page up where you (or whoever) can post compressed final copies of all the software as one package to make it easy for those who dont want to mess with svn.

Ill start trying to get Eclipse and the plugins working under Windows (my HD with Fedora died last week RIP old HD from an Pentium 2 Dell).

@gnirts: Yes spell check was removed. FF2 has spell check if you use that. It might come back to the forum but it also might not.

[AustinSchuh]

Originally Posted by shawger

But I agree with your point, Makefiles + text editors are definately the most flexible and robust way to go.

I have been using Wine, Debian, makefiles, and vim to program our robot for the past 2 years. I have trouble finding the correct compiler flags. Would there be any way to extract the makefile that compiles the code from the eclipse project without installing Eclipse?

[chris31]

Originally Posted by AustinSchuh

I have been using Wine, Debian, makefiles, and vim to program our robot for the past 2 years. I have trouble finding the correct compiler flags. Would there be any way to extract the makefile that compiles the code from the eclipse project without installing Eclipse?

I havent tried it, but give this a shot.

PHP Code:

#!/usr/bin/env python

#Auto Makefile Generator
#Copyright under terms of GPL
#Based on Team 245's old Makefile....
#        Copyright (C) 2005  Team 245
#
#        This program is free software; you can redistribute it and/or modify
#        it under the terms of the GNU General Public License as published by
#        the Free Software Foundation; either version 2 of the License, or
#        (at your option) any later version.
#
#        This program is distributed in the hope that it will be useful,
#        but WITHOUT ANY WARRANTY; without even the implied warranty of
#        MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#        GNU General Public License for more details.
#
#        You should have received a copy of the GNU General Public License
#        along with this program; if not, write to the Free Software Foundation,
#        Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.


import os

DEBUG=False
VERSION="0.1.92 (0.2 beta 3)"

def printGPLBanner():
    print "Makefile Generator, version "+VERSION+", Copyright (C) 2005 Adam-Bots"
    print "This software comes with ABSOLUTELY NO WARRANTY"
    print "This is free software, and you are welcome to redistribute it under certain conditions; See the accompanying license for details"
    
def isCygwin():
    import os;
    return os.platform=='cygwin'

def isLinux():
    import os;
    return os.platform.beginswith('linux')

def mccPath():
    #Find path to the MCC folder.
    if isCygwin():
        pass
def sprint(msg,level=0):
    # Prints a message of a given verbosity:
        #Level 0 : Print regardless of status
        #Level 1 : Print if DEBUG is set
    if level == 0:
        print msg
    elif level == 1:
        if DEBUG:
            print "DEBUG:",msg
    else:
        print msg
def mccCommand():
    return "mcc18"
def mccArgs():
    return "-D_FRC_BOARD -w3 pa=3 -O+ -nw=2066"
def linkerCommand():
    return "mplink"
def mp2hexCommand():
    return "mp2hex"
def ifiLoaderCommand():
    return "picloader_textmode"
def ifiSerialDevice():
    return "/dev/ttyS0"
def ifiReadLogfile():
    return "./read.log"
def codePath():
    unixish_path="Z:"+os.getcwd()+"//"
    return unixish_path.replace("/","\\")
def libPath():
    return "/opt/mcc18/lib"
def includePath():
    return "/opt/mcc18/h"
def includePathWindows():
    return "Z:\\\\opt\\\\mcc18\\\\h"

printGPLBanner();
print
print
print

sprint("Opening the Makefile",1)
print
outfile=open('Makefile','w')
outfile.write('#This is automatically generated by the configure.py script\n#Keep your dirty hands off');
outfile.write("\n")
outfile.write('#Run ./configure.py to generate a fresh one.')
outfile.write("\n")
outfile.write('MCC18='+mccCommand())
outfile.write("\n")
outfile.write("PIC=18F8722 # Don't change")
outfile.write("\n")
outfile.write("ARGS="+mccArgs())
outfile.write("\n")
outfile.write("LINKER="+linkerCommand())
outfile.write("\n")
outfile.write("MP2HEX="+mp2hexCommand())
outfile.write("\n")
outfile.write("IFILOAD="+ifiLoaderCommand())
outfile.write("\n")
outfile.write("SERIAL_DEV="+ifiSerialDevice())
outfile.write("\n")
outfile.write("READLOG="+ifiReadLogfile())
outfile.write("\n")
outfile.write("LIB_PATH="+libPath())
outfile.write("\n")
outfile.write("CODE_PATH="+codePath())
outfile.write("\n")
outfile.write("INCLUDE_PATH="+includePath())
outfile.write("\n")
outfile.write("INCLUDE_PATHW="+includePathWindows())
outfile.write("\n")
outfile.write("\n\n\n\n")


sprint("Enumerating Target Object Files...")
import os;
all_targets=""
pipe=os.popen("find . -maxdepth 1 -name \"*.c\" | gawk '{gsub(/\\.c/,\".o\");print}' | uniq",'rt') 
line=pipe.readline()
while line != "":
    all_targets+=line[2:-1]
    all_targets+=" "
    line=pipe.readline()

all_targets.rstrip()

outfile.write("ALL_TARGETS="+all_targets);
outfile.write("\n")
sprint("Enumerating Header Files...")

pipe=os.popen("find . -name \"*.h\"",'rt')
line=pipe.readline()
headers=""
while line != "":
        headers+=line[2:-1]
        headers+=" "
        line=pipe.readline()
headers.rstrip()


outfile.write("INCLUDE_FILES="+headers);
outfile.write("\n")
outfile.write("############ Targets: ")
outfile.write("\n")
outfile.write("default: FrcCode.hex")
outfile.write("\n")

sprint("Writing static targets...")
outfile.write("""
#Remove all the individual file backup (The files ending with ~)
#NOTE that this does NOT remove your tbz2 backups!
clean-backup-files:
    @echo -e "Removing all the ~ backup files your annoying editor makes..."
    @find . -name "*~" |xargs rm -f

#Removes all compiled files from the directory
clean: clean-backup-files clean-deps nohex
    @echo -e "Cleaning compiler intermediate files..."
    @rm -rf *.o *.err

#Remove deps folder
clean-deps:
    @echo -e "Cleaning dependency folder..."
    @rm -rf .deps
    @mkdir .deps
    @touch .deps/dummy

#Remove hexfiles
nohex:
    @echo -e "Cleaning linker output and hex files..."
    @rm -rf *.hex *.cod *.cof

#These all start the IFI Loader.
safeload: prettycode clean check load
load: FrcCode.hex
    $(IFILOAD) FrcCode.hex $(SERIAL_DEV)

read:
    @echo -e "Monitoring $(SERIAL_DEV) for data"
    @echo -e "Output will also be logged to $(READLOG)"
    @echo -e "---------"
    @cat $(SERIAL_DEV) | tee $(READLOG) || /bin/true
    
    
prettycode:
    @echo -e "Using indent to autoformat your .c and .h files..."
    @indent *.c *.h
all: clean FrcCode.hex
%.o: %.c
    @echo -e "Compiling $@..."
    @echo -e "1.   Checking Dependencies for $@"
    @cpp -nostdinc -isystem $(INCLUDE_PATH) -M -MP $< -MF .deps/$*.deps
    @echo -e "2.   Launching Compiler..."
    @echo -n "A thought to keep you occupied:  "
    @fortune -s || echo "GET FORTUNE"
    @$(MCC18) -p=$(PIC) -fo $@ $< /i\\""$(INCLUDE_PATHW)"\\" $(ARGS) 
    @echo -e "Done with $@."




FrcCode.hex :  $(ALL_TARGETS) $(INCLUDE_FILES)
    @echo -e "Linking..."
    $(LINKER) /l\\""$(LIB_PATH)"\\" \\""18f8722.lkr"\\" $(ALL_TARGETS) \\""$(CODE_PATH)FRC_library.lib"\\" /m\\""FrcCode.map"\\" /o\\""FrcCode.cof"\\"
    $(MP2HEX) FrcCode.cof



.deps/*: 
    @echo -e "Creating Dependency Makefiles..."
    @mkdir -p .deps
    @touch .deps/dummy
    @echo -e "Done!"

include .deps/*
""")
print
print

sprint("Makefile is generated, setting up working directory....")
os.system('rm -rf .deps')
os.system('mkdir .deps')
os.system('touch .deps/dummy')

print
print
print

sprint("Finished. To build, run 'make'") 


EDIT: I got Eclipse up and running on my XP laptop. I got it compiling code and all. Ill be grabbin a copy of Astros code and making sure it all runs on windows.

[Astronouth7303]

I got a basic distro of Eclipse, CDT, and the toolchain up.

Win32 - Eclipse 3.2.1, CDT 3.1.1, MCC18 toolchain (com.astro73.fdt version) (130.6 MB)

This package is for Windows. This should allow teams to get started using Eclipse quickly. All settings are at defaults.

NOTE: This package does not include Cygwin Make. You must have either Cygwin make or a native Win32 Make. MinGW Make will not work. If you get errors about being unable to find "W:\" or similar, you are using MinGW Make.



To make your own version:

1. Download the eclipse archive, extract
2. Download the CDT archive file, extract to the same location
3. Grab the com.astro73.fdt.mcc18.toolchain JAR file from the above file and put it in your plugins dir
4. Compress the entire directory.

[edit]This project got approved on sourceforge: https://sourceforge.net/projects/firstclipse/. No code up yet, but the project's there. I'll save the joining process for another post.[/edit]

[Astronouth7303]

First, I forgot to say that mirroring the download is ok.

I've moved the subversion to SourceForge, and the jar file for what I posted earlier is in the downloads section on the project page.

If you want commit access, you will need a SourceForge ID. Please send that to me and I will add you to the project.

In order to develop the plugins, you will need:

• Eclipse SDK 3.2+
• Eclipse CDT SDK
• Subclipse (use the instuctions for Callisto)
• PyDev (only needed if you want to work on the wrapper scripts)

Note that if you just installed PyDev, you need to go to the preferences and configure your interpreters.

Instructions on loading the projects:

1. Go to File > New > Project...
2. Select SVN > Checkout Projects from SVN. Hit Next.
3. Select Create a new repository location. Hit Next.
4. Enter https://firstclipse.svn.sourceforge....ot/firstclipse as the URL. Hit Next.
5. Accept the SSL fingerprint (I recomend permanently)
6. When asked for the folder, select everything under trunk (except for mcc-wrapper if you're not dealing with the Python stuff).
7. Hit Finish.
8. Wait. It will probably take awhile. Grab another dew. Brew some coffee. Think about how awesome this will be when done.

When all is said and done, you should have 6 plugins, 1 site, 1 feature patch, and maybe 1 other project (mcc-wrapper).

Almost all of it is just framework. Hardly any real code.

Notes:

• This is the bleeding edge. It may not always work or even compile.
• I recomend setting your workspace to UTF-8, but this is not required.
• Please use the Java 1.4 compiler.