Articles Tagués ‘MSP430’

Bonjour à tous !

Aujourd’hui je vous propose de faire un arroseur automatique avec un système de mesure un peu spéciale, puisqu’il ne coûte rien (il fait partie du circuit en lui-même !) et est normalement inusable.

Idée globale

Le projet est somme toute assez banal : faire un système permettant d’arroser une plante en toute autonomie (ou presque). On doit donc :

– mesurer l’humidité dans la terre.

– suivre le niveau d’eau dans le réservoir.

– commander une petite pompe.

– Avoir une batterie

– Le tout en consommant le moins possible.

Choix techniques

Evidemment, chez moi, qui dit basse conso dit MSP430 🙂 je suis donc parti sur un MSP430G2452, celui fourni avec le launchpadG2 en plus du G2553. La principale différence entre les deux c’est qu’il n’a pas de port série hardware (mais il y a un soft pour débuguer et on a pas besoin de plus ici). Mais ce qui a en plus assurer ce choix, c’est les facultés pour faire des mesures capacitives. En effet de base sur cette gamme sont intégrées des fonctions permettant de faire des boutons type « touch ». Ce type de mesure consiste tout simplement à mesurer une variation de capacité. Je vais détailler le principe dans le paragraphe suivant, en attendant voici le lien vers le topic sur le forum 43oh où est fournie une librairie pour Energia (et oui évidemment je vais coder sous cette IDE 😉 ).

Librairie CapTouch

Mesure capacitive

Pour commencer il faut savoir ce qu’est un condensateur : c’est en fait en quelque sorte un mini réservoir de stockage électrique, comme une pile quoi, mais capable d’absorber et de fournir cette énergie stockée de manière très rapide. Alors il existe beaucoup de technologie de condensateur, mais beaucoup reposent sur un principe de superposition de plaques conductrices entrelacées. Il y a deux « jeux de plaques », chacune pour une borne du condensateur : une à la masse, l’autre pour le courant « condensé » (j’avoue que c’est en écrivant cette phrase que je me rend compte que je ne sais pas comment on appelle les bornes d’un condensateur !).

Plus la surface est grande, et plus l’écart entre les plaques est réduite, plus la capacité est importante. Autre facteur important (et c’est celui qui nous intéresse en fait ici) la capacité à isoler de l’isolant qui sépare les plaques. Un matériaux est caractérisé par une constante diélectrique, qui indique grosso modo sa capacité à conduire plus ou moins l’électricité. Et ici on jouer avec ça : en faisant varier l’humidité dans la terre on va changer sa constante diélectrique et donc notre mesure de capacité qui va augmenter.

Il nous faut donc deux électrodes (nos plaques du condensateur) et entre les deux, la terre du pot (ou l’eau du réservoir car on va tant qu’à faire utiliser la même technique !). Dans l’idée on veut faire ça :

Ici en fait je n’ai pas placer face à face mes électrodes, c’est pas grave ça marche aussi, et ça ressemble d’ailleurs dans le principe à un bouton touch  :

Quelques liens en vrac qui font seront peut-être plus parlant :

https://www.youtube.com/watch?v=0du-QU1Q0T4

http://www.analog.com/library/analogdialogue/archives/49-04/capacitive_sensing.html

http://www.positron-libre.com/cours/electrotechnique/notion-electricite/condensateur-capacite.php

Pourquoi ce type de mesure ?

La principale raison est que normalement c’est inusable, surtout en comparaison est des mesures résistives. En effet, la technique « classique » très simple à faire consiste à planter deux dans la terre, à ajouter une autre résistance pour former un pont et hop on alimente le tout et on regarde la tension au point milieu du pont. Plus d’infos :

http://www.electroschematics.com/6519/simple-soil-moisture-sensor-arduino-project/

Problème de cette méthode : imaginer la tronche des électrodes qui auront passé l’année en terre … Elles vont s’oxyder, la mesure dériver … Et en plus, si vous ne pilotez l’alimentation du pont, vous aller faire une électrolyse et la en quelques jours ça va commencer à dériver.

Avec une mesure capacitive, étant donné qu’il n’y a aucun contact électrique avec l’environnement, point de risque d’électrolyse ou d’attaque des métaux 🙂 ça veut également dire qu’on peut facilement s’adapter pour mesurer n’importe quel liquide. Ça veut également dire qu’on peut par exemple mesurer un niveau d’essence sans risque d’explosion (bon je suis pas responsable de ce que vous foutrez avec ce tuto, donc je suis responsable de rien ! Si vous ne savez pas ce que vous faites jouez pas avec les liquides inflammables 😉 ).

Niveau d’eau

Y’a quelques années j’avais fait un montage un peu similaire, et j’avais relevé un détails technique d’importance : vous vous êtes peut-être dit que vous pouviez vous passer du niveau d’eau du réservoir, en fait non. Sur mon premier proto, je n’en avais pas. Est arrivé le jour où il s’est vidé sans que je m’en rende compte. Et ça m’a vidé la batterie très rapidement puisque la pompe ne pompant plus rien, l’humidité ne remontait pas donc mon microcontroleur s’est acharné …

Moralité : il faut suivre le niveau d’eau.

Le circuit

arroseur eagle

 

A gauche la partie qu’on plante en terre, à droite la mesure de niveau d’eau. Alors ça se voit pas bien, mais sur la partie mesure d’eau, il y a deux zones sur la colonne de droite : un petit carré en bas qui sert de référence, et la grande pour mesurer le niveau à proprement parler. En fait je considère que l’eau arrive au moins au niveau au-dessus du petit carré. Connaissant sa hauteur, on peut ensuite en déduire un rapport capacité = f(niveau).

Les fichier CAD pour Eagle sont dispos sur mon Github. Comme je le disais l’avantage c’est que c’est directement intégré dans le circuit. On fait son circuit, on peint et vernis les électrodes (je rappelle qu’un condensateur ne conduit pas le courant, si on trempe dans l’eau comme ça ça va faire un court-circuit !). A noter que j’avais prévu des résistances pour tuner la mesure. En fait mes essais ont montré qu’il valait mieux mettre un condensateur de faible valeur (j’avais des 22pF dans mes archives et ça marche très bien). Donc sur le schéma électrique, au lieu des résistance de pull-down, je vous conseille de mettre des condensateur de quelques dizaine de pF, ça stabilise la mesure et ça fait beaucoup moins du n’importe quoi.

Une fois tout en place :

 

IMG_20150726_140000 IMG_20150726_135949 IMG_20150726_135934 IMG_20150726_140022

Le code

Le code ici est vraiment enfantin : d’une part Energia simplifie énormément les choses, et ensuite la librairie CapTouch intègre la mise en sommeil. Donc en fait on peut faire des mesures en permanence, même si on a l’impression que le microcontroleur turbine tout le temps, en fait il n’en est rien, ce n’est qu’une vision macroscopique (temporellement parlant). Si on dilatait le temps, on verrait que le microcontroleur passe la très large majorité de son temps en sommeil.

Pour l’algo il n’y a finalement pas grand chose à dire : comme il faut un certain temps à l’eau pour se diffuser dans la terre, je préfère y allait par « petite touche ». On arrose donc un peu, on attend, on mesure, si c’est pas assez on arrose encore …

J’ai optimisé un peu le code en créant une fonction utilisant un pointeur vers l’objet Captouch. Ca évite de réécrire trois fois la même routine …

Tout est dispo sur mon github.

Bon sinon il est pas vraiment optimiser du tout. J’ai pas tester mon système d’étalonnage, pas introduit de système de calibration … Comme je l’ai dit plus haut, je voulais déjà vérifier si dans le principe j’étais bon. Donc pas la peine de me lancer des cailloux parce que c’est pas top top, je le sais. Et n’empêche que ça fait le job 🙂

Version 2

Je ne sais pas si je la ferai mais j’ai déjà un paquet d’idées pour une V2 🙂 (pas la fusée hein) :

– Réduire la taille du circuit (->passage en CMS).

– Rajouter des boutons (pour la calibration ou forcer l’arrosage).

– Commande lumière artificielle.

– Mesure constantes environnementale (température, pression, ensoleillement).

– Connectivité internet (wifi surement) pour suivi/commande.

– Autonome énergétiquement (panneau solaire ?).

– Autonome en eau.

– Utilisation de l’acran Sharp qu’on trouve sur le boosterpack de TI : www.ti.com/tool/430BOOST-SHARP96

Il a la particularité de consommer très peu (quelques µA avec un rafraichissement de 1 Hz ce qui plus que suffisant dans notre cas…)

Bonjour à tous,

Bon décidément les temps sont durs … Un boulot monstre, dur dur de s’occuper du blog :s

Du coup je vous pond une petite news parce qu’elle est quand même intéressante cette nouvelle :p

Texas Instrument vient de sortir une nouvelle gamme de microcontrôleur : les MSP432. Grosso modo, ce sont ARM Cortex M4F avec très faible conso, comme les MSP430. Bon du coup il ne faut pas s’attendre à des furies non plus puisqu’il tourne au maxi à 48 mhz. Mais la conso peut tomber à 850 nA avec RTC, donc vraiment pas mal ! Et puis bon après on a les autres joyeusetés des ARM, à savoir tout plein de la flash, tout plein de la RAM, des ADC plus performants, pleins de port série, SPI, i2c … Bref, de quoi faire !

En plus de cette nouvelle série de puce, TI a eu le bon goût de sortir un launchpad équipé avec (qui abandonne au passage la robe rouge pour la noire), et Energia a eu le meilleur goût encore de sortir une nouvelle version supportant ce nouveau launchpad et d’introduire le multitasking, appuyer par RTOS qui est l’OS temps réel de Texas Instrument, qui permet de faire ce que ça dit c’est à dire du multitâche. Grosso modo, fini les prisse de tête quand on veut faire tourner plusieurs choses en même temps 🙂 alors techniquement ce n’ai jamais du vrai multitasking qui nécessite plusieurs coeurs (et oui faut PC d’avant, simple cœur, vous aviez l’impression de lancer plusieurs choses en même temps mais ce n’était pas réellement le cas) mais dans l’idée on subdivise chaque action en sous-action pour les enchaîner au fur et à mesure et donner l’illusion que tout se déroule en même temps. Prenons un garagiste qui doit changer vos disque et faire la vidange, il peut dévisser le bouchon, enlever les quatre boulons d’une roue, lever la voiture, mettre le bac dessous, enlever la roue … Et au final vous récupérer votre voiture entretenue.

Dans les fait ici la nouvelle version ici intègre un exemple qui permet de faire clignoter des led à partir de 3 blink de base. Vous trouverez plus d’info ici.

Autres petites découvertes que j’ai fait au passage : TI se met au cloud avec notamment une version de Code Composer Studio en ligne. Plutôt sympa ! Il suffit de créer un compte (gratuit) pour y accéder. On note une option intéressante qui permet directement de se synchroniser avec github pour importer ses librairies.

Egalement un service pour avoir tous les exemples de codes mis à dispo par TI, ainsi qu’une application pour obtenir directement les brochages de certaines puces. Cette dernière appli je vois pas trop l’utilité pour le moment …

Enfin au niveau matériel, comme je suis pas mal wifi en ce moment, j’étais passé à côté du CC3200 en version MOD, ce qui signifie chez TI que c’est un petit module qui intègre tout ce qu’il faut. Pas de ARM à souder et autre, on soude ça comme un module GPS quoi, et c’est plié. Beaucoup moins galère que de prendre les composants un à un … Le revers c’est que c’est évidemment plus cher et qu’à la base les CC3200 ne sont pas donnés comparée à une concurrence farouche (mt7681, ESP8266 ….) : 36€ chez Mouser ! Aie … Tout dépend le besoin c’est sûr, mais passé d’un CC3200 à un esp8266 fait gagné 34€ … Certes vous risquez de galérer un peu plus, mais suivant le projet ça fait réfléchir.

 

A bientôt !

 

 

 

 

Salut à tous,

Micro news pour vous prévenir d’une nouvelle promo TI sur les eZ430-Chronos : -60%  !

Ce qui nous fait la montre à  23.2$ au lieu de 58$ !! Frais de port compris comme d’hab chez TI 🙂

Comme je l’ai précisé dans ma précédente news, bientôt programmable sous Energia (donc aussi facilement qu’une Arduino)

La news TI

Offre valable jusqu’au 14 juillet on dirait, donc ne trainez pas trop non plus 😉

A bientôt !

 

Bonjour un tous !

Petit billet en coup de vent pour vous signaler cette excellente promo :

http://e2e.ti.com/blogs_/b/msp430blog/archive/2013/09/01/back-to-school-sale-part-3-ez430-chronos.aspx?hootPostID=bbd6f981fa800499b085bf3d206f4526

Tout y est, la déduction se fait dans la partie Payment en rentrant le code correspondant indiqué dans le lien. A 29$ (frais de port compris !!) ça vaut carrément le coup ! Perso j’ai direct craqué 😉

Bonjour à tous !

Alors aujourd’hui je vous propose de faire communiquer un MSP430 et une Arduino par une liaison sans-fil à base de NRF24l01+.

Nrf24L01, késako ?

Ces modules de communication sont très intéressants pour plusieurs raisons :

* Le prix : à moins de 3€ sur ebay par module, on peut imaginer créer tout un réseau pour presque rien.
* Ce sont des transceivers : à la fois émetteur et récepteur.
* 2,4 ghz : ça élimine beaucoup d’interférences.
* 128 canaux et plusieurs canaux de réception par module : ça permet d’avoir plusieurs émetteurs pour un seul récepteur sans risquer de collision.
* Plusieurs fonctions directement implémentées : ré-émission automatique, CRC (checksum) …
* Portée : 100m en champs libre, 20 m en intérieur (après ça dépend des murs et du débit). Pour 12€ il existe des modules avec amplificateur de puissance, pas testé mais la portée est annoncée à 1000 mètres.
* La consommation (le point qui m’intéresse, vous après verrez pourquoi 😉 ) : à fond ils bouffent 12mA et à la plus faible puissance on tombe à 8 mA. Mais ce n’est pas tout, il utilise la technologie Shockburst qui consiste lors d’une émission à émettre toutes les trames d’un coup. Autrement dit, si on communique à 10 kbits par seconde avec le module alors il va « accumuler » les données, et une fois qu’on lui demande de transmettre il envoi tout d’un coup, ce qui réduit au maximum la consommation. Enfin on peut les mettre en veille, la consommation tombe alors à moins de 1µA (mais le SPI est toujours actif !). Le réveil est assez rapide (<130µs).

Bref ils ont de quoi convaincre ! Datasheet : http://www.nordicsemi.com/kor/Products/2.4GHz-RF/nRF24L01P

Un doc en anglais, une sorte de synthèse commentée de la datasheet qui m’a pas mal aidé (attention cependant elle traite des modules pas « + ») : http://www.diyembedded.com/tutorials/nrf24l01_0/nrf24l01_tutorial_0.pdf

Comparé à la version « + » il n’y a surtout que quelque registres qui changent.

Si vous voulez plus d’infos et/ou vous limiter au cas de l’arduino, je vous recommande les articles de M. Skywodd : http://skyduino.wordpress.com/2012/01/20/tutoriel-arduino-mirf-v2-nrf24l01/ http://skyduino.wordpress.com/2012/02/01/arduino-transmission-valeur-analogique-par-nrf24l01/

Alors pourquoi interfacer un MSP430 et un Nrf ?

Et bien comme vous l’avez vu, la consommation est particulièrement optimisée, et c’est également la spécialité des MSP430 (et en plus les deux utilisent du 3,3V). Prenons un exemple simple : une sonde de température ambiante. On n’a pas besoin de prendre la température toutes les secondes, seulement une mesure toute les 10 secondes, voire une toute les minutes. Et voilà le principe de fonctionnement :

1) Réveil du MSP430 et du NRF24L01+.

2) Acquisition de la température.

3) Emission radio vers la base.

4) On rendort tout le monde pendant 10 sec.

Les étapes 1) 2) et 3) prennent environ 200 µs. Donc pendant la très grande majorité du temps, la consommation est inférieure à 2µA, et pendant 200µs elle reste très modérée : 400µA du NRF + 400µA pour un MSP430 à 1mhz. L’émission consomme 12 mA mais pendant 10-20 µs.

J’ai fait un essai avec une émission toutes les 2 secondes, alimenté par un condensateur goldcap 5F. Ca a tenu 2 jours, ce qui me donnait une consommation de ~10µA. Avec un pile bouton 200 mAh, ce montage pourrait tenir : 200 000 / 10 / 24 / 365 = 2,3 an ! Et à 0,5 hz de fréquence ! Imaginez si vous greffez un panneau solaire ou si on passe à une émission par minute … Les applications sont quasi infinies !

Allez, assez de théorie place à la pratique !

Alors sachez que je me suis pas mal débattu avec ce trio … Car il y a quelques paramètres qui diffèrent entre les deux librairies, et le problème c’est qu’on bosse en aveugle : tant que tous les paramètres ne sont pas bons, il n’y a pas de communication et le debug est pour ainsi dire quasi-impossible … Bref voici le code côté MSP430 (lib = https://github.com/spirilis/msprf24) :

#include <msp430.h>
#include "msprf24.h"
#include "nrf_userconfig.h"

char addrTX[]={'t','e','s','t','2'};

char buf[]={0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15}; // trame exemple

int main(void) {

WDTCTL = WDTPW + WDTHOLD;
BCSCTL2 = SELM_0 + DIVM_0 + DIVS_0;

if (CALBC1_1MHZ != 0xFF) {
DCOCTL = 0x00;
BCSCTL1 = CALBC1_1MHZ; /* Set DCO to 1MHz */
DCOCTL = CALDCO_1MHZ;
}

BCSCTL1 |= XT2OFF + DIVA_3;
BCSCTL3 = XT2S_0 + LFXT1S_0 + XCAP_0;
TA0CCTL0 = CM_0 + CCIS_0 + OUTMOD_0 + CCIE; // configuration du timer à 1 s
TA0CCR0 = 4095;
TA0CTL = TASSEL_1 + ID_0 + MC_1;

UCB0CTL1 |= UCSWRST; // configuration du SPI
UCB0CTL0 = UCMSB + UCMST + UCMODE_0 + UCSYNC;
UCB0CTL1 = UCSSEL_2 + UCSWRST;
UCB0BR0 = 64;
UCB0BR1 = 6;
UCB0CTL1 = ~UCSWRST;

P1DIR|=BIT0;

rf_crc=RF24_EN_CRC|RF24_CRCO; // CRC active, 16-bit
rf_addr_width=5; // On utilise une adresse de 5 bytes
rf_speed_power=RF24_SPEED_2MBPS|RF24_POWER_0DBM; // vitesse 1MBPS et puissance max
rf_channel=1;

msprf24_init();

msprf24_set_pipe_packetsize(0,16); // payload de 16 byte sur le pipe 0
msprf24_open_pipe(0,1); // ouverture du pipe avec Auto-Acknowledgement

w_tx_addr(addrTX); // configuration adresse émission
w_rx_addr(0,addrTX); // configuration adresse réception idem à celle de transmission
                      // pour permettre la réception de l'ACK

msprf24_standby(); // module en veille (pas endormi)

while(1){

if(msprf24_is_alive()) { // fait clignoter la LED rouge sur launchpad si
	P1OUT^=BIT0; // le nrf est bien connecté
}else{
	P1OUT&=!BIT0;
}

LPM3; // on endort

w_tx_payload(16,buf); // on charge le FIFO avec le tableau buf
msprf24_activate_tx(); // émission
msprf24_get_irq_reason(); // récupère les alertes du NRF
while(!(rf_irq && RF24_IRQ_TX)) msprf24_get_irq_reason(); // tant que la transmission n’est pas finie, on boucle
msprf24_irq_clear(RF24_IRQ_TX); // on efface les flags d’alerte

}

}

#pragma vector=TIMER0_A0_VECTOR
__interrupt void TIMER0_A0_ISR_HOOK(void) {
LPM3_EXIT;
}

+

Modification du nrf_userconfig.h : en haut il y des constantes suivant la fréquence de fonctionnement, il suffit de décommenter la partie qui vous correspond et de commenter les autres et en bas la partie hardware pour définir où sont brancher les pins CE, CSN et IRQ si vous l’utilisez. J’avoue j’ai pas approfondi le code plus que ça, et il n’est pas optimisé. Il y a surement des lignes que je pourrai virer, mais ils m’avaient tellement fait galérer ces modules que j’en avez marre xD

Comme je vais reprendre ce principe bientôt, je publierai une mise à jour 😉

Côté Arduino :

#include <SPI.h>
#include <Mirf.h>
#include <nRF24L01.h>
#include <MirfHardwareSpiDriver.h>

void setup(){
  Serial.begin(9600);
  ConfigMirf();

  Serial.println("Listening...");
}

void loop(){

  if( Mirf.dataReady()){

    byte data[Mirf.payload];
    Mirf.getData(data);

    for (int i=0;i<16;i++){
      Serial.print(data[i]);
      Serial.print(" ");
    }
Serial.println(" ");

  }

}

void ConfigMirf(){

  Mirf.spi = &MirfHardwareSpi;
  Mirf.cePin=8;
  Mirf.csnPin=7;

  Mirf.init();

  Mirf.setRADDR((byte *)"2tset");
  Mirf.setTADDR((byte *)"1tset");
  Mirf.payload = 16;
  Mirf.config();

}

+

Modification du fichier Mirf.h : en effet chose étonnante les créateur de cette lib n’ont pas créé de fonction directe pour modifier la gestion de la CRC … Il faut modifier cette ligne en haut :


#define mirf_CONFIG ((1<<EN_CRC) | (1<<CRCO) ) // CRC active 2 bytes, correspond ici avec le code du MSP 430

#define mirf_CONFIG ((1<<EN_CRC) | (0<<CRCO) ) // CRC active 1 byte

#define mirf_CONFIG ((0<<EN_CRC) | (0<<CRCO) ) // CRC désactivée

Alors vous aurez peut-être noter les petites différences :

* Les adresses ne sont pas dans le même ordre.

* Les canaux sont décalé de 1 (MSP = de 1 à 128, Arduino = de 0 à 127)

Alors après bien sur vous pouvez remplir buf avec ce que vous voulez. A noter également qu’ici je n’ai pas géré la mise en sommeil du Nrf, seulement celle du MSP, mais c’est très facile, il suffit de faire :


msprf24_powerdown(); // endort

msprf24_standby(); // réveil, nécessite 130µs d’après la datasheet

Pour recevoir côté MSP430, en gardant les paramètres du précédent code :


msprf24_get_irq_reason();

if(rf_irq && RF24_IRQ_RX) {

msprf24_irq_clear(RF24_IRQ_RX);

r_rx_payload(16,buf);

}

Bon la du coup ça reste assez simpliste au niveau des fonctionnalités, mais débroussaillé tout ça m’a pris un temps fou vu ces quelques différences foireuses dures à débusquer … Mais ça fait déjà le principal : envoyer et recevoir des données. Je n’ai pas été très explicite dans le code, si vous comprenez pas n’hésitez pas je compléterais 😉

Enjoy !

EDIT 12/06/13 : suite à des problèmes d’un lecteur j’ai repris mon code et trouvé quelques erreurs. En fait il y a quelque chose qui m’échappe avec le registre EN_AA qui permet l’activation de l’auto-acknowledgment. Il s’agit d’une fonction qui permet à l’émetteur de confirmer que son message a bien été reçu. Je ferai un peu plus de test demain mais je pense avoir trouvé. En tout cas j’ai édité les codes de l’articles qui fonctionnent avec un launchpad équipé d’un G2553 et une Arduino nano (ou Uno et compagnie c’est pareil, testé sur Mega également, il suffit d’adapter les n° de pins).

Une remarque également : la librairie Arduino utilise le pipe 1 pour recevoir car apparemment c’est le pipe 0 qui reçoit les ACK, ce qui permet de le garder libre. C’est pourquoi sur le MSP430 il faut configurer le pipe 0 avec la même adresse que celle utilisée pour l’envoi, une façon de reconnaître la provenance de l’ACK et d’éviter tout conflit.

 

EDIT n°2 13/06/13 : deux points : j’ai approfondi le coup de l’auto-acknowledgment. Il faut également que ce paramètre soit synchronisé sur les deux parties ! Par défaut le nrf l’a d’activé, donc si on ne précise pas côté Arduino, il faut utiliser sur le MSP430 :

msprf24_open_pipe(0,1);

+

Il faut mettre d’adresse du destinataire en réception sur le pipe 0.

Si on ne veut pas d’ACK, dans ce cas on désactive côté arduino avec :

Mirf.configRegister(EN_AA,0); // ACK disabled

+

Côté MSP :

msprf24_open_pipe(0,0);

Second point le câblage. Bon côté Arduino y’a pas de mystère je pense. Côté MSP :

MISO P1.6
MOSI P1.7
SCK P1.5
CE P2.4
CSN P2.3

Attention, CE et CSN sont dépendants de ce que vous avez mis dans nrf_userconfig.h. Pour avoir cette config j’ai :


/* CSN SPI chip-select */
#define nrfCSNport 2
#define nrfCSNportout P2OUT
#define nrfCSNpin BIT3

/* CE Chip-Enable (used to put RF transceiver on-air for RX or TX) */
#define nrfCEport 2
#define nrfCEportout P2OUT
#define nrfCEpin BIT4