Diff: TA.cpp

Revision:

18:affef3a7db2a

Parent:

17:d8b901d791fd

Child:

23:26f27c462976

--- a/TA.cpp	Tue Nov 03 07:05:15 2015 +0000
+++ b/TA.cpp	Sun Nov 29 13:52:53 2015 +0000
@@ -1,4 +1,5 @@
 #include "TA.h"
+
 #include <nrf51.h>
 #include <mbed.h>
 #include <device.h>
@@ -125,20 +126,32 @@
 
 std::vector<Message*> *messages;
 
+//NeoStrip *neo;
+
 TA::TA()
 {
+    buzzPin = 1;
     neopixel_init(&m_strip, dig_pin_num, leds_per_strip);
     neopixel_clear(&m_strip);
     messages = new std::vector<Message*>();
+    
 }
 
 void TA::post_color(uint32_t rgb)
 {
+    if (rgb == 0)
+    {
+          neopixel_clear(&m_strip);  
+          return;
+    }
     
     for (int i = 0; i <= leds_per_strip; ++i)
     {
         neopixel_set_color_and_show(&m_strip, i, (rgb >> 16) & 0xFF, (rgb >> 8) & 0xFF, rgb & 0xFF);
+        //neo->setPixel(i, rgb);
     } 
+    
+    buzzPin = 1;
 }
 
 void TA::mask_color(uint32_t rgb)
@@ -154,7 +167,7 @@
   
   for (int i = 0; i <= leds_per_strip; ++i)
     {
-        neopixel_set_color_and_show(&m_strip, i, (rgb >> 16) & 0xFF, (rgb >> 8) & 0xFF, rgb & 0xFF);
+ //       neopixel_set_color_and_show(&m_strip, i, (rgb >> 16) & 0xFF, (rgb >> 8) & 0xFF, rgb & 0xFF);
     } 
 }
 
@@ -296,7 +309,215 @@
 
 void TA::spin(void)
 {
+    #if 0
+    static byte payload [6];
+    static bool message_in_queue = false;
+    static bool waiting_for_ack = false;
+    static byte dest_cone = 0;
+    static uint16_t index = 0;
+    static uint16_t ack_tries = 0;
+    static uint8_t send_tries = 0;
+    static unsigned long ack_start = 0;
+    static unsigned long random_wait = 0;
+    static unsigned long random_wait_start = 0;
+    static unsigned long mem_monitor_start = 0;
+
+    // if(millis() - mem_monitor_start > 2000){
+    //   mem_monitor_start = millis();
+    //   Ram_TableDisplay();
+    // }
+
+#if 0
+    if(tripped())
+    {//buttons() && millis() - activated_start > 1000){
+        cap_enable = 1;
+        wait_ms(100);
+        cap_enable = 0;
+        //activated_start = millis();
+        //Serial.println(F("toggled cap sense power"));
+    }
+#endif    
+    if(powering_up2)
+    {
+        unsigned long t = millis() - powerup_start;
+        
+        if(t > powerup_toggle)
+        {
+            buzzPin = !buzzPin;
+            powerup_toggle *= 1.2;
+        }
+        
+        if(t > 1250)
+        {
+            buzzPin = 0;
+            powering_up2 = false;
+        }
+    }
+    else if(powering_up1)
+    {
+        unsigned long t = millis() - powerup_start;
+        
+        if(t > powerup_toggle)
+        {
+            buzzPin = !buzzPin;
+            powerup_toggle *= 0.95;
+            powerup_start = millis();
+        }
     
+        if(powerup_toggle < 10)
+        {
+            buzzPin = 0;
+            powering_up1 = false;
+        }
+    }
+    else
+    {
+        if(beeping && (millis()-beep_start > beep_duration)) 
+            beeping = false;
+        if(pulsing && (millis()-pulse_start > pulse_duration)) 
+            pulsing = false;
+        if(beeping)
+            buzzPin = 1;
+        else if( pulsing && (((millis()-pulse_start) % pulse_period) < pulse_on))
+        {
+            if(!(mask & SILENT))
+                buzzPin = 1;
+            mask_color(0);
+        }
+        else
+        {
+            if(pulsing)
+                mask_color(current_color);
+            buzzPin = 0;
+        }
+    }
+/*
+    if(!waiting_for_ack && radio.ReceiveComplete())
+    {
+        if(radio.CRCPass())
+        {
+            receive_buffer.put(radio.GetSender());
+            for(byte i = 0; i < *radio.DataLen; i++)
+                receive_buffer.put(radio.Data[i]);
+        }
+       
+        if(radio.ACKRequested())
+        {
+            wait_us(1300);
+            radio.SendACK();
+            //Serial.println(F("Sent ACK"));
+        }
+    }
+    */
+
+    //if(index > 4999 || waiting_for_ack){
+    if(waiting_for_ack)
+    {
+        //Serial.println(F("Waiting for ack"));
+        bool success = radio.ACKReceived(dest_cone);
+        
+        if(success || send_tries > 15)
+        {
+            //Serial.print(F("dequeued: "));
+            //Serial.println((uint16_t)payload[1]<<8 + payload[2]);
+            message_in_queue = false;
+            waiting_for_ack = false;
+            unsigned long t = micros() - ack_start;
+            //Serial.print(F("Received ACK, microseconds: "));
+            //Serial.println(t);
+            //ack_tries = 0;
+          
+            message_in_queue = false;
+            send_tries = 0;
+                
+            /*Serial.print(F("Sent "));
+            Serial.print((char)payload[0]);
+            Serial.print(F(", to cone "));
+            Serial.println(dest_cone);*/
+        }
+        else
+        {
+            if(micros() - ack_start > 10000)
+            {
+                //Serial.println(F("no ACK"));
+                waiting_for_ack = false;
+                random_wait_start = micros();
+                random_wait = random(1500,3000);
+                /*if(send_tries > 15){
+                Serial.print(F("Failed to deliver message to cone "));
+                Serial.println(dest_cone);
+                message_in_queue = false;
+                send_tries = 0;
+                }*/
+                if(send_tries > 4) 
+                    random_wait = random(3000,9000);
+                //Serial.print(F("Failed to deliver message, waiting "));
+                //Serial.println(random_wait);
+                //ack_tries = 0;
+    
+                /*if(send_tries%50 == 0){
+                Serial.print(send_tries);
+                Serial.println(F(" tries"));
+                }*/
+            }
+        }
+        // ack_tries++;
+    }
+    else if(message_in_queue && micros() - random_wait > random_wait_start)
+    {// && index%64 == 0){
+        requestACK = true;
+        //Serial.println(F("sending"));
+        radio.Send(dest_cone, payload, 6, requestACK);
+        //Serial.println(F("sent"));
+        //Serial.print(F("Trying to send: "));
+        //uint16_t temp = (uint16_t)payload[1]<<8;
+        //temp += (uint8_t)payload[2];
+        //Serial.println((uint8_t)payload[0]);
+        send_tries++;
+        ack_start = micros();
+        
+        if(!radio.ACKReceived(dest_cone)) 
+            waiting_for_ack = true; // the 'if' is here to prevent the radio from going to sleep and missing the ACK
+        else 
+            message_in_queue = false;
+    }
+    else 
+    {
+    /*if(send_buffer.getSize() > 0 && message_in_queue == false){
+      payload[0] = send_buffer.get();
+      //Serial.print(F("Got from queue: "));
+      //Serial.println((char)payload[0]);
+      message_in_queue = true;
+    }*/
+    while(send_buffer.getSize() > 4 && message_in_queue == false)
+    {
+      payload[0] = send_buffer.get();
+      payload[1] = send_buffer.get();
+      payload[2] = send_buffer.get();
+      payload[3] = send_buffer.get();
+      payload[4] = send_buffer.get();
+      dest_cone = send_buffer.get();
+      payload[5] = send_buffer.get();
+      /*Serial.println(F(""));
+      Serial.println(F("sending..."));
+      Serial.println(payload[0], BIN);
+      Serial.println(payload[1], BIN);
+      Serial.println(payload[2], BIN);
+      Serial.println(payload[3], BIN);
+      Serial.println(payload[4], BIN);
+      Serial.println(dest_cone, BIN);      
+      Serial.println(payload[5], BIN);
+      Serial.println(F(""));*/
+      if((char)payload[5] == '%')
+        message_in_queue = true;
+      else 
+      {
+        while(send_buffer.getSize() > 0 && send_buffer.get() != '%'); // if we didn't land on the end of a message, peel stuff off until we are
+      }
+    }
+  }
+  
+  #endif
 }
 
 bool TA::activated(void)