Diff: main.cpp

Revision:

13:a436ba0b78e8

Parent:

12:a55f77a0e188

Child:

15:7c2e70c36b98

Child:

21:73db1bea19b1

diff -r a55f77a0e188 -r a436ba0b78e8 main.cpp
--- a/main.cpp	Tue Mar 07 02:12:21 2017 +0000
+++ b/main.cpp	Tue Mar 07 04:37:39 2017 +0000
@@ -6,7 +6,8 @@
 const float HALF_PERIOD = 0.05; // secondes
 
 Serial pc(USBTX, USBRX, 9600);
-Serial uart(p13, p14, 9600);
+DigitalIn in(p14);
+DigitalOut out(p13);
 Thread ThreadLecture;
 
 bool transmit = false;      //faux pour le debut de demi-periode d'envoie d'un bit, vrai pour la 2ème demi-periode
@@ -16,19 +17,19 @@
         trame_length;       //longueur de la trame complete
 //test
 
-bool bIsHalfPeriod = false;
+bool clockTick = false;
   
 extern "C" void RIT_IRQHandler(void) {
     //clear flag
     LPC_RIT->RICTRL |= bit0; //write 1 to clear bit
     
-    bIsHalfPeriod = !bIsHalfPeriod;
+    //bIsHalfPeriod = !bIsHalfPeriod;
 }
 
 void p14_interrupt()
 {    
     // On turn off les interrupts de lecture une fois qu'on a détecter un message
-    uart.attach(NULL, uart.RxIrq);
+    //uart.attach(NULL, uart.RxIrq);
 
     // On envoie le signal au thread de lecture
     ThreadLecture.signal_set(1);
@@ -39,98 +40,119 @@
     while(true) 
     {
         // Attente passive d'un message entrant
-        uart.attach(&p14_interrupt, uart.RxIrq);
+        //uart.attach(&p14_interrupt, uart.RxIrq);
         ThreadLecture.signal_wait(1);
         
         // Lis le message. Retourne une exception si il y a une erreur
-        vector<char> message = uart_read(uart);
+        //vector<char> message = uart_read(uart);
         
-        if (!message.empty())
-        {
+        //if (!message.empty())
+        //{
             // Affiche le message à l'écran
-            pc.printf(&message[0], message.size());
-        }
+            //pc.printf(&message[0], message.size());
+        //}
     }
 };
 
 void rit_init()
 {
-    LPC_SC->PCONP |= bit16;                             //Power Control for Peripherals register: power up RIT clock
-    LPC_SC->PCLKSEL1 |= (bit26 && bit27);               //Peripheral clock selection: divide clock by 8 (run RIT clock by 12.5MHz)
-    LPC_RIT->RICOUNTER = 0;                             //set counter to zero
-    LPC_RIT->RICOMPVAL = 250000000 * HALF_PERIOD;       //interrupt tick every HALF_PERIOD
-    LPC_RIT->RICTRL |= bit1;                            // clear timer when counter reaches value
-    LPC_RIT->RICTRL |= bit3;                            // enable timer
-     
-    //enable interrupt
-    NVIC_SetPriority(RIT_IRQn, 31);
-    NVIC_EnableIRQ(RIT_IRQn);
+    //Timer 1 (match)
+    LPC_SC->PCLKSEL0 |= (1 << 4);           // pclk = cclk timer1
+    LPC_SC->PCONP |= (1 << 2);              // timer1 power on
+    LPC_TIM1->MR0 = CLOCKS_TO_SECOND / 100; // 10 ms
+    LPC_TIM1->MCR = 3;                      // interrupt and reset control
+                                            // Interrupt & reset timer on match
+    LPC_TIM1->EMR = (3 << 4);
+    NVIC_EnableIRQ(TIMER1_IRQn);            // enable timer interrupt
+    LPC_TIM1->TCR = 1;                      // enable Timer
+ 
+    //Timer 2 (cap)
+    LPC_SC->PCLKSEL1 |= (1 << 12);          // pclk = cclk timer2
+    LPC_SC->PCONP |= (1 << 22);             // timer2 power on
+    LPC_TIM2->TC = 0;                       // clear timer counter
+    LPC_TIM2->PC = 0;                       // clear prescale counter
+    LPC_TIM2->PR = 0;                       // clear prescale register
+    LPC_TIM2->TCR |= (1 << 1);              // reset timer
+    LPC_TIM2->TCR &= ~(1 << 1);             // release reset
+    LPC_TIM2->IR = 0xFFFFFFFF;              // clear interrupt register
+    LPC_TIM2->CCR |= 0x0000007;             // enable rising-edge and falling-edge capture on 2.0
+    NVIC_EnableIRQ(TIMER2_IRQn);            // enable timer interrupt
+    LPC_TIM2->TCR = 1;                      // start Timer
 };
 
+bool codeManchester(bool bit, bool clock)
+{
+    return (bit == clock);
+}
+
 void send_data()
 {
-    if (!transmit) { //Si on est dans la premiere demi-periode d'envoie
-        if (((trame_sent[byte_sent_pos] >> bit_sent) & 0x01) == 1) { //Verifier le bit à envoyer et preparer la prochaine interruption pour prendre sa valeur
-            LPC_RIT->EMR |= 1 << 5;
-            LPC_RIT->EMR &= ~(1 << 4);
-        } else {
-            LPC_RIT->EMR |= 1 << 4;
-            LPC_RIT->EMR &= ~(1 << 5);
-        }
-    } else {        //Si on est dans la 2eme demi-periode d'envoie, toggle a la prochaine interruption
-        LPC_RIT->EMR |= 3 << 4;
+    out = codeManchester(((trame_sent[byte_sent_pos] >> bit_sent) & 0x01), clockTick);  // Encodage Manchester
+    if(clockTick)
+    {
         bit_sent--;
     }
-    transmit = !transmit;       //varier entre la 1ere et 2eme partie de demi-periode
-    LPC_RIT->MR0 += HALF_PERIOD;    //preparer la prochaine interruption a une demi-periode plus loin
+    clockTick = !clockTick;       //varier entre la 1ere et 2eme partie de demi-periode
     if (bit_sent < 0) {     //Si l'octet a ete envoye
         bit_sent = 7;       //remettre la position initiale pour le prochain octet
         byte_sent_pos++;    //incrementer l'octet
-        if (byte_sent_pos > trame_length) {  //Si la trame a ete envoyee
-            LPC_RIT->MCR &= 0;             //desactiver les interruptions du MAT
-            LPC_RIT->EMR &= ~(3 << 4);     //remettre a zero le registre EMR (00 pour rien faire, 01 pour mettre a 1, 10 pour mettre a 0 et 11 pour toggle)
+        if (byte_sent_pos >= trame_length) {  //Si la trame a ete envoyee
             byte_sent_pos = 0;
-            transmit = false;
+            clockTick = false;
         }
     }
 }
 
-void get_text()
+//création de la trame
+void create_trame(char message[],int taille)
 {
     CRC16 *myCRC = new CRC16();
+    unsigned short resultCRC = myCRC->calculateCRC16(message,taille); 
     
     trame_sent[0] = 0x55;    //Preambule
     trame_sent[1] = 0x7E;    //Start
     trame_sent[2] = 0x00;    //Type + Flag mis a 0x00
+    trame_sent[3] = (char)taille;     //Longueur du message (Max 33 caractères)
     
+    //message
+    for (int i=0;i<taille;i++)
+    {
+        trame_sent[taille + 4] = message[i];
+    }
+        
+    //CRC16
+    trame_sent[taille + 4] = (resultCRC >> 8) & 0xFF;
+    trame_sent[taille + 5] = resultCRC & 0xFF;
+    
+    trame_sent[taille + 6] = 0x7E;    //End
+    trame_length = taille + 7;        //Longueur de la trame
+}
+
+//obtention du texte
+void get_text()
+{
     pc.printf("\n\rYour text : ");
     int count = 0;
     char c = 0x00;
     char text[73];
-    while(c != 0x0D && count < 73) { //Tant que c'est different de '\r' et un maximum de 33 caractères 
+    while(c != 0x0D && count < 73) { //Tant que c'est different de '\r' et pour un maximum de 73 caractères 
         c = pc.getc();
-        trame_sent[count + 4] = c;   //Ajouter les caractères tapés au clavier dans le message
         text[count] = c;
         pc.putc(c);
         count++;
     }
-    trame_sent[3] = (char)count;     //Longueur du message (Max 33 caractères)
     
-    unsigned short resultCRC = myCRC->calculateCRC16(text,count);     
-    trame_sent[count + 4] = (resultCRC >> 8) & 0xFF;
-    trame_sent[count + 5] = resultCRC & 0xFF;
-    
-    trame_sent[count + 6] = 0x7E;    //End
-    trame_length = count + 6;        //Longueur de la trame
-    
+    create_trame(text,count);
 }
 
 void write()
 {
     byte_sent_pos = 0;
     bit_sent = 7;
-    LPC_RIT->MCR = 1;                      //Permettre les interruption du MAT
-    LPC_RIT->MR0 = LPC_RIT->TC + HALF_PERIOD;  //Faire une interruption a la prochaine demi-periode
+    clockTick = false;
+    //TODO start interrupt timer 1 
+    //LPC_RIT->MCR = 1;                      //Permettre les interruption du MAT
+    //LPC_RIT->MR0 = LPC_RIT->TC + HALF_PERIOD;  //Faire une interruption a la prochaine demi-periode
 }
 
 int main() {