Can DeepSeek R1 Actually Write Good Code?

0:00 what is up car and tech fans and welcome back to another garage tinkering video last year we made a video where we compared five different web-based AI chat applications to see how they differed when it came to writing Arduino code to see which one was the best and unless you've been living under a bit of a rock this week you'll know that a massive new player has been disrupting basically the entire AI landscape this week with deep seek so I thought it'd be worth while asking the question is deep seek any good at writing uino code So today we're going to test it in the previous video which you can check out on the link up here we looked at chat GPT uh find pi perplexity and Claude and

0:49 Claude came out on top in our comparison but none of them got the solution that we were looking for exactly right so we're going to repeat the exact conditions that we used in our previous test just for fairness and see how deep seat gets on and those conditions are that we have a prompt for an application that we want to build it's pretty simple we'll look at that in a second we give the AI an opportunity to produce the code we test the code and then whatever errors come up we tell it back to deep seek let it try and fix any problems and then re-upload that so it gets one opportunity to fix its mistakes it's the exact same conditions we did with the other five so I think it really creates

1:36 a nice Level Playing Field the Arduino setup that we're using looks like this it is very simple we're using a bog standard basic Arduino Nano uh there are two buttons connected to it one to pin six and the other one to pin 10 and a small neopixel strip uh that is connected into pin 2 it all works I've Ted it this morning the lights all come on everything's groovy so what is the prompt that we're going to use and I've copied it from when I did it before and this is what we're looking at I need help making an uino application that does the following things we have an Arduino Nano and connected to pin 2 is a string of 186 neopixel lights I don't

2:22 actually have that really long string of lights anymore so we'll just reduce it to 12 because that will mean we can see if the entire strip lights up or just 12 light up which is a kind of an additional test there's a button connected to pin six when it's pressed it should toggle whether or not the lights are on there is another button connected to pin 10 when this is pressed the colors should cycle through the colors of the rainbow moving to the next color each time it is pressed when it reaches Violet at the end of the cycle it should return to Red this is the only bit that I expect a little bit of like flare um from the AI because it has to interpret what the colors of the rainbow are so it needs to obviously have that

3:08 knowledge and it needs to know that it's a looping cycle uh so none of the ones previously managed to get that completely right so it' be interesting to see what happen the state which is a keyw for it of whether the lights are on and off and the color that they are currently set to should be stored in nonvolatile memory and when the application turns off on the previous state should be reloaded now I've helped it along a little bit there by telling it nonvolatile memory so there's certain things that we're looking for so ways that arduinos store stuff in their internal memory so it's called nonvolatile memory so that's just a little way of helping it along into the right area use serial print lines to print on and off when the lights are turned on and off and print the name and

3:54 the value of the color when it changes so this is our setup code got two buttons One turns it on and off one Cycles the colors it's pretty simple um but again none of them got it quite right last time so do we want to use deep think uh to do solve reasoning problems it's not is it a reasoning problem yeah let's let's keep that turned on because it is really kind of a reasoning problem and we'll see what it does I have genuinely not run this before don't know what it's going to do um we'll see and really I only created an account on deep sync yesterday so so I've not really had a chance to play with it at all but I have seen that it does this thing where it thinks first through all the steps and like the rationale behind what it's trying to

4:40 tell you and then once it's done all this it tells you the the response at the end and I like that I like the fact it's taking the time to go okay well what should my response be what things do I need to think about before I say the answer I think more humans could uh do with adopting that skill and it is really thinking about this one so let's see what it's what it's saying before we see the response so let's tackle this uino project it wants an application for a nano that controls neopixels with two buttons and Sayes a state let's break down each requirement step by step good first the hardware neopixel strip is connected to pin two buttons on six and 10 need to make sure the buttons are configured with polet resistors either internally or externally since the N has

5:26 internal bullets I'll enable those to avoid floating pins is what we want to see next the first button six toggles the lights on and off so I track the current onoff state and toggle it when the button is pressed debouncing is important to prevent multiple triggers from a single press maybe use a simple debounce by checking the time since the last press again that is that's good that's what we would want to see the second button pin 10 Cycles through the rainbow colors each should advance to the next color the colors are red green orange green blue indigo violet correct and then back to Red you need to Define to colors perhaps using HSV or RGB conversion for smoother transitions but maybe start with predefined RGB values for Simplicity yeah that's exactly how I would go about it store the current color index and increment on each press wrapping around

6:12 after Violet again that is how I would do it moving through an index of a of an array nonvolatile memory storage the Nano has eom eom is exactly what I was hoping to see it's its internal nonvolatile memory storage I did kind of handhold it that so I use the eprom library to save the state on off and the current color index when the device starts up read the values from eprom and restore the nanop pixels accordingly however eom has limited write Cycles so it should only write when the state changes not every time a button is pressed so track if the state or color has changed and only save then well every button press forces a state change so it will do everything every time a button is pressed um so

6:59 that's it's like first misthink but it'll it'll still work by the looks of things seral communication print on or off when the state toggles and the color name and value when it changes need to map each color index to its name and RGB value so yep we're hoping to see you know some kind of of mapping between names and colors so putting all that together include the libraries neopixel for the LEDs eom for storage the constants pin for neopixels buttons number of LEDs eom address for state and color index declare the variables current state onoff current color index last button State for the bouncing and the last the bounce time that all seems very reasonable initialize the neopixels set

7:45 the buttons to have an internal pull-up set up the serial communication read the last say State and color from eom apply them on Startup then in our Loop check button six for presses when pressed tockle the state update the LEDs to save e prom right to serial check 10 for presses when pressed increment color index wrap around after six question mark update color save to e prom print color value handle the debounce by checking if enough time is pressed wait the rainbow colors are seven colors red orange yellow green blue indigo violet so the indices would be Zer to six when pressing increment indexed if it's seven reset to zero or maybe not to six to go back to so modulo 7 I like the way it's like internally debating with itself um

8:33 what is trying to understand here is the difference between an index value and a count so uh the indexes of an array go from Zer to X um so the very first value is zero whereas if you were just counting how many colors are there in the rainbow you'd go red orange yellow green blue It Go Violet as seven because the first one you count as one you don't count it as zero so it's trying to just differentiate the difference there between uh the number of colors and the index number of colors but the user says when it reaches Violet next press turns to Red so index six is violet next press goes to set so it's it's used my correct grammar uh to its advantage and because I will use the word next press returns to Red if I said when it gets to Violet

9:20 it goes to Red maybe it would have looped it in that same press I don't know for the colors uh predefined AR of structs with names and RGB values for example struct color has a name and an RGB value um then it sets up the ones with the different rgbs so red is red green blue yeah orange is this mix yellow is full yeah these all seem right that's green that's blue IND game Violet seem yeah about right neopixel color uses color RGB so maybe use that I like I like the way it's going through this the neopixel Library set pixel color function can take separate RGB videos or a 32bit color so for the color of the definitions maybe create an

10:06 array of 32bit colors using the art fruit the pixel color function to generate them oh heck when the color index changes set all pixels to that color if the lights wrong if the lights wrong nice catch so that's a catch that if you're pressing the toggle color button but the lights on on you shouldn't be showing the change toggle color for e prom stor save the on off as a bite 01 good uh yeah you could do b or you could do a ball oh can you do a ball with eom it's been a while since I've used eom because I use uh esp32s pretty much exclusively and they don't use eom but yeah anyway uh and a color index is a bite 0 to six on Startup read these values if the values are invalid set defaults it might set these as a single

10:53 pair of btes which is why it is you using btes for the bouncing the buttons you use a simple approach where check the button state has been stable for a certain amount of time e 50 milliseconds so when a button's pressed wait for the bounce delay before registering again good Implement Edge detection track the previous state of each button and when the current reading is different and stable trigger the action good code structure this is very in depth in Loop read the current button States F each button check the if the low is compared to the last state if the state has changed note the time if the state has been stable for than the bounce delay than trigger the action so this is just saying to put in a very simple State manager so rather than just doing everything on the on the D press it's creating a state manager to say what is

11:39 the current state of the button and then as the loop happens has that state changed so is the button down up um it's a good way of just forcing this debounce that he's talking about wait the standard Deb approach is to check if the button state has been the same for the bounce DeLay So for each button state is the read of the button if the state is not equal to the previous state then the debounce has happened previously and then yeah so some more State Management stuff here but since those two buttons need to handle each separately maybe create a help function to handle the bouncing for each button alternatively track each button the last state Bounce Time Etc Jesus Christ oh my God there's so much okay we're going to have to we're going to have to speed up here because it's it's

12:25 thought so much about each one of these steps so we've got a debounce in here uh yeah so handle each one separately check each button for the last state debounce keep it simple a simple approach where we check if the button pressed only trigger once per press ignoring repeats for a certain time that's good idea obviously you could use the bounce two Library bounce 2 library is uh a really good way of doing it and it is a a good debouncing Library um a lot of packages that we've looked at on this uh Channel have have used that library but they didn't mention using external libraries Beyond neopixel and eom since Cod should be self-contained perhaps using avoid using bounce 2 and handle the bouncing manually so it's trying not to use

13:10 libraries I think if you can avoid using libraries a lot of the time it's worth it but there's a difference we're got to look at here between you know readability and um you know maintainability but to keep the code manageable implements are basically bound of the cool down 200 milliseconds since the last press alternative use Edge detection trigger on the falling Edge after debouncing yeah it's really thinking through this so this is bunch more stuff like wait perhaps this is getting too complicated let me outline the steps for each button for toggle six when the button is pressed togg the lights on off similarly when it's pressed do the index so in the code each Loop it rightor and check the state with the bouncing read the state compared to previous state if

13:56 it's changed reset the debounce timer the has been stable for the bounce delay then check his falling Edge depressed okay I don't think I would think through it in this when steps I'm a human with a PhD in doing this but given time and Straits perhaps use a sybol approach with a cool down period for each button press yeah okay so this is doing lots and lots of thinking through the different ways of approaching this State Management on button pressing so let's let's move past this because we could be here forever okay so they're still thinking about the different ways of doing it wait it I like the way it keeps going wait so when the lights are to on setle pixels to the current color and show when off clear them for the color

14:42 increment the color index mod seven so um mod s which is the thing that just Loops it back to the start of the index uh then set all colors to that button do the serial prints read and write the values so for each color in the aray have the same name and hex value then when the color changes WR them out so it's just talking about creating a standardized format then it's talking about uh the neopixel is a 32 bit the first bite is ignored so oh it's going to try and do it like this is it it's going to do bite stepping so that's what this is is is Shifting the bites um not sure I would do it this way but I'm going to give it the benefit of the doubt I think what it's going to try and do is do it as a hex value like this so it's going to store it as a hex value

15:27 and then it's going to use this ndn stuff in order to shift the bites in order to create the values anyway we'll give it the benefit of the doubt again so again still talking about different ways of creating my color it's debating the different ways of doing it that that's how I would uh yeah just use straight RGB values as opposed to doing HEX number calculations it's just not worth the overhead so again still talking about different ways of handling and doing the colors it's a bit tedious but manageable just okay so setting defaults from eom checking whether or not the the values coming from the memory are valid that's good you need to handle this during setup so do all this

16:14 in the setup feel like we're getting somewhere now then defining different functions to do different things this is a rehash of what we've basically talked about I think it's just writing out the code and then confirming it seems to have confirmed it but there's an issue um for the handle current toggle state is red if it changed to the last to bounce time so it's still debating with itself about this the bounce timer issue I mean is thorough is definitely thorough so we can see it's really debating with itself and it thinks that this is the code so let's just copy it rather than reading it in here so this is what it says it's done so toggle the lights with button on pin six cycle through the rainbow colors State

16:59 persistance using eom serial outputs for status changes and the bounced button inputs this is basically everything we want connect up the hardware we've already done that sequences red orange yellow green blue inteo violet repeats correct onor off when toal lights color name and hex value when changing colors it's gone for hex has it um and then uh e prom so two memory addresses one for the state and the other one for the color if I just minimize that and bring in brand spanking new uh one of these and we paste the code in let's just take a quick look at it so uh we've got the neopixel library included the eom library included we've got definitions for the pins um the constant of the number of uh pixels in the strip what

17:46 are the bounce delay is we've got the initialization of the strip defined structure which is saying what is the name of the color then it's storing it in its RGB which is good that's how I would do it and then it's the def all those colors as a an array object so it can then like just move through these one at a time and pull out the various values these are the addresses of the two eom values so you know uh eom address zero is going to hold the state whereas address one is going to hold the color some Global variables to handle you know Flags so whether or not the lights are on uh what the current color index is so this is basically defining defaults as well as you know doing loading States stuff when we start up we set the pin modes to the two

18:34 buttons uh it hasn't set the pin mode of the output one but shouldn't necessarily be a problem begin the neopixel strip and then show The neopixel Strip which is something you have to do to initialize it uh read whether or not the lights are on and from the state and whether or not what the current color index is read that from the state if the lights on is greater than one lights on is false okay so that's just an error checking so just trying to say is basically is the light on value zero or one which is the only supposedly valid inputs and same if the index is greater than or equal to seven it does a reset so that's good update the LEDs and then print the state um so that update LEDs function uh if the lights are on then we

19:21 set a new instance of the object using that colors array that we've created at the top and we fill based on the red green and blue that we've pulled out of that one based on the index so the current one that's good if the lights are off then send strip clear and then strip show so that feels correct and what was the other function in the top there print state so it's got a separate print yeah so it prints whether the lights are on and off nice and simple our Loop we've got the handle the toggle button and handle the color button so the toggle button the onoff button is just a digital read if the reading is not equal to last toggle State then last debounce time is millisecond so this is just that that debounce handling which is what all this is if reading is low

20:07 then it inverts the flag and then it updates LEDs saves the states and then prints the state good and I presume save state is just e prom updates yeah so it saves the state of both of them that's interesting that's the first time I've seen something that I wouldn't have done it like that because every time you press either button it sets the state of both the color and the onoff I would have handled them separately because at the moment if I spam on and off I'm writing to address one with the color change in it which doesn't need to happen it'll work I think but it's just not quite how I would have done it and then print state which we've seen and then the color button again it reads whether or not it been pressed it does

20:53 the The Bouncing so if the button's been pressed then the index increments by one but it uses a modulus down to seven so if the number gets to seven it Loops back down if the lights are on then update the LEDs so it's not going to update the LEDs if if lights on is equal to false that's it anyway let's upload the code and see what it does so right now it's showing nothing which is what we would expect because the defaults are off and no color so first button should turn it on and off we're getting nothing no serial prints nothing happening what has gone wrong so something is wrong basically it's printed off which is what you would

21:40 expect the print State runs at the end of setup so I would expect it to print the current state but the buttons aren't working like I said s this video I'm going to give this exactly the same test parameters that I gave the other five AIS when we tested them and tell it what's not working and see if it can fix it itself but we need to tell it what is not working and uh is best when using AI platforms to this to try and be as precise and succinct as possible about what the problem is so the problem is when the application starts up for the first

22:25 time the serial prints both in order to show equivalent state but when I press either button nothing that's about it that's all I can tell it really um be interesting to see what it thinks the problem is um and how it verifies what the problem is does it go through a similar process that like I a developer of 20 odd years would go through in order to figure out what was going on like the first thing I would do was remove all of the debounce checking and just even

23:11 though it will probably create errors and make the debounce go too crazy I would start by removing them and just making sure that we're verifying that we're getting the button input use that to verify the e prom read right and the the actual setting of the lights but my suspicion if there's anything wrong with this it's going to be something to do with the way it's done the debouncing that would be where my my gut feels it's debating with itself a lot here so stepping through the code which is wait let me check again it is really having a big think about what it wants to commit to this is the least committal AI I've

23:56 ever seen it doesn't just spit out the ab it goes oh it could be this oh but wait oh no it's this oh but wait it's this but oh but wait it's this it kind of uh yeah it overthinks the problem and I've noticed that that is a habit of all of these kind of Chatty eyes is they have a habit of sometimes really overthinking and I noticed it in particular well while I talk to you about it while I wait for this thing to decide what it wants to do um it they had a habit of instead of going back and fixing the root of a problem they would try and like stack more and more solutions on top so you can sometimes end up with this massively over complicated solution whereas really the answer is just step it back and you know go take stuff away to find the solution

24:43 rather than adding stuff on it's been a good few minutes and it's still thinking I'm not sure how long is it going to take this is this is potentially oh here we go we finally we've got a solution the likely issues some some two factors Shar the balce timing between two buttons and e prom initialization handling here's the corrected code with a separate debounce and improved handling so I'm guessing in these setup values yeah we've got two debounce states now to handle that separately okay rest of the code Remains the Same okay so I just need to take this bit here and insert it up to the handle color button right

25:29 upload come back and look at what it's actually written in a minute right now I just want to see if it works right try again and nothing still I'm genuinely surprised we have nothing at this point like what is wrong so it has not worked at all which is a shame because I think it's it's really close but let let's do how I would do this and remove all of this this is how I would go about solving this so simplify it so read it if the reading is low then do the thing it might spam things a little bit but at least we'll know and verify whether or

26:14 not there's a problem somewhere else so that's just on the toggle button so right as what does it do now right so it works now but I you see it it's not reliable because it's handling trigger States as various things happen with this button which is exactly why you need a debounce but we can now see that that's what the problem is is that the bounce state so what actually is the problem it's something um in this code so let's see what it's actually doing where's gone wrong um if reading so the value coming in from the button is not equal to the last total state so it's man managing the state of whether or not the

27:01 button is in or out if it's not equal so if it has changed then the toggle to bounce is equal to Millis which is a time stamp of right now and then it moves on if milis again minus last toggle to bounce but it's just set last toggle to bounce is greater than the bounce delay so this is the problem here what it's doing is setting this to bounce here to a time now then it's doing another thing immediately so this thing hasn't had Millis here to Millis here and this last bounce delay it hasn't had a chance to be greater than that the bounce delay so that's

27:46 where it's uh making a mistake I bet and it is really not the right way of doing uh handling of De bounces or anything but I reckon if we got rid of that and we got rid of that so we just have if reading is not equal to the last state then the last toal state is equal to reading so it's flipping this state and then saying if the reading is low so it only then does it on the the down I if we did that on both of these that one and that one and then just put again not the way I

28:32 would ever do this in an application but if we just put a delay in here and we did that as the code I've got a feeling that's going to fix it all let's take a look so left button yeah is now working as you would expect off on off on and the second button red orange yellow green blue indigo violet obviously there's very little difference between those but these are rgp strips so it's going to be limited and then back around to the start and they do that fine uh what about the

29:18 State Management so yellow and on turn that off turn it on again is still yellow and on um and move to green and off remove it put it back in still off but it is still green yep that has fixed it so it clearly did a lot of it great once we fixed that small debounce issue the toggle button onoff did exactly what it expected to the color cycle worked fine and when we look at the code here you can see it was doing what we wanted by printing out the color and the hex value for that color which is what we requested of it it stored everything into the e prom correctly and reset

30:04 those things when the power was turned on and off to the device the only thing that it messed up was handling that debounce properly and it seemed to over complicate things and it was trying to do management of the state and the timing to bounce and it hadn't seemed to realize it was setting a value then comparing that same value immediately and hadn't realized that thing hadn't had time to change I expect that with with one more request to it we could get it to fix everything um and I'm just going to try it for curiosity um use the bounce 2 library to handle the debounce instead I think if I give it the opportunity to use this external library

30:51 then it's going to stop overthinking things it will rip out everything that's done already and use it as per the way the Library works and that should make things a lot easier um so let's see what it does um I've got a feeling as well that if you turned off this deep think you wouldn't get 10 minutes of it thinking through every think um but you know here's the revised code right so we've got the new bounce two library in here we have to initialize it which we've done all of this setup of the code stuff here is still the same attaching the D bouncers to those buttons with a a small intervall I would set this interval here as a global um

31:37 constant but what are you going to do uh everything else looks pretty much the same until here so togg with the bouncer just makes life a little bit easier there so let's just copy that put it back into here and give it like one final chance to uh get everything working let's see it does so let's have a go yeah there we go it has fixed it if I do a few steps yeah it's fixed it just by tunning it to remove the erroneous bits of code that is now exactly what we would expect it to run like so by turning it basically this is the actual issue stop over the complicating it

32:24 remove everything that you've done and use a simple library in order to handle the thing that you are seemingly having problems with everything is running exactly as I would have expected to and I've got a feeling that if it had decided to use the debounce 2 library from the offset which we saw it debate using it would have probably got this entire thing right first time when I compare it to the five AIS that we looked at previously which if we remind ourselves was chat GPT orbe it an old version now clawed again an old version Now find perplexity and Pi the latter of the three I've not touched again since it has actually got a lot closer to the

33:11 full solution working directly out of the box and any of those other ones did and it required very little handholding to end up with what is actually a decent robust generally well thought through solution there's one thing that I would change in this final bit of code and it's the set State and where they've set the state for both the lights and the color no matter which button is pressed I would separate those out and handle those separately because you're doing memory rights to each address for each button press where you don't need to do that just handle them separately each button relates to each individual memory slot but other than that it's actually I'm actually decently impressed with this it's uh yeah got very close to being a really

33:58 good solution in very very little work now is it perfect no and none of these AIS are perfect they all require a bit of handholding to get them to where they need to be but you know two years ago we didn't have this technology full stop and now within half an hour if I came into this problem with zero coding knowledge I could probably get this entire thing up and going so for entry level developers which trying to just you know black the way through this solution finding pretty good how would I rate it compared to the other five that we looked at yeah this is the best one uh well done well done China you have kicked it

34:44 out of the park with this now is it 50 times better that I'm hearing people say that this AI is 50 times better uh for this no uh 50 time better would have got it right first time but it's it's definitely a a a marked improvement and everything that he doing is correct and I like the way it's stepping through the process and you can see it debating with itself about the right way to solutionize problems it's exactly how I work as a developer but it's still falling into that trap or when something goes wrong it's trying to move forwards and you know tag more stuff on in order to fix it rather than stepping backwards which is often what you need to do when you're problem solving as developer you need to remove things and go okay well

35:29 what happens when I remove all this stuff to its simplest form and then move forwards again from there is it going to replace all developers immediately no no not immediately anyway but the next years are going to be both interesting and scary if you're in that space still so there we go a look at Deep seek or I guess deep think as an option for coding arduinos it is very good and I'm I'm sure I'm going to be utilizing it a lot going forwards for little bits of problem solving even me as a 20 odear developer I still utilize software like this to you know help me identify things that I've overlooked because we're all human and we all make mistakes but so do AIS the only differen is we don't come with a disclaimer that says that I hope

36:16 you found this one interesting later on this year we are going to set a new problem and test it across a range of AIS again because a lot of them have updated in the last 68 months since I last did this problem and I want to give their newest states and their newest versions an opportunity to you know compete on a Level Playing Field so we'll come up with a new problem for them and we'll test that later in the year so if you want to see that make sure you hit subscribe otherwise we've got lots and lots of cool ongoing projects that utilize AI as well as my big old brain if you want to chat about this stuff feel free to stick any of your feelings in the comments and I'm sure there'll be some back and forth about this um otherwise you can hop over to my Discord we're going to create a channel on there just for talking about

37:03 AI because I think it's going to be a Hot Topic going forwards link for that is in the description if you wanted to join that's it for this one though whatever you do with the rest of your day folks have a wicked one and I'll see you in the next video take it easy peeps byebye