Diff: TA.cpp

Revision:

17:d8b901d791fd

Child:

18:affef3a7db2a

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/TA.cpp	Tue Nov 03 07:05:15 2015 +0000
@@ -0,0 +1,374 @@
+#include "TA.h"
+#include <nrf51.h>
+#include <mbed.h>
+#include <device.h>
+#include <vector> 
+
+/* !SR
+ * Can't find any boards which use the nrf51822 and have analog output enabled. Currently
+ * all analog stuff has been commented out.
+ */
+ 
+ #define NEED_CONSOLE_OUTPUT 1 /* Set this if you need //////////////////////DEBUG messages on the console;
+                               * it will have an impact on code-size and power consumption. */
+
+#define LOOPBACK_MODE       0  // Loopback mode
+
+#if NEED_CONSOLE_OUTPUT
+#define DEBUG(...) { printf(__VA_ARGS__); }
+#else
+#define DEBUG(...) /* nothing */
+#endif /* #if NEED_CONSOLE_OUTPUT */
+ 
+
+extern unsigned long millis();
+extern unsigned long micros();
+extern int random(int numberone, int numbertwo);
+
+ByteBuffer TA::send_buffer;
+ByteBuffer TA::receive_buffer;
+
+uint8_t TA::node_id;//        1  //network ID used for this unit
+uint8_t TA::network_id;//    99  //network ID used for this network
+uint8_t TA::gateway_id;//     1  //the ID of the network controller
+uint8_t TA::ack_time;//      50  // # of ms to wait for an ack
+
+//encryption is OPTIONAL
+//to enable encryption you will need to:
+// - provide a 16-byte encryption KEY (same on all nodes that talk encrypted)
+// - to call .Encrypt(KEY) to start encrypting
+// - to stop encrypting call .Encrypt(NULL)
+uint8_t TA::KEY[] = "ABCDABCDABCDABCD";
+uint16_t TA::interPacketDelay;// = 1000; //wait this many ms between sending packets
+
+// Need an instance of the Radio Module
+//byte TA::sendSize;//=0;
+//char TA::payload[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+//bool TA::requestACK;//=true;
+
+//neopixels_spi TA::neopixels;
+
+
+unsigned long millis();
+
+unsigned long micros();
+
+
+/** Macro for min() 
+ *
+ * @param any
+ */
+#define min(a,b)                  ((a)<(b)?(a):(b))
+/** Macro for max()
+ *
+ * @param any
+ */
+#define max(a,b)                  ((a)>(b)?(a):(b))
+
+/** generates a random number between two numbers
+ *
+ * @param numberone minimum value for random number
+ * @param numbertwo maximum value for random number
+ */
+int random(int numberone, int numbertwo) {
+    int random = 0;
+    if ((numberone < 0) && (numbertwo < 0)) {
+        numberone = numberone * -1;
+        numbertwo = numbertwo * -1;
+        random = -1 * (rand()%(numberone + numbertwo));
+    }
+    if ((numbertwo < 0) && (numberone >= 0)) {
+        numbertwo = numbertwo * -1;
+        random = (rand()%(numberone + numbertwo)) - numbertwo;
+    }
+    if ((numberone < 0) && (numbertwo >= 0)) {
+        numberone = numberone * -1;
+        random = (rand()%(numberone + numbertwo)) - numberone;
+    } else {
+        random = (rand()%(numberone + numbertwo)) - min(numberone, numbertwo);
+    }
+    return random;
+}
+
+// ########## End code taken from audrino library ##########
+
+uint8_t TA::mask;
+
+// outputs
+//uint8_t TA::buzzPin;
+uint8_t TA::red;
+uint8_t TA::green;
+uint8_t TA::blue;
+
+neopixel_strip_t m_strip;
+
+uint8_t dig_pin_num =  16;
+uint8_t leds_per_strip = 18;
+uint8_t led_to_enable = 1;
+
+#if 0
+DigitalOut TA::enable_1(p4);
+DigitalOut TA::enable_2(p7);
+DigitalOut TA::enable_3(p8);
+
+
+DigitalOut TA::cap_enable(A3);
+#endif
+DigitalOut TA::buzzPin(p20);
+
+#if 0
+// inputs
+DigitalIn TA::touch_1(A0);
+DigitalIn TA::touch_2(A1);
+DigitalIn TA::touch_3(A2);
+#endif
+
+std::vector<Message*> *messages;
+
+TA::TA()
+{
+    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)
+{
+    
+    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);
+    } 
+}
+
+void TA::mask_color(uint32_t rgb)
+{
+   // enable_1 = 0;
+   // enable_2 = 0;
+   // enable_3 = 0;
+  //neopixels.setRGBStrip1((rgb >> 16) & 0xFF, (rgb >> 8) & 0xFF, rgb & 0xFF);
+  
+  //enable_1 = (mask & 0x01)?1:0;
+  //enable_2 = (mask & 0x02)?1:0;
+  //enable_3 = (mask & 0x04)?1:0;
+  
+  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);
+    } 
+}
+
+void TA::beep(uint16_t ms)
+{
+    beeping = true;
+    beep_start = millis();
+    beep_duration = ms;
+}
+
+void TA::beep_off(void)
+{
+    beeping = false;   
+}
+
+void TA::powerup(uint8_t sound)
+{
+    powerup_start = millis();
+    beeping = false;
+    pulsing = false;
+    powering_up1 = false;
+    powering_up2 = false;
+
+    if(sound == 1)
+    {
+        powering_up1 = true;
+        powerup_toggle = 300;
+    }
+    
+    if(sound == 2)
+    {
+        powering_up2 = true;
+        powerup_toggle = 20;
+    }
+}
+
+void TA::pulse(uint16_t on_time, uint16_t period, uint16_t ms, uint32_t rgb)
+{
+    current_color = rgb;
+    pulsing = true;
+    pulse_start = millis();
+    pulse_period = period;
+    pulse_on = on_time;
+    pulse_duration = ms;   
+}
+
+void TA::pulse_off(void)
+{
+    pulsing = false;
+}
+
+int TA::get_buffer_size(void)
+{
+    return send_buffer.getSize();    
+}
+
+bool TA::send(Message *m)
+{
+    send_immediate(m); 
+    return true;   
+}
+
+void TA::send_immediate(Message *m)
+{
+    Message *tmp = new Message;
+    DEBUG("in send_imediate: %d '%c'\n", m->cone, m->command);
+    
+    tmp->command = m->command;
+    tmp->cone    = m->cone;
+    
+    // Fake version of the function, push this onto the reply queue
+    if (messages->size() < 50)
+    {
+        messages->push_back(tmp);
+    }
+    else
+    {
+        DEBUG("TA message queue too full!\n");    
+    }
+}
+
+bool TA::sendRaw(uint8_t *message, uint8_t len, uint8_t cone)
+{
+
+    return true;    
+}
+
+bool TA::recieve(Message *m)
+{
+   bool processed = true;
+top:
+    processed = true;
+
+   //DEBUG("receiving\n");
+   if (messages->size() > 0)
+   {
+       Message *lm = messages->front();
+       
+       DEBUG("got messaage with command: '%c'\n", lm->command);
+       
+       // Now populate the outgoing message based on the incoming
+       if (lm->command == 'z')
+       {
+            m->cone = lm->cone;   
+        } 
+        else
+        {
+            DEBUG("Unknown command: '%c'\r\n", lm->command);   
+            processed = false; 
+        }
+        
+        messages->erase(messages->begin());
+        
+        if (lm)
+        {
+           delete lm;    
+        }
+        
+        if (!processed)
+        {
+            // Clear out the queue if we don't know what
+            // to do with the message
+            goto top;    
+        }
+   }
+   else
+   {
+        processed = false;
+    }
+    
+    return processed;   
+}
+
+bool TA::waitForAck(int cone) 
+{
+   
+    return true;
+}
+
+void TA::spin(void)
+{
+    
+}
+
+bool TA::activated(void)
+{
+    return true;   
+}
+
+bool TA::tripped(void)
+{
+    return false;
+}
+
+uint8_t TA::buttons(void)
+{
+    uint8_t buttons = 0;
+
+    return buttons;  
+}
+
+void TA::setMask(uint8_t the_mask)
+{
+    mask = the_mask;
+}
+
+void TA::initialize(uint8_t address)
+{
+}
+
+/* Can't find a way of implementing this function.
+ *
+ * !SR
+ */
+void TA::Ram_TableDisplay(void)
+{
+    
+}
+
+/* Not sure if this work. Taken from: https://developer.mbed.org/questions/6994/How-to-print-Free-RAM-available-RAM-or-u/
+ *
+ * !SR
+ */
+void TA::get_free_memory(void)
+{
+    char   stackVariable;
+    char   *heap;
+    unsigned long result;
+    heap  = (char*)malloc(4);
+    result  = &stackVariable - heap;
+    free(heap);
+    
+    //serial->printf("Free memory: %ul\n\n",result);
+}
+
+void TA::check_mem(void)
+{
+    uint8_t * heapptr, * stackptr;
+    unsigned int stack, heap = 0;
+
+    stackptr = (uint8_t *)malloc(4);          // use stackptr temporarily
+    heapptr = stackptr;                     // save value of heap pointer
+    free(stackptr);      // free up the memory again (sets stackptr to 0)
+  
+    stack = __current_sp() ;
+    heap = (uint16_t)heapptr;
+    uint16_t last_call = *(stackptr++);
+    
+    //serial->printf("Stack: 0x");
+    //serial->printf("%x ",stack);
+    //serial->printf("Heap: 0x");
+    //serial->printf("%x\n",heap);
+    //serial->printf("Last call: 0x");
+   // serial->printf("%x\n",last_call);
+    get_free_memory();
+}
+