Tuesday, March 22, 2016

Let's Discover FPGA !!

La technologie FPGA (Field-Programmable Gate Array) continue de gagner du terrain au domaine :  le march� mondial du FPGA devrait passer d'1,9 milliard de dollars en 2005 � 2,75 milliards d'ici 2010. Depuis leur invention par Xilinx en 1984, les FPGA sont partis d'un simple r�le d'� interfa�age d'appoint � pour arriver � v�ritablement remplacer les ASIC (circuits int�gr�s � application sp�cifique) et les processeurs personnalis�s dans des applications de contr�le et de traitement de signaux.


Afin d'expliquer ce succ�s, cet article propose une introduction � la technologie FPGA et met en �vidence quelques-uns des nombreux avantages que les FPGA sont aujourd'hui les seuls � offrir, introduire le lien direct entre FPGA et VHDL.


Les FPGA (Field Programmable Gate Arrays ou "r�seaux logiques programmables") sont des composants enti�rement reconfigurables ce qui permet de les reprogrammer � volont� afin d'acc�l�rer notablement certaines phases de calculs.
R�sultat de recherche d'images pour "fpga vs asic logo"
L'avantage de ce genre de circuit est sa grande souplesse qui permet de les r�utiliser � volont� dans des algorithmes diff�rents en un temps tr�s court.
Le progr�s de ces technologies permet de faire des composants toujours plus rapides et � plus haute int�gration, ce qui permet de programmer des applications importantes.
Les FPGA sont bien distincts des autres familles de circuits programmables tout en offrant le plus haut niveau d'int�gration logique.

Les circuits FPGA sont constitu�s d'une matrice de blocs logiques programmables entour�s de blocs d'entr�e sortie programmable. L'ensemble est reli� par un r�seau d'interconnexions programmable. 
Il y a 4 principales cat�gories disponible commercialement:

  • Tableau sym�trique.
  • En colonne.
  • Mers de portes.
  • Les PLD hi�rarchique.




Voici la structure interne d'un FPGA de type matrice sym�trique. Il s'agit de l'architecture que l'on retrouve dans les FPGA de la s�rie XC4000 de chez Xilinx.

On programme aussi les interconnexions entre les cellules:


Anisi que les entr�es et sorties du circuit. L'avantage des FPGA est de pouvoir �tre configur� sur place, sans envoi du circuit chez le fabricant, ce qui permet de les utiliser quelques minutes apr�s leur conceptions. Les FPGA les plus r�cents sont configurables en une centaine de millisecondes. Les FPGA sont utilis�s pour un d�veloppement rapide et bon march� des ASIC.
Les cinq principaux atouts de la technologie FPGA:

  • Performances
  • Temps de mise sur le march�
  • Co�t
  • Fiabilit�
  • Maintenance � long terme
Passons au VHDL maintenant, en faite la d�finition g�n�rale de cette derni�re va vous expliquez pourquoi on la utilise au programmation du FPGA.
VHDL est le sigle de VHSIC hardware description language ; VHSIC vient quant � lui de very-high-speed integrated circuits, une initiative de la D�fense am�ricaine dans les ann�es 1980 visant la construction de circuits int�gr�s tr�s rapides. Le VHDL est un langage de description du mat�riel utilis� en �lectronique. En tant que standard, il est ind�pendant du logiciel utilis� pour la compilation, la programmation des composants, la simulation, etc.Il autorise plusieurs m�thodologies de conception (comportemental, flot de donn�es, structurel) tout en �tant d'un tr�s haut niveau d'abstraction en �lectronique (il est ind�pendant de la technologie utilis�e : FPGA, CPLD, ASIC, etc.). Cette abstraction permet d'ailleurs de le simuler sur ordinateur avant de programmer la moindre puce.Lors de sa conception, l'objectif n'�tait pas de produire un nouveau langage ex nihilo : la D�fense avait r�cemment mis au point le langage Ada, il �tait pr�f�rable de partir sur ces bases et en exploiter autant que possible la syntaxe, en l'adaptant au contexte de l'�lectronique num�rique.  

Il n'est pas le seul sur le march� : Verilog, par exemple, est �galement un langage tr�s utilis�, poss�dant une syntaxe fort diff�rente mais des fonctionnalit�s �quivalentes, si ce n'est �gales. VHDL semble plus utilis� en Europe. Une belle proportion des outils disponibles supportent indiff�remment les deux.

Aujourd'hui je vais vous montrer comment initialer un tel projet en VHDL et le faire implanter sur une carte FPGA.
Le logiciel sur lequel on va �crire nos programme en VHDL est :

ISE WebPACK Design Software

Voici ce premier exemple du programme VHDL fait pas � pas sur ISE dans la vid�o si dessous:



Le programme que j'ai �crit si dessus est celui la :


-- Company:
-- Engineer: Aymen Lachkhem
-- Create Date: 19:06:52 03/21/2016
-- Design Name:
-- Module Name: Logic_Gate_Code - Behavioral
-- Project Name:
-- Target Devices:
-- Tool versions:
-- Description:
-- Dependencies:
-- Revision:
-- Revision 0.01 - File Created
-- Additional Comments:
---------------------------------------------------------------------
library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
-- Uncomment the following library declaration if using
-- arithmetic functions with Signed or Unsigned values
--use IEEE.NUMERIC_STD.ALL;

-- Uncomment the following library declaration if instantiating
-- any Xilinx primitives in this code.
--library UNISIM;
--use UNISIM.VComponents.all;
entity Logic_Gate_Code is
Port ( x : in STD_LOGIC;
y : in STD_LOGIC;
s : out STD_LOGIC);
end Logic_Gate_Code;
architecture Behavioral of Logic_Gate_Code is
begin
s <= x AND y;
end Behavioral;


Ce logiciel nous offre l'utilit� d'�viter d'�crire notre programme comme si dessous en mais de faire r�aliser une programmation graphique " Schematic" , c�ci facilite la programmation il suffit de choisir les ports ou les circuits int�gr�es ou les portes logiques qu'on a besoin de le faire connecter pour avoir notre fonctionnement demand�.
Voila un exemple de ce que j'ai dis, dans la vid�o au dessous j'ai r�alis� un projet sur ISE pas � pas mais au lieu d'�crire mot a mot mon programme j'ai juste fait intervenir le Schematic.


   
  


Kinect Arduino Robot

Bonjour, Comme il est indiqu� au titre de cette article je vais aujourd'hui illustrer les �tapes � suivre pour r�aliser un robot, un syst�me manipul� en g�n�rale guid� et command� par ce qu'on appelle Kinect.



Commen�ons tout d'abord par d�finir Kinect pour ceux qui les connaissent pas encore:
R�sultat de recherche d'images pour "kinect game"
Il s�agit en faite d�une cam�ra bas�e  sur des techniques d�interaction d�velopp�es par la soci�t� PrimeSense, nomm�e avant par le nom de code du projet, � Project Natal �, Elle est bas�e sur un p�riph�rique d�entr�e branch� avec la console Xbox 360 qui permet d�interagir par une certaine commande vocale, reconnaissance de mouvement et d�image.
R�sultat de recherche d'images pour "kinect"
On peut ainsi jouer sur des jeux sp�cialement d�velopp�s pour le projet, donc sans aucune manette ni p�riph�rique autre que son propre corps. Cette d�tection de mouvements sans p�riph�riques �tait d�j� pr�sente dans l�EyeToy de Sony.Ce vid�o vous montrerez comment �a fonctionne le kinect
Le 21 octobre 2010, Microsoft d�voile la premi�re publicit� officielle de son nouveau p�riph�rique, montrant � quel point la firme vise le grand public. Le g�ant de l'informatique a confirm� d�penser plus de 500 millions de dollars en marketing pour s'assurer de toucher au maximum la population.
Initialement hostile au portage du Kinect sur les PC, la soci�t� Microsoft a finalement chang� d'avis et a introduit Kinect pour Windows au 1er f�vrier 2012. Pour un prix sensiblement sup�rieur, cette version pour PC inclut de nouvelles fonctionnalit�s (par exemple le capteur a �t� repens� pour fonctionner � partir d�une distance de 50 cm. Kinect pour Windows inclut un kit de d�veloppement afin de permettre aux d�veloppeurs de cr�er leurs propres applications.
Revenons maintenant au caract�ristiques principales de cette cam�ra si d�velopp�e :
  • Capteur :
    • Lentilles d�tectant la couleur et la profondeur
    • Micro � reconnaissance vocale
    • Capteur motoris� pour suivre les d�placements
  • Champ de vision :
    • Champ de vision horizontal : 57 degr�s
    • Champ de vision vertical : 43 degr�s
    • Marge de d�placement du capteur : � 27 degr�s
    • Port�e du capteur : 1,2 m � 3,5 m (� partir de 50 cm pour la version Kinect for Windows)
  • Flux de donn�es :
    • 320 � 240 en couleur 16 bits � 30 images par seconde
    • 640 � 480 en couleur 32 bits � 30 images par seconde
    • Audio 16 bits � 16 kHz
  • Syst�me de reconnaissance physique :
    • Jusqu�� 6 personnes et 2 joueurs actifs (4 joueurs actifs avec le SDK 1.0)
    • 20 articulations par squelette
    • Application des mouvements des joueurs sur leurs avatars Xbox Live
  • Audio :
    • Chat vocal Xbox Live et chat vocal dans les jeux (n�cessite un compte Xbox Live Gold)
    • Suppression de l��cho
    • Reconnaissance vocale multilingue (pour les fran�ais, cette fonction est disponible depuis le 06 d�cembre 2011 via une M�J de la Xbox ).


L'objectif de notre projet c'est de savoir relier ce kinect avec une prototype Electronique compos�e d'une carte Arduino uno simple et 4 servomoteurs de fa�on savoir traiter l'information revenante de ce kinect et la traduire en mouvement instantan�, intelligent et direct.

Pour ceci on eu besoin de r�aliser une interface graphique sur processing (Download here) de but a faire afficher la squelette d��tre humain capt�e par kinect, d'autre plan de capt� les articulations logiques des ces organes (bras, �paules,main,....)

Comme premier plan on a arriv� a faire traduire les informations prises par kinect en 4 Angles principales (Epaule et coude droites Angles et Epaule et coude gauche angles).
Le programme processing est si dessous:



// Kinect Robot Processing Program

import SimpleOpenNI.*;
SimpleOpenNI kinect;
import processing.serial.*;
Serial port;
void setup() {
size(640, 480);
kinect = new SimpleOpenNI(this);
kinect.enableDepth();
kinect.enableUser();
kinect.setMirror(true);
println(Serial.list());
String portName = Serial.list()[0];
port = new Serial(this, portName, 9600);

}
void draw() {
kinect.update();
PImage depth = kinect.depthImage();
image(depth, 0, 0);
IntVector userList = new IntVector();
kinect.getUsers(userList);
if (userList.size() > 0) {
int userId = userList.get(0);
if ( kinect.isTrackingSkeleton(userId)) {drawSkeleton(userId);

// get the positions of the three joints of our arm
PVector rightHand = new PVector();
kinect.getJointPositionSkeleton(userId,
SimpleOpenNI.SKEL_RIGHT_HAND,
rightHand);
PVector rightElbow = new PVector();
kinect.getJointPositionSkeleton(userId,
SimpleOpenNI.SKEL_RIGHT_ELBOW,
rightElbow);
PVector rightShoulder = new PVector();
kinect.getJointPositionSkeleton(userId,
SimpleOpenNI.SKEL_RIGHT_SHOULDER,
rightShoulder);
// we need right hip to orient the shoulder angle
PVector rightHip = new PVector();
kinect.getJointPositionSkeleton(userId,
SimpleOpenNI.SKEL_RIGHT_HIP,
rightHip);
// reduce our joint vectors to two dimensions
PVector rightHand2D = new PVector(rightHand.x, rightHand.y);
PVector rightElbow2D = new PVector(rightElbow.x, rightElbow.y);
PVector rightShoulder2D = new PVector(rightShoulder.x,
rightShoulder.y);
PVector rightHip2D = new PVector(rightHip.x, rightHip.y);
// calculate the axes against which we want to measure our angles
PVector torsoOrientation =
PVector.sub(rightShoulder2D, rightHip2D);
PVector upperArmOrientation =
PVector.sub(rightElbow2D, rightShoulder2D);
// calculate the angles between our joints
float shoulderAngle = angleOf(rightElbow2D,
rightShoulder2D,
torsoOrientation);
float elbowAngle = angleOf(rightHand2D,
rightElbow2D,
upperArmOrientation);
// show the angles on the screen for debugging
fill(255,0,0);
scale(3);
text("R shoulder: " + int(shoulderAngle) + "\n" +
" elbow: " + int(elbowAngle), 20, 20);
print(int(elbowAngle));
print(": elbow angle");
print(int(shoulderAngle));
println(": shoulder angle");


//////////////////////////////////////////////////////////////////////////////////////////////
PVector leftHand = new PVector();
kinect.getJointPositionSkeleton(userId,
SimpleOpenNI.SKEL_LEFT_HAND,
leftHand);/////////////
PVector leftElbow = new PVector();
kinect.getJointPositionSkeleton(userId,
SimpleOpenNI.SKEL_LEFT_ELBOW,
leftElbow);
PVector leftShoulder = new PVector();
kinect.getJointPositionSkeleton(userId,
SimpleOpenNI.SKEL_LEFT_SHOULDER,
leftShoulder);
// we need right hip to orient the shoulder angle
PVector leftHip = new PVector();
kinect.getJointPositionSkeleton(userId,
SimpleOpenNI.SKEL_LEFT_HIP,
leftHip);
// reduce our joint vectors to two dimensions
PVector leftHand2D = new PVector(leftHand.x, leftHand.y);
PVector leftElbow2D = new PVector(leftElbow.x, leftElbow.y);
PVector leftShoulder2D = new PVector(leftShoulder.x,
leftShoulder.y);
PVector leftHip2D = new PVector(leftHip.x, leftHip.y);
// calculate the axes against which we want to measure our angles
PVector torsoOrientation1 =
PVector.sub(leftShoulder2D, leftHip2D);
PVector upperArmOrientation1 =
PVector.sub(leftElbow2D, leftShoulder2D);
// calculate the angles between our joints
float shoulderAngle1 = angleOf(leftElbow2D,
leftShoulder2D,
torsoOrientation1);
float elbowAngle1 = angleOf(leftHand2D,
leftElbow2D,
upperArmOrientation1);
// show the angles on the screen for debugging
fill(255,0,0);
scale(1);
text("L shoulder: " + int(shoulderAngle1) + "\n" +
" elbow: " + int(elbowAngle1), 120, 20);
print(int(elbowAngle));
print(": elbow angle");
print(int(shoulderAngle));
println(": shoulder angle");
print(int(elbowAngle1));
print(": elbow angle");
print(int(shoulderAngle1));
println(": shoulder angle");
//println(int(shoulderAngle));

byte out[] = new byte[4];
out[0] = byte(int(shoulderAngle));
out[1] = byte(int(elbowAngle));
out[2] = byte(int(shoulderAngle1));
out[3] = byte(int(elbowAngle1));
port.write(out);
}
}


}
float angleOf(PVector one, PVector two, PVector axis) {
PVector limb = PVector.sub(two, one);
return degrees(PVector.angleBetween(limb, axis));
}
// user-tracking callbacks!
void onNewUser(SimpleOpenNI curContext, int userId) {
println("onNewUser - userId: " + userId);
println("\tstart tracking skeleton");

curContext.startTrackingSkeleton(userId);
}
void drawSkeleton(int userId) {
stroke(0);
strokeWeight(5);
kinect.drawLimb(userId, SimpleOpenNI.SKEL_HEAD, SimpleOpenNI.SKEL_NECK);
kinect.drawLimb(userId, SimpleOpenNI.SKEL_NECK, SimpleOpenNI.SKEL_LEFT_SHOULDER);
kinect.drawLimb(userId, SimpleOpenNI.SKEL_LEFT_SHOULDER, SimpleOpenNI.SKEL_LEFT_ELBOW);
kinect.drawLimb(userId, SimpleOpenNI.SKEL_LEFT_ELBOW, SimpleOpenNI.SKEL_LEFT_HAND);
kinect.drawLimb(userId, SimpleOpenNI.SKEL_NECK, SimpleOpenNI.SKEL_RIGHT_SHOULDER);
kinect.drawLimb(userId, SimpleOpenNI.SKEL_RIGHT_SHOULDER, SimpleOpenNI.SKEL_RIGHT_ELBOW);
kinect.drawLimb(userId, SimpleOpenNI.SKEL_RIGHT_ELBOW, SimpleOpenNI.SKEL_RIGHT_HAND);
kinect.drawLimb(userId, SimpleOpenNI.SKEL_LEFT_SHOULDER, SimpleOpenNI.SKEL_TORSO);
kinect.drawLimb(userId, SimpleOpenNI.SKEL_RIGHT_SHOULDER, SimpleOpenNI.SKEL_TORSO);
kinect.drawLimb(userId, SimpleOpenNI.SKEL_TORSO, SimpleOpenNI.SKEL_LEFT_HIP);
kinect.drawLimb(userId, SimpleOpenNI.SKEL_LEFT_HIP, SimpleOpenNI.SKEL_LEFT_KNEE);
kinect.drawLimb(userId, SimpleOpenNI.SKEL_LEFT_KNEE, SimpleOpenNI.SKEL_LEFT_FOOT);
kinect.drawLimb(userId, SimpleOpenNI.SKEL_TORSO, SimpleOpenNI.SKEL_RIGHT_HIP);
kinect.drawLimb(userId, SimpleOpenNI.SKEL_RIGHT_HIP, SimpleOpenNI.SKEL_RIGHT_KNEE);
kinect.drawLimb(userId, SimpleOpenNI.SKEL_RIGHT_KNEE, SimpleOpenNI.SKEL_RIGHT_FOOT);
kinect.drawLimb(userId, SimpleOpenNI.SKEL_RIGHT_HIP, SimpleOpenNI.SKEL_LEFT_HIP);
noStroke();
fill(100,200, 0);
// drawJoint(userId, SimpleOpenNI.SKEL_HEAD);
// drawJoint(userId, SimpleOpenNI.SKEL_NECK);
// drawJoint(userId, SimpleOpenNI.SKEL_LEFT_SHOULDER);
// drawJoint(userId, SimpleOpenNI.SKEL_LEFT_ELBOW);
// drawJoint(userId, SimpleOpenNI.SKEL_NECK);
// drawJoint(userId, SimpleOpenNI.SKEL_RIGHT_SHOULDER);
// drawJoint(userId, SimpleOpenNI.SKEL_RIGHT_ELBOW);
// drawJoint(userId, SimpleOpenNI.SKEL_TORSO);
// drawJoint(userId, SimpleOpenNI.SKEL_LEFT_HIP);
// drawJoint(userId, SimpleOpenNI.SKEL_LEFT_KNEE);
// drawJoint(userId, SimpleOpenNI.SKEL_RIGHT_HIP);
// drawJoint(userId, SimpleOpenNI.SKEL_LEFT_FOOT);
// drawJoint(userId, SimpleOpenNI.SKEL_RIGHT_KNEE);
// drawJoint(userId, SimpleOpenNI.SKEL_LEFT_HIP);
// drawJoint(userId, SimpleOpenNI.SKEL_RIGHT_FOOT);
// drawJoint(userId, SimpleOpenNI.SKEL_RIGHT_HAND);
// drawJoint(userId, SimpleOpenNI.SKEL_LEFT_HAND);
}
void onLostUser(SimpleOpenNI curContext, int userId)
{
println("onLostUser - userId: " + userId);
}
void onVisibleUser(SimpleOpenNI curContext, int userId)
{
// println("ongle 1" , o);

}

   
L'autre phase c'�tait savoir manipuler ces angles traduites par Processing en mouvement instantan� de 4 servomoteurs (deux bras manipulateurs), Tout simplement en utilisant Arduino et en reliant les 4 servomoteurs en 4 sorties PWM d'arduino de fa�on suivante: 


// Kinect Robot Arduino Program 

#include <Servo.h>
// declare both servos

Servo shoulder;
Servo elbow;
// setup the array of servo positions 2
int nextServo = 0;
int servoAngles[] = {0,0};
void setup() {
// attach servos to their pins 3
shoulder.attach(9);
elbow.attach(10);
Serial.begin(9600);
}
void loop() {
if(Serial.available()){
int servoAngle = Serial.read();
servoAngles[nextServo] = servoAngle;
nextServo++;
if(nextServo > 1){
nextServo = 0;
}
shoulder.write(servoAngles[0]);
elbow.write(servoAngles[1]);
}
}
   

Comme �a se voit au bout du programme, le serial a r�alis� cette tache de lire les angles et la biblioth�que servo.h d'arduino les traduites en mouvement instantan�es.

Voila votre vid�o d�monstratif de fonctionnement:




  
http://letselectronic.blogspot.com/
Done by Houssem and Aymen 

benham.houssem@gmail.com 
aymenlachkem@gmail.com 

   

Wednesday, March 16, 2016

Finding the Top of a Major Swing

The hardest thing for me to do as you will know if you are a regular reader of this blog is to hold onto a trade. I've been working on this issue for the whole of my trading life.

The charts below show how such a major top or bottom can be found. Its a matter of using order flow at the right context spots. The bar charts shows the latest tools I use. The buttons at the top of the chart allow me to have Flo trigger trades that meet most combinations of context and order flow combinations. The human eye is still needed as yet to verify the context. The second chart - Market Profile - shows the split's POC that held the market twice. The bar chart shows the reversal of the order flow at the right context for that chart. All that is needed is to have enough contracts so you can scale out at relevant chart areas.




Monday, March 7, 2016

Why Algos Work!

One of the reasons that algos for hybrid trading work so well is that it makes me focus on what's important and to ignore what's not.

Recent studies, talked about here, show that if you know what to ignore you can focus on what's important. The article is well worth a read.

Applying that to trading means that I create a trading plan and then strengthen my ability to stick to that plan by having an algo do the triggering based on the rules in my trading plan but only after I arm it for each specific trade after I have determined that the extra context components of the TP are present.

This means I have plenty of time before the trade triggers to arm my algo and then let it shoot the order with just 1 ms of latency when all the rules are met.

As the Great One said, "how sweet it is".

Friday, March 4, 2016

Numbers and Orderflow and Algos

Writing this waiting for the monthly unemployment numbers.

The pic tells the story. Selling revealed itself after the market went overbought. It sold all the way down to the POC of the day's Volume Profile. I've been doing a lot of work on using Volume Profiles intra day and I'll be showing more about that. We've got a lot of information about order flow in our data stream and we have the technology to reveal the information we need to trade CP. Its now just a matter of learning how to use it. We're in very competative markets. We are competing against a lot of smart people and HFTs. Using algos is a must for most of us if we are to succeed.


The markets liked the number, at first but over cooked it. Then the opportunities showed themselves. The buttons at the top of the chart allow me to place trades based on a combination or orderflow and context. Go Flo.


Wednesday, March 2, 2016

Simple Heart Rate Measurement Using Pic

Simple Heart Rate Measurement Using PIC.

L'objectif de ce projet est comme indiqu� au titre de cet article, non seulement afficher les battement cardiaque d��tre humain mais d'afficher le nombre exacte de battement chaque minutes.


D�finissons tout d'abord la notion du battement cardiaque du c�ur.

Le rythme cardiaque, aussi appel� les pulsations cardiaques, est le nombre de fois que votre c�ur bat par minute. Un rythme cardiaque normal d�pend de l�individu, de son �ge, de la taille de son corps, de son niveau de forme physique, de son �tat cardiovasculaire, s�il est debout ou assis, s�il prend ou non des m�dicaments et m�me de la temp�rature de l�air. Les �motions peuvent aussi avoir un impact sur le rythme cardiaque, �tant donn� que ce dernier s��l�ve quand un danger est d�tect� ou si l�on vit d�autres facteurs de stress.

Ceci tout le monde le connait, comme �tant des �lectroniciens notre d�finition de ce dernier est comme ceci:

La fr�quence cardiaque est le nombre de battements cardiaques (ou pulsations) par unit� de temps (g�n�ralement la minute). C'est une notion quantitative qui peut aussi se d�finir en cycles par seconde, par l'inverse de la p�riode.
La fr�quence cardiaque au repos varie selon l'�ge :
  • Nouveau-n� : 140 +/- 50
  • 1�2 ans : 110 +/- 40
  • 3�5 ans : 105 +/- 35
  • 6�12 ans : 95 +/- 30
  • adolescent ou adulte : 70 +/- 10
  • personne �g�e : 65 +/- 5.

Donc il s'agit d'un signal a haute fr�quence et tr�s faible amplitude a le faire mesurer afficher et calculer

Le Principe de faire adapter se petit signal au niveau visuel est bas�e sur le circuit photo transistor avec Led a cot�.
Afficher l'image d'origine .
Comment �a fonctionne ? 
c'est tout a fait simple, en faite il s'agit d'une diode Led capable a convertir l'alimentation r�cu a travers son anode vers un rayonnement lumineux, ce dernier va se communiquer avec un photo transistor.
Un photo-transistor est un composant �lectronique capable de r�agir � la lumi�re (photo en grec) en laissant passer plus ou moins de courant.
Comme les transistors, le photo-transistor est con�u selon une base, yb �metteur, un collecteur. Mais la base est sensible � la lumi�re et contr�le donc le passage du courant dans le collecteur. Certains mod�les de transistors peuvent d�ailleurs �tre lim�s jusqu�� faire apparaitre leur base pour que la lumi�re agisse dessus.
Le photo-transistor est beaucoup plus sensible qu�une photo-diode. Un montage classique � base de photo-transistor est le Darlington : un photo-transistor contr�le un transistor classique, tr�s efficace pour des barri�res lumineuses ou des d�tections d�obstacles.

Alors imaginons qu'on va mettre le doigts d'un �tre humain entre ces deux composants �lectroniques, la sortie sur le collecteur de photo transistor va s�influencer directement avec le battement cardiaque r�agit au doigts,
D'ici �a sorte le principe le reste c'est de savoir manipuler ce signal pour �tre affichable et mesurable simplement.
Pour ceci j'ai r�alis� ce montage compos� de quelques filtres et des amplificateurs op�rationnelles fonctionnent en r�gime lin�aire.

 Cot� mat�riels et �quipement n�cessaire y a rien cher puisque il s'agit des petits r�sistances et des petits condensateurs pas plusse et j'ai bas� mon amplification/filtrage sur le circuit int�gr� LM324 qui inclus dedans d�j� 4 amplificateurs.
Pour le test sur isis j'ai remplac� le signal sortie du collecteur de transistor par un g�n�rateur simple de pulsation de valeur 3.4 Hz � peut pr�s du fr�quence de battement optimal de c�ur humain.

L'allure de signal Vout sur un oscilloscope est comme ceci indiqu� au vid�o:
















     

Sunday, February 28, 2016

Scalping and Short Term Trading is Like Jujitsu - Using the HFTs to Profit

As these markets continue in their transition, one think looks like it will remain a permanent part of trading: the algo. There's algos and there's HFTs. While a retail trader can't be an effective HFT, we can use algos and we do.

This leads me to Jujitsu. The Wikipedia here says:
Jujutsu (/d?u?'d?u?tsu?/ joo-JOOT-soo; Japanese: ??, jujutsu About this sound listen ) is a Japanese martial art and a method of close combat for defeating an armed and armored opponent in which one uses no weapon or only a short weapon.[1][2]"Ju" can be translated to mean "gentle, soft, supple, flexible, pliable, or yielding." "Jutsu" can be translated to mean "art" or "technique" and represents manipulating the opponent's force against himself rather than confronting it with one's own force.[1] Jujutsu developed to combat the samurai of feudal Japan as a method for defeating an armed and armored opponent in which one uses no weapon, or only a short weapon.[3] Because striking against an armored opponent proved ineffective, practitioners learned that the most efficient methods for neutralizing an enemy took the form of pins, joint locks, and throws. These techniques were developed around the principle of using an attacker's energy against him, rather than directly opposing it.[4]

The part of the quote printed in bold above was emboldened by me to highlight the main idea I'm talking about: "use an attacker's (HFT's) energy against him.

In previous posts I've talked about seeing the order flow. Its something that has been the focus of this blog since its beginning in what seems a lifetime ago now, October 2009.

On the floor our function was to take the other side of the trade of the "paper". We were liquidity providers. However, where we differed from market makers was that we only took the other side of trades that we wanted to take. So if, say, we identified a broker coming in with what looked like a big buy order, the smart thing to do was to sell him the last 100 contracts. In addition, we may have also front run his order, buying ahead of his big order and selling to him as he filled his order pushing price in our favour.

No more floor locals.

But we have something now that we didn't have then. We can count the volume contract by contract and see whether the buyers or the sellers were more anxious.

The nub of all this is how to use the technology we have now to trade the way we did on the floor. We had an enormous edge on the floor and this edge is here now, using the right technology and the right strategy.

Traders are looking for a way to use a relatively low amount of capital with limited risk per trade and the ability to make a living trading small size. "Using an attacker's energy against him" is the way to do it.

More to come on this subject.