Kaštanový koláč Gordona Ramseye

Ingredience

  • 250g loupaných, vařených kaštanů
  • 250g kvalitní hořké čokolády
  • 250g másla, nesoleného
  • 125g cukru (krupice, krystal)
  • 4 vejce
  • 125ml smetany
  • 125ml plnotučného mléka

Příprava je primitivní. Ale musí se dělat pečlivě :)

Máslo a čokoládu rozehřejeme ve vodní lázni. Cukr utřeme se žloutky. Smetanu, mléko a nakrájené kaštany dáme vařit – jakmile směs přejde do varu, sundáme a rozmixujeme. Ušleháme sníh ze 4 bílků. Čokoládovou směs, cukr a kaštany smícháme a vymícháme dohladka. Opatrně vmícháme ušlehaný sníh. Dáme péct do vyhřáté trouby (170oC) na 20-30minut.

Po pečení vyndáme, necháme chvíli chladnout – dort se stáhne a popraská – a podáváme buď ještě teplé nebo necháme úplně vychladnout.

Pár tipů:
Pokud máte vejce v lednici, nechte je pár hodin ohřát a stabilizovat se. Sníh musí být lesklý a pevný – ideálně šlehat v kovové misce, přidat špetku soli.

20131219-222524.jpg

rails + passenger + nginx maintenance mode

I need to add maintenance page to some rails app, running with passenger and nginx. Here’s some config and steps.

You just need to add static html file to app_root/public/maintenance.html – and I assume css files on /assets url.

so, here’s nginx config:

server {
  listen 80;
  server_name = www.example.com;
  root /home/deploy/www.example.com/public;
  passenger_enabled on;
  passenger_min_instances 5;

  set $maintenance 0;

  # is there maintenance file set?
  if (-f $document_root/../tmp/maintenance.txt) {
    set $maintenance 1;
  }

  # exclude /assets
  if ( $uri ~* ^/assets\/\.* ) {
    set $maintenance 0;
  }

  # in maintenance mode - send 503 status
  if ($maintenance = 1) {
    return 503;
  }

  # maintenance mode
  error_page 503 @503;

  # rewrite everything to maintenance.html
  location @503 {
    rewrite ^ /maintenance.html last;
    break;
  }
}

setting maintance mode is really simple – set app_root/tmp/maintenance.txt file – when escaping, just remove that file.

Need to split big SQL dump into separate databases?

I do. So I’ve written small bash script to do so. I think it’s self explanatory and does it’s job well :)

#!/bin/bash

if [[ $# -lt 1 ]]; then
  echo "Usage: $0 filename"
  exit 1
fi

FILE=$1
echo "Spliting "$FILE""

# default filename for sql headers
dbname=header

cat $FILE | while read line; do
 # echo $line
  if [[ $line =~ ^USE\ \`([^\`]*)\`\; ]]; then
    dbname=${BASH_REMATCH[1]}
    echo "Found db '$dbname'"
  fi
  echo $line >> $dbname.sql
done

I do NOT have CREATE DATABASE in sql file, thus set to USE..

Change image in UIImageView – RubyMotion

I needed to change image in my UIImageView, but simply setting new image using myImageView.setImage didn’t work. There’s simple workaround

@button = UIView.alloc.initWithFrame(frame)
buttonImage = UIImageView.alloc.initWithFrame(@button.bounds)
buttonImage.setTag(1) # set any number you want
buttonImage.autoresizingMask = UIViewAutoresizingFlexibleWidth | UIViewAutoresizingFlexibleHeight
@button.addSubview buttonImage

and now set the image

self.button.viewWithTag(1).setImage(UIImage.imageNamed('answer_bar_white.png').resizableImageWithCapInsets(UIEdgeInsetsMake(18, 18, 18, 18)))

you can remove resizableImageWithCapInsets – I’m using square images to make UIImageView of any size.

Blink LED2 – LPC1769

LPCXpresso finally beaten. Installed new v5, imported all the CMSIS needed and setup brand new, my very first, MCU example code :) I’m using LPC1769 sample board from Embedded Artists.

#ifdef __USE_CMSIS
#include "LPC17xx.h"
#endif

#include <cr_section_macros.h>
#include <NXP/crp.h>

// Variable to store CRP value in. Will be placed automatically
// by the linker when "Enable Code Read Protect" selected.
// See crp.h header for more information
__CRP const unsigned int CRP_WORD = CRP_NO_CRP ;

int main(void) {
    // Set P0_22 to 00 - GPIO
    LPC_PINCON->PINSEL1 &= (~(3 << 12));
    // Set GPIO - P0_22 - to be output
    LPC_GPIO0->FIODIR |= (1 << 22);

    volatile static uint32_t i;
    while (1) {
        LPC_GPIO0->FIOSET = (1 << 22); // Turn LED2 on
        for (i = 0; i < 1000000; i++);
        LPC_GPIO0->FIOCLR = (1 << 22); // Turn LED2 off
        for (i = 0; i < 1000000; i++);
    }
    return 0;
}

and the same in assembler (from http://pygmy.utoh.org/riscy/cortex/led-lpc17xx.html)

;;; led-lpc17xx.asm
;;; written by Frank Sergeant
;;;    frank@pygmy.utoh.org
;;;    http://pygmy.utoh.org/riscy
;;; This program is in the public domain.  See http://pygmy.utoh.org/riscy/cortex/
;;; for notes about the program and how to assemble, link, and burn to flash.

;;; Blink the LED on the LPCXpresso LPC1769 ARM Cortex M3 board
;;; (or any LPC17xx ARM board with perhaps minor modifications).

;;; The LED on the Xpresso board is labeled LED2 and is just to the
;;; left of (inside of) J6-36.  It is connected to P0.22. The LED is
;;; on when P0.22 is high.
        
;;; Directives
        .thumb                  ; (same as saying '.code 16')
        .syntax unified

;;; Equates

        .equ LED_MASK, 0x00400000 ; i.e., bit 22
        
        .equ PINSEL0,  0x4002C000
        .equ PINSEL1,  0x4002C004

        .equ FIO0DIR,      0x2009C000 ; port direction, 0 (default) = input
        .equ FIO0MASK,     0x2009C010 ; port direction, 0 (default) = input
        .equ FIO0PIN,      0x2009C014
        .equ FIO0SET,      0x2009C018
        .equ FIO0CLR,      0x2009C01C
        
        .equ STACKINIT,   0x10004000

        .equ LEDDELAY,    300000

.section .text
        .org 0

;;; Vectors
vectors:
        .word STACKINIT         ; stack pointer value when stack is empty
        .word _start + 1        ; reset vector (manually adjust to odd for thumb)
        .word _nmi_handler + 1  ;
        .word _hard_fault  + 1  ;
        .word _memory_fault + 1 ;
        .word _bus_fault + 1    ;
        .word _usage_fault + 1  ;

_start:

        ldr r6, = PINSEL1
        ;; set P0.22 as a GPIO pin
        ;; P0.22 is controlled by bits 13:12 of PINSEL1
        ;; xxxx xxxx xxxx xxxx xx11 xxxx xxxx xxxx
        ;;    0    0    0    0    3    0    0    0

        ldr r0, [r6]
        bic r0, r0, # 0x00003000  ; clear bits 13:12 to force GPIO mode
        str r0, [r6]


        ;; set LED output pin (i.e. P0.22) as an output
        ldr r6, = FIO0DIR             ; for PORT0
        mov r0, # LED_MASK            ;  all inputs except for pin 22
        str r0, [r6]
        
        ;; r0 still contains LED_MASK 
        ldr r5, = FIO0CLR
        ldr r6, = FIO0SET

loop:
        str r0, [r5]            ; clear P0.22, turning off LED
        ldr r1, = LEDDELAY
delay1:
        subs r1, 1
        bne delay1

        str r0, [r6]            ; set P0.22, turning on LED
        ldr r1, = LEDDELAY
delay2:
        subs r1, 1
        bne delay2

        b loop                 ; continue forever

_dummy:                        ; if any int gets triggered, just hang in a loop
_nmi_handler:
_hard_fault:
_memory_fault:
_bus_fault:
_usage_fault:
        add r0, 1
        add r1, 1
        b _dummy

Download file using AFNetwork

set your Rakefile

  app.pods do
    pod 'AFNetworking'
    ...
  end
  def downloadFile(url, file, filesize)
    url = NSURL.URLWithString(url)
    request = NSURLRequest.requestWithURL(url)
    operation = AFHTTPRequestOperation.alloc.initWithRequest(request)
    operation.outputStream = NSOutputStream.outputStreamToFileAtPath(file, append: false)

    unless filesize.nil?
      SVProgressHUD.showProgress(0, status: "Downloading file")
      operation.setDownloadProgressBlock(lambda{|bytesRead, totalBytesRead, totalBytesExpected|
        SVProgressHUD.showProgress((((totalBytesRead/filesize.to_f)*100.0).round)/100.0, status: "Downloading file")
      })
    end

    operation.setCompletionBlockWithSuccess(lambda{|request, response|
      SVProgressHUD.dismiss unless filesize.nil?
    }, failure: lambda{|request, err|
      SVProgressHUD.dismiss unless filesize.nil?

      @alert = UIAlertView.alloc.initWithTitle('Error',
          message: 'Error when downloading data.', delegate: nil, cancelButtonTitle: 'OK',
          otherButtonTitles: nil)
      @alert.show
    })
    operation.start
  end

when downloading multiple files, use NSOperationQueue

# change donwloadFile

def downloadFile..
 ...
 operation # was operation.start
end
@queue = NSOperationQueue.alloc.init
@queue.name = "FileDownload"
@queue.maxConcurrentOperationCount = 1   # number of concurrent downloads

@queue.addOperation(downloadFile(url, file, filesize))

Makronky – “italská meringue”

Po několika neúspěšných pokusech, prolézání netu skrz naskrz jsem objevil recept a metody – a hlavně odpovědi na otázky, které si klade snad každý makronkovač.

“Proč?”

A odpověď byla

“Protože vše bylo špatně!”

Ale začneme od začátku. Recept a postup je jednoduchý, ale každá chyba a zdánlivá maličkost se nám vrátí v podobě popraskaných makronek, prázdných schránek nebo placatých mandlových sušenek.

Připravme si:

  • teploměr na rozvar, kdo nemá a neumí to očkem, nemusí dále číst
  • 200g mandlové mouky
  • 200g cukru moučky (bohužel jsem u nás neobjevil tu bez škrobu)
  • 200g cukru krystal
  • 50ml vody
  • 150g bílků (cca 5 vajec)
  • barvivo – ideálně gelové

K jednotlivým surovinám. Mandlovou moučku jsem po několika pokusech ji prosévat použil celou. Neprosetou. Bílky – důležité je vejce nechat odležet, vyklepout bílek a nechat ohřát na pokojovou teplotu, tzn. aspoň hodinu – ideálně den, dva. Dále je třeba, aby v bílcích nebyla byť sebemenší stopa čehokoli jiného.

A teď k tomu zajímavějšímu. Budu to psát v bodech, ať se každý může orientovat podle sebe.

  1. Do kastrůlku dáme krystal a vodu. Používám nerez se silným dnem. Dáme vařit na mírný plamen. Zamícháme pouze jednou nebo dvakrát, pak není třeba.
  2. Smícháme cukr moučku a mandlovou mouku. Mixerem mísíme aspoň dvě minuty.
  3. 1/2 bílků oddělíme a dáme na stranu
  4. Druhou polovinu dáme do mísy a vyšleháme sníh. A teď to důležité. Šleháme na vysokou rychlost, žádný cmrndání a šudlání. Zároveň druhým okem hlídáme rozvar. Jeho teplota nesmí překročit 118oC – po dosažení vypnout
  5. Předpokládám, že jste dočetli až sem a tudíž v druhé ruce máte kastrolek s rozvarem
  6. Snižte mixer na pomalý chod a vlévejte rozvar do sněhu. Někdo to leje po misce, já lil přímo do sněhu – ale ne do vrtulek. Lít se musí pomalu, tenkým “čurkem”, ideálně na několik kroků.
  7. Po vlití rozvaru mixer naplno a mixujeme, mixujeme, mixujeme, dokud směs nebude krásně lesklá a pevná. Aspoň 3-5 minut. Musí také zchladnout.
  8. Smícháme první polovinu bílků s mandlovou moučkou a cukrem a mícháme. Mícháme tak dlouho, dokud z toho není těsto.
  9. Do směsi postupně vmícháme bílky s cukrem. POSTUPNĚ! Třeba načtyřikrát. A teď další důležitá věc. Pokud nechcete mít skořápky bez obsahu, míchejte proti stěně mísy, razantně, ale s citem. Není cílem sníh zase překonvertovat na bílek, ale dostat pryč vzduch a “zhutnit” hmotu.
  10. Pak je možné směs rozdělit, obarvit a hurá na plech.
  11. Není nezbytně nutné s plechem mlátit o zem – toť každého volba

Pečení by mělo následovat. Nicméně. Je třeba nechat makronky zaschnout. A pozor. Je špatné málo i hodně. Začít můžete od 15minut a skončit někde u hodiny. Záleží to na bílcích a surovinách, jak měly hodně v sobě vody. Každopádně, jakmile přestává povrch lepit, šup s tím do trouby. Pečeme na 160oC asi 15minut, uprostřed trouby. Pokud na pečícím papíru, stačí 12minut.

Voila! Plnění nechám na každém z vás, já plním ganáží. Pokud se povedly, napište to prosím do komentářů.

Chyby:

  • popraskané makronky – přesušení nebo špatná směs – málo bílků
  • duté makronky – moc vzduchu, chyba při mísení s mandlovou směsí
  • placaté – špatný sníh z bílků

PS: Francouzská/italská. Rozdíl? Francouzská je lehčí, sníh se smíchá rovnou s cukrem, takže se eliminuje spoustu chyb s rozvarem, ale chuťově, dámy a pánové, chuťově je to jinde :-)