/ - Diff - Colony - Robotics Club

Revision 583

finished my lights driver, but it doesn't work; it turns the lights on to one color, and they stay that way, no matter what.

     int main(void) {
     	dragonfly_init(ALL_ON);
     	orb1_set(200,0,0);
     	orb2_set(0,0,200);
     	while(1)
+    	{
+    	}
     	return 0;
+    }

     endif
     # Place -I, -L options here
     CINCS = -I$(COLONYROOT)/code/lib/include/libdragonfly
     CINCS += -L$(COLONYROOT)/code/lib/bin
     CINCS = -I../libdragonfly
     CINCS += -L../libdragonfly
     ifdef USE_WIRELESS
     	CINCS += -I$(COLONYROOT)/code/lib/include/libwireless
     	#CINCS += -I$(COLONYROOT)/code/lib/include/libwireless
     endif
     #---------------- Compiler Options ----------------

     // an orb node
     struct ORB_NODE {
     	int is_changed;
     	uint16_t new_angle;
        uint8_t num;
        uint16_t angle;
        uint16_t port_val;
        int time_split; // this will store the amount of time the timer needs to be set to from previous pin
     } ORB_NODE;
     struct ORB_SMALL {
     	int number;
     	int split;
     } ORB_SMALL;
     struct ORB_SORT {
     	struct ORB_SMALL orbs[ORB_COUNT];
     } ORB_SORT;
     // the status of the orbs
     struct ORB_STATUS_STRUCT {
        struct ORB_NODE orbs[ORB_COUNT];
        int changes[ORB_COUNT]; // when an orb changes, its number will go from 0 to 1
        uint8_t change_count;
        uint8_t new_angles;
        uint8_t current_orb;
     } ORB_STATUS;
     struct ORB_CHANGED_ORBS {
     	int orb_number;
     	uint16_t new_angle;
     } ORB_CHANGED_ORBS;
     struct ORB_CHANGED_ORBS_STRUCT {
     	struct ORB_CHANGED_ORBS changed_orbs[ORB_COUNT];
     } ORB_CHANGED_ORBS_STRUCT;
     struct ORB_ORDER { // 0 will store number of first orb to turn off, 1 of second, etc.
     	int order[ORB_COUNT];
     } ORB_ORDER;
     void sort_orbs(void); // this function will copy new values into angle values
     void calc_split_times(void); // this function will calculate split times and place them in the appropriate orbs
     //void calc_split_times(void); // this function will calculate split times and place them in the appropriate orbs
     // use compare C to reset every pulse + check new times
     SIGNAL (SIG_OUTPUT_COMPARE3C){
     SIGNAL (TIMER3_COMPC_vect){
           ORB_STATUS.current_orb=0; // reset the orb we're looking at
     		if(ORB_STATUS.change_count>0)
     		if(ORB_STATUS.new_angles>0)
+    		{
     			uint8_t mysreg;
     			mysreg=SREG;
     			cli();
     			sort_orbs();
     			calc_split_times();
     			SREG = mysreg;
     			ORB_STATUS.new_angles=0;
     			//calc_split_times();
+    		}
     	  // now that we've done everything, turn on all the lights
     	  ORB_PORT |= ORBMASK;
     	  // reset the time
     	  OCR3C = TCNT3+ORB_RESET;
     	  // turn ocr3a back on and set the time for the lights off counter
     	  ETIMSK |= _BV(OCIE3A); //turn on oc3a interrupt
     	  OCR3A = TCNT3+ORB_STATUS.orbs[0].time_split; //set time
     	  // turn ocr3b back on and set the time for the lights off counter
     	  ETIMSK |= _BV(OCIE3B); //turn on oc3b interrupt
     	  OCR3B = TCNT3+ORB_SORT.orbs[0].split; //set time
+    }
     // use compare A for turning lights off
     SIGNAL (SIG_OUTPUT_COMPARE3A){
     SIGNAL (TIMER3_COMPB_vect){
     		//pull the correct ones down
           ORBPORT &= ~(ORB_STATUS.orbs[ORB_ORDER.order[ORB_STATUS.current_orb]].port_val);
     	int i;
     	  ORBPORT &= ~(ORB_STATUS.orbs[ORB_SORT.orbs[ORB_STATUS.current_orb].number].port_val);
     	  int num_updated_orbs = 1;
     		// HERE, YOU ALSO NEED TO CHECK IF ANY OTHER ORBS HAVE THE SAME TIME!!!!!!!!!!!!!!!!@#!#!@#!@#!@#, update num updated
     		// check if any of the others have the same time
     	for(i=ORB_STATUS.current_orb+1;i<ORB_COUNT;i++)
+    	{
     		if(ORB_SORT.orbs[i].split==ORB_SORT.orbs[i-1].split)
+    		{
     			ORBPORT &= ~(ORB_STATUS.orbs[ORB_SORT.orbs[i].number].port_val);
     			num_updated_orbs++;
+    		}
     		else
+    		{
     			break;
+    		}
+    	}
     	  ORB_STATUS.current_orb+=num_updated_orbs; //now look at next orb transition
           if (ORB_STATUS.current_orb < ORB_COUNT) { //if it isnt the end...
     			//setup timer for next pull down
              OCR3C = TCNT3+ORB_STATUS.orbs[ORB_STATUS.current_orb].time_split;
              OCR3B = TCNT3+(ORB_SORT.orbs[ORB_STATUS.current_orb].split - ORB_SORT.orbs[ORB_STATUS.current_orb-1].split);
+         }
           else { //we are done with these pulses
     		//turn off this timer until it is reset
     		ETIMSK &= ~(_BV(OCIE3A));
     		ETIMSK &= ~(_BV(OCIE3B));
+    	  }
+    }
     void sort_orbs(void)
+    {
     	int i;
     	int j;
     	// first, we copy in new values
     	for(i=0;i<ORB_COUNT; i++)
+    	{
     		if(ORB_STATUS.orbs[i].is_changed==1)
+    		{
     			ORB_STATUS.orbs[i].is_changed=0;
     			ORB_STATUS.orbs[i].angle=ORB_STATUS.orbs[i].new_angle;
+    		}
+    	}
     	// next, we fill in ORB_SORT
     	for(i=0;i<ORB_COUNT;i++)
+    	{
     		ORB_SORT.orbs[i].number=i;
     		ORB_SORT.orbs[i].split=ORB_STATUS.orbs[i].angle;
+    	}
     	// and now we sort it
     	for(i=0;i<ORB_COUNT;i++)
+    	{
     		int min = ORB_SORT.orbs[i].split;
     		int index = i;
     		for(j=i+1;j<ORB_COUNT;i++)
+    		{
     			if(ORB_SORT.orbs[j].split < min)
+    			{
     				min=ORB_SORT.orbs[j].split;
     				index=j;
+    			}
+    		}
     		struct ORB_SMALL tmporb=ORB_SORT.orbs[i];
     		ORB_SORT.orbs[i]=ORB_SORT.orbs[index];
     		ORB_SORT.orbs[index]=tmporb;
+    	}
     	// now, calculate split times; up till now, the time is stored as 0-255, now convert it to clock cycles
     	for(i=0;i<ORB_COUNT;i++)
+    	{
     		ORB_SORT.orbs[i].split=ORB_RESET/255*ORB_SORT.orbs[i].split;
+    	}
+    }
     void orb_init()
+    {
        uint8_t mysreg;
-...
     	mysreg=SREG;
     	cli(); //turn off interrupts for now
     	ORB_STATUS.new_angles=0;
     	//we're looking at the 1st orb
     	ORB_STATUS.current_orb=0;
     	//store values
-...
           ORB_STATUS.orbs[i].num = i;
     	  //i'm not sure why he starts at 1023, so i'm making it 0 for now
           ORB_STATUS.orbs[i].angle = 0; //1023;	//127 is a pretty stupid start angle, but oh well
     	  ORB_STATUS.changes[i]=1; // each orb has been "changed"
     	  ORB_STATUS.orbs[i].is_changed=1; // each orb has been "changed"
     	  ORB_STATUS.orbs[i].new_angle = 0;
     	  ORB_SORT.orbs[i].split=0;
     	  ORB_SORT.orbs[i].number=i;
+    	}
     	ORB_STATUS.new_angles=1;
     	ORB_STATUS.orbs[0].port_val=ORB1_RED;
     	ORB_STATUS.orbs[1].port_val=ORB1_GREEN;
     	ORB_STATUS.orbs[2].port_val=ORB1_BLUE;
-...
     	TCCR3B = _BV(CS31); //set a prescale of 8
     	TCCR3C = 0; // sets normal operation
     	ETIMSK |= _BV(OCIE3C); //turn on oc3c interrupt
     	ETIMSK |= _BV(OCIE3A); //turn on oc3a interrupt
     	ETIMSK |= _BV(OCIE3B); //turn on oc3b interrupt
     	OCR3C = TCNT3+ORB_RESET; // WHAT HAPPENS IF THE TIMER IS ON FOR A VERY LONG TIME; OVERFLOW?
     	OCR3A = TCNT3+ORB_RESET;
     	OCR3B = TCNT3+ORB_RESET/2;
     	SREG=mysreg;
+    }
-...
     	orb=orb&0x07; //only have 8
     	angle=angle&0xff; //only accept 0-255
     	angle=255-angle; //inverse intensity
     /*
     	angle=angle<<2; //scale up so that we dont run it too often
     	angle+=3; //0 values dont really work
       */
     	// check if the angle is different, if it is, update our status
     	if(angle!=ORB_STATUS.orbs[orb].angle)
+    	{
     		ORB_STATUS.new_angles++;
     		ORB_STATUS.changes[orb]=1;
     		mysreg=SREG;
     		cli();
     		ORB_STATUS.new_angles=1;
     		ORB_STATUS.orbs[orb].is_changed=1;
     		ORB_STATUS.orbs[orb].new_angle = angle;
     		SREG = mysreg;
+    	}
     	mysreg=SREG;
     	cli();
       ORB_CHANGED_ORBS_STRUCT.changed_orbs[orb].new_angle=angle;
     //    ORB_STATUS.orbs[orb].angle = angle; //update angle
     	SREG = mysreg;
       // dont see why you need to track changes, so might as well just change it
       /*
     	mysreg=SREG;
     	cli();
         ORB_STATUS.orb_angles[orb] = angle; //update angle
     	SREG = mysreg;
     	*/
     /*
     	if (ORB_STATUS.orb_angles[orb] != angle) { //if the angle has changed
     	  mysreg=SREG;
     	  cli(); //disable interrupts
           ORB_STATUS.orb_angles[orb] = angle; //update angle
           ORB_STATUS.new_angles = 1;
     	  SREG=mysreg; //put interrupt status back
+       }
        */
+    }
     void orb1_set(unsigned char red, unsigned char green, unsigned char blue)

Also available in: Unified diff

Project

General

Profile

Colony

Revision 583