The problem

Using shift registers is a common practice in the cases when you need a lot of low-frequency digital signals or connecting serial communication line (like USB) to a bus with a parallel interface. In this tutorial I’ll obtain 8-bit signal out of Arduino Nano using only 3 output pins. To do that I’ll use 74HC595 shift register and a breadboard.

First of all lets connect shift register to the push-buttons to take an intuition of working with it:

Here’s my breadboard:

A chip on the left is 74HC595 shift register. You see a switch and push buttons in the middle. Arduino on the right is only for obtaining the power (GND and +5V). You’re able to look at Ben Eater manually controlling his shift register here.

Using Arduino Nano to control shift register

Lets connect our microcontroller kit to the shift register. Arduino Nano's scheme (PDF, 79 KiB) may be very helpful. We’re using just two Arduino’s pins now: D12 and D13. D13 is also connected to the Arduino’s LED so we’re able to look at serial data transmission.

Install some packages to program AVR microcontrollers (if you’re using APT):

sudo apt install avr-libc avrdude binutils-avr gcc-avr srecord

You’re able to take the source code from my GitHub repo:

git clone https://github.com/quasiyoke/shift-register-arduino-nano.git
git checkout shift-register-demo

To compile your source code you’ll need to run several console commands. I’ve found a great Makefile helping in that here. I’ve customized it in several ways:

1. changed the programming language from C++ to C (there’re some considerations for doing that),
2. removed fuses flashing (their default configuration is OK usually),
3. changed BAUD rate, clock frequency and MCU type according to our hardware (ATMega328P).

Please note that Makefile should be indented using tabs instead of spaces – this is very important requirement. Here’s the Makefile contents:

baud=57600
src=src/main
build=build
asset=project
avrType=atmega328
avrFreq=16000000
programmerDev=/dev/ttyUSB0
programmerType=arduino

cflags=-std=c99 -g -DF_CPU=$(avrFreq) -Wall -Os -Werror -Wextra

memoryTypes=calibration eeprom efuse flash fuse hfuse lfuse lock signature application apptable boot prodsig usersig

.PHONY: backup clean disassemble dumpelf eeprom elf flash help hex makefile object program

help:
  @echo 'backup       Read all known memory types from controller and write it into a file. Available memory types: $(memoryTypes)'
  @echo 'clean        Delete automatically created files.'
  @echo 'disassemble  Compile source code, then disassemble object file to mnemonics.'
  @echo 'dumpelf      Dump the contents of the .elf file. Useful for information purposes only.'
  @echo 'eeprom       Extract EEPROM data from .elf file and program the device with it.'
  @echo 'elf          Create $(build)/$(asset).elf'
  @echo 'flash        Program $(build)/$(asset).hex to controller flash memory.'
  @echo 'help         Show this text.'
  @echo 'hex          Create all hex files for flash, eeprom.'
  @echo 'object       Create $(build)/$(asset).o'
  @echo 'program      Do all programming to controller.'

#all: object elf hex

clean:
  rm -f $(build)/$(asset).elf $(build)/$(asset).eeprom.hex $(build)/$(asset).flash.hex $(build)/$(asset).o $(build)/$(asset).lst
  rm -df $(build)
  @date

$(build):
  mkdir $(build)

object: $(build)
  avr-gcc $(cflags) -mmcu=$(avrType) -Wa,-ahlmns=$(build)/$(asset).lst -c -o $(build)/$(asset).o $(src).c

elf: object
  avr-gcc $(cflags) -mmcu=$(avrType) -o $(build)/$(asset).elf $(build)/$(asset).o
  chmod a-x $(build)/$(asset).elf 2>&1

hex: elf
  avr-objcopy -j .text -j .data -O ihex $(build)/$(asset).elf $(build)/$(asset).flash.hex
  avr-objcopy -j .eeprom --set-section-flags=.eeprom="alloc,load" --change-section-lma .eeprom=0 -O ihex $(build)/$(asset).elf $(build)/$(asset).eeprom.hex

disassemble: elf
  avr-objdump -s -j .fuse $(build)/$(asset).elf
  avr-objdump -C -d $(build)/$(asset).elf 2>&1

eeprom: hex
  #avrdude -p$(avrType) -c$(programmerType) -P$(programmerDev) -b$(baud) -v -U eeprom:w:$(build)/$(asset).eeprom.hex
  @date

dumpelf: elf
  avr-objdump -s -h $(build)/$(asset).elf

program: flash eeprom

flash: hex
  avrdude -p$(avrType) -c$(programmerType) -P$(programmerDev) -b$(baud) -v -U flash:w:$(build)/$(asset).flash.hex
  @date

backup:
  @for memory in $(memoryTypes); do \
    avrdude -p $(avrType) -c$(programmerType) -P$(programmerDev) -b$(baud) -v -U $$memory:r:./$(avrType).$$memory.hex:i; \
  done

Here’s the source code from src/main.c:

#include <avr/io.h>
#include <util/delay.h>

#define BYTE_LENGTH (8)
#define LED_PIN (PB5)
#define SERIAL_OUTPUT_PIN (LED_PIN)
#define CLK_PIN (PB4)

const char MESSAGE[] = {
  0b00000000,
  0b10101010,
  0b11111111,
  0b00110011,
};

int main(void) {
  DDRB = _BV(SERIAL_OUTPUT_PIN)
    | _BV(CLK_PIN);

  for (int i = 0; ; i = (i + 1) % sizeof(MESSAGE)) {
    char valueByte = MESSAGE[i];

    for (char j = BYTE_LENGTH - 1; j >= 0; --j) {
      char valueBit = (valueByte >> j) & 1;
      // Set serial output to `0`
      PORTB &= ~(_BV(SERIAL_OUTPUT_PIN));
      // Send current bit value to serial output
      PORTB |= valueBit << SERIAL_OUTPUT_PIN;
      // Make a rising edge of clock signal
      PORTB |= _BV(CLK_PIN);
      // Make a falling edge of clock signal
      PORTB &= ~(_BV(CLK_PIN));
      _delay_ms(250);
    }
  }
}

To compile and flash the program, execute:

sudo make flash

Here’s a video of this program working:

Bit manipulation

Note that the line:

PORTB |= _BV(SHIFT_REGISTER_CLK_PIN);

compiles to single assembly language instruction:

sbi 0x05, 4

This instruction does exactly what we want: sets fourth bit (PB4) of the fith I/O port (PORTB) to 1. You’re able to look at ATMega328P datasheet (PDF, 5.1 MiB, page 433) to check that.

This line:

PORTB &= ~(_BV(SHIFT_REGISTER_CLK_PIN));

compiles to single assembly instruction too:

cbi 0x05, 4

and sets PB4 to 0. That’s all thanks to AVR Libc input/output optimizations.

_BV macro refers to “bit value” and was defined in AVR Libc as follows:

#define _BV(bit) \
  (1 << (bit))

Controlling 74HC595’s storage register

Usually there’s no need to see how does shift register fills in: we need ready-to-use bytes out of it. For that purpose 74HC595 has internal storage register. To control it we need to use third Arduino’s pin DD11:

Lets change our program to control storage register. Checkout shift-register-with-storage-register GIT tag or change the source code manually:

#include <avr/io.h>
#include <util/delay.h>

#define BYTE_LENGTH (8)
#define LED_PIN (PB5)
#define SERIAL_OUTPUT_PIN (LED_PIN)
#define SHIFT_REGISTER_CLK_PIN (PB4)
#define REGISTER_CLK_PIN (PB3)

const char MESSAGE[] = {
  0b00000000,
  0b10101010,
  0b11111111,
  0b00110011,
};

int main(void) {
  DDRB = _BV(SERIAL_OUTPUT_PIN)
    | _BV(SHIFT_REGISTER_CLK_PIN)
    | _BV(REGISTER_CLK_PIN);

  for (int i = 0; ; i = (i + 1) % sizeof(MESSAGE)) {
    char valueByte = MESSAGE[i];
    // Make a falling edge of storage register clock signal
    PORTB &= ~(_BV(REGISTER_CLK_PIN));

    for (char j = BYTE_LENGTH - 1; j >= 0; --j) {
      char valueBit = (valueByte >> j) & 1;
      // Set serial output to `0`
      PORTB &= ~(_BV(SERIAL_OUTPUT_PIN));
      // Send current bit value to serial output
      PORTB |= valueBit << SERIAL_OUTPUT_PIN;
      // Make a rising edge of shift register clock signal
      PORTB |= _BV(SHIFT_REGISTER_CLK_PIN);
      // Make a falling edge of shift register clock signal
      PORTB &= ~(_BV(SHIFT_REGISTER_CLK_PIN));
    }

    // Make a rising edge of storage register clock signal
    PORTB |= _BV(REGISTER_CLK_PIN);
    _delay_ms(250);
  }
}

This program works very well. It shows information on the LEDs byte-by-byte hiding shift register operation inside the chip. It looks more boring than a previous setup but it’s more useful in practice:

I’ve captured signals coming out of Arduino Nano using my oscilloscope:

On a channel 1 (blue) you see the storage register clock signal. On a channel 2 (yellow) you see shift register clock signal. Microcontroller pushes a byte of data into the shift register bit-by-bit with a shift register clock and outputs the whole byte on a positive edge of the storage register clock signal.

Let’s see writing a single bit into the shift register in a more detail:

On a channel 1 (blue) you see the serial data signal now. On a channel 2 (yellow) you see shift register clock signal.

Reducing I/O operations count

Input/output operations (writing to the PORTB) are pretty slow and one should reduce their count if possible. For someone who’re used to do usual programming it looks like we’re able to optimize inner cycle this way (GIT tag optimization):

for (char j = BYTE_LENGTH - 1; j >= 0; --j) {
  char valueBit = (valueByte >> j) & 1;
  /*
   * Send current bit value to serial output and
   * make rising edge of shift register clock signal
   * with only one I/O operation
   */
  PORTB = valueBit << SERIAL_OUTPUT_PIN
    | _BV(SHIFT_REGISTER_CLK_PIN);
  // Make a falling edge of shift register clock
  PORTB &= ~(_BV(SHIFT_REGISTER_CLK_PIN));
}

Unfortunatelly, this won’t work. Such a program makes shift register to decode serial signal incorrectly: delayed by one bit! You won’t find any troubles inside the program if you disassemble it. The key of solving the problem lays in an oscillogram:

Natural result of joining several I/O operations into one is that serial data signal and shift register clock rising edges are simultaneous now. But SNx4HC595 datasheet (PDF, 2.1 MiB) says (on a page 7) that set-up time between serial data signal edge (SER) and shift register clock edge (SRCLK) should be at least 20 ns (30 ns in a worst case). This fact is a good reason to make one more I/O operation (checkout GIT branch master):

for (char j = BYTE_LENGTH - 1; j >= 0; --j) {
  char valueBit = (valueByte >> j) & 1;
  // Send current bit value to serial output
  PORTB = valueBit << SERIAL_OUTPUT_PIN;
  // Make rising edge of shift register clock signal
  PORTB |= _BV(SHIFT_REGISTER_CLK_PIN);
  // Make a falling edge of shift register clock
  PORTB &= ~(_BV(SHIFT_REGISTER_CLK_PIN));
}

This time our program works correctly:

Notice that last listing differs from the first variant of the program by omitting the stage of “Setting serial output to 0“. This way we’ve reduced amount of I/O operations from 4 to 3 with keeping our setup functional.

Disassembling your object files

There’s a couple of situations when you need to look at the compiled program’s instructions to have a complete understanding of its work. You’re able to do that with AVR GCC toolkit.

First of all change permissions of build directory (because it was set to root during the flashing):

sudo chown -R $USER build

Now you’re able to disassemble your object file:

avr-objdump --source build/project.elf > build/listing.lst

The --source option intersperses initial C code in the output.

Here’s the listing’s fragment of the last version of the program:

a8: 47 e0         ldi r20, 0x07 ; 7
aa: 50 e0         ldi r21, 0x00 ; 0

  for (char j = BYTE_LENGTH - 1; j >= 0; --j) {
    char valueBit = (valueByte >> j) & 1;
ac: 06 2e         mov r0, r22
ae: 00 0c         add r0, r0
b0: 77 0b         sbc r23, r23
b2: 9b 01         movw  r18, r22
b4: 04 2e         mov r0, r20
b6: 02 c0         rjmp  .+4       ; 0xbc <main+0x26>
b8: 35 95         asr r19
ba: 27 95         ror r18
bc: 0a 94         dec r0
be: e2 f7         brpl  .-8       ; 0xb8 <main+0x22>
c0: 21 70         andi  r18, 0x01 ; 1
    PORTB = valueBit << SERIAL_OUTPUT_PIN;
c2: 22 95         swap  r18
c4: 22 0f         add r18, r18
c6: 20 7e         andi  r18, 0xE0 ; 224
c8: 25 b9         out 0x05, r18 ; 5
    PORTB |= _BV(SHIFT_REGISTER_CLK_PIN);
ca: 2c 9a         sbi 0x05, 4 ; 5
    PORTB &= ~(_BV(SHIFT_REGISTER_CLK_PIN));
cc: 2c 98         cbi 0x05, 4 ; 5
ce: 41 50         subi  r20, 0x01 ; 1
d0: 51 09         sbc r21, r1
d2: 78 f7         brcc  .-34      ; 0xb2 <main+0x1c>
  }

  PORTB |= _BV(REGISTER_CLK_PIN);
d4: 2b 9a         sbi 0x05, 3 ; 5

You see a weird way of doing bit shift (offsets b4–be) and as compiler optimizes I/O operations (offsets ca, cc, d4). Such listing is obviously may be very useful.

Conclusion

Perhaps, you’ve noticed at the oscillogram that microcontroller pushes each subsequent bit of a single byte faster and faster. The program sends most significant bits slower than less significant because of bit shifting operation. To make microcontroller shift bits for a constant time will be a good hometask for you.

I hope this post will help you to start working with AVR microcontrollers on Ubuntu.

This article’s toolchain consist of:

1. Any text editor (I prefer Sublime Text),
2. GNU ARM Embedded toolchain,
3. OpenOCD,
4. Open source STLINK tool.

As you can see, I’ve used most of the parts from my last post. This toolchain will give you even more control and transparency on building process and of course it doesn’t have any proprietary software in it (except Sublime, but you’re able to use Atom or Vim).

You need some library to program your microcontroller (MCU) because usually you need to operate a plenty of sophisticated registers. All these registers usually have addresses like this: 0x40020C00. It’s better to operate with some human-readable code instead of all this digits, so you either need to define addresses as constants by yourself or use a library written by experienced developers. In my last post I used proprietary STM32 L1 standard peripheral library. Today I’m going to show you how to use GNU libopencm3 for that.

GNU ARM Embedded toolchain

I’m going to repeat installation steps from last article here to achieve completeness of this guide. So, usual APT commands for installing ARM cross-compilation tools (assuming you’re using some Debian-based distribution like Ubuntu):

sudo add-apt-repository ppa:team-gcc-arm-embedded/ppa
sudo apt update
sudo apt install gcc-arm-none-eabi gdb-arm-none-eabi

If installation finished correctly you should be able to test toolchain’s version.

arm-none-eabi-gcc --version

OpenOCD

Setting up the tool for hardware debugging.

sudo apt install openocd

Open source STLINK tool

cd ~/Downloads/
git clone https://github.com/texane/stlink.git
cd ~/Downloads/stlink/
sudo install -m 644 etc/udev/rules.d/49-stlinkv2.rules /etc/udev/rules.d/49-stlinkv2.rules
sudo udevadm control --reload-rules

libopencm3 examples

libopencm3 is a GNU alternative for STM32 standard peripheral libraries. The project’s GitHub contains libopencm3 examples repository. If you clone this repo you’ll be able to build any example and flash it with simple terminal commands.

git clone https://github.com/libopencm3/libopencm3-examples.git
cd libopencm3-examples
git submodule init
git submodule update
make

When I did it, building have stopped with error at building examples/sam/d/d10-xplained-mini/miniblink/ stage (examples rev.: 9fbac7d, libopencm3 rev.: 13d4302). I don’t know what’s the reason of that but I don’t care about Atmel SAM. If you’ve got the same error ignore it, connect your STM32 L152 Discovery board through USB Mini-B cable and execute the following:

cd examples/stm32/l1/stm32l-discovery/miniblink
make flash

And that’s it! After that your board should start blinking with its LED.

LCD ticker

Let’s write some simple program using libopencm3 library. For example, LCD ticker.

The screen should display some text moving it forward rapidly.

LCD hello

At first I recommend you to write some trivial example to make sure all your tools are working right.

Let’s show some text at our screen. It’s already done at one of libopencm3 examples. This example just displays “*HELLO” string. I’ve copied it to my repo and adopted Makefile. The link is already pointing at the 1-lcd-hello tag.

To flash the program on your board just execute this:

git clone https://github.com/quasiyoke/stm32-l152-lcd-ticker.git cd stm32-l152-lcd-ticker git checkout 1-lcd-hello -- . make flash

Find lcd_display_hello function inside main.c. This function determines the text we’re showing. Try to specify some other string. For example: “BYEBYE”

static void lcd_display_hello (void)
{
    do {} while (!lcd_is_for_update_ready ());
    clear_lcd_ram (); // all segments off
    write_char_to_lcd_ram (0, 'B', true);
    write_char_to_lcd_ram (1, 'Y', true);
    write_char_to_lcd_ram (2, 'E', true);
    write_char_to_lcd_ram (3, 'B', true);
    write_char_to_lcd_ram (4, 'Y', true);
    write_char_to_lcd_ram (5, 'E', true);

    lcd_update ();
}

After your modifications, flash MCU again:

make flash

If you’ve broken something, don’t worry! Just checkout initial revision:

git checkout 1-lcd-hello -- .

Writing LCD ticker code

We’ll make LCD ticker in two steps:

1. Writing function which shows arbitrary text
2. Making the text move

Let’s make lcd_display_hello show any string from some specified position. I think this function should have another name since that: lcd_show. Look at the code:

/**
 * Shows maximal possible part of the given text on LCD screen. If text is too
 * short, shows it cycled.
 * @param text Text to show
 * @param offset Positive offset inside the text from which we should
 *  start showing it
 */
static void lcd_show(char* text, int offset)
{
    const int TEXT_LENGTH = strlen(text);

    do {} while (!lcd_is_for_update_ready());

    for (int i=0; i<LCD_LETTERS_COUNT; ++i) {
        write_char_to_lcd_ram(i, text[(offset + i) % TEXT_LENGTH], true);
    }

    lcd_update();
}

This function is called from main() with TEXT specified at main.h file.

You’re able to try this code by executing this:

git checkout 2-lcd-show -- .
make flash

Try to change offset specified at main function to see different parts of the string on the screen or shorten the string to less than 6 characters to see it repeated.

Moving text

To make text move let’s add infinite cycle to main():

int main(void)
{
    const int TEXT_LENGTH = strlen(TEXT);

    lcd_init();

    for (int offset=0; ; ++offset, offset%=TEXT_LENGTH) {
        lcd_show(TEXT, offset);

        // Wait a bit
        for (int i=0; i<100000; ++i) {
            __asm__("nop");
        }
    }

    return 0;
}

And this is the final program as you can see it in my repository.

To flash it do the following:

git checkout master
make flash

Advanced RISC Machines Ltd. (ARM) is developing their processor designs which are allowed to license by various hardware manufacturers. ARM does not produce any hardware chips at all! One of the last ARM’s processors is Cortex family. It belongs to ARM v7 architecture and has 3 modifications (profiles):

• The A profile is designed for high-performance open application platforms.
• The R profile is designed for high-end embedded systems in which real-time performance is needed.
• The M profile is designed for deeply embedded microcontroller-type systems.

Cortex-M3 processor is based on one profile of the v7 architecture, called ARM v7-M, an architecture specification for microcontroller products. There’s “The Definitive Guide to the ARM Cortex-M3” (PDF, 15 MiB) — it fits perfetly for those who want to study ARM MCUs’ core.

One of ARM’s partners is ST Microelectronics. ST produces a family of 32-bit MCUs. STM32 F2, STM32 F1 and STM32 L1 series are based on Cortex-M3 core. Like other manufacturers ST surrounds Cortex-M core with a bunch of peripheral circuits giving I/O abilities and various features like timers, ADC, temperature measurement and so on. These peripheral devices are specific to each manufacturer. ST has a range of tools for evaluation of their MCUs. They’re not very expensive and give you ability to try some of chip’s features without soldering a single wire.

My friends gave me 32L152CDISCOVERY—STM32 Discovery kit which has on its board:

• STM32L152RCT6—256 KB Flash memory, 32 KB RAM, 8 KB EEPROM MCU,
• ST-LINK/V2—in-circuit debugger and programmer connected to USB Mini-B socket (most likely your phone uses another plug),
• 24-segments LCD,
• touch sensor,
• 2 MCU-controlled LEDs,
• 1 MCU-connected button.

Last few days I’ve spent trying to configure work with my Discovery board on Ubuntu 16.04. In this article I’ve described set up of the following toolchain:

1. Eclipse CDT,
2. GNU ARM Eclipse Plug-in,
3. GNU ARM Embedded toolchain,
4. OpenOCD.
5. Open source STLINK tool

I like this setup so much because it has no proprietary tools in it, I have a full control over each step of board programming and such configuration is pretty common and production-ready.

Eclipse CDT

If you still haven’t installed Eclipse CDT, do it right now.

First of all, install Java.

sudo apt install openjdk-8-jre

Download latest Eclipse CDT (Eclipse IDE for C/C++ Developers) from the official website and extract it to /opt/. The specific edition used here is Eclipse IDE for C/C++ Developers v. Mars.2 Release (4.5.2).

cd /opt/ && sudo tar -zxvf ~/Downloads/eclipse-*.tar.gz

To make Eclipse available from launcher we should create shortcut (courtesy to UbuntuHandbook and Ask Ubuntu 1 2).

gksudo gedit /usr/share/applications/eclipse.desktop

Paste the following content to the opened file and save it.

[Desktop Entry]
Name=Eclipse CDT
Type=Application
Exec=env UBUNTU_MENUPROXY=0 SWT_GTK3=0 /opt/eclipse/eclipse
Terminal=false
Icon=/opt/eclipse/icon.xpm
Comment=Integrated Development Environment
NoDisplay=false
Categories=Development;IDE;
Name[en]=Eclipse CDT

Now you should be able to open Eclipse from Unity Dash. I’ll assume that you place your Eclipse workspace here: ~/workspace/

After that we need to install GNU ARM Plug-in using Eclipse’s internal package manager. To do that go to Help > Install new software. We need to add plugin’s repository to “Work with” field. Press “Add…” button and add “GNU ARM Eclipse Plug-in” repository: http://gnuarmeclipse.sourceforge.net/updates

Useful keystrokes

• Ctrl + B — build project,
• F11 — start debugging,
• F8 — resume execution (when program have paused at some breakpoint),
• Ctrl + F2 — stop debugging,
• Ctrl + F8 — switch perspective (from Debug to C/C++ and backwards).

How to make Eclipse launch the same debug configuration each time?

You should go to Window > Preferences > Run/Debug > Launching. Select the option “Always launch the previously launched application”. It’s located at the bottom of the dialog. Courtesy to Stack Overflow.

GNU ARM Embedded toolchain

We’re going to compile on our machine MCU’s flash having another processor architecture. This is called cross-compilation. To do that we need special toolchain. Installation is straight-forward for every Ubuntu user.

sudo add-apt-repository ppa:team-gcc-arm-embedded/ppa
sudo apt update
sudo apt install gcc-arm-none-eabi gdb-arm-none-eabi

If installation finished correctly you should be able to test toolchain’s version.

arm-none-eabi-gcc --version

If this command ran correctly, toolchain lays at /usr/bin/. In case when toolchain lays in other place you should specify its location in Eclipse here: Window > Preferences > C/C++ > Build > Global Tools Path.

OpenOCD

OpenOCD is a tool for debugging hardware. Ubuntu has pretty fresh OpenOCD v0.9 in its repos now.

sudo apt install openocd

Open source STLINK tool

cd ~/Downloads/
git clone https://github.com/texane/stlink.git
cd ~/Downloads/stlink/
sudo install -m 644 etc/udev/rules.d/49-stlinkv2.rules /etc/udev/rules.d/49-stlinkv2.rules
sudo udevadm control --reload-rules

Create blinking “Hello world”

In this section we’ll make our board blink with its LED. Eclipse GNU ARM Plug-in has a set of STM32 F-series “hello world” example projects. We need to modify one to test our Discovery board equiepped with STM32 L1-series MCU.

In Eclipse open File > New > C Project. Choose some Project name (I’ll use stm32-l1-blink name below) and Project type: “STM32F10x C/C++ Project”. The toolchain should be “Cross ARM GCC”. Press “Next”. On the following wizard’s page choose Flash size: 256 kB, RAM size: 32 kB (that’s our STM32L152RCT6 MCU parameters), all other fields leave without changes. Go through the wizard pressing “Next” to the “Finish”.

Let’s try to build the project to check if toolchain works. Press Project > Build All (Ctrl + B). When compilation finish, you should see Binaries/stm32-l1-blink.elf MCU flash. Compilation works but we should modify the source code.

“Hello world” generated by Eclipse contains library for working with STM32 F10x peripheral devices. You can download such library for STM32 L1 series from official website (you’ll need registration) or my copy (ZIP, 18 MiB, v1.3.1). Unpack it to “home” (assuming you’ve downloaded it to ~/Downloads/):

unzip ~/Downloads/stm32-l1-peripherals-library-v1.3.1.zip -d ~

Peripherals library now unpacked to ~/STM32L1xx_StdPeriph_Lib_V1.3.1/. To merge it with our project you should do the following (assuming your Eclipse workspace is at ~/workspace/):

rm ~/workspace/stm32-l1-blink/include/stm32f10x_conf.h
cp ~/STM32L1xx_StdPeriph_Lib_V1.3.1/Project/STM32L1xx_StdPeriph_Templates/stm32l1xx_conf.h ~/workspace/stm32-l1-blink/include/stm32l1xx_conf.h

rm ~/workspace/stm32-l1-blink/system/include/cmsis/stm32f10x.h
cp ~/STM32L1xx_StdPeriph_Lib_V1.3.1/Libraries/CMSIS/Device/ST/STM32L1xx/Include/stm32l1xx.h ~/workspace/stm32-l1-blink/system/include/cmsis/stm32l1xx.h

rm ~/workspace/stm32-l1-blink/system/include/cmsis/system_stm32f10x.h
cp ~/STM32L1xx_StdPeriph_Lib_V1.3.1/Libraries/CMSIS/Device/ST/STM32L1xx/Include/system_stm32l1xx.h ~/workspace/stm32-l1-blink/system/include/cmsis/system_stm32l1xx.h

rm ~/workspace/stm32-l1-blink/system/src/cmsis/system_stm32f10x.c
cp ~/STM32L1xx_StdPeriph_Lib_V1.3.1/Project/STM32L1xx_StdPeriph_Templates/system_stm32l1xx.c ~/workspace/stm32-l1-blink/system/src/cmsis/system_stm32l1xx.c

rm -rf ~/workspace/stm32-l1-blink/system/include/stm32f1-stdperiph/
cp -r ~/STM32L1xx_StdPeriph_Lib_V1.3.1/Libraries/STM32L1xx_StdPeriph_Driver/inc/ ~/workspace/stm32-l1-blink/system/include/stm32l1-stdperiph/

rm -rf ~/workspace/stm32-l1-blink/system/src/stm32f1-stdperiph/
cp -r ~/STM32L1xx_StdPeriph_Lib_V1.3.1/Libraries/STM32L1xx_StdPeriph_Driver/src/ ~/workspace/stm32-l1-blink/system/src/stm32l1-stdperiph/

cp -rf ~/STM32L1xx_StdPeriph_Lib_V1.3.1/Libraries/CMSIS/Include/ ~/workspace/stm32-l1-blink/system/include/cmsis/

rm ~/workspace/stm32-l1-blink/system/include/cmsis/core_cm4.h
rm ~/workspace/stm32-l1-blink/system/src/cmsis/vectors_stm32f10x.c
cp ~/STM32L1xx_StdPeriph_Lib_V1.3.1/Libraries/CMSIS/Device/ST/STM32L1xx/Source/Templates/TrueSTUDIO/startup_stm32l1xx_md.s ~/workspace/stm32-l1-blink/system/include/cmsis/startup_stm32l1xx_md.S

After that go to Project > Properties > C/C++ Build > Settings and point to fresh peripheral library’s “Includes” for Cross ARM GNU Assembler, Cross ARM C Compiler and Cross ARM C++ Compiler: just change directory path from ../system/include/stm32f1-stdperiph to ../system/include/stm32l1-stdperiph

In the same window replace STM32F10X_MD preprocessor definition with STM32L1XX_MD. Do that in “Preprocessor” tabs of Cross ARM GNU Assembler, Cross ARM C Compiler and Cross ARM C++ Compiler.

We still can’t build the project because of slight differences between STM32 F1 and STM32 L1 peripherals’ libraries.

include/BlinkLed.h

Edit include in the header of BlinkLed.h:

#include "stm32l1xx.h" // Was `stm32f10x.h`

Correct definitions for blue LED on 32L152CDISCOVERY:

#define BLINK_PORT_NUMBER               (1) /* Was 2 */
#define BLINK_PIN_NUMBER                (6) /* Was 12 */
#define BLINK_ACTIVE_LOW                (0) /* Was 1 */

#define BLINK_GPIOx(_N)                 ((GPIO_TypeDef *)(GPIOA_BASE + (GPIOB_BASE-GPIOA_BASE)*(_N)))
#define BLINK_PIN_MASK(_N)              (1 << (_N))
#define BLINK_RCC_MASKx(_N)             (RCC_AHBPeriph_GPIOA << (_N)) /* Used `RCC_APB2Periph_GPIOA` */

src/BlinkLed.c

Edit blink_led_init definition:

void blink_led_init()
{
  // Enable GPIO Peripheral clock
  RCC_AHBPriphClockCmd(BLINK_RCC_MASKx(BLINK_PORT_NUMBER), ENABLE); // Used `RCC_APB2PeriphClockCmd`

  GPIO_InitTypeDef GPIO_InitStructure;

  // Configure pin in output mode
  GPIO_InitStructure.GPIO_Pin = BLINK_PIN_MASK(BLINK_PIN_NUMBER);
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_40MHz; // Was `GPIO_Speed_50MHz`
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT; // Was `GPIO_Mode_Out_PP`
  GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL; // New
  GPIO_InitStructure.GPIO_OType = GPIO_OType_PP; // New
  GPIO_Init(BLINK_GPIOx(BLINK_PORT_NUMBER), &GPIO_InitStructure);

  // Start with led turned off
  blink_led_off();
}

To understand what’s going on in this function read article about STM32 F0 GPIO. To understand STM32 L1 GPIO’s peculiarities I encourage you to look at STM32 L1 reference manual. You’re able to download it from official website or use (PDF, 13 MiB, v13).

system/include/cmsis/cmsis_device.h

#ifndef STM32L1_CMSIS_DEVICE_H_
#define STM32L1_CMSIS_DEVICE_H_

#include "stm32l1xx.h"

#endif // STM32L1_CMSIS_DEVICE_H_

After this modifications the project can be built without errors.

Debugging setup

Open Run > Debug Configurations and create new configuration by double-clicking “GDB OpenOCD Debugging”. Rename it as “OpenOCD debug”, choose current project at “Main” tab and configure work with the board in “Config options” field at “Debugger” tab: -f "/usr/share/openocd/scripts/board/stm32ldiscovery.cfg" -f "/usr/share/openocd/scripts/interface/stlink-v2.cfg"

Now, if you press Debug button your board will be flashed and interactive debug session will be started. You’re able to download my stm32-l1-blink project (ZIP, 609 KiB) if any.

Do you want to talk with somebody, practice in foreign languages or you just want to have some fun? Rand Talk will help you! It’s an anonymous bot matching you with a random stranger of desired sex speaking on your language: t.me/RandTalkBot.

1. Choose the language you’d like to talk. Are you know several languages? Enumerate them from your native language to less known, e.g.: “English, Deutsch, Español”. Most of the languages should be specified in English.

2. Choose your sex and your partner’s sex (or don’t specify). The bot is in the lack of women. If you’re a man, you’ll need to wait for a while. The more you wait—the closer you are to the head of the queue.

3. Talk! Attach photos, videos and documents to your messages. The bot supports almost every type of messages except replies and forwarded messages.

The bot is able to talk with you on English, Russian, German, Spanish or Italian language. If you want to help with Rand Talk’s translation on another languages or you want to participate in development, welcome to the GitHub repository (AGPL).

That’s the first time:

1. I’ve written Telegram bot,
2. I’ve used Python 3 coroutines at my project,
3. I did use unit tests so widely during development.

During first weeks of work more that 15 thousand people have come to the bot. Most of them speak Italian. English is the second language by popularity. Russian is on the third place. Users are able to send invitational links to their friends. This helps experienced users to invite newbies. To send the invite type in any of your Telegram chats: @RandTalkBot and press Space key: Telegram’s inline query will help you to get your individual invite link in one tap. For every invited user you’ll get bonuses which’ll speed up new partners’ search.

Unfortunatelly, only 17% of users are women. To fight with such gender inequality Rand Talk gives its bonuses smartly. You’re able to earn 3 bonuses for every “girl” and only 1 for every “boy” you’ll invite. Once Rand Talk will have more females than males, it will switch to generous rewarding you for men automatically.

I would be glad to meet you at my anonymous chat! t.me/RandTalkBot.

Вам нужно общение, хотите отточить иностранный язык или просто повеселиться? На помощь придет Rand Talk—бот для анонимного общения со случайными собеседниками: t.me/RandTalkBot.

1. Выберите язык, на котором вы сможете общаться. Знаете несколько языков? Укажите их все—от родного к самым плохо изученным, например так: «Русский, English, Español». Для большинства языков пока нужно использовать их название на английском.

2. Укажите ваш пол и пол собеседника (или не указывайте). Внимание, девушки! У нас дефицит женского населения :) Если вы мужчина, это ничего—когда бот временно не может найти для вас партнера подходящего пола, говорящего с вами на одном языке, он перейдёт в режим ожидания. Чем дольше вы ждете, тем вы ближе к началу очереди—всё честно.

3. Общайтесь: прикрепляйте к сообщениям фотографии, видео, документы. Поддерживаются все типы писем за исключением перенаправленных сообщений.

Бот может разговаривать с вами на русском, английском, немецком, испанском или итальянском. Если вы хотите помочь с переводом Rand Talk’а на другие языки или хотите поучаствовать в разработке, добро пожаловать в репу на GitHub (AGPL).

За первые несколько недель работы бота в него зашло более 15 тысяч человек. В основном они говоярт по-итальянски и по-английски. Русский—третий по популярности язык. Основная часть новых пользователей узналa о боте благодаря инвайтам—специальным ссылкам, которые рассылали своим контактам старожилы. Чтобы отправить инвайт, наберите в любом своём чате название нашего бота: @RandTalkBot и нажмите пробел—благодаря inline-запросам Telegram вы в один тап отправите ссылку на бот. За каждого приглашенного пользователя вы получите баллы, которые ускорят поиск новых собеседников.

К сожалению, пока только 17% пользователей—женщины. Для борьбы с гендерным неравенством, бот, начиная с 8-го марта 2016 года, начал автоматически отслеживать соотношение мужчин и женщин. Сейчас за каждую приглашённую девушку вы получите 3 балла, а за мужчин—только 1 балл.

Буду рад встретить вас в анонимном чате! t.me/RandTalkBot.

I did work on coursework about universal charging device from the September of 2015. I’m developing this device’s modification until now.

There’re specialized charger controlling chips. Why do I work on my device if anyone can use such chip with only a few mounted passive components? The feature of my project is its universality—it should have ability to change charging accumulator’s type without physical intervention at least in theory.

Every accumulators’ variety has its own charging regime. For example lead-acid battery is charged by constant voltage, but nickel-cadmium battery—by constant current.

As the basement for my work I’ve used AVR450 demo board (PDF, 411 KiB), regulated by AVR microcontroller AT90S4433. This board is able to charge various accumulators only changing MCU’s flash.

You’re able to monitor charging process with AVR450. Using RS232 interface you can see on computer current through the accumulator, voltage on it and accumulator’s temperature. Why such information could be important when you’re charging ordinary accumulator? Li-ion accumulators which I was focused at aren’t as simple as they’re look. For full and fast charging they should pass through two stages:

1. constant current charging (I),
2. constant voltage charging (U).

You may see this stages on graph from “Annual Radio Journal” 2013, no. 27 (RU, DJVU, 25 MiB): at some point we should switch the stages. We want to see on the computer’s screen something like that after Li-ion accumulator charging from zero. We’re interested in stability of desired parameters and in precision of stages’ switching moment.

But AVR450’s microcontroller is obsolete at least because it’s hard to find in shops. I have a desire to renovate the scheme using modern ARM-microcontroller STM32L152RBT6. This chip is slightly excess for such charging device, but I want to study modern microcontrollers this way.

At this moment preliminary device scheme is ready. It still needs to pick up exact resistors’ values, but in general it should stay as is.

I’ve used breadboarding with STM32L152 Discovery board actively during the development. This made me sure that the scheme will work when I order expensive PCB.

I hope that I’ll extend this post with assembled device photos and final schematic files soon.

С сентября 2015 года я занимался курсовым проектом, целью которого является разработка универсального устройства для заряда различных типов аккумуляторов. Работа над модификацией этого прибора идёт до сих пор.

Существуют специализированные микросхемы-контроллеры за­ря­да,—и в чём же тог­да пре­лесть моей работы, если можно использовать готовый электронный модуль с минимумом навесных элементов? Особенность моей конструкции в том, что передо мной было поставлено требование универсальности зарядного устройства—чтобы была по крайней мере теоретическая возможность сменить тип заряжаемых аккумуляторов, не внося физических изменений в устройство.

Каждая разновидность аккумуляторов заряжается в отличном от других режиме. К примеру, свинцовые аккумуляторы нужно заряжать постоянным напряжением, а вот никель-кадмиевые (NiCd)—постоянным током.

В основу моей конструкции легла демонстрационная плата AVR450 (PDF, 411 KiB), использующая микроконтроллер AVR AT90S4433. Эта плата позволяет осуществлять зарядку аккумуляторов различных типов, не меняя ничего кроме прошивки микроконтроллера.

AVR450 даёт возможность следить за процессом заряда. Если подключить модуль к компьютеру по интерфейсу RS232, можно пронаблюдать за током через аккумулятор, отслеживать напряжение на нём и температуру его корпуса. Казалось бы, что интересного можно увидеть, если записать эти показатели у обычного аккумулятора? Оказывается, Li-ion аккумуляторы, на которых было принято решение сфокусироваться, не так просты. Для быстрой и полной их зарядки требуется пройти через два этапа:

1. зарядка постоянным током (I),
2. зарядка постоянным напряжением (U).

На графике из Радиоежегодника от 2013 года, выпуск 27 (DJVU, 25 MiB) наглядно показаны эти процессы: как от первого этапа мы переходим ко второму. Зарядив Li‑ion аккумулятор с нуля и собрав показания с AVR450, хотелось бы увидеть на экране компьютера что-то подобное. В реальной жизни представляет интерес постоянство нужных показателей и точность соблюдения требуемого момента смены этапов.

Однако микроконтроллер, использованный в AVR450, устарел хотя бы потому, что его уже трудно найти в продаже. У меня возникло желание модернизировать схему, использовав в ней современный ARM-микроконтроллер STM32L152RBT6. Эта микросхема несколько избыточна для относительно несложного зарядного устройства, но мне очень хотелось попутно научиться работать с современными микроконтроллерами.

На настоящий момент готова предварительная принципиальная схема зарядного устройства. В ней ещё требуется подобрать номиналы резисторов обратной связи операционных усилителей, но в общих чертах она измениться не должна.

В процессе разработки я активно применял макетирование с использованием платы STM32L152 Discovery и заранее купленных деталей, предназначенных для установки в реальную схему. Это вселяло в меня уверенность, что устройство заработает, когда уже будет заказана дорогостоящая печатная плата.

Надеюсь, что в скором времени я дополню этот пост фотографиями изготовленного устройства и конечными чертежами.

Instagram bot written in Python 3.5 that cycles through specified hashtags and automatically likes pictures with those hashtags to get more followers. The bot also follows people and unfollows them after specified period of time. Unfollowed people are saved in DB to prevent following them again. To find new people to follow it uses list of followers of people you have followed.

During installation process it saves people followed by you as “followed long time ago” and unfollows them at the first start.

The bot doesn’t use Instagram API so all credentials you need are your login and password.

I’ve forked this bot from the Marc Laventure’s repository. It was rewritten significantly: Python version was raised up and lots of new features were added.

Deployment

$ virtualenv --python=/usr/bin/python3 instabotenv$ cd instabotenv$ source bin/activate(instabotenv) $ git clone https://github.com/quasiyoke/InstaBot.git(instabotenv) $ cd InstaBot(instabotenv) $ pip install -r requirements.txt

Create MySQL DB:

CREATE DATABASE IF NOT EXISTS instagram CHARACTER SET utf8 COLLATE utf8_general_ci;
CREATE USER instabot@localhost IDENTIFIED BY 'GT8H!b]5,9}A7';
GRANT ALL ON instagram.* TO instabot@localhost;

Create configuration.yml file containing your credentials, e.g.:

credentials:
  username: "your_username"
  password: "eKeFB2;AW6fS}z"
db:
  host: "localhost"
  name: "instagram"
  user: "instabot"
  password: "GT8H!b]5,9}A7"
following_hours: 120
hashtags:
  - I
  - люблю
  - Python
instagram:
  limit_sleep_time_coefficient: 1.3
  limit_sleep_time_min: 30
  success_sleep_time_coefficient: 0.5
  success_sleep_time_max: 6
  success_sleep_time_min: 4
logging:
  version: 1
  formatters:
    simple:
      class: logging.Formatter
      format: "%(asctime)s - %(levelname)s - %(name)s - %(message)s"
  handlers:
    console:
      class: logging.StreamHandler
      level: DEBUG
      formatter: simple
    file:
      class: logging.handlers.RotatingFileHandler
      level: DEBUG
      formatter: simple
      filename: log.log
      maxBytes: 10485760
      backupCount: 10
      encoding: utf-8
  loggers:
    instabot:
      level: DEBUG
  root:
    level: DEBUG
    handlers:
      - console
users_to_follow_cache_size: 300

Where:

• following_hours—how long users will stay followed.
• hashtags—list of hashtags to get photos to like. Optional. By default bot won’t like anything.
• logging—logging setup as described in this howto.
• users_to_follow_cache_size—how much users should be fetched for following. The cache is being filled in once a minute. Optional. By default bot won’t follow anybody.

Create necessary DB tables:

(instabotenv) $ ./instabot_runner.py install configuration.yml

Run:

(instabotenv) $ ./instabot_runner.py configuration.yml

Feedly is a web RSS reader. It gives you ability to comfortably read news from any source you like. RSS is widely supported by various websites. You can receive updates from this site using RSS too!

My Firefox extension indicates if the website you browse has RSS feed. If it hasn’t the extension doesn’t bother you (it looks like gray inactive Feedly icon). But if the site has RSS you can instantly add it to the Feedly with several clicks.

I’ve started this project with forking original Add to Feedly extension. Saeed Moqadam have written very simple and great extension but it lacks some features I want. Some websites have several RSS feeds simultaneously. In such cases they usually provide short description of each feed. This information is very simple to extract from the webpage. I did it and called my fork “Add to Feedly Plus”.

Despite from its simplicity, my addon was unexpectedly popular at Mozilla Firefox extensions’ catalog. At its peak daily users count was around 2.6 thousand people. It’s first so popular program written by me.

Audience of my extension is decreasing. You’re able to look at the stats here. Perhaps I’ll try do something with it in the future.

I was very pleased by Yufan Lou’s pull request extending the list of supported RSS MIME types (courtesy of Robert MacLean). Now Add to Feedly Plus supports the following full (I hope) list of RSS MIME types:

application/rss+xml
application/rdf+xml
application/atom+xml
application/xml
text/xml

You’re welcome to install my addon or to view its source code at GitHub.

По всему миру любители собирают электронные часы, в которых для вывода информации (отображения цифр) используются «многоэлектродные индикаторы тлеющего разряда» или т.н. «газоразрядные индикаторы». По-английски эти радиолампы зовут «nixie tubes», а часы на такой элементной базе: «nixie clock». В популярности этого увлечения легко убедиться, поискав «nixie clock» картинки. Интересная особенность большинства таких часов—использование, можно сказать, морально устаревших индикаторов (разумеется, из эстетических соображений) совместно с современными цифровыми микросхемами. По‑моему прекрасная мода, в гонке за которой я с удовольствием участвую.

У меня есть шесть газоразрядных индикаторов ИН-12А. Их достаточно подробные характеристики можно найти в справочнике «Электровакуумные, электронные и газоразрядные приборы» под редакцией А.С. Ларионова, с. 514.

Важное свойство большинства радиоламп вообще—необходимость в источнике высокого напряжения. К примеру, мои ИН-12А гарантированно зажигаются при напряжении 170 В. Разумеется, это совсем не тысячи вольт анодного напряжения какого-нибудь кинескопа, но уверяю вас, что этого несколько раз хватит для пробоя типичного цифрового компонента.

Если вы соберётесь делать такие часы, первую половину проблем вам создаст цифровая часть (например, программирование микроконтроллера), а вторую—капризная схема источника высокого напряжения. Такой источник отвечает за повышение напряжения, на пример, с 12 В до требуемых 170 В. Будьте готовы для него:

1. искать где-то катушку с не только заданной индуктивностью (сотни микрогенри), но и током насыщения (около 1 А),
2. покупать дорогие полевые транзисторы, которые будут норовить сгореть,
3. внимательно следить при макетировании не только за тем, чтобы не было лишних контактов, но и за наличием всех необходимых соединений—здесь это часто служит причиной порчи деталей,
4. налаживать схему, постоянно остерегаясь удара высоким напряжением.

Приведённый здесь фрагмент схемы Sunny Clock на микросхеме MC34063AD, которая дала толчок моим изысканиям, принимает 12 В в узле P12V и генерирует высокое анодное напряжение в узле HV. Поначалу я думал в точности повторить этот модуль в своей конструкции, однако оказалось, что полевой транзистор Q1 ощутимо нагревается в процессе работы без каких-либо разумных для того оснований. Судя по всему, многих повторивших эту схему устраивает такое поведение, поскольку нагрев не очень существенный, однако некоторый перфекционизм во мне сопротивлялся таким компромиссам.

Благодаря одному материалу я узнал, что у MC34063AD есть возможность только «подтягивать» затвор транзистора Q1 к +12 В и нет возможности задать ему нулевой потенциал. Поскольку для полевых транзисторов характерна некоторая ёмкость затвора, для того, чтобы полевик закрылся, требуется резистор R12—это через него разряжается затвор. Сие решение, конечно, ущербно, поскольку во время переходного процесса по разрядке затвора транзистор находится в линейном режиме, и на нём выделяется тепло. Из той же статьи я почерпнул грамотное решение этой проблемы с использованием дополнительного PNP-транзистора (Q2 на моей схеме ниже), которое хорошо показало себя на практике.

Для управления устрашающими сотнями вольт с помощью хиленького микроконтроллера можно использовать десяток достаточно высоковольтных транзисторов, либо специализированную микросхему К155ИД1, как это сделал я. Она также содержит дешифратор, что сэкономит порты микроконтроллера.

На фото вы можете видеть процесс испытания дешифратора. На макетную плату поданы два напряжения: +180 В—для питания индикатора и +5 В—для микросхемы. Для задания нужного двоичного кода достаточно «занулить» требуемые ножки дешифратора: TTL-логика означает, что все неприсоединённые ножки будут «подключены» к высокому уровню сами по себе.

Ниже приведена слегка модифицированная схема Sunny Clock, которая мной не испытывалась.

У этой конструкции есть существенные недостатки.

1. Из схемы этого явно не видно, но я изначально предполагал распределить три анодных оптопары по цифрам следующим образом: 12:31:23—такое распределение означает, что для того, чтобы погасить оба разряда минут, к примеру, придётся подать высокое напряжение на все катоды соответствующих ламп. Оказывается, как замечают на уже упоминавшемся выше сайте, гасить индикаторы таким образом не рекомендуется:

   Do not blank, by turning all cathodes off. Especially, when using cathode drivers like a 74141 (or its Russian equivalent). If you attempt this with these devices, they will see over ~100V, and will conduct thru more than one cathode at a time. This will look similar to ghosting. These devices are leaky, so at least one cathode should be ON at all times.

   Чтобы иметь возможность погасить на мгновение нужную пару ламп, составляющих число, следует распределить оптопары по индикаторам следующим образом: 11:22:33—значит чтобы погасить, к примеру, минуты, вы можете просто снять анодное напряжение оптопарой номер 2. Это пригодится, например, для режима настройки часов, чтобы мигать настраиваемым числом: часами, минутами или секундами.

2. Схема использует морально устаревший микроконтроллер ATMega8. В рамках моей постоянной программы по изучению ARM, я бы хотел использовать в своих часах STM32L152RBT6.

3. Микроконтроллер вполне может взять на себя функции микросхемы MC34063AD. Все микроконтроллеры обладают широкими возможностями по генерации ШИМ-сигналов и АЦП, подходящим для создания отрицательной обратной связи, следящей за уровнем высокого напряжения. Тем самым мы не только избавляемся от лишнего корпуса, но и получаем возможность без труда интеллектуально менять анодное напряжение на индикаторах—к примеру, в зависимости от условий освещения.

В скором будущем эта статья, надеюсь, будет дополнена фотографиями прототипа.

Amateurs around the world are building electronic clock using “cold cathode display” or ”nixie” tubes for displaying digits. Such clock are usually called nixie clock. If you search for “nixie clock” pictures you’ll see how popular they are. Interesting nixie clock feature is that they’re using obsolete indicators (for aesthetic purpose of course) but modern chips. I think this trend is charming and I’m happy to participate in it.

I have six IN12-A nixie tubes. You may find their properties at some reference.

Important radio valves’ requirement is high anode voltage. My IN12-A tubes are shining reliably at 170 V. Of course that’s far from thousands of volts for some CRT, but such voltage can kill typical digital component several times at once.

If you’re building such clock first part of your troubles will be produced by digital circuit (flashing your MCU for example) and second part by cranky high voltage generator. Such power source is responsible for stepping up voltage from e.g. 12 V to desirable 170 V. You should be ready to:

1. find somewhere coil with specified inductivity (hundreds of microhenry) and saturation current (approximately 1 A),
2. buy expensive field-effect transistors which will tend to burn out,
3. look for redundant and missing contacts between the parts carefully, the latter are risky in such schemes too,
4. debug the scheme bewaring of high voltage strokes continuously.

The following Sunny Clock scheme (ru) fragment based on MC34063AD chip was the starter for my discoveries. It takes 12 V at P12V node and generates high anode voltage at HV node. At first I’ve tried to reproduce this module as is but it turned out that transistor Q1 is pretty hot without any rational reason. It looks like most of amateurs are OK with such behavior because this heating isn’t significant but I wasn’t satisfied with this compromise.

Thanks to some article I’ve discovered that MC34063AD is able to only pull up Q1 transistor’s gate to +12 V but it can’t pull the gate down. FETs have significant gate’s capacity so you need resistor R12 to discharge and “close” it. Such solution isn’t perfect at all because during transition the transistor works in linear mode and heats up. The same article gave me good solution for this trouble. Additional PNP transistor (Q2 on the scheme below) closes the FET very good without any heating.

To manipulate terrifying hundreds of volts using weak microcontroller you’re able to use a bunch of high voltage transistors or specialized K155ID1 chip as I did. It also contains binary decoder which will keep some MCU’s ports for another tasks.

The photo shows decoder probing process. The breadboard is powered with +180 V for the tube and +5 V for the chip. To specify desired binary code you need to pull down “zero” decoder’s pins. TTL logic implies that all unconnected pins will be pulled up by themselves.

You may see modified Sunny Clock scheme below. I didn’t test it.

This schematic has significant flaws.

1. You are unable to see that using only the scheme but I assumed to distribute three anode optocouplers this way: 12:31:23—such distribution means that you need to turn high voltage on all cathodes of minutes (for example) to turn them off. The site I mentioned above says that turning tubes off this way isn’t appropriate:

   Do not blank, by turning all cathodes off. Especially, when using cathode drivers like a 74141 (or its Russian equivalent). If you attempt this with these devices, they will see over ~100V, and will conduct thru more than one cathode at a time. This will look similar to ghosting. These devices are leaky, so at least one cathode should be ON at all times.

   To be able to turn off desired pair of the digits, one must distribute the optocouplers this way: 11:22:33—that means you can blank minutes just by turning anode voltage with optocoupler number 2. That may be useful for setup mode to blink with configurable number: hours, minutes or seconds.

2. The scheme uses obsolete ATMega8 MCU. I want to change it to STM32L152RBT6 because I’m studying ARM microcontrollers.

3. MCU could take the responsibility of MC34063AD chip. Every microcontroller has wide abilities of generating PWM signals and ADC for feedback loop for high voltage. This makes possible not only reducing of chips’ count but also change anode voltage wisely depending on lighting conditions.

I hope that I’ll extend the article with prototype’s photos in the future.

Pomeranian spitz breed

Pomeranian spitz is a small dogs’ breed with very long, magnificent hair. Spitz’ puppies are very expensive because of their wonderful decorative properties. The most known spitz today is a Boo Bear (but its haircut isn’t typical for spitz). The dogs breeding is very popular in Russia, Europe and Canada. Lots of people are dreaming about such puppy and ride across the globe trying to buy the pomeranian of their dream.

The website was made for pomeranian spitz nursery “Kapustkin Pitomnik”. The club owners are selling puppies from the 2000. Their mother dogs are extremely expensive and very pedigreed. The owners were interested in their own electronic representation and they asked me to help them with the website. They wanted to create honorable and clear view on their great kennel.

Design

I’ve used Inkscape for doing the sketches when I did design the site. The sketches are good to discover your view to the project without distraction at technical moments. You’re just drawing. CSS and browsers’ quirks aren’t inventing instead of you.

Content management system

To make the kennel’s owners able to add fresh content on the website I’ve created advanced content management system. The CMS gives them ability to interactively create new entities (dogs or broods), crop photos and edit pages, advertisements and banners in “what you see is what you get” manner.

Each photo is provided with the nursery’s watermark automatically.

Mobile users

I didn’t expect it but most of the website users are using mobile phones for browsing! Later I’ve discovered that they’re coming from the link from the kennel’s instagram profile.

Mobile version of the website has a little bit less information than “big brother”. Larger controls, smaller pictures, only necessary details.

I think that I’ve completed the task. The nursery had a good internet residence.

The website is no longer functional since 2019, but you can get familiar with it at Internet Archive.

Представьте сайт, на котором каждый может скачать программное обеспечение – клиент, скачивание и работа которого в течение какого-то времени (скажем, получаса) даёт возможность осуществить распределённый подбор пароля.

Обыкновенно:

1. Вы оставляете на сайте заявку на подбор пароля.

2. Сайт немедленно пушит запущенному у вас клиенту задачу на подбор пароля c вашей машины, а также несколько задач-довесков на подбор пароля от других пользователей. Задание на подбор пароля содержит:

   • Пользовательские идентификационные данные.
   • Смещение внутри файла-словаря, с которого следует начать перебор.
   • Схема подбора паролей сайта: URL, HTTP-method, POST-data, HTTP-Cookies, маркер успешно подобранной страницы (скорее всего, наличие или отсутствие на ней некоторой строки), минимальную задержку между запросами и прочее.

3. Клиент с высоким приоритетом подбирает пароль от интересующего вас аккаунта, параллельно подбирая задачи с более низким приоритетом.

4. Спустя некоторое значительное время работы вашего клиента сайт рассылает другим работающим в данный момент клиентам вашу задачу и начинается теперь уже распределённая работа над подбором.

5. Клиент, подобравший пароль, сообщает его на сервер.

6. Сервер, получив пароль, командует всем клиентам остановить подбор задачи.

Минусищищщще этой схемы в том, что её можно использовать лишь для совсем не важных вам аккаунтов: кто угодно, лишь немного возлюбопытствовав, увидит, что за аккаунты подбираются его машиной, а если повезёт, получит и пароль.

Второй минус, или слабое место, в том, что очень скоро некто напишет клиента, который станет врать. Нетрудно поймать за руку того, кто сообщает ложный пароль (нужно лишь воспользоваться известными нам критериями), однако ловить разгильдяя-лгунишку, который качает фильмы вместо того, чтобы помогать подбирать, и при этом хвалится своими преодолёнными чанками в файлах-словарях, кажется, очень трудно. Ключ к решению этой проблемы в том, что нужно заставить посетителей дорожить своей репутацией: старожилы должны быть достойны более высокого приоритета подбора своих паролей на чужих машинах, к примеру.

Можно использовать сайт-honeypot, постоянно размещая заявки на его взлом. Сравнив статистику запросов на нём и заявленные клиентами данные, найти шарлатанов должно быть просто; после этого достаточно пометить их, сразу отменив распределённый подбор их задач, а спустя некоторое случайное время работы клиента, занести его в окончательный и беспощадный чёрный список. Все эти реверансы с нарушителем нацелены на то, чтобы замести следы к honeypot’у, который следует держать в тайне.

Нужно нисколько не поощрять владельца машины, с которой был подобран пароль к отдельно взятому аккаунту. Как бы это ни было, наверное, маркетингово неправильно, «везучесть» ничего не стоит, в отличии от объёма перебранных паролей. Это сведёт число создателей подложных аккаунтов к минимуму.

Клиенты при переборе оказываются весьма рационально нагруженными: ведя подбор собственной задачи, они в интервалах простоя выполняют запросы к другим задачам. Если проект станет успешен в подборе, проводя статистику мы сможем принимать обоснованные решения об эффективности словарей. Только представьте, каким умным может стать алгоритм выставления приоритета перебору: вероятно, более высокий приоритет задача должна получить на клиентах, имеющих до неё пинг меньше сравнительно с как их собственными задачами, так и с пингами на других машинах до этой задачи. Полагаю, следует сразу заявить о том, что ваши пароли могут стать в результате известны кому угодно, даже не пытаясь закрыть код клиента и расхваливать HTTPS: только выложив его публично, мы получаем шанс дать ход замечательным идеям талантливых программистов. Такой ресурс будет полезен хотя бы тем, что станет первым хостингом схем подбора паролей на различных сайтах, что делает систему применимой даже когда вы вынуждены подбирать пароль к какому-то важному аккаунту: для этого случая в клиенте должен быть предусмотрен режим приватного, нераспределённого перебора.

Я не одобрю побуждений, которые могут сподвигнуть кого-то пользоваться подобным ресурсом (задумайтесь: не очень важные человеку аккаунты, наверное, какой-то не имеющей к нему отношения персоны – по всей видимости это мелочная месть за какой-то пустяк?), но мне очень нравится идея, сама по себе.

…ну вот, никогда не понимал обожателей оружия, возвышенных, видевших его только в музеях и книгах, а сам…

Данный текст был рождён как тредик на форуме python.su, не удостоенный никакого внимания.

My first version control system was Mercurial. I’ve learned about it from UTP podcast (Russian). So the first public repository I had was on Bitbucket. Now I’m using GitHub for that. I’ll try to take short overview of my GitHub account here.

telepot

An example of my work at foreign open source project. telepot is a Python framework for Telegram Bot API. I’ve used it in my Rand Talk bot project.

My hosting provider had only Python 3.3 on its machines at the beginning of 2016. To use telepot you need at least Python 3.4. I’ve discovered that my program works well with telepot installed on Python 3.3 if I bring one additional package to it. My first pull request to telepot adds Python 3.3 compatibility to it. Unfortunately Nick Lee—an author of the framework don’t want to support one additional language version so he has refused my pull request. Today I think that he was right because just after one email to my hosting provider they have installed fresh version of Python.

In the February of 2016 ability to send silent messages was added to the Telegram. Telegram bots were able to send such messages too. GitHub user boxama has added such ability to synchronous telepot methods. In my pull request I’ve added this feature to async methods because Rand Talk is an asynchronous bot. This time my pull request was accepted successfully.

Yet another Turing machine

Turing machine is a mathematical model of computer. Any algorithm can be executed on such machine. Classic programming exercise is a Turing machine implementation. If you’re able to implement Turing machine on some language this language is Turing complete and you can execute any algorithm on it.

I’ve implemented Turing machine using C language. My repo has some simple Turing machine tables: simple rotating animation, arithmetic and logical conjunction, string copying, subtraction and their tests.

It was very pleasant to accept Anton Chekanin’s pull request. He’s an author of subtraction algorithm table and its tests.

Keys of Peace (not finished)

Free website allowing you to keep your passwords encrypted with a single “master password”. You don’t need to remember all passwords from your accounts so they could be very long and hard to crack.

Unlike usual password managers this project assumes that you don’t need any specific application to have access to your passwords. Just imagine: you’re opening browser at your friend’s laptop at some far trip and you’re still able to use your private accounts securely.

You’re not ready to show your passwords to my website? You don’t have to! Modern cryptography allows to build zero trust scheme where client code does all the job with the passwords right at your browser. The server just stores encrypted blobs.

Keys of Peace idea was extremely hard to implement right because of several reasons:

1. Client-side cryptography is insecure by itself. That’s obvious but you’re able to read this in-depth article if you want.

   For example you can’t guarantee to your users that you will send them only honest scripts each time. Perhaps at some day your website will be hacked and Mallory replace your client code with malicious program exposing users’ “master passwords” to Mallory’s server.

2. There’re web password managers like Clipperz which are existing since 2006. Despite of high Clipperz’ crew proficiency the service isn’t very popular.

3. Passwords’ storage should be done right. At first alpha-incarnation of Keys of Peace website I did use my own poorly designed storage format. Looking at article on password managers database security (PDF) I’ve decided that I should switch to Password Safe storage format. I haven’t finished my work on saving passwords database in such storage.

Keys of Peace repository had the largest amount of the stars across all my repos but even the list of its problems isn’t finished. This project pushed me to read Shneier’s Applied Cryptography book and to pass Cryptography I course. Believe me, Keys of Peace is a shockingly tough and very interesting project.

I did use MobileLexicon English to Russian dictionary on my cell phone for some time. This dictionary has horrible interface and pretty good vocabulary. You need to apply some force to obtain translations from it. This program didn’t satisfy me.

I’ve written MobileLexicon database converter to my own binary format. It stores the dictionary in the prefix tree. The midlet I’ve also written is able to read such database.

PieceOfDictionary is a combination of converter and the dictionary midlet.

Features

You’re able to

• enter English words using virtual qwerty keyboard on touchphones (should work on the hardware qwerty too),
• switch interface languages in the “Options” and turn on/off fullscreen mode with long tap,
• use predictive text input on the phones with digital keyboard,
• watch words’ history by pressing “Left” / “Right” keys or by swiping to the left/right.

Dictionaries are the best candidates to implement predictive text input by program developer. It’s strange that I didn’t see that in other programs.

Russian letters are often situated on the keys with small differences. E.g. “Fly phones“ aren’t using usual order: абвг | деёжз | ийкл | мноп | рсту | фхцч | шщъы | ьэюя, but you’re able to setup letters’ placement in the program’s preferences.

There’s no translation direction menu. You can see that various directions’ words articles were mixed with each other. There’s no need in such menu: just press right keys and you’ll see your word.

In the case when you’re entering the word using virtual keyboard translation direction menu would be definitely excess: you’ve already chosen input language.

Words articles are sorted in the following order:

1. amount of non-space chars in article’s key,
2. ISO 639-2 language tag (eng, rus)—lexicographically,
3. article’s keys—lexicographically.

PieceOfDictionary’s first launch parameters are specified in parameters.xml file. The program was intended for using any amount of dictionaries. XML files were used for interface translations too. I’ve used kXML to read XML. I had an idea of building a website allowing to add necessary dictionaries to JAR archive (and to edit parameters.xml.

MIDP 2.0 doesn’t have methods of reading UTF-8 files and maximal file size was limited in several JVMs. I’ve written a bunch of EasyReadingFile classes allowing to work with UTF-8 and to seek across the colony of files forming one large “file”.

I recommend the program to the owners of MIDP cell phones’ with digital keyboard because the dictionary has predictive text input (like T9 or iTAP) across vocabulary’s words.

Download PieceOfDictionary

PieceOfDictionary.jar 0.0.1 (1.3 MiB)

Sources (1.3 MiB)

Use, change, publish it but specify my authorship somewhere please.

The program was published on 4pda.ru initially.

Когда мне понадобился небольшой оффлайн англо-русский словарь под рукой, первым мидлетом, на который я наткнулся, оказался MobileLexicon. Этот словарь отличает ужасный интерфейс и сравнительно неплохая словарная база: часто требуется прикладывать дополнительные усилия для того, чтобы выудить слово из него. Не стану особенно вдаваться в минусы этой программы, достаточно только сказать, что она меня не удовлетворяет.

Поэтому написал конвертер MobileLexicon-словарных баз в собственный бинарный формат, представляющий словарь в виде префиксного дерева, и научил читать этот формат свой мидлет.

Нарекаю связку конвертер-мидлет PieceOfDictionary.

Именно «кусок словаря»—это не ошибка.

Возможности

• вводить английские слова с помощью виртуальной qwerty-клавиатуры на телефонах с тачскрином (должно работать и с хардварным qwerty),
• переключать языки интерфейса в «Опциях» и менять полноэкранный и нормальный режимы долгим тапом до опупения,
• пользоваться предиктивным вводом текста на телефонах с цифровой клавиатурой,
• просматривать историю введённых слов, нажимая Вправо-Влево или делая соответствующие жесты пальцем на экране.

Словари—лучшие кандидаты на реализацию предиктивного ввода разработчиком программы; странно, что я такого не видел в чужих программах.

Если по поводу нанесения английских букв на цифровые клавиши есть какая-то всеобщая договорённость, то русские часто (например, на «телефонах Fly») размещены с отклонениями от чаще встречающегося абвг | деёжз | ийкл | мноп | рсту | фхцч | шщъы | ьэюя, поэтому в настройках программы предиктивный ввод текста отлично настраивается.

Меню выбора направления перевода просто нет—как видите, слова из различных направлений расположились вперемешку. Оно, в самом деле, не нужно: только запустив программу можно сразу нажимать на кнопочки и ждать (все минусы предиктивного ввода присутствуют), пока (не) появится желаемое слово.

Для ввода с виртуальной клавиатуры диалог выбора направления перевода был бы вовсе раздражающим атавизмом, поскольку пользователь уже выбрал язык ввода.

Словарные статьи сортируются в следующем порядке:

1. количество непробельных символов в ключах к статьям,
2. ISO 639-2 тэги языков ключей (eng, rus)—по алфавиту,
3. ключи—по алфавиту.

Параметры, с которыми PieceOfDictionary запускается в первый раз, задаются в файле parameters.xml. Изначально предусматривалось, что программа может иметь любое количество любых словарей. В XML-файлах хранятся и переводы на различные языки. Для мобильных устройств XML, возможно, не оптимальный вариант хранения информации, но альтернативы вроде INI-подобного формата показались мне неприятными. Для работы с XML я использовал kXML.

В MIDP 2.0 не входят средства для чтения из файла подлинного UTF-8, ни в одном из классов не реализована функция seek как таковая и это не говоря уже о том, что максимальный размер читаемого файла во многих JVM ограничен. Поэтому было написано семейство классов со странным названием EasyReadingFile, которые позволяют работать с этим подвидом Unicode и даже делать seek по «колонии» файлов, составляющих один большой «файл», который не каждый телефон смог бы прочесть.

В дальнейшем можно было бы создать сайт, скрипты которого добавляли бы в JAR-архив нужные файлы и редактировали бы «parameters.xml» в соответствии с пожеланиями пользователей.

Если расширится ассортимент словарей, то действительно в программе начнёт иметь смысл возможность если не выбора направления перевода, то, наверное, отключения временно ненужных словарей до востребования.

Рекомендую обладателям телефонов с цифровыми клавишами, поскольку реализован предиктивный ввод текста (что-то вроде T9 или iTAP исключительно по словам, имеющимся в словаре).

Скачать PieceOfDictionary

PieceOfDictionary.jar 0.0.1 (1,3 МиБ)

Исходники (1,3 МиБ)

Смотрите, пользуйтесь, изменяйте, но просто обозначьте где-то, пожалуйста, моё изначальное авторство.

Программа изначально была выложена на 4pda.ru, где не пользовалась особой популярностью.