What language do you use?

[Qbranch]

Robotics: C
General Purpose Embedded: C
Fast Routines: Assembly
School: Java
Calculator: TIbasic and C (yes, there is a compiler)
Quick/Dirty Interfaces and I/O: VB6 (NOT .NET), C++, or QB

-Q

[gobeavs]

Robotics: C
Most other things: Ruby

Learning C# though as a sort of middle-ground.

[Cjmovie]

Robotics: C
Simple Programs: C+ (Yes, C and C++ mixture. If you can call it that)
Complex Programs: C++
Web Development: PHP, SQL (MySQL), XHTML, CSS, Javascript
Low-Level (Such as OS-DEV): x86 ASM
School: Java (which I used to hate with a passion; not so much anymore)

Among other things...
SX Assembly for the SX52 Microcontroller (Crazy thing, 80MHz! You can write a video kernel in it - software black and white NTSC :-) )
And I've experimented with many C-based scripting languages.

[Tom Bottiglieri]

C#

[dcbrown]

MICRO32 , for low-level h/w bit pushing projects
MACRO32, for assembler level
BLISS for high level...

Of course my first "electronics" class in high school votech did involve 6.3VAC and filaments....

But seriously, any programming language can be used... it is how you use it that counts as long as the resulting run-time execution profile, code size, or data space used doesn't put you at a disadvantage over some other language or tool.

Personally, I always look at the assembler generated by the compiler to see if I'm using things correctly to match the processor architecture. If a line of C code is compiled into 30-40 instructions, then I probably didn't choose the best programming method for solving the problem. For example, in one piece of code I just finished I needed to walk an array and move all the entries up one until some end condition. Putting the code in a loop looked good in C - nice and compact - until I looked at the compiled code. It took some 196 cycles on average to do all the array indexing computations, move the data around, and do end condition check for just 2 array entries with the for loop. In contrast, unwinding the for loop across the whole array

array[0] = array[1];
array[1] = array[2];
...

takes only 64 cycles to always move the whole array even though its like 8-10x more C code. The particular chunk of code started life as a singly linked list structure, but computationally it was just too expensive in terms of compiled code size and execution time. Building a lookaside/ordered index table as a companion to the data structures was much more effecient on the current processor in this case.

The argument of using oop or this or that os is often moot - none of those run very well at all on the current architecture. Moving to a processor that does run linux, say, still doesn't begin to address the issues introduced by using a full blown os; namely no pre-emptive scheduling and very long latency issues in terms of use within a real-time system such as a robot. Yes, there are flavors and changes you can make to get linux to almost be rtos capable, but that typically means either throwing some serious h/w at it or reduction of kernel services to something that means you're really not running linux but some strangled subset there of.

The flip side is learning to program well with an architecture that is both powerful and weak at the same time.

The test of learning to program well is capitalizing on the PICs strengths while recognizing and avoiding its weaknesses as much as possible. If you can do this using some other language or interface - great! Go for it! But for now, I'll stick to C and EasyC as both put me only at a slight disadvantage over assembler if the proper programming method is found and utilized.

Bud

[cjelly]

For the robot I code in C. Last year, we started a dashboard in VB.NET (that was the main language that my friend and I knew) but eventually converted over to C# after discovering dashboard code that already had most of the work done on it (it was posted on ChiefDelphi somewhere).

Personally, I used .NET for a while, but I found that everything Microsoft makes for development products (that is worth using that is) is very expensive. I do like the express editions of .NET 2.0, but they are somewhat limiting, especially SQL Server Express.

For a job I was doing last year I was forced to switch over to PHP running on an Apache server with a MySQL database backend, and it was so much less restrictive than Microsoft, it was free, and it was more logical I found. I ended up switching my hosting from Microsoft Hosting (on IIS) to Linux Hosting (on Apache).

[Jake M]

Personally, I always look at the assembler generated by the compiler to see if I'm using things correctly to match the processor architecture.[/quote]

Not to sound like an idiot, but how do you do this? I know assembly language quite well, but I never really found an application for it in practical programming. Is there a way to do this in FRC programming as well?

[Astronouth7303]

Originally Posted by Jake M

Not to sound like an idiot, but how do you do this? I know assembly language quite well, but I never really found an application for it in practical programming. Is there a way to do this in FRC programming as well?

Use the list file. It's optionally generated by the linker.

[dcbrown]

In MPLAB IDE, View->Disassembly Listing or View->Program Memory.

If using Program Memory view, I select the "Symbolic" tab at the bottom of the window.

For example,

void EventHandler_Remove( void )
{
unsigned char ndx;

    for (ndx=0; ndx<MAX_EVENT; ndx++)
    {
	EV_Links[ndx] = EV_Links[ndx+1];
	if (EV_Links[ndx] == 0xFF ) break;
    }
    return;
}

Generates 33 instruction cycles per loop plus 9 instruction cycles of overhead/setup. It could take a maximum of 537 instruction cycles to complete if the event array is full.

526:                   for (ndx=0; ndx<MAX_EVENT; ndx++)
  6002    6ADF     CLRF 0xfdf, ACCESS
  6004    0E10     MOVLW 0x10
  6006    5CDF     SUBWF 0xfdf, W, ACCESS
  6008    E21D     BC 0x6044
  6040    2ADF     INCF 0xfdf, F, ACCESS
  6042    D7E0     BRA 0x6004
527:                   {
528:               	EV_Links[ndx] = EV_Links[ndx+1];
  600A    28DF     INCF 0xfdf, W, ACCESS
  600C    6AEA     CLRF 0xfea, ACCESS
  600E    0FE0     ADDLW 0xe0
  6010    6EE9     MOVWF 0xfe9, ACCESS
  6012    0E07     MOVLW 0x7
  6014    22EA     ADDWFC 0xfea, F, ACCESS
  6016    50EF     MOVF 0xfef, W, ACCESS
  6018    6EE6     MOVWF 0xfe6, ACCESS
  601A    50DF     MOVF 0xfdf, W, ACCESS
  601C    6AEA     CLRF 0xfea, ACCESS
  601E    0FE0     ADDLW 0xe0
  6020    6EE9     MOVWF 0xfe9, ACCESS
  6022    0E07     MOVLW 0x7
  6024    22EA     ADDWFC 0xfea, F, ACCESS
  6026    52E5     MOVF 0xfe5, F, ACCESS
  6028    50E7     MOVF 0xfe7, W, ACCESS
  602A    6EEF     MOVWF 0xfef, ACCESS
529:               	if (EV_Links[ndx] == 0xFF ) break;
  602C    50DF     MOVF 0xfdf, W, ACCESS
  602E    6AEA     CLRF 0xfea, ACCESS
  6030    0FE0     ADDLW 0xe0
  6032    6EE9     MOVWF 0xfe9, ACCESS
  6034    0E07     MOVLW 0x7
  6036    22EA     ADDWFC 0xfea, F, ACCESS
  6038    50EF     MOVF 0xfef, W, ACCESS
  603A    08FF     SUBLW 0xff
  603C    E101     BNZ 0x6040
  603E    D002     BRA 0x6044
530:                   }
531:                   return;
  6044    D005     BRA 0x6050

This is executed at interrupt time and looks a bit wordy. An alternative is code that does the following:

void EventHandler_Remove( void )
{
    EV_Links[0] = EV_Links[1];
    EV_Links[1] = EV_Links[2];
    <snip>
    EV_Links[15] = EV_Links[16];
    return;
}


533:                   EV_Links[0] = EV_Links[1];
  6046    C7E1     MOVFF 0x7e1, 0x7e0
  6048    F7E0     NOP
534:                   EV_Links[1] = EV_Links[2];
  604A    C7E2     MOVFF 0x7e2, 0x7e1
  604C    F7E1     NOP

This generates 32 instruction cycles for processing the whole array. So this code has more C code but executes faster than even the minimum 1 time through the arrray using the for loop. Although I can easily read the code and what it is doing, I'm really only interested in instruction counts. If the instructions being generated for each line of C code look a bit high in count, then I usually investigate and possibly re-think what I'm doing based upon how often the code is being executed and how time critical the code is. One of the weaknesses of the PIC18F architecture is array and pointer manipulation - for example - but there are other programming methods of organizing and processing the data to avoid or mitigate those weaknesses.

Bud

[something]

C - Robotics
C++ - most x86/x86_64 stuff
assembly - small PIC projects
English - general human interaction

David

[drakesword]

c & asm -> FIRST
Java -> most complicated projects
Basic 6.0 -> Simple apps for testing purposes
Basic .NET -> Refigned version of above
C++ -> DirectX
LUA -> Gmod (hey its a language)

I would really like to see the Java TinyVM used on the FRC, but thats just a dream.

[matt 1923]

[AustinSchuh]

I use C mostly. I want to learn an interpereted language, but haven't invested the time to learn one. Ruby sounds cool from what my brother has done with it. He created a simulator that takes input from the OI dashboard to drive a robot on the screen rendered with OpenGL.
I also use GTK+ under Linux for graphics.
I have been using latex for typesetting. It is a programing language specifically designed for making nicely formated (math or english) papers which are compiled into pdf and ps files for viewing.

[ace123]

I would say Python all the way for an interpreted language.

The other day one of the programmers on my robotics team was asking about how to check if his joystick curve function was working. I was able to rewrite a prototype function in a python editor, stick a for-loop at the bottom the file, and run it, all in about 1-2 minutes (he was still explaining to someone about how it would or wouldn't work when I finished).

The really nice thing about Python is that it has hundreds of *useful* library functions, especially in the string and math realms. It has native BigInt support, and much else.

One problem is that it has no strict typing. This can also be a huge benefit if you are trying to use code intended for one thing for a completely different purpose.

I actually learned python as a scripting language for Vega Strike, but I'm so glad I know it now. Perl feels less "right" than python... too much syntax, and not enough sense to it.

Also, I would say C++ for best compiled language... It has a pretty nice library of functions, it's native, and it runs all C libraries with few hassles. It has some methods for garbage colleciton, and a lot of other features that make it really generous for a compiled language.

Speaking of C++, I've heard Objective-C (I've never used it however) is a nice language (though it hurts my eyes to look at it). It supposedly now has garbage collection support, yet it's compiled. I wonder how they did that...

Java and PHP are okay... but they feel messy. I used to really like PHP for web development, but I learned about Django which is a much more structured web development method written in Python.