K8055 with Windows 7

I’ve just bought a new PC with WINDOWS 7 and want to get my K8055 card working again!
The old computer used WINDOWS XP.
The Velleman disk containing the K8055 software dates from October 2009 and is marked VPDC4. Although I can see the files using WINDOWS 7, set-up is ‘incompatible’ and I cannot use it.
Can I download updated software or get a disk?
Thanks in anticipation.

Here is the link to download the latest software package for the K8055:
velleman.eu/downloads/files/ … rsion4.zip

Just extract the package.
When extracted, copy the file K8055D.DLL from the folder \DLL_v4.0.0.0 to the \Windows\System32 folder.
In 64-bit environment copy the file to \Windows\SysWOW64 folder.

Hi, I’m new here.
I wanted to say thank you in advance for the wonderful support on this forum. It helped me a lot!
But I still have a question, I’ve searched the forum for it but I couldn’t find the solution.

I soldered my k8055 2 days ago and have tried to make a simple c++ console application ever since.
I succeeded a few hours ago by making a win 32 console project in Visual C++ Express on my XP 32-bit laptop.
To make the application I used the old dll, header and library-files (the k8055d_c ones).

Afterwards I tried to make the same application on my windows 7 64bit computer (with the k8055d_c files).
I let the exe run, but nothing happened on the interface card.
I read on the forum that you needed to have the new dll and header files in order to let the card do its work.
So I replaced the old dll, header and lib-files with the new ones from the newest K8055DemoBCB.

While compiling the error “corrupt library file” showed up. So my question is, is this a good library file from the
K8055DemoBCB example? Or is it really corrupt?

This is the link to the K8055DemoBCB with the (for me) corrupt library
velleman.eu/downloads/files/ … rsion4.zip

and this is my project from Visual C++ with the old files (this worked on the 32 bit system):

Sorry for the bad download site (waiting time).

Thanks in advance,


The .lib file is not corrupt but it is only for the Borlabd C++Builder and it is not compatible with Microsoft C++.
Borland and Microsoft have different formats for their lib files.

There in the latest K8055 software package is no .lib file for the Microsoft C++.

Instead you may use explicit (run time) linking to the DLL.
Please see the example in the subfolder \examples\K8055DemoDevC
There is a simple C++ console application for Bloodshed Dev-C++.
I think you may easily modify the source code for Microsoft C++ compiler.

In this thread there is another example code using explicit linking. It is for other product but you see the principle: viewtopic.php?f=3&t=4063

Here you’ll find instructions how to use the explicit (run time) linking: http://msdn.microsoft.com/en-us/library/784bt7z7(VS.71).aspx
Please check also this link how to use GetProcAddress: msdn.microsoft.com/en-us/library/64tkc9y5.aspx

Thanks for the fast reply!
I will definitely try the explicit linking method. I saw it in your Timer example too.
But I’m new with c++ so I first wanted to try and make it work the easy way.

Thanks so much!

EDIT: It works perfectly, thanks!

Thanks to VEL255 for the support! I’m not an expert and will ask my son to carry out the work in due course.
Thanks again.

Hi Simon,

I still cannot find the source code for your K8055 firmware anywhere on your pcusbprojects Google site. Can you tell us where you published that?


Please, look at PC USB Project Expert Advice Section: https://sites.google.com/site/pcusbprojects/9-ask-the-expert

Interesting, the “additional features” on this page read like a 1:1 copy of the Open8055 firmware features.

sites.google.com/site/pcusbproj … is-website

PS: On re-reading this I realized that you actually copied the Open8055 firmware features as a “question”. It is almost a verbatim copy of this forum post: viewtopic.php?f=3&t=7480&start=105#p35936

You only reworded the first two sentences to refer to your particular firmware.

Maybe the text of the answer on my website, was not written clearly enough for everyone to realize the major differences between Open8055 and PC USB Projects K8055(N) support… Now, this was corrected and the information was updated…

All the VB.NET source code is available for free… PC USB Projects is not a 1:1 copy of the Velleman FW, it offers much more functionality, while retaining backwards compatibility. There are many examples that vastly supersede the functionality that you mentioned. My FW has also been extended from the time of the Q&A that you mention in your post. Please, see my Programming guides for PIC18F2xJ50 and PIC32MX250F128B microcontrollers for more information.

  • Important commands have been added to HID, like:
    = DataMemRead()

These enable accress to all µC functionality through its internal functional units registers. The original Velleman FW and other open FW that emulates it only allow very limited functionality. Emulation is supported by the FW on this site, but the priority is to support much more functionality.

  • native 32-bit and 64-bit Windows support (64-bit DDLs)
  • microcontroller programmer support functions (ICSP and JTAG) which enable you to make your own microcontroller programmer
  • I2C bus support and advanced digital sensors support
  • much more…

There is also support for 32-bit PIC32MX250F128B microcotnroller (including adapters for K8055 and K8055N), which is also in a 28-pin chip, but much more advanced than an 8-bit PIC18F24J50… I hope this answers your question and that this post does not get deleted by a “higher force” (i.e. forum editor).


I wonder if you ever actually implement what you claim is possible with your firmware. On your website you claim that “You can easily operate servo motors in different configurations, either through PWM driven DACs, or directly through one of the other 3 PWM modes”.

Standard hobby servos operate at a PWM frequency of 40-60 Hz with a pulse width of 1 to 2 ms (sometimes a wider range is accepted). Even the cheapest servo packs 256 steps into that one millisecond. If I do some math on that, at the average of 50 Hz, the PWM period is 20 ms. The range of control is only 1/20th of that, the range between 1 and 2 ms. At 10 Bit PWM resolution, the whole 20 ms is divided into 1024 steps ranging from 0 to 100% duty cycle, but the servo control signal only uses 1/20th of that, which leaves you with only 50 steps to control the servo’s position, not the full 256 step resolution, the servo has. And better servos have up to 1024 steps resolution.

Regardless of all that, the PIC18F* micro controllers cannot produce a PWM frequency that low. The PWM frequency is calculated as 1 / ((PMR2 + 1) * Tosc * [TMR2 Prescale]). At Fosc = 48 Mhz, PMW2 = 255 and prescale 1:1, that is a “minimum” of 46.875 KHz. Roughly 1000 times the frequency, a standard servo understands. Even with the maximum prescaler of 16, which would mean to sacrifice precision, you don’t get that low. Or are you running on something other than Fosc = 48 MHz?

How in the world are you controlling a standard servo with your firmware?

To set TIMER2 prescaler to 1:16 just use the following commands in VB.NET:

Dim PIC As SVLib_PIC18F24J50.SVPICAPI = New SVLib_PIC18F24J50.SVPICAPI ’ initialization of PIC object
Dim x as Integer

if x>=0 then
x=x or 3
… error reading register memory …
End If

You can basicaly do anything that your PIC18F or PIC32MX VB.NET SW and microcontroller FW and HW can do together… Low frequency PWM signal generation much is easier than generating high frequency PWM signals… You can easily do low frequency 16-bit or 32-bit PWM for servo motors in a Windows or Linux thread using just two basic I/O commands: PIC.SetDigitalChannel(x) and PIC.ClearDigitalChannel(x) or PIC.SetPin(x) and PIC.ClearPin(x)… There is a choice of 8 such digial channels on each K8055 or K8055N experiment board…

ALSO READ: The original Microchip document: DS39931D (PIC18F46J50 Data Sheet that also applies to PIC18F2xJ50 microcontrollers)… See pages 211, 212, 251, 253+ … It is clear that PWM frequences in a range of a few kHz may be easily obtained. Available enhanced PWM configurations for stepper motore are described on page 253 of the data sheet.

If this is not enough, simply use a much more advanced PIC32MX250F128B microcontroller with 16-bit PWM resolution … All the HW and VB.NET support is also available from PC USB Projects website…

This is entirely wrong. The limit of 1 HID output message per millisecond and the uncontrollable USB latency makes this impossible.

Right kilohertz, not hertz. So you are not controlling a servo, you are controlling stepper motors instead. That explains it.

I understand.

If you need 1-channel 32-bit low fewquency PWM generator in FW, buy a PIC18F26J50 and go to Downloads section on PC USB Projects and get:

and go to: https://sites.google.com/site/pcusbprojects/4-velleman-experiment-board-k8055-pic-replacement/v-pic18f26j50-low-frequency-pwm-generator

PIC18F26J50 fits directly to your K8055N-2 board. Simply use a screw driver or other tool to replace the chip…

If you need an 8-channel 32-bit low frequency PWM generator in FW, buy a PIC32MX250F128B and go to Downloads section on PC USB Projects and get:

  • SVPIC32F250F128B IO Module v2.7.4 - all subversions.zip
  • 8-channelLFgenerator.zip or 8-channelLFgenerator x64.zip
    Its realy fun to drive 8 servo motors with a single chip… You can also plug in a cristmas tree…

Read more here: https://sites.google.com/site/pcusbprojects/4-velleman-experiment-board-k8055-pic-replacement/u-8-channel-low-frequency-pwm-generator

I use a PIC32MX250F128B to K8055 experiment board adapter, also avalilable for free from my website… PIC32MX250F128B is light years more advanced than an 8-bit PIC18F24J50…
I must stress that it is all in firmware… So, PC may disconnect when the configuration is loaded into RAM… It works like a clockwork… The operating range is from zero to about 90 kHz, but you can easily get 20 Hz, 50 Hz, 100 Hz, 200 Hz … 2 kHz on all 8 channels…

I think a PIC32 is total overkill for such a trivial application. Especially when a PIC18F2550 or 25K50 can do the job just fine and can be used on a P8055N-2 board without any hardware modifications at all.

If you think so, just use a PIC18F2550 with my firmware https://sites.google.com/site/pcusbprojects/4-velleman-experiment-board-k8055-pic-replacement/w-velleman-k8055-1-board-easy-upgrade

By the way:

Bill Gates ones stated: “640K ought to be enough for anybody”. Today’s PCs have abundance of memory and computing power compared to the previous generations of PCs and they cost equal or less, but we still use them to write simple texts that we could easily type on 15 years old computers with Windows XP… But it is more fun to have nicer graphics and nice gadgets that come with Windows 7 and Windows 8…

The same holds for microcontrollers: [color=#FF0000]PIC32MX250F128B costs almost the same.[/color] It has the same 28-SDIP casing. It has similar functional units, but many of them are much more advanced versions that enable much higher precision of output signal generation and much better input signal analysis… It is easily accessible from a VB.NET application with the DLLs and HEX files provided on PC USB Project website… It is just a lots more functionality for an euro more… Backward compatibility with PIC18F24J50 and K8055N is provided… So I see no reason, why not… But if you have storage full obsolete 8-bit microcontrollers and an obsolete microcontroller programmer it is entirely your problem… I would not use a PC XT today. The biggest problem with PIC18 is the lack of RAM… By the way… Many people think that you need to modify K8055 or K8055N PCB to connect a PIC32MX250F128B adapter, but in fact this is not true… You just remove the obsolete PIC16C745 or PIC18F24J50 and plug in the adapter… The adapter is really cheap to build… As much as I know, you have to modify the PCB to connect PIC18F2550 and you cannot program it without taking it of the PCB… PIC18F24J50, PIC18F265J50 and PIC32MX250F128B all use low programming voltage and can be easily reprogrammed in place with your own programmer or PICkit3. But, if you are building your own circuit (without K8055 or K8055N), it is almost no difference in the number of electrical elements, if you use PIC32MX250F128B, or PIC18F24J50…
Anyway, PIC18F26J50 FW version with a low frequency generator will be provided soon, since the already working C++ functions for PIC32MX250F128B will have to be just a little optimized to use less RAM…

By the way! How many independent LF PWM channels do your FW support? Or, how many servo motors can your FW drive? One or more?


The P8055-1 board needs minimal modifications. The USB low speed pull up resistor R35 must be removed. When using the PIC18F25K50, no further modifications are necessary as the PIC has an accurate enough internal oscillator and can ignore the 6 MHz crystal. When using a PIC18F2550, the crystal needs to be replaced with a 4 MHz one.

Zero modifications are necessary for the P8055N-2 board.

I use the 2550 or 25K50 since both have 256 bytes of EEPROM. I plan to implement functionality that uses the EEPROM for startup configuration and settings. For example, one could configure the PIC so that it on power on uses digital outputs 1-4 in servo mode and set to neutral (1.5 ms pulse width) or some other values.

Both chips are pin compatible and no adapter is needed. They simply replace the original PIC.

The Open8055 firmware is currently written to be used with the HID boot loader. Once that is programmed with a PicKit3 or similar, the chip stays on the board and can be reprogrammed with new firmware via USB, very fast and easy. It might be worthwhile to switch to the Microchip boot loader. I believe that one can even be used from within the IDE, but I haven’t checked that yet. Also the P8055N-2 board has an ICSP header, so no chip removal necessary even if you don’t want to use a boot loader. The PicKit3 programmer is supported by the Microchip IDE.

The Open8055 firmware drives up to 8 servos on the digital output ports. The firmware uses interrupts for the precise timing of less than +/- 1 microsecond for the pulse length. It does not use the CCP modules for that, so the regular two PWM/DAC outputs are still available to be used for motor control or other applications. The firmware also continues to produce the last output signals when it is connected to a powered hub and the PC is disconnected/powered off. This whole setup can be used to build stand alone micro controller experiments.

With all its functionality, the Open8055 firmware doesn’t even use half the memory of a PIC18F2550 yet. This might have to do with the fact that my programming experience goes back to the time, when 64 KB RAM in a desktop computer were considered a lot. When working with micro controllers, I just go back to the programming habits that we used to have in those days.

BTW, I found that the K8055 and K8055N have so much noise on the supply rail, which is also used as ADC reference voltage, that 10 bits precision are not really achievable. The Open8055 firmware currently does use 10 bits and continuously samples both ADC channels (also using interrupts). An HID report can at the most be sent once per millisecond, so the firmware calculates the average of all measurements since the last HID report was sent. Not optimal but better than just taking one sample.

My designs need no modifications of PCB at all, except for PIC18F2550 and K8055-1 board: https://sites.google.com/site/pcusbprojects/4-velleman-experiment-board-k8055-pic-replacement You just plug in a newly programmed chip PIC18F24J50 or PIC18F26J50 or an adapter with PIC32MX250F128B. You can always return the original chip with a simple replacement. No soldering, no risk of damaginig the expensive Velleman PCB… You can also program and debug all three chips above “on the fly” with PICkit3 through SK9 connector, or connector on the PIC32MX250F128B to K8055 or K8055N adapter (see the adapter specifications on PC USB Projects website)…

PIC32MX250F128B FW uses interrupts, too.

Let me explain about the bootloader… If one has an intention to program the microcontroller in VB.NET, C#.NET or C++.NET he or she would probably not need to program the microcotroller directly. However, PC USB Project PIC32MX250F128B firmware allows entering new programming code in RAM as well as into EEPROM. The appropriate USB commands are already available. Entering user defined exectable code into RAM enables one to check the design prior to programming the code into EEPROM. It much easier to generate locations independent executable code for PIC32MX250F128B than PIC18F microcontrollers, where there are many limitations posed by Harward CPU architecture. PIC32MX250F128B has the same basic architecture as a PC or an Apple Mac… When you have your code in place, you have just to run it…

QUOTE: “BTW, I found that the K8055 and K8055N have so much noise on the supply rail, which is also used as ADC reference voltage, that 10 bits precision are not really achievable. The Open8055 firmware currently does use 10 bits and continuously samples both ADC channels (also using interrupts). An HID report can at the most be sent once per millisecond, so the firmware calculates the average of all measurements since the last HID report was sent. Not optimal but better than just taking one sample.”

You should check your PC’s (or the workstation’s that you use) power supply, or the USB cables that you use. I use quality USB 2.0 cables and a quality 650 W power supply in my PC and I have never experienced such problems. 10-bits A/D conversion is easily achievable, if you setup the microcontroller’s ADC according to Microchip’s specifications. It is important to know that all sound cards and inbuilt sound chips on PC’s motherboards work from 16-bits up to 32-bits precision and they also do not experience such problems

So, where is your design advantage?

You cannot possibly use any of the J chips on an unmodified K8055 board. It supplies 5V to Vdd and the J chips are designed for 3.3V. You would damage the chip. The PIC18F2550 and PIC18F25K50 can run on both, 3.3V and 5V.

You also cannot possibly use full speed USB with an unmodified K8055 board. R35 forces the USB connection to be low speed. It must be removed.

Your claim “No soldering, no risk of damaginig the expensive Velleman PCB” therefor can only apply to the K8055N. Quite honestly, I think someone who has successfully assembled the K8055 is not going to “damage” the board when removing one resistor.

Code doesn’t go into EEPROM, it goes into Flash. With the Flash being good for guaranteed 10,000 programming cycles (in reality you get many more), there is very little advantage of running code in RAM first. Especially if the chip can be flashed with a boot loader over USB.

The advantage of using a pin compatible PIC is that one doesn’t need an adapter. An adapter means completely unnecessary extra cost.

If you want to use a PIC18F24J50 or a PIC18F26J50 microcontroller on a K8055 board, you have to use a simple adapter from PC USB Projects website, because it is not entirely pin compatible with PIC16C745.
But you still do not need to modify your K8055 experiment board: [color=#FF0000]No soldering on the original Velleman PCB![/color] [color=#FF0000]The adapter works with USB 2.0 full speed, [/color]so you even make your K8055 board to communicate with your PC much faster… You just make the adapter and you plug it in… That’s it… If you want to remove it, you take it out and you replace it with the original chip… I suggest that you closely observe the numerous photos on my website.
The fact is also that if you program a microcontroller in place, it is 2 or 3 times faster than if you have to pull out the chip every time you need to reprogram it. K8055 board lacks this connector, but my PIC32MX250F128B adapter has it. It is also easy to add such a connector to the PIC18F2xJ50 to K8055 adapter… No wonder, why K8055N boards were designed with SK9 connectors. The connectors perfectly fit to PICkit3 though Velleman has never officially described their real purpose. But it is clear to me that if you want to program K8055N board, you can do it directly via SK9 connector with PICkit2 or PICkit3. You need no bootloader or programming header… You can also do it without ever removing the microcontroller. Debugging in place is also a big plus… With PICkit3 you can even debug in real time… It’s at least 10 times faster than classical programming…, because you can instantly see what is not working in your code…

Even more: Uploading an executable code to microcontroller’s RAM speeds up debugging (no time needed for programming the microcontroller EEPROM) and greaty widens the posibilties to use different algoritms. Suppose that you are building a truly universal microcontroller (not just for Microchip microcontrollers) and all kinds of (E)EPROMs programmer… There are so many different programming algorithms that they could hardly all fit into the microcontroller’s EEPROM, but they can be easily uploaded from a PC any time you need them…

So, where is your design advantage?