Scoreboard Schematic

Scoreboard PCB

Circuit

Circuit is pretty straight as you can see. An external C/C power supply is needed to power the circuit. There is a voltage regulator so the supply in this case can be up to 15V (I didn’t measure consumption yet). The regulator has its respective capacitors in the input and output, used as filters. The bluetooth module and the microcontroller are connected through a single wire between module’s UART TXD and the PB5 pin of the ATtiny fused as an input (read more on Part 2 of this series).
A blue led with a resistor is attached to PIN24 of the bluetooth module, it will blink while the module is waiting for a connection and keep on when a connection is established, that’s using the default module firmware linvor1.5 that comes pre-programmed from DealExtreme, if you buy a different module or use a different firmware, you will need to review all the pin connections. According to the bluetooth module datasheet (at least the one that is supposed to be the correct one) you should put a 10K resistor from the reset pin to the ground, BUT actually I had to remove it to get the module working, otherwise it won’t even turn on. So DO NOT PUT R2.

The meaning of the pads in the PCB is the following:

• PAD1: Input supply V+
• PAD2: V- (ground)
• PAD3: HSYNC to the VGA connector DB-15 pin 13
• PAD4: VSYNC to the VGA connector DB-15 pin 14
• PAD5: RGB to the VGA connector DB-15 pin 1 to 3
• PAD6: Ground to the VGA connector DB-15 pin 5 to 10

Scoreboard on the breadboard

Scoreboard on PCB (top view)

Scoreboard on PCB (bottom view)

Scoreboard Android Application

	;
	; UART read input
	; This code is executed every 635 cycles in the Scoreboard code
	;
	in r18, _SFR_IO_ADDR(PINB)		; 1 clock

	cpi r25, 0
	breq waitlow
	inc r25
	mov r16, r25
	andi r16, 0x0F
	cpi r16, 7
	brne chkfornext5togo
	lsr r19
	sbrc r18, INPUT
	ori r19, 0x80
	nop
	rjmp chkfornext
chkfornext5togo:
	nop
	nop
	nop
	nop
	nop
chkfornext:
	cpi r16, 14
	brne chkend3togo
	subi r25, 0xEF	; add 17
	andi r25, 0xF1
	rjmp chkend
chkend3togo:
	nop
	nop
	nop
chkend:
	nop
	rjmp hsyncoff

waitlow:
	; waiting for low
	sbrs r18, INPUT
	inc r25
	nop
	delay3x 4
	nop
	nop
	rjmp hsyncoff

hsyncoff:
	...... HSYNC code ......
        ...... if r25 == 0x91 then the UART was read and stored in r19......
	...... process and reset both registers ....

Since we read one byte at the time, it seems pretty convenient for our project to define a set of “commands” (of one byte long), to set the characters that must be displayed (four commands to set each one of characters), and additionally another command to display little square on the corners of the screen which will indicate who is currently serving.
Here is our list of commands:

0 0 0 1 D D D D		(character 1) [0-D] -> 0 1 2 3 4 5 6 7 8 9 (SPACE) B O G
0 0 1 0 D D D D		(character 2)
0 0 1 1 D D D D		(character 3)
0 1 0 0 D D D D		(character 4)
0 1 0 1 0 0 0 1		(serve A top)
0 1 0 1 0 0 1 0		(serve B bottom)
0 1 0 1 0 1 0 0		(serve A top)
0 1 0 1 1 0 0 0		(serve b bottom)

All we need now is a device to connect to the bluetooth module and send the commands.
Don’t miss the final part of this project, that I will publish soon including source codes and a controller developed for Android platforms.

Configuring the Bluetooth Module with Arduino

The bluetooth module comes with a firmware called “linvor1.5″ by default (at least the one on DX). To program it, you need to send a series of AT commands via the TX/RX pins, Arduino seems to be ideal for this task. Connect two cables between the TX/RX of the Arduino and the RX/TX of the Bluetooth module (they need to be crossed, RX with TX and TX with RX). Then put the following code on the Arduino:

int incomingByte = 0;	// for incoming serial data

void setup() {
  Serial.begin(9600);
  Serial.print("AT");
}

void loop() {
	// send data only when you receive data:
	if (Serial.available() > 0) {
		// read the incoming byte:
		incomingByte = Serial.read();

		// say what you got:
		Serial.write(incomingByte);
	}

}

Upload it to the Arduino and click on the Monitor, you will get the following response:

Now we are going to change the default name to “scoreboard”, to do so, replace the Serial.print("AT") with Serial.print("AT+NAMEscoreboard") and repeat the procedure.
Finally, we need to set the baud rate to 2400, using the following command: Serial.print("AT+BAUD2")


Comments and questions are welcome!

Related Posts
Scoreboard (Part 1: VGA signal from an ATtiny45)

Stuff from dealextreme.com

Soldering BT module to the adapter

• Version 1 (the one in the pictures) with a higher separation between the pins.
• Version 2 improved to use less space for smaller breadboards (I didn’t produce this one).

BT Module Adapter PDF

Tiny Pong VGA on the protoboard

Tiny Pong VGA - Fritzing

VGA pinout

#!/bin/sh
avr-gcc -mmcu=attiny45 -mmcu=attiny45 -Wall -gdwarf-2 -Os -std=gnu99 -funsigned-char -funsigned-bitfields -fpack-struct -fshort-enums -MD -MP -MT pong.o -MF pong.o.d  -x assembler-with-cpp -Wa,-gdwarf2 -c pong.S tables.S
avr-gcc -mmcu=attiny45 -Wl,-Map=pong.map pong.o tables.o -o pong.elf
avr-objcopy -O ihex -R .eeprom -R .fuse -R .lock -R .signature pong.elf pong.hex
avr-objcopy -j .eeprom --set-section-flags=.eeprom="alloc,load" --change-section-lma .eeprom=0 --no-change-warnings -O ihex pong.elf pong.eep || exit 0
avr-size -C --mcu=attiny45 pong.elf
rm *.o
rm *.o.d
rm pong.eep
rm pong.elf
rm pong.map

And to upload it to the chip (note that I’m using the Arduino with mega-isp) I use the following script

#!/bin/sh
[ -e "/dev/tty.usbserial-A8008VmU" ] && PORT=/dev/tty.usbserial-A8008VmU || PORT=/dev/ttyUSB0
avrdude -F -P $PORT -p attiny45 -c avrisp -b 19200 -U flash:w:pong.hex
# fuses
# WARNING: fuses with PB5 as I/O port
#avrdude -F -P $PORT -p attiny45 -c avrisp -b 19200 -U flash:w:pong.hex -Ulfuse:w:0xce:m -Uhfuse:w:0x5f:m -Uefuse:w:0xff:m

Uncomment the last line to program the fuses.

Code

The source code is almost the same as the first version, but I fixed a few bugs. First, the Bresenham’s algorithm was wrongly implemented, and since I needed it only to calculate the next position of the ball when the angle is 22.5 or 67.5, I realized that was easier to simply increment the X (or Y) coordinate when the ball is at an even position.
Regarding the button reading, it is done during the vertical blanking zone, 60 times per second which gives a pretty good responsiveness – see the chkinput label in the code for more details.





Download the Tiny Pong 2.0 source code
Enjoy!

USB Keyboard Emulator

For the USB keyboard part, I’ve used the V-USB for Arduino code, which in turns uses V-USB library. You will need to install the V-USB for Arduino to make the “pde” work.

Circuit

The Arduino shield for this project is pretty simple, I’ve attached a regular LCD module to have an output to avoid a second computer just to see the progress or result.
A couple of Zener diodes to make the USB keyboard interface (it’s one of the four options suggested in the V-USB Readme, here is a link to another project that uses this method also).
There is a button which is used to pause/continue the attack. If you keep the button pressed for more than 2 seconds, the attack will be reset.

Sniff the VGA

To know the color of the pixel in the middle of the screen, we need to read the analog Red signal, and also the vertical and horizontal synch pulses to know when to read the Red. The first attempt was using Arduino’s attachInterrupt to capture the HSYNC and VSYNC but the overhead made the USB keyboard to stop working.

The ISR() and SIGNAL() macros seems to work better in this case, so the VSYNC pulse will reset a global variable called h_line while the HSYNC will increment it to know in which line is the VGA frame being drawn.

Our waitWrongPassword function does the analysis of the pixel. It waits for a few seconds to appear the red pixel, and keeps looking at the line counter so when it is in the #238 (almost the vertical middle in an 640×480 resolution) it will delay a little bit to get the horizontal middle timing, and read the analog input.

Then, after reading the red analog input the result is compared to see if the ‘wrong password’ dialog is popped, I’m talking about the if (valueR > 140). You will probably need to change this value, according to your VGA card levels.

Code

You need to define the character set that you want to use for the attack. To do this, modify the charset array adding the USB key codes you want to use. We only have KEY_A, KEY_B, KEY_C by default in the example code. Also, you need to modify a second array called charset_log which must have the same size, but instead of the key code it reflects the printable byte, for logging purposes.
The other thing you need to change is the maximum length of the password, by default set to 4. Look for the MAX_LEN define.
The state is periodically saved in the EEPROM so in case of power failure, you can continue from the last (or near the last) tested password.


Download the code here, and feel free to modify it if you need.


Here some pictures of the shield

An iPod box for the case

Tone transfer method to make the board. A little bit burnt due to the excessive ironing.

Front

Back

So, I’ve used the scoreboard source as a base and changed a little bit the pinout.

                       ATtiny45
                  +-----------------+
                  |                 |
           IN ----| 1 (PB5) (VCC) 8 |---- +5V
    22pf          |                 |
  +--||----+------| 2 (PB3) (PB2) 7 |---- HSYNC
  |       [ ] XTAL|                 |
  +--||----+------| 3 (PB4) (PB1) 6 |---- VSYNC
  | 22pf          |                 |
  +---------------| 4 (GND) (PB0) 5 |---- RGB
  |               |                 |
 GND              +-----------------+

Now the RGB is connected to PB0, and there is a good reason for this. I’m still using the same technique of storing what I want to render in registers but instead of 4, this time I’m using 15 so I can achieve an horizontal resolution of 120 by 96 to make the pixels somehow squared. Now, to be able to walk trough the 120 bits and turn the RGB pin on/off accordingly (and evenly) I needed to crop the code, removing the loops (so you will see a lot of similar code in the part that renders the line) and the conditional skip now replaced by an “add with carry” after the shift into a temporary register that will be used with “out” which is less expensive than “sbi” and “cbi”.

So, in terms of code optimization, this:

	; r1 bit 0
	cbr r16, 1
	lsl r1
	adc r16, r22
	out PORT, r16
	... repeated 120 time (8 times per bit and 15 times per register)

Is better than:

	ldi r16, 0x08
line44:
	rol r8
	brcc rgboff44
	nop
	; RGB on
	sbi PORT, RGB		; sbi = 2 clocks
	rjmp cont44
rgboff44:
	; RGB off
	cbi PORT, RGB		; cbi = 2 clocks
	nop
	nop
cont44:
	dec r16
	nop
	nop
	nop
	nop
	nop
	brne line44

There are also other parts of the code that might be of interest. For example, I’ve use LFSR to add some pseudo-random variables to the ball direction and the paddle “computer” movements. Also, I’ve used the Bresenham’s line algorithm to determine the ball position.
The missing part, is still the input. I’m not sure how this will work with only one pin available, but I guess I’ll work out something with the Bluetooth module and one of the synch signals (if even possible).
I’ve tried to add some intro screen or “splash”, but the program memory is so small that I’ve quickly exceeded the 4096 available bytes.

Download the Tiny Pong 1.0 source code and enjoy!

First Impressions

I’ve got one of these boards like a month ago, and I can tell you so far that I like many things about it. First of all the simplicity of plugging the USB cable and get things working almost instantly. I don’t think is necessary to explain anything in this blog since the Internet is plenty of Arduino tutorials, examples, projects, documents, forums, etc. If you just got one of this boards, your starting point should be here: http://arduino.cc/en/Guide/HomePage
So, first thing you will do is download the Arduino software, install it and try to upload one of the sample programs already included like the blinking led, using the provided IDE.

Easy

If you are impatient like me, you will probably read the first page and then jump to the board and try to connect components, like a led or maybe a 16×2 LCD display, etc. and you will quickly discover that it IS really easy to use: the core Arduino API already have functions to handle LCD displays, interruptions are trivial with “attachInterrupt”, then with the “shiftOut” function you can extend your ports by attaching one or more 74HC595, and many other features.

First Depressions

On the other hand, I don’t like the IDE, maybe because I’m adult?. If you are used to any other IDE, like eclipse, or notepad.exe (he he), you may not like the IDE too. I mean, if you select a text and press Ctrl+F, what do you expect to appear in the search box? well, according to this IDE, nothing or the text from the last search. Not to talk about the annoying (Java?) bug that doesn’t allows you to use dead keys with some specific combinations of JDK and OS.
Then you have the Sketches concept. Sketches, are files with .pde extension which happens to be actually C++ files. Before building this file, the IDE instruments it to add a core include “WProgram.h” and prototypes all your functions. Then the IDE will link with the core files which already includes a very simple main() that calls the init(), setup() and loop() functions, as you can see in the core Arduino source code main.cpp:

#include 

int main(void)
{
	init();

	setup();

	for (;;)
		loop();

	return 0;
}

A more advanced test

I’ve been able to convert the Arduino into an USB keyboard with a few external components following the example from www.practicalarduino.com which uses the Arduino V-USB library which in turns uses the Virtual USB Port for AVR microcontrollers. This will be the base for one of my upcoming project involving brute-force attack BIOS hacking .

Shields

Finally, I would like to recommend this shield if you need an ISP programmer: The Mega-ISP Shield.
I made it, it works and is great! really. With this shield you can convert your Arduino into an ISP programmer by loading the mega-isp “sketch”.

As a side note, you will notice that you won’t be able to create a shield using the regular perforated boards, because of the pin alignment. Unless you only need pins 1 to 7 Xor 8 to 13 from the D port.

One of the challenges was trying to use cheap components (except for the monitor) and Atmel’s ATtiny45 sounds great for this purpose. It can run at 20MHz with an external oscillator, the downside is that the number of I/O pins available is very limited. The external oscillator will take PB2 and PB3, thus using an external clock (a crystal with some circuitry that generates TTL) I could save PB2!, unfortunately I don’t have one, and is not easy to find here.

There are still 4 pins available, PB0 and PB1 will be used for the VGA HSYNC and VSYNC respectively, PB2 to generate the RGB (only one color!). PB5 to get the input information that I want to display, hopefully this will come from a bluetooth module specially tuned for this, or from another ATtiny45 in the worst case.

VGA signal generation

I knew that 20MHz would be enough to generate an acceptable VGA output because of Linus Akesson’s Craft project. In this case he uses an ATmega88 with more I/O ports. Like you can read in his page, this is all about VGA timing. Sending the horizontal and vertical sync pulses at the right time is essential, so the obvious language for having control of every cycle used was assembler (using the gnu compiler in this case).

You can read more about VGA timings in the Wikipedia and here. Basically I send a HSYNC pulse during the so called “horizontal blanking” period just before painting each of the 480 lines. After the 480, I need to send another 45 lines to make the vertical blanking period (no RGB is sent). During the blanking period I also need to send the VSYNC pulse, to signalize that the frame painting is about to start (talking in ‘lines’ the VSYNC pulse will be between line 10 and 12 of the vertical blanking).

The horizontal blanking can be divided in three parts: the front porch 0.94µs, the sync pulse 3.77µs and the back porch 1.89µs. I take advantage of these cycles to determine which information should be ‘painted’ according to the line number. Since I’m trying to paint 4 numbers to display the score, I’ve defined that each character is 8×10 so it can be represented in only 10 bytes. So I store the line that I need to paint for each character in 4 different registers. Also I need to repeat the line vertically to give some proportional height to the characters this is done by mapping line number to font lines in a fixed table. That will result in very ugly and big characters, but that’s OK for the scope of this project .

Schematic

No Eagle for now, but here is an ASCII schematic of the circuit.

                      ATtiny45
                  +-----------------+
                  |                 |
           IN ----| 1 (PB5) (VCC) 8 |---- +5V
    22pf          |                 |
  +--||----+------| 2 (PB3) (PB2) 7 |---- RGB
  |       [ ] XTAL|                 |
  +--||----+------| 3 (PB4) (PB1) 6 |---- VSYNC
  | 22pf          |                 |
  +---------------| 4 (GND) (PB0) 5 |---- HSYNC
  |               |                 |
 GND              +-----------------+

Note: I’ve used an external 12v power source with a 5v voltage regulator 78L05. In my case it was very important to put two filter capacitors in the input and output of the regulator, without them the noise generated by the power supply won’t let the monitor synchronize properly.

Some code

Let’s see some interesting parts.

Character definition. Like I said the characters have a fixed size of 8×10, in the code they look like this:

number0:
	.byte 0b00000000
	.byte 0b00111000
	.byte 0b01000100
	.byte 0b01000100
	.byte 0b01000100
	.byte 0b01000100
	.byte 0b01000100
	.byte 0b00111000
	.byte 0b00000000
	.byte 0b00000000

The mapping between screen lines and font lines looks like this:

maplines1:
	; map lines (from 50 to 205)
	.byte 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
	.byte 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
	.byte 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
	.byte 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
	.byte 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01
	.byte 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01
	.byte 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01
	...

So lines 50 to 88 will map to the first character line (I keep 50 lines of margin at the top and 50 at the bottom, so I actually use 380 lines, divided by ten will result in 38 VGA lines for each font line).

Finally, to get the font line data given the font line number (in r17), I’ll use the lpm instruction like this:

linefor0:
	ldi ZL, lo8(number0)
	ldi ZH, hi8(number0)
	add ZL, r17
	adc ZH, r22
	lpm
	ret

The code doesn’t look complicated at all. The complicated part maybe was making sure to get the right timings, that will be measuring the cycles used between each part of the code. I found that AVR Studio is a great tool for debugging, however cycle measuring between two instructions in the code is something that can take some time, I could’t found conditional breakpoints, and clicking 480 times the “continue” button to test the limits can be a little bit annoying. So, I’ve made a little tool in Python / PySide to help me with this measuring. It’s like an assembler emulator with only a few instructions implemented and of course cycle calculation.

Everything, including the AVR debugger is available for download here. You can do whatever you want with it at your own risk, and in case you feel more comfortable with a license: BSD

Scoreboard source Part 1

Things to do for the next parts:
- Once my cheap Bluetooth module arrives from China, I’ll try to hack it. If I can’t modify its firmware at all, I’ll probably end up with a second ATtiny doing the communication between my VGA ATtiny board and the module.
- Make the Android program to communicate with the Bluetooth module (I guess its plenty of examples in the Internet)
- Last thing, would be trying to improve the characters on screen. I don’t have too much memory in the ATtiny, and certainly not much processing capacity between each pixel, but I guess I can try to emulate some squared pixels, maybe like this:

I could event try to get the yellowish color by putting some diodes in the correct RGB wires, but that’s for next chapter.

Enjoy!

Too easy? Ok, a real ninja hacker solution would had been taking apart the photo frame, put a Linux on the nice ARC processor through the JTAG interface and then plug some Wi-Fi dongle and do Everything directly on the DPF itself. But that’s just dreaming, we don’t have experience nor time for that.

Now you may ask, why didn’t you plug a monitor on the machine and just display whatever you want directly on the monitor? and the first reason is, we don’t have spare LCD monitors for this purpose (in fact we have many CRT monitors that nobody uses, but that requires just too much space). The second reason is that we wanted to do something more exiting, like hacker things .

So we setup everything: we made the scripts to generate the images, installed Ubuntu Linux 10.4 on the Itona and actually we borrowed another 512mb (flash) hard disk form another Itona and put it in the secondary IDE to get a RAID configuration with 1GB of space, just enough for Ubuntu and our script. Then realized of a small problem, as soon as you plug the DPF on the USB port, it enters in “transfer mode” and stops displaying the images. No matter if you eject, unmount, safe remove, shut down the computer, etc. the photo frame wont show the pictures until you physically unplug the USB cable (cut off the +5V). Here is were our ingenious circuit enters in action. A USB interrupter controlled by the parallel port (I guess serial RS-232 would work fine also using one of the signal pins).
After googling, I’ve found a circuit that seemed usable for this purpose. Just a couple transistors and a few resistors is everything we need.

Crop the board and put it in a case…



Finally, the whole thing mounted:
The Itona hidden behind the desk…

And the DPF showing the reports!!

For the circuit you will need:

• 1k resistor (2)
• 10k resistor (2)
• PNP transistor
• NPN transistor
• USB connectors, 1 to plug into the computer, the other whatever is better for your DPF
• DB-25 male connector (if you decided to do it via parallel too)

IMPORTANT: following image was borrowed from http://forum.allaboutcircuits.com/showthread.php?t=38544&page=2

I’ve connected the control-in to the PIN #2 of the DB-25, and the PIN #20 to the ground.
To turn the parallel port signal on/off I’ve made the following program in C (para.c):

#include 
#include 
#include 
#include 
#include 
#include 
#include 

#include


static int pfd;

int main(int argc, char* argv[])
{
	unsigned char data=0;

	if (argc != 3) {
		printf("Usage:\n\tpara [port] [val]\n\nport: parallel port e.g. /dev/parport0\nval:  1 to activate all data bits in parallel port, or\n      0 to disable all data bits in parallel port\n\n");
		return 1;
	}
	if (argv[2][0] == '1') {
		data=0xff;
	}
	pfd = open(argv[1], O_RDWR);
	if (pfd < 0) {
		perror("Failed to open port");
		exit(0);
	}
	if ((ioctl(pfd, PPEXCL) < 0) || (ioctl(pfd, PPCLAIM) < 0)) {
		perror("Failed to lock port");
		close(pfd);
		exit(0);
	}
	printf("Setting %s data bits to: %.2X\n", argv[1], data);
	ioctl(pfd, PPWDATA, &data);
	close(pfd);
	return 0;
}

The idea of this project is to control (switch off/on) two power sockets with a computer by using its USB port. I’ve chosen USB in first place because I wanted to experiment with the PIC18F4550 microchip’s microcontroller, and secondly because the power supplied by this port (500mA) is enough to activate a relay without any additional power supply.

The firmware is based in SIXCA USBDAQ which is in turn based on microchip’s CDC sample. USBDAQ is extremely easy to use. It implements a very simple set of ASCII commands to turn on/off the digital outputs, that I use to control the two relays. I just needed to adjust the bMaxPower in order to negotiate the 500mA with the host, and I also changed the vendor ID and the name of the device to USocket.

I’ve also made the schematic and board design of the circuit with Eagle, but I never used it since I made it on a strip board , so if you plan to use it please double check everything before.

The whole project including PIC firmware and Eagle files is available for download. You are free to use or modify it as you like, but please verify Microchip’s CDC sample license if you plan to use it for commercial applications.

Disclaimer: This project involves high voltage electricity. You should not attempt this project unless you are comfortable with basic concepts of AC and DC electricity, induction, and reading circuit schematics. You and your adult supervisor are responsible for your safety when doing this project!

Advice: Despites the high voltage part of the circuit is virtually isolated from the controller circuit by relays, these devices always represents a risk of mechanical failure and they can possibly damage your equipment or even cause physical injuries, so we (the author or the webmasters) are not responsible of any lose or damage.

The Circuit

Figure 1 – Schematic

Pretty much the same as USBDAQ but two (identical) sub-circuits were added to control the relays. A Darlington-transistor is used to protect the hardware. Once again, the idea was obtained from the web (thanks to google) and here is the link to the original article.

The PCB is divided in 3 little boards, for commodity and socket case space issues. (I’ve used only 2 strip boards in the actual prototype).

Figure 2 – Board

List of materials:

• IC1 – PIC16F4550 Microchip’s micro-controller (datasheet)
• Q2 – Crystal 20Mhz
• R1 – Resistor 4.7K
• R2 – Resistor 1M
• R3, R5 – Resistors 150
• R4, R6 – Resistors 100K
• K1, K3 – 5v Relays. I’ve used FBR211 by Fujitsu (datasheet)
• D1, D2, D3. D4 – Diodes 1N4004
• Q1, Q3 – BC517 Darlington-transistors (datasheet)
• LED1, LED2 – Regular leds
• C1, C2 – Capacitors 22pF
• C3 – Capacitor 470pF
• X1 – Mini-USB Connector Type B (datasheet)

PIC Firmware

Here is what I needed to modify from the original SIXCA USBDAQ:

I set bMaxPower to 250, which means 500mA. The power provided by hosts and hubs is twice the value of bMaxPower field, but in reality they are likely to allocate either 100 or 500 milliamperes rather than the specified amount.

The file modified is the one that contains the USB descriptor: fw/cdc/autofiles/usbdsc.c

/* Configuration 1 Descriptor */
CFG01=
{
/* Configuration Descriptor */
sizeof(USB_CFG_DSC),    // Size of this descriptor in bytes
DSC_CFG,                // CONFIGURATION descriptor type
sizeof(cfg01),          // Total length of data for this cfg
2,                      // Number of interfaces in this cfg
1,                      // Index value of this configuration
0,                      // Configuration string index
_DEFAULT,               // Attributes, see usbdefs_std_dsc.h
250,                    // Max power consumption (2X mA) 250 = 500mA

...

In the same file I modified the Vendor ID, Product ID and corresponding strings

/* Device Descriptor */
rom USB_DEV_DSC device_dsc=
{
sizeof(USB_DEV_DSC),    // Size of this descriptor in bytes
DSC_DEV,                // DEVICE descriptor type
0x0200,                 // USB Spec Release Number in BCD format
CDC_DEVICE,             // Class Code
0x00,                   // Subclass code
0x00,                   // Protocol code
EP0_BUFF_SIZE,          // Max packet size for EP0, see usbcfg.h
0xAF01,                 // Vendor ID
0xAF0A,                 // Product ID: CDC RS-232 Emulation Demo
0x0000,                 // Device release number in BCD format
0x01,                   // Manufacturer string index
0x02,                   // Product string index
0x00,                   // Device serial number string index
0x01                    // Number of possible configurations
};

...

rom struct{byte bLength;byte bDscType;word string[16];}sd001={
sizeof(sd001),DSC_STR,
'a','l','f','e','r','s','o','f','t','.',
'c','o','m','.','a','r'};

rom struct{byte bLength;byte bDscType;word string[21];}sd002={
sizeof(sd002),DSC_STR,
'A','l','f','e','r','S','o','f','t',' ',
'U','S','o','c','k','e','t',' ','1','.','0'};

And the file driver/win2k_winxp/mchpcdc.inf  Windows, to match the new vendor, product ID and description

[DeviceList]
%DESCRIPTION%=DriverInstall, USB\VID_AF01&PID_AF0A

...

;------------------------------------------------------------------------------
;  String Definitions
;------------------------------------------------------------------------------

[Strings]
MCHP="alfersoft.com.ar"
MFGNAME="alfersoft.com.ar"
DESCRIPTION="Communications Port"
SERVICE="AlferSoft USocket 1.0"

Programming the PIC

I’ve used WinPic800 to program the PIC. Here is a screenshot of the parameters I used to program it.

Commands

I didn’t modified any of the USBDAQ commands. They are all available but I only need to use these 4 commands:

• *A01 (activate relay 1)
• *A00 (deactivate relay 1)
• *A11 (activate relay 2)
• *A10 (deactivate relay 2)

All the commands are followed by an enter (chr(13) or ‘\n’).

Installing (Windows)

1. Plug the device into the USB port, the following message will appear in the tray bar.



2. In the first page of the “Found New Hardware Wizard” select “No, not this time” and click Next button.



3. Select the “Install from a list or specific location (Advanced)” option and click Next button.



4. Mark the “Include this location in the search:” and browse for the directory where the .inf file is located (driver\win2k_winxp)



5. This message will appear:



6. And then this one:



7. When the installation is done press “Finish”



8. After that the hardware is ready to use.

Testing (Windows)

1. Go to the device manager and locate the new COM port added, in my example COM10 was added



2. Open Hyperterminal and choose a name for the new conection



3. Select the new COM port



4. Set the Bit rate to 115200



5. This step is optional to see what we are typing on the screen, choose ASCII Setup



6. Then mark “Echo typed characters locally”



7. Finally connect and type one of the commands

Installing (Linux – Ubuntu)

1. Plug it. That’s it! a new device probably called /dev/ttyACM0 will be added by the OS.

Testing (Linux – Ubuntu)

1. Open gtkterm if you don’t have it installed type “sudo apt-get install gtkterm” from a terminal



2. Go to Configuration -> Port, set the port to /dev/ttyACM0, the speed to 115200 and click OK



3. Select Configuration -> Local echo
4. Type the command and press enter

Problem

After I mounted everything in the case a problem appeared, if I plug the USB cable to the computer and then the socket to the wall, the PIC hangs. But it works well the other way round (first plug to the wall and the to the computer). That is probably because the high voltage cables are too close to the PIC and unfortunatelly I’m not an expert in that matter and I don’t know how to fix it except by putting the circuit in a separated box. Experts needed! If you know another way to fix it please let me know!

Pictures

Download

Link to download USocket project, enjoy it!